Attachment #63031 for issue #102151

View | Details | Raw Unified | Return to issue 102151
Collapse All | Expand All

Lines 824-829 public: Link Here

(-)sc/inc/document.hxx (+1 lines)
824	ScRange* pLastRange = NULL,	824	ScRange* pLastRange = NULL,
825	Rectangle* pLastMM = NULL ) const;	825	Rectangle* pLastMM = NULL ) const;
826		826
		827	void SkipOverlapped( SCCOL& rCol, SCROW& rRow, SCTAB nTab ) const;
827	BOOL IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;	828	BOOL IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
828	BOOL IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;	829	BOOL IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
829		830

Lines 4534-4539 BOOL ScDocument::RefreshAutoFilter( SCCOL nStartCol, SCROW nStartRow, Link Here

(-)sc/source/core/data/document.cxx (+7 lines)
4534	return bChange;	4534	return bChange;
4535	}	4535	}
4536		4536
		4537	void ScDocument::SkipOverlapped( SCCOL& rCol, SCROW& rRow, SCTAB nTab ) const
		4538	{
		4539	while (IsHorOverlapped(rCol, rRow, nTab))
		4540	--rCol;
		4541	while (IsVerOverlapped(rCol, rRow, nTab))
		4542	--rRow;
		4543	}
4537		4544
4538	BOOL ScDocument::IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const	4545	BOOL ScDocument::IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
4539	{	4546	{

Lines 37-42 Link Here

(-)sc/source/ui/inc/cellsh.hxx (+1 lines)
37	#include <svx/svdmark.hxx>	37	#include <svx/svdmark.hxx>
38	#include <tools/link.hxx>	38	#include <tools/link.hxx>
39	#include "formatsh.hxx"	39	#include "formatsh.hxx"
		40	#include "address.hxx"
40		41
41	class SvxClipboardFmtItem;	42	class SvxClipboardFmtItem;
42	class TransferableDataHelper;	43	class TransferableDataHelper;




    BOOL				bInActivatePart;
    BOOL				bInZoomUpdate;
    BOOL				bMoveIsShift;
    BOOL				bNewStartIfMarking;

    BOOL                bOldSelection;          // old style (inverting) of selection


    static void		SetScrollBar( ScrollBar& rScroll, long nRangeMax, long nVisible, long nPos, BOOL bLayoutRTL );
    static long		GetScrollBarPos( ScrollBar& rScroll, BOOL bLayoutRTL );

    void            GetPageMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, SCsCOL& rPageX, SCsROW& rPageY);
    void            GetAreaMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, 
                                           SCsCOL& rAreaX, SCsROW& rAreaY, ScFollowMode& rMode);

protected:
    void			UpdateHeaderWidth( const ScVSplitPos* pWhich = NULL,
                                        const SCROW* pPosY = NULL );


    void			FindNextUnprot( BOOL bShift, BOOL bInSelection = TRUE );

    void			SetNewStartIfMarking();

    void            SetTabNo( SCTAB nTab, BOOL bNew = FALSE, BOOL bExtendSelection = FALSE );
    void            SelectNextTab( short nDir, BOOL bExtendSelection = FALSE );



    BOOL			IsBlockMode() const		{ return bIsBlockMode; }

    void            ExpandBlock(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode);
    void            ExpandBlockPage(SCsCOL nMovX, SCsROW nMovY);
    void            ExpandBlockArea(SCsCOL nMovX, SCsROW nMovY);

    void			MarkColumns();
    void			MarkRows();
    void			MarkDataArea( BOOL bIncludeCursor = TRUE );




        {
            // ADD mode: keep the selection, start a new block when marking with shift again
            bKeep = TRUE;
            pTabViewShell->SetNewStartIfMarking();
        }
    }

    if (bSel)
    {
        switch (nSlotId)
        {
            case SID_CURSORDOWN:
                rReq.SetSlot(SID_CURSORDOWN_SEL);
            break;
            case SID_CURSORUP:
                rReq.SetSlot(SID_CURSORUP_SEL);
            break;
            case SID_CURSORRIGHT:
                rReq.SetSlot(SID_CURSORRIGHT_SEL);
            break;
            case SID_CURSORLEFT:
                rReq.SetSlot(SID_CURSORLEFT_SEL);
            break;
            case SID_CURSORPAGEDOWN:
                rReq.SetSlot(SID_CURSORPAGEDOWN_SEL);
            break;
            case SID_CURSORPAGEUP:
                rReq.SetSlot(SID_CURSORPAGEUP_SEL);
            break;
            case SID_CURSORPAGERIGHT:
                rReq.SetSlot(SID_CURSORPAGERIGHT_SEL);
            break;
            case SID_CURSORPAGELEFT:
                rReq.SetSlot(SID_CURSORPAGELEFT_SEL);
            break;
            case SID_CURSORBLKDOWN:
                rReq.SetSlot(SID_CURSORBLKDOWN_SEL);
            break;
            case SID_CURSORBLKUP:
                rReq.SetSlot(SID_CURSORBLKUP_SEL);
            break;
            case SID_CURSORBLKRIGHT:
                rReq.SetSlot(SID_CURSORBLKRIGHT_SEL);
            break;
            case SID_CURSORBLKLEFT:
                rReq.SetSlot(SID_CURSORBLKLEFT_SEL);
            break;
            default:
                ;
        }
        ExecuteCursorSel(rReq);
        return;
    }

    SCsCOLROW nRTLSign = 1;
    if ( pData->GetDocument()->IsLayoutRTL( pData->GetTabNo() ) )
    {


void ScCellShell::ExecuteCursorSel( SfxRequest& rReq )
{
    sal_uInt16 nSlotId  = rReq.GetSlot();
    ScTabViewShell* pViewShell = GetViewData()->GetViewShell();
    short				nRepeat = 1;

    if ( pReqArgs != NULL )
    {
        const	SfxPoolItem* pItem;
        if( IS_AVAILABLE( FN_PARAM_1, &pItem ) )
            nRepeat = ((const SfxInt16Item*)pItem)->GetValue();
    }

    switch (nSlotId)
    {
        case SID_CURSORDOWN_SEL:
            pViewShell->ExpandBlock(0, 1, SC_FOLLOW_LINE);
        break;
        case SID_CURSORUP_SEL:
            pViewShell->ExpandBlock(0, -1, SC_FOLLOW_LINE);
        break;
        case SID_CURSORRIGHT_SEL:
            pViewShell->ExpandBlock(1, 0, SC_FOLLOW_LINE);
        break;
        case SID_CURSORLEFT_SEL:
            pViewShell->ExpandBlock(-1, 0, SC_FOLLOW_LINE);
        break;
        case SID_CURSORPAGEUP_SEL:
            pViewShell->ExpandBlockPage(0, -1);
        break;
        case SID_CURSORPAGEDOWN_SEL:
            pViewShell->ExpandBlockPage(0, 1);
        break;
        case SID_CURSORPAGERIGHT_SEL:
            pViewShell->ExpandBlockPage(1, 0);
        break;
        case SID_CURSORPAGELEFT_SEL:
            pViewShell->ExpandBlockPage(-1, 0);
        break;
        case SID_CURSORBLKDOWN_SEL:
            pViewShell->ExpandBlockArea(0, 1);
        break;
        case SID_CURSORBLKUP_SEL:
            pViewShell->ExpandBlockArea(0, -1);
        break;
        case SID_CURSORBLKRIGHT_SEL:
            pViewShell->ExpandBlockArea(1, 0);
        break;
        case SID_CURSORBLKLEFT_SEL:
            pViewShell->ExpandBlockArea(-1, 0);
        break;
        default:
            ;
            return;
    }
    rReq.AppendItem( SfxInt16Item(FN_PARAM_1, nRepeat ) );
    rReq.AppendItem( SfxBoolItem(FN_PARAM_2, TRUE) );
    ExecuteSlot( rReq, GetInterface() );
}

void ScCellShell::ExecuteMove( SfxRequest& rReq )

        {
            // ADD mode: keep the selection, start a new block when marking with shift again
            bKeep = TRUE;
            pTabViewShell->SetNewStartIfMarking();
        }
    }


Lines 3960-3966 sal_Int8 ScGridWindow::DropTransferObj( ScTransferObj* pTransObj, SCCOL nDestPos Link Here

(-)sc/source/ui/view/gridwin.cxx (-3 / +6 lines)
3960	if ( bDone )	3960	if ( bDone )
3961	{	3961	{
3962	pView->MarkRange( aDest, FALSE, FALSE );	3962	pView->MarkRange( aDest, FALSE, FALSE );
3963	pView->SetCursor( aDest.aEnd.Col(), aDest.aEnd.Row() );	3963
		3964	SCCOL nDCol = pViewData->GetCurX() - aSource.aStart.Col();
		3965	SCROW nDRow = pViewData->GetCurY() - aSource.aStart.Row();
		3966	pView->SetCursor( aDest.aStart.Col() + nDCol, aDest.aStart.Row() + nDRow );
3964	}	3967	}
3965		3968
3966	pDocSh->GetUndoManager()->LeaveListAction();	3969	pDocSh->GetUndoManager()->LeaveListAction();
Lines 4068-4074 sal_Int8 ScGridWindow::DropTransferObj( ScTransferObj* pTransObj, SCCOL nDestPos Link Here
4068	pView->EnterMatrix( aFormula );	4071	pView->EnterMatrix( aFormula );
4069		4072
4070	pView->MarkRange( aDest, FALSE, FALSE );	4073	pView->MarkRange( aDest, FALSE, FALSE );
4071	pView->SetCursor( aDest.aEnd.Col(), aDest.aEnd.Row() );	4074	pView->SetCursor( aDest.aStart.Col(), aDest.aStart.Row() );
4072	}	4075	}
4073		4076
4074	pDocSh->GetUndoManager()->LeaveListAction();	4077	pDocSh->GetUndoManager()->LeaveListAction();
Lines 4102-4108 sal_Int8 ScGridWindow::DropTransferObj( ScTransferObj* pTransObj, SCCOL nDestPos Link Here
4102	if ( bDone )	4105	if ( bDone )
4103	{	4106	{
4104	pView->MarkRange( aDest, FALSE, FALSE );	4107	pView->MarkRange( aDest, FALSE, FALSE );
4105	pView->SetCursor( aDest.aEnd.Col(), aDest.aEnd.Row() );	4108	pView->SetCursor( aDest.aStart.Col(), aDest.aStart.Row() );
4106	}	4109	}
4107	}	4110	}
4108		4111

Lines 667-673 BOOL ScViewFunctionSet::SetCursorAtCell( SCsCOL nPosX, SCsROW nPosY, BOOL bScrol Link Here

(-)sc/source/ui/view/select.cxx (-1 / +4 lines)
667	}	667	}
668	}	668	}
669	if (bStarted)	669	if (bStarted)
		670	// If the selection is already started, don't set the cursor.
670	pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab, FALSE, FALSE, TRUE );	671	pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab, FALSE, FALSE, TRUE );
		672	else
		673	pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
671	}	674	}
672	else	675	else
673	{	676	{
Lines 703-711 BOOL ScViewFunctionSet::SetCursorAtCell( SCsCOL nPosX, SCsROW nPosY, BOOL bScrol Link Here
703		706
704	bStarted = TRUE;	707	bStarted = TRUE;
705	}	708	}
		709	pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
706	}	710	}
707		711
708	pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
709	pViewData->SetRefStart( nPosX, nPosY, nTab );	712	pViewData->SetRefStart( nPosX, nPosY, nTab );
710	if (bHideCur)	713	if (bHideCur)
711	pView->ShowAllCursors();	714	pView->ShowAllCursors();

Lines 384-390 BOOL lcl_HasRowOutline( const ScViewData& rViewData ) Link Here

(-)sc/source/ui/view/tabview.cxx (-1 lines)
384	bInActivatePart( FALSE ), \	384	bInActivatePart( FALSE ), \
385	bInZoomUpdate( FALSE ), \	385	bInZoomUpdate( FALSE ), \
386	bMoveIsShift( FALSE ), \	386	bMoveIsShift( FALSE ), \
387	bNewStartIfMarking( FALSE ), \
388	bOldSelection( FALSE )	387	bOldSelection( FALSE )
389		388
390		389




#include "waitoff.hxx"
#include "globstr.hrc"
#include "scmod.hxx"
#include "tabprotection.hxx"

#define SC_BLOCKMODE_NONE		0
#define SC_BLOCKMODE_NORMAL		1

        InvertBlockMark( nBlockStartX,nBlockStartY,nBlockEndX,nBlockEndY );
#endif
        UpdateSelectionOverlay();

        bNewStartIfMarking = FALSE;		// use only once
    }
}

void ScTabView::SetNewStartIfMarking()
{
    bNewStartIfMarking = TRUE;
}

void ScTabView::DoneBlockMode( BOOL bContinue )            // Default FALSE
{
    //	Wenn zwischen Tabellen- und Header SelectionEngine gewechselt wird,

        aHdrFunc.SetAnchorFlag( FALSE );
}

void ScTabView::GetPageMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, SCsCOL& rPageX, SCsROW& rPageY)
{
    SCCOL nCurX;
    SCROW nCurY;
    aViewData.GetMoveCursor( nCurX,nCurY );

    ScSplitPos eWhich = aViewData.GetActivePart();
    ScHSplitPos eWhichX = WhichH( eWhich );
    ScVSplitPos eWhichY = WhichV( eWhich );

    SCsCOL nPageX;
    SCsROW nPageY;
    if (nMovX >= 0)
        nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, 1, eWhichX )) * nMovX;
    else
        nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, -1, eWhichX )) * nMovX;

    if (nMovY >= 0)
        nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, 1, eWhichY )) * nMovY;
    else
        nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, -1, eWhichY )) * nMovY;

    if (nMovX != 0 && nPageX == 0) nPageX = (nMovX>0) ? 1 : -1;
    if (nMovY != 0 && nPageY == 0) nPageY = (nMovY>0) ? 1 : -1;

    rPageX = nPageX;
    rPageY = nPageY;
}

void ScTabView::GetAreaMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, 
                                       SCsCOL& rAreaX, SCsROW& rAreaY, ScFollowMode& rMode)
{
    SCCOL nNewX = -1;
    SCROW nNewY = -1;
    SCCOL nCurX = -1;
    SCROW nCurY = -1;

    if (aViewData.IsRefMode())
    {
        nNewX = aViewData.GetRefEndX();
        nNewY = aViewData.GetRefEndY();
    }
    else if (IsBlockMode())
    {
        nNewX = nBlockEndX;
        nNewY = nBlockEndY;
    }
    else
    {
        nNewX = nCurX = aViewData.GetCurX();
        nNewY = nCurY = aViewData.GetCurY();
    }

    ScDocument* pDoc = aViewData.GetDocument();
    SCTAB nTab = aViewData.GetTabNo();

    //  FindAreaPos kennt nur -1 oder 1 als Richtung

    SCsCOLROW i;
    if ( nMovX > 0 )
        for ( i=0; i<nMovX; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab,  1,  0 );
    if ( nMovX < 0 )
        for ( i=0; i<-nMovX; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab, -1,  0 );
    if ( nMovY > 0 )
        for ( i=0; i<nMovY; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab,  0,  1 );
    if ( nMovY < 0 )
        for ( i=0; i<-nMovY; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab,  0, -1 );

    if (eMode==SC_FOLLOW_JUMP)                  // unten/rechts nicht zuviel grau anzeigen
    {
        if (nMovX != 0 && nNewX == MAXCOL)
            eMode = SC_FOLLOW_LINE;
        if (nMovY != 0 && nNewY == MAXROW)
            eMode = SC_FOLLOW_LINE;
    }

    if (aViewData.IsRefMode())
    {
        rAreaX = nNewX - aViewData.GetRefEndX();
        rAreaY = nNewY - aViewData.GetRefEndY();
    }
    else if (IsBlockMode())
    {
        rAreaX = nNewX - nBlockEndX;
        rAreaY = nNewY - nBlockEndY;
    }
    else
    {
        rAreaX = nNewX - nCurX;
        rAreaY = nNewY - nCurY;
    }
    rMode = eMode;
}

namespace {

bool lcl_isCellQualified(ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, bool bSelectLocked, bool bSelectUnlocked)
{
    bool bCellProtected = pDoc->HasAttrib(
        nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_PROTECTED);

    if (bCellProtected && !bSelectLocked)
        return false;

    if (!bCellProtected && !bSelectUnlocked)
        return false;

    return true;
}

void lcl_moveCursorByProtRule(
    SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY, SCTAB nTab, ScDocument* pDoc)
{
    bool bSelectLocked = true;
    bool bSelectUnlocked = true;
    ScTableProtection* pTabProtection = pDoc->GetTabProtection(nTab);
    if (pTabProtection && pTabProtection->isProtected())
    {
        bSelectLocked   = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
        bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
    }

    if (nMovX > 0)
    {
        if (rCol < MAXCOL)
        {
            for (SCCOL i = 0; i < nMovX; ++i)
            {
                if (!lcl_isCellQualified(pDoc, rCol+1, rRow, nTab, bSelectLocked, bSelectUnlocked))
                    break;
                ++rCol;
            }
        }
    }
    else if (nMovX < 0)
    {
        if (rCol > 0)
        {
            nMovX = -nMovX;
            for (SCCOL i = 0; i < nMovX; ++i)
            {
                if (!lcl_isCellQualified(pDoc, rCol-1, rRow, nTab, bSelectLocked, bSelectUnlocked))
                    break;
                --rCol;
            }
        }
    }

    if (nMovY > 0)
    {
        if (rRow < MAXROW)
        {
            for (SCROW i = 0; i < nMovY; ++i)
            {
                if (!lcl_isCellQualified(pDoc, rCol, rRow+1, nTab, bSelectLocked, bSelectUnlocked))
                    break;
                ++rRow;
            }
        }
    }
    else if (nMovY < 0)
    {
        if (rRow > 0)
        {
            nMovY = -nMovY;
            for (SCROW i = 0; i < nMovY; ++i)
            {
                if (!lcl_isCellQualified(pDoc, rCol, rRow-1, nTab, bSelectLocked, bSelectUnlocked))
                    break;
                --rRow;
            }
        }
    }
}

}

void ScTabView::ExpandBlock(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode)
{
    if (!nMovX && !nMovY)
        // Nothing to do.  Bail out.
        return;

    ScTabViewShell* pViewShell = aViewData.GetViewShell();
    bool bRefInputMode = pViewShell && pViewShell->IsRefInputMode();
    if (bRefInputMode && !aViewData.IsRefMode())
        // initialize formula reference mode if it hasn't already.
        InitRefMode(aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo(), SC_REFTYPE_REF);

    ScDocument* pDoc = aViewData.GetDocument();

    if (aViewData.IsRefMode())
    {
        // formula reference mode

        SCCOL nNewX = aViewData.GetRefEndX();
        SCROW nNewY = aViewData.GetRefEndY();
        SCTAB nRefTab = aViewData.GetRefEndZ();

        bool bSelectLocked = true;
        bool bSelectUnlocked = true;
        ScTableProtection* pTabProtection = pDoc->GetTabProtection(nRefTab);
        if (pTabProtection && pTabProtection->isProtected())
        {
            bSelectLocked   = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
            bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
        }

        lcl_moveCursorByProtRule(nNewX, nNewY, nMovX, nMovY, nRefTab, pDoc);

        if (nMovX)
        {
            SCCOL nTempX = nNewX;
            while (pDoc->IsHorOverlapped(nTempX, nNewY, nRefTab))
            {
                if (nMovX > 0)
                    ++nTempX;
                else
                    --nTempX;
            }
            if (lcl_isCellQualified(pDoc, nTempX, nNewY, nRefTab, bSelectLocked, bSelectUnlocked))
                nNewX = nTempX;
        }

        if (nMovY)
        {
            SCROW nTempY = nNewY;
            while (pDoc->IsVerOverlapped(nNewX, nTempY, nRefTab))
            {
                if (nMovY > 0)
                    ++nTempY;
                else
                    --nTempY;
            }
            if (lcl_isCellQualified(pDoc, nNewX, nTempY, nRefTab, bSelectLocked, bSelectUnlocked))
                nNewY = nTempY;
        }

        pDoc->SkipOverlapped(nNewX, nNewY, nRefTab);
        UpdateRef(nNewX, nNewY, nRefTab);
        AlignToCursor(nNewX, nNewY, eMode);
    }
    else
    {
        // normal selection mode

        SCTAB nTab = aViewData.GetTabNo();

        if (!IsBlockMode())
            InitBlockMode(aViewData.GetCurX(), aViewData.GetCurY(), nTab, true);

        lcl_moveCursorByProtRule(nBlockEndX, nBlockEndY, nMovX, nMovY, nTab, pDoc);
    
        if (nBlockEndX < 0)
            nBlockEndX = 0;
        else if (nBlockEndX > MAXCOL) 
            nBlockEndX = MAXCOL;
    
        if (nBlockEndY < 0)
            nBlockEndY = 0;
        else if (nBlockEndY > MAXROW)
            nBlockEndY = MAXROW;
    
        pDoc->SkipOverlapped(nBlockEndX, nBlockEndY, nTab);
        MarkCursor(nBlockEndX, nBlockEndY, nTab, false, false, true);
        AlignToCursor(nBlockEndX, nBlockEndY, eMode);
    }
}

void ScTabView::ExpandBlockPage(SCsCOL nMovX, SCsROW nMovY)
{
    SCsCOL nPageX;
    SCsROW nPageY;
    GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
    ExpandBlock(nPageX, nPageY, SC_FOLLOW_FIX);
}

void ScTabView::ExpandBlockArea(SCsCOL nMovX, SCsROW nMovY)
{
    SCsCOL nAreaX;
    SCsROW nAreaY;
    ScFollowMode eMode;
    GetAreaMoveEndPosition(nMovX, nMovY, SC_FOLLOW_JUMP, nAreaX, nAreaY, eMode);
    ExpandBlock(nAreaX, nAreaY, eMode);
}

void ScTabView::UpdateSelectionOverlay()
{
    for (USHORT i=0; i<4; i++)




{
    ScDocument* pDoc = aViewData.GetDocument();
    SCTAB nTab = aViewData.GetTabNo();
	pDoc->SkipOverlapped(nPosX, nPosY, nTab);
        --nPosX;
    while (pDoc->IsVerOverlapped( nPosX, nPosY, nTab ))
        --nPosY;

    BOOL bRefMode = SC_MOD()->IsFormulaMode();



    HideAllCursors();

    if ( bShift && bNewStartIfMarking && IsBlockMode() )
    {
        //	used for ADD selection mode: start a new block from the cursor position
        DoneBlockMode( TRUE );
        InitBlockMode( aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo(), TRUE );
    }

        //	aktiven Teil umschalten jetzt in AlignToCursor

    AlignToCursor( nCurX, nCurY, eMode );
    //!		auf OS/2: SC_FOLLOW_JUMP statt SC_FOLLOW_LINE, um Nachlaufen zu verhindern ???

    if (bKeepSel)
    {    
        SetCursor( nCurX, nCurY );		// Markierung stehenlassen

        // If the cursor is in existing selection, it's a cursor movement by 
        // ENTER or TAB.  If not, then it's a new selection during ADD
        // selection mode.

        const ScMarkData& rMark = aViewData.GetMarkData();
        ScRangeList aSelList;
        rMark.FillRangeListWithMarks(&aSelList, false);
        if (!aSelList.In(ScRange(nCurX, nCurY, aViewData.GetTabNo())))
            // Cursor not in existing selection.  Start a new selection.
            DoneBlockMode(true);
    }
    else
    {
        if (!bShift)
        {
            // Remove all marked data on cursor movement unless the Shift is locked.
            ScMarkData aData(aViewData.GetMarkData());
            aData.ResetMark();
            SetMarkData(aData);
        }

        BOOL bSame = ( nCurX == aViewData.GetCurX() && nCurY == aViewData.GetCurY() );
        bMoveIsShift = bShift;
        pSelEngine->CursorPosChanging( bShift, bControl );


void ScTabView::MoveCursorPage( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )
{
    SCCOL nCurX;
    SCROW nCurY;
    aViewData.GetMoveCursor( nCurX,nCurY );

    ScSplitPos eWhich = aViewData.GetActivePart();
    ScHSplitPos eWhichX = WhichH( eWhich );
    ScVSplitPos eWhichY = WhichV( eWhich );

    SCsCOL nPageX;
    SCsROW nPageY;
    GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
        nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, 1, eWhichX )) * nMovX;
    else
        nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, -1, eWhichX )) * nMovX;

    if (nMovY >= 0)
        nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, 1, eWhichY )) * nMovY;
    else
        nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, -1, eWhichY )) * nMovY;

    if (nMovX != 0 && nPageX == 0) nPageX = (nMovX>0) ? 1 : -1;
    if (nMovY != 0 && nPageY == 0) nPageY = (nMovY>0) ? 1 : -1;

    MoveCursorRel( nPageX, nPageY, eMode, bShift, bKeepSel );
}

void ScTabView::MoveCursorArea( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )
{
    SCsCOL nNewX;
    SCsROW nNewY;
    GetAreaMoveEndPosition(nMovX, nMovY, eMode, nNewX, nNewY, eMode);
    MoveCursorRel(nNewX, nNewY, eMode, bShift, bKeepSel);
    SCROW nNewY = nCurY;

    ScDocument* pDoc = aViewData.GetDocument();
    SCTAB nTab = aViewData.GetTabNo();

    //	FindAreaPos kennt nur -1 oder 1 als Richtung

    SCsCOLROW i;
    if ( nMovX > 0 )
        for ( i=0; i<nMovX; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab,  1,  0 );
    if ( nMovX < 0 )
        for ( i=0; i<-nMovX; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab, -1,  0 );
    if ( nMovY > 0 )
        for ( i=0; i<nMovY; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab,  0,  1 );
    if ( nMovY < 0 )
        for ( i=0; i<-nMovY; i++ )
            pDoc->FindAreaPos( nNewX, nNewY, nTab,  0, -1 );

    if (eMode==SC_FOLLOW_JUMP)					// unten/rechts nicht zuviel grau anzeigen
    {
        if (nMovX != 0 && nNewX == MAXCOL)
            eMode = SC_FOLLOW_LINE;
        if (nMovY != 0 && nNewY == MAXROW)
            eMode = SC_FOLLOW_LINE;
    }

    MoveCursorRel( ((SCsCOL)nNewX)-(SCsCOL)nCurX, ((SCsROW)nNewY)-(SCsROW)nCurY, eMode, bShift, bKeepSel );
}

void ScTabView::MoveCursorEnd( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )

    else if (nMovY>0)
        nNewY=nPosY+nAddY;

//	aViewData.ResetOldCursor();
    aViewData.SetOldCursor( nNewX,nNewY );
	pDoc->SkipOverlapped(nNewX, nNewY, nTab);
    while (pDoc->IsHorOverlapped( nNewX, nNewY, nTab ))
        --nNewX;
    while (pDoc->IsVerOverlapped( nNewX, nNewY, nTab ))
        --nNewY;

    MoveCursorAbs( nNewX, nNewY, eMode, bShift, FALSE, TRUE );
}


        SCCOL nPosX = rRange.aStart.Col();
        SCROW nPosY = rRange.aStart.Row();
        ScDocument* pDoc = aViewData.GetDocument();
		pDoc->SkipOverlapped(nPosX, nPosY, nTab);
        while (pDoc->IsHorOverlapped( nPosX, nPosY, nTab ))		//! ViewData !!!
            --nPosX;
        while (pDoc->IsVerOverlapped( nPosX, nPosY, nTab ))
            --nPosY;

        aViewData.ResetOldCursor();
        SetCursor( nPosX, nPosY );

Lines 396-405 void ScTabViewShell::Execute( SfxRequest& rReq ) Link Here

(-)sc/source/ui/view/tabvwsh3.cxx (-4 / +1 lines)
396	// und Cursor setzen	396	// und Cursor setzen
397		397
398	// zusammengefasste Zellen beruecksichtigen:	398	// zusammengefasste Zellen beruecksichtigen:
399	while ( pDoc->IsHorOverlapped( nCol, nRow, nTab ) ) //! ViewData !!!	399	pDoc->SkipOverlapped(nCol, nRow, nTab);
400	--nCol;
401	while ( pDoc->IsVerOverlapped( nCol, nRow, nTab ) )
402	--nRow;
403		400
404	// Navigator-Aufrufe sind nicht API!!!	401	// Navigator-Aufrufe sind nicht API!!!
405		402




    {
        //!	public Methode um Position anzupassen

        SCCOL nOrigX = rPosX;
        SCROW nOrigY = rPosY;
        pDoc->SkipOverlapped(rPosX, rPosY, nTabNo);
        bool bHOver = (nOrigX != rPosX);
        bool bVOver = (nOrigY != rPosY);
            { --rPosY; bVOver=TRUE; }

        if ( bRepair && ( bHOver || bVOver ) )
        {

Return to issue 102151

Lines 179-185 private: Link Here

(-)sc/source/ui/inc/tabview.hxx (-3 / +8 lines)
179	BOOL bInActivatePart;	179	BOOL bInActivatePart;
180	BOOL bInZoomUpdate;	180	BOOL bInZoomUpdate;
181	BOOL bMoveIsShift;	181	BOOL bMoveIsShift;
182	BOOL bNewStartIfMarking;
183		182
184	BOOL bOldSelection; // old style (inverting) of selection	183	BOOL bOldSelection; // old style (inverting) of selection
185		184
Lines 203-208 private: Link Here
203	static void SetScrollBar( ScrollBar& rScroll, long nRangeMax, long nVisible, long nPos, BOOL bLayoutRTL );	202	static void SetScrollBar( ScrollBar& rScroll, long nRangeMax, long nVisible, long nPos, BOOL bLayoutRTL );
204	static long GetScrollBarPos( ScrollBar& rScroll, BOOL bLayoutRTL );	203	static long GetScrollBarPos( ScrollBar& rScroll, BOOL bLayoutRTL );
205		204
		205	void GetPageMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, SCsCOL& rPageX, SCsROW& rPageY);
		206	void GetAreaMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode,
		207	SCsCOL& rAreaX, SCsROW& rAreaY, ScFollowMode& rMode);
		208
206	protected:	209	protected:
207	void UpdateHeaderWidth( const ScVSplitPos* pWhich = NULL,	210	void UpdateHeaderWidth( const ScVSplitPos* pWhich = NULL,
208	const SCROW* pPosY = NULL );	211	const SCROW* pPosY = NULL );
Lines 391-398 public: Link Here
391		394
392	void FindNextUnprot( BOOL bShift, BOOL bInSelection = TRUE );	395	void FindNextUnprot( BOOL bShift, BOOL bInSelection = TRUE );
393		396
394	void SetNewStartIfMarking();
395
396	void SetTabNo( SCTAB nTab, BOOL bNew = FALSE, BOOL bExtendSelection = FALSE );	397	void SetTabNo( SCTAB nTab, BOOL bNew = FALSE, BOOL bExtendSelection = FALSE );
397	void SelectNextTab( short nDir, BOOL bExtendSelection = FALSE );	398	void SelectNextTab( short nDir, BOOL bExtendSelection = FALSE );
398		399
Lines 483-488 public: Link Here
483		484
484	BOOL IsBlockMode() const { return bIsBlockMode; }	485	BOOL IsBlockMode() const { return bIsBlockMode; }
485		486
		487	void ExpandBlock(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode);
		488	void ExpandBlockPage(SCsCOL nMovX, SCsROW nMovY);
		489	void ExpandBlockArea(SCsCOL nMovX, SCsROW nMovY);
		490
486	void MarkColumns();	491	void MarkColumns();
487	void MarkRows();	492	void MarkRows();
488	void MarkDataArea( BOOL bIncludeCursor = TRUE );	493	void MarkDataArea( BOOL bIncludeCursor = TRUE );

Lines 88-97 void ScCellShell::ExecuteCursor( SfxRequest& rReq ) Link Here

(-)sc/source/ui/view/cellsh4.cxx (-30 / +87 lines)
88	{	88	{
89	// ADD mode: keep the selection, start a new block when marking with shift again	89	// ADD mode: keep the selection, start a new block when marking with shift again
90	bKeep = TRUE;	90	bKeep = TRUE;
91	pTabViewShell->SetNewStartIfMarking();
92	}	91	}
93	}	92	}
94		93
		94	if (bSel)
		95	{
		96	switch (nSlotId)
		97	{
		98	case SID_CURSORDOWN:
		99	rReq.SetSlot(SID_CURSORDOWN_SEL);
		100	break;
		101	case SID_CURSORUP:
		102	rReq.SetSlot(SID_CURSORUP_SEL);
		103	break;
		104	case SID_CURSORRIGHT:
		105	rReq.SetSlot(SID_CURSORRIGHT_SEL);
		106	break;
		107	case SID_CURSORLEFT:
		108	rReq.SetSlot(SID_CURSORLEFT_SEL);
		109	break;
		110	case SID_CURSORPAGEDOWN:
		111	rReq.SetSlot(SID_CURSORPAGEDOWN_SEL);
		112	break;
		113	case SID_CURSORPAGEUP:
		114	rReq.SetSlot(SID_CURSORPAGEUP_SEL);
		115	break;
		116	case SID_CURSORPAGERIGHT:
		117	rReq.SetSlot(SID_CURSORPAGERIGHT_SEL);
		118	break;
		119	case SID_CURSORPAGELEFT:
		120	rReq.SetSlot(SID_CURSORPAGELEFT_SEL);
		121	break;
		122	case SID_CURSORBLKDOWN:
		123	rReq.SetSlot(SID_CURSORBLKDOWN_SEL);
		124	break;
		125	case SID_CURSORBLKUP:
		126	rReq.SetSlot(SID_CURSORBLKUP_SEL);
		127	break;
		128	case SID_CURSORBLKRIGHT:
		129	rReq.SetSlot(SID_CURSORBLKRIGHT_SEL);
		130	break;
		131	case SID_CURSORBLKLEFT:
		132	rReq.SetSlot(SID_CURSORBLKLEFT_SEL);
		133	break;
		134	default:
		135	;
		136	}
		137	ExecuteCursorSel(rReq);
		138	return;
		139	}
		140
95	SCsCOLROW nRTLSign = 1;	141	SCsCOLROW nRTLSign = 1;
96	if ( pData->GetDocument()->IsLayoutRTL( pData->GetTabNo() ) )	142	if ( pData->GetDocument()->IsLayoutRTL( pData->GetTabNo() ) )
97	{	143	{
Lines 172-209 void ScCellShell::GetStateCursor( SfxItemSet& /* rSet */ ) Link Here
172		218
173	void ScCellShell::ExecuteCursorSel( SfxRequest& rReq )	219	void ScCellShell::ExecuteCursorSel( SfxRequest& rReq )
174	{	220	{
175	const SfxItemSet* pReqArgs = rReq.GetArgs();	221	sal_uInt16 nSlotId = rReq.GetSlot();
176	USHORT nSlotId = rReq.GetSlot();	222	ScTabViewShell* pViewShell = GetViewData()->GetViewShell();
177	short nRepeat = 1;
178
179	if ( pReqArgs != NULL )
180	{
181	const SfxPoolItem* pItem;
182	if( IS_AVAILABLE( FN_PARAM_1, &pItem ) )
183	nRepeat = ((const SfxInt16Item*)pItem)->GetValue();
184	}
185		223
186	switch ( nSlotId )	224	switch (nSlotId)
187	{	225	{
188	case SID_CURSORDOWN_SEL: rReq.SetSlot( SID_CURSORDOWN ); break;	226	case SID_CURSORDOWN_SEL:
189	case SID_CURSORBLKDOWN_SEL: rReq.SetSlot( SID_CURSORBLKDOWN ); break;	227	pViewShell->ExpandBlock(0, 1, SC_FOLLOW_LINE);
190	case SID_CURSORUP_SEL: rReq.SetSlot( SID_CURSORUP ); break;	228	break;
191	case SID_CURSORBLKUP_SEL: rReq.SetSlot( SID_CURSORBLKUP ); break;	229	case SID_CURSORUP_SEL:
192	case SID_CURSORLEFT_SEL: rReq.SetSlot( SID_CURSORLEFT ); break;	230	pViewShell->ExpandBlock(0, -1, SC_FOLLOW_LINE);
193	case SID_CURSORBLKLEFT_SEL: rReq.SetSlot( SID_CURSORBLKLEFT ); break;	231	break;
194	case SID_CURSORRIGHT_SEL: rReq.SetSlot( SID_CURSORRIGHT ); break;	232	case SID_CURSORRIGHT_SEL:
195	case SID_CURSORBLKRIGHT_SEL: rReq.SetSlot( SID_CURSORBLKRIGHT ); break;	233	pViewShell->ExpandBlock(1, 0, SC_FOLLOW_LINE);
196	case SID_CURSORPAGEDOWN_SEL: rReq.SetSlot( SID_CURSORPAGEDOWN ); break;	234	break;
197	case SID_CURSORPAGEUP_SEL: rReq.SetSlot( SID_CURSORPAGEUP ); break;	235	case SID_CURSORLEFT_SEL:
198	case SID_CURSORPAGERIGHT_SEL: rReq.SetSlot( SID_CURSORPAGERIGHT_ ); break;	236	pViewShell->ExpandBlock(-1, 0, SC_FOLLOW_LINE);
199	case SID_CURSORPAGELEFT_SEL: rReq.SetSlot( SID_CURSORPAGELEFT_ ); break;	237	break;
		238	case SID_CURSORPAGEUP_SEL:
		239	pViewShell->ExpandBlockPage(0, -1);
		240	break;
		241	case SID_CURSORPAGEDOWN_SEL:
		242	pViewShell->ExpandBlockPage(0, 1);
		243	break;
		244	case SID_CURSORPAGERIGHT_SEL:
		245	pViewShell->ExpandBlockPage(1, 0);
		246	break;
		247	case SID_CURSORPAGELEFT_SEL:
		248	pViewShell->ExpandBlockPage(-1, 0);
		249	break;
		250	case SID_CURSORBLKDOWN_SEL:
		251	pViewShell->ExpandBlockArea(0, 1);
		252	break;
		253	case SID_CURSORBLKUP_SEL:
		254	pViewShell->ExpandBlockArea(0, -1);
		255	break;
		256	case SID_CURSORBLKRIGHT_SEL:
		257	pViewShell->ExpandBlockArea(1, 0);
		258	break;
		259	case SID_CURSORBLKLEFT_SEL:
		260	pViewShell->ExpandBlockArea(-1, 0);
		261	break;
200	default:	262	default:
201	DBG_ERROR("Unbekannte Message bei ViewShell (CursorSel)");	263	;
202	return;
203	}	264	}
204	rReq.AppendItem( SfxInt16Item(FN_PARAM_1, nRepeat ) );
205	rReq.AppendItem( SfxBoolItem(FN_PARAM_2, TRUE) );
206	ExecuteSlot( rReq, GetInterface() );
207	}	265	}
208		266
209	void ScCellShell::ExecuteMove( SfxRequest& rReq )	267	void ScCellShell::ExecuteMove( SfxRequest& rReq )
Lines 348-354 void ScCellShell::ExecutePage( SfxRequest& rReq ) Link Here
348	{	406	{
349	// ADD mode: keep the selection, start a new block when marking with shift again	407	// ADD mode: keep the selection, start a new block when marking with shift again
350	bKeep = TRUE;	408	bKeep = TRUE;
351	pTabViewShell->SetNewStartIfMarking();
352	}	409	}
353	}	410	}
354		411

Lines 125-134 void ScTabView::ClickCursor( SCCOL nPosX, SCROW nPosY, BOOL bControl ) Link Here

(-)sc/source/ui/view/tabview3.cxx (-78 / +29 lines)
125	{	125	{
126	ScDocument* pDoc = aViewData.GetDocument();	126	ScDocument* pDoc = aViewData.GetDocument();
127	SCTAB nTab = aViewData.GetTabNo();	127	SCTAB nTab = aViewData.GetTabNo();
128	while (pDoc->IsHorOverlapped( nPosX, nPosY, nTab )) //! ViewData !!!	128	pDoc->SkipOverlapped(nPosX, nPosY, nTab);
129	--nPosX;
130	while (pDoc->IsVerOverlapped( nPosX, nPosY, nTab ))
131	--nPosY;
132		129
133	BOOL bRefMode = SC_MOD()->IsFormulaMode();	130	BOOL bRefMode = SC_MOD()->IsFormulaMode();
134		131
Lines 921-942 void ScTabView::MoveCursorAbs( SCsCOL nCurX, SCsROW nCurY, ScFollowMode eMode, Link Here
921		918
922	HideAllCursors();	919	HideAllCursors();
923		920
924	if ( bShift && bNewStartIfMarking && IsBlockMode() )
925	{
926	// used for ADD selection mode: start a new block from the cursor position
927	DoneBlockMode( TRUE );
928	InitBlockMode( aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo(), TRUE );
929	}
930
931	// aktiven Teil umschalten jetzt in AlignToCursor	921	// aktiven Teil umschalten jetzt in AlignToCursor
932		922
933	AlignToCursor( nCurX, nCurY, eMode );	923	AlignToCursor( nCurX, nCurY, eMode );
934	//! auf OS/2: SC_FOLLOW_JUMP statt SC_FOLLOW_LINE, um Nachlaufen zu verhindern ???	924	//! auf OS/2: SC_FOLLOW_JUMP statt SC_FOLLOW_LINE, um Nachlaufen zu verhindern ???
935		925
936	if (bKeepSel)	926	if (bKeepSel)
		927	{
937	SetCursor( nCurX, nCurY ); // Markierung stehenlassen	928	SetCursor( nCurX, nCurY ); // Markierung stehenlassen
		929
		930	// If the cursor is in existing selection, it's a cursor movement by
		931	// ENTER or TAB. If not, then it's a new selection during ADD
		932	// selection mode.
		933
		934	const ScMarkData& rMark = aViewData.GetMarkData();
		935	ScRangeList aSelList;
		936	rMark.FillRangeListWithMarks(&aSelList, false);
		937	if (!aSelList.In(ScRange(nCurX, nCurY, aViewData.GetTabNo())))
		938	// Cursor not in existing selection. Start a new selection.
		939	DoneBlockMode(true);
		940	}
938	else	941	else
939	{	942	{
		943	if (!bShift)
		944	{
		945	// Remove all marked data on cursor movement unless the Shift is locked.
		946	ScMarkData aData(aViewData.GetMarkData());
		947	aData.ResetMark();
		948	SetMarkData(aData);
		949	}
		950
940	BOOL bSame = ( nCurX == aViewData.GetCurX() && nCurY == aViewData.GetCurY() );	951	BOOL bSame = ( nCurX == aViewData.GetCurX() && nCurY == aViewData.GetCurY() );
941	bMoveIsShift = bShift;	952	bMoveIsShift = bShift;
942	pSelEngine->CursorPosChanging( bShift, bControl );	953	pSelEngine->CursorPosChanging( bShift, bControl );
Lines 1080-1147 void ScTabView::MoveCursorRel( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, Link Here
1080		1091
1081	void ScTabView::MoveCursorPage( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )	1092	void ScTabView::MoveCursorPage( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )
1082	{	1093	{
1083	SCCOL nCurX;
1084	SCROW nCurY;
1085	aViewData.GetMoveCursor( nCurX,nCurY );
1086
1087	ScSplitPos eWhich = aViewData.GetActivePart();
1088	ScHSplitPos eWhichX = WhichH( eWhich );
1089	ScVSplitPos eWhichY = WhichV( eWhich );
1090
1091	SCsCOL nPageX;	1094	SCsCOL nPageX;
1092	SCsROW nPageY;	1095	SCsROW nPageY;
1093	if (nMovX >= 0)	1096	GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
1094	nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, 1, eWhichX )) * nMovX;
1095	else
1096	nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, -1, eWhichX )) * nMovX;
1097
1098	if (nMovY >= 0)
1099	nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, 1, eWhichY )) * nMovY;
1100	else
1101	nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, -1, eWhichY )) * nMovY;
1102
1103	if (nMovX != 0 && nPageX == 0) nPageX = (nMovX>0) ? 1 : -1;
1104	if (nMovY != 0 && nPageY == 0) nPageY = (nMovY>0) ? 1 : -1;
1105
1106	MoveCursorRel( nPageX, nPageY, eMode, bShift, bKeepSel );	1097	MoveCursorRel( nPageX, nPageY, eMode, bShift, bKeepSel );
1107	}	1098	}
1108		1099
1109	void ScTabView::MoveCursorArea( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )	1100	void ScTabView::MoveCursorArea( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )
1110	{	1101	{
1111	SCCOL nCurX;	1102	SCsCOL nNewX;
1112	SCROW nCurY;	1103	SCsROW nNewY;
1113	aViewData.GetMoveCursor( nCurX,nCurY );	1104	GetAreaMoveEndPosition(nMovX, nMovY, eMode, nNewX, nNewY, eMode);
1114	SCCOL nNewX = nCurX;	1105	MoveCursorRel(nNewX, nNewY, eMode, bShift, bKeepSel);
1115	SCROW nNewY = nCurY;
1116
1117	ScDocument* pDoc = aViewData.GetDocument();
1118	SCTAB nTab = aViewData.GetTabNo();
1119
1120	// FindAreaPos kennt nur -1 oder 1 als Richtung
1121
1122	SCsCOLROW i;
1123	if ( nMovX > 0 )
1124	for ( i=0; i<nMovX; i++ )
1125	pDoc->FindAreaPos( nNewX, nNewY, nTab, 1, 0 );
1126	if ( nMovX < 0 )
1127	for ( i=0; i<-nMovX; i++ )
1128	pDoc->FindAreaPos( nNewX, nNewY, nTab, -1, 0 );
1129	if ( nMovY > 0 )
1130	for ( i=0; i<nMovY; i++ )
1131	pDoc->FindAreaPos( nNewX, nNewY, nTab, 0, 1 );
1132	if ( nMovY < 0 )
1133	for ( i=0; i<-nMovY; i++ )
1134	pDoc->FindAreaPos( nNewX, nNewY, nTab, 0, -1 );
1135
1136	if (eMode==SC_FOLLOW_JUMP) // unten/rechts nicht zuviel grau anzeigen
1137	{
1138	if (nMovX != 0 && nNewX == MAXCOL)
1139	eMode = SC_FOLLOW_LINE;
1140	if (nMovY != 0 && nNewY == MAXROW)
1141	eMode = SC_FOLLOW_LINE;
1142	}
1143
1144	MoveCursorRel( ((SCsCOL)nNewX)-(SCsCOL)nCurX, ((SCsROW)nNewY)-(SCsROW)nCurY, eMode, bShift, bKeepSel );
1145	}	1106	}
1146		1107
1147	void ScTabView::MoveCursorEnd( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )	1108	void ScTabView::MoveCursorEnd( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, BOOL bShift, BOOL bKeepSel )
Lines 1206-1219 void ScTabView::MoveCursorScreen( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode Link Here
1206	else if (nMovY>0)	1167	else if (nMovY>0)
1207	nNewY=nPosY+nAddY;	1168	nNewY=nPosY+nAddY;
1208		1169
1209	// aViewData.ResetOldCursor();
1210	aViewData.SetOldCursor( nNewX,nNewY );	1170	aViewData.SetOldCursor( nNewX,nNewY );
1211		1171	pDoc->SkipOverlapped(nNewX, nNewY, nTab);
1212	while (pDoc->IsHorOverlapped( nNewX, nNewY, nTab ))
1213	--nNewX;
1214	while (pDoc->IsVerOverlapped( nNewX, nNewY, nTab ))
1215	--nNewY;
1216
1217	MoveCursorAbs( nNewX, nNewY, eMode, bShift, FALSE, TRUE );	1172	MoveCursorAbs( nNewX, nNewY, eMode, bShift, FALSE, TRUE );
1218	}	1173	}
1219		1174
Lines 1497-1507 void ScTabView::MarkRange( const ScRange& rRange, BOOL bSetCursor, BOOL bContinu Link Here
1497	SCCOL nPosX = rRange.aStart.Col();	1452	SCCOL nPosX = rRange.aStart.Col();
1498	SCROW nPosY = rRange.aStart.Row();	1453	SCROW nPosY = rRange.aStart.Row();
1499	ScDocument* pDoc = aViewData.GetDocument();	1454	ScDocument* pDoc = aViewData.GetDocument();
1500		1455	pDoc->SkipOverlapped(nPosX, nPosY, nTab);
1501	while (pDoc->IsHorOverlapped( nPosX, nPosY, nTab )) //! ViewData !!!
1502	--nPosX;
1503	while (pDoc->IsVerOverlapped( nPosX, nPosY, nTab ))
1504	--nPosY;
1505		1456
1506	aViewData.ResetOldCursor();	1457	aViewData.ResetOldCursor();
1507	SetCursor( nPosX, nPosY );	1458	SetCursor( nPosX, nPosY );

Lines 1891-1902 BOOL ScViewData::GetPosFromPixel( long nClickX, long nClickY, ScSplitPos eWhich, Link Here

(-)sc/source/ui/view/viewdata.cxx (-6 / +5 lines)
1891	{	1891	{
1892	//! public Methode um Position anzupassen	1892	//! public Methode um Position anzupassen
1893		1893
1894	BOOL bHOver = FALSE;	1894	SCCOL nOrigX = rPosX;
1895	while (pDoc->IsHorOverlapped( rPosX, rPosY, nTabNo ))	1895	SCROW nOrigY = rPosY;
1896	{ --rPosX; bHOver=TRUE; }	1896	pDoc->SkipOverlapped(rPosX, rPosY, nTabNo);
1897	BOOL bVOver = FALSE;	1897	bool bHOver = (nOrigX != rPosX);
1898	while (pDoc->IsVerOverlapped( rPosX, rPosY, nTabNo ))	1898	bool bVOver = (nOrigY != rPosY);
1899	{ --rPosY; bVOver=TRUE; }
1900		1899
1901	if ( bRepair && ( bHOver \|\| bVOver ) )	1900	if ( bRepair && ( bHOver \|\| bVOver ) )
1902	{	1901	{

Lines 62-67 Link Here

(-)sc/source/ui/view/tabview2.cxx (-7 / +291 lines)
62	#include "waitoff.hxx"	62	#include "waitoff.hxx"
63	#include "globstr.hrc"	63	#include "globstr.hrc"
64	#include "scmod.hxx"	64	#include "scmod.hxx"
		65	#include "tabprotection.hxx"
65		66
66	#define SC_BLOCKMODE_NONE 0	67	#define SC_BLOCKMODE_NONE 0
67	#define SC_BLOCKMODE_NORMAL 1	68	#define SC_BLOCKMODE_NORMAL 1
Lines 178-193 void ScTabView::InitBlockMode( SCCOL nCurX, SCROW nCurY, SCTAB nCurZ, Link Here
178	InvertBlockMark( nBlockStartX,nBlockStartY,nBlockEndX,nBlockEndY );	179	InvertBlockMark( nBlockStartX,nBlockStartY,nBlockEndX,nBlockEndY );
179	#endif	180	#endif
180	UpdateSelectionOverlay();	181	UpdateSelectionOverlay();
181
182	bNewStartIfMarking = FALSE; // use only once
183	}	182	}
184	}	183	}
185		184
186	void ScTabView::SetNewStartIfMarking()
187	{
188	bNewStartIfMarking = TRUE;
189	}
190
191	void ScTabView::DoneBlockMode( BOOL bContinue ) // Default FALSE	185	void ScTabView::DoneBlockMode( BOOL bContinue ) // Default FALSE
192	{	186	{
193	// Wenn zwischen Tabellen- und Header SelectionEngine gewechselt wird,	187	// Wenn zwischen Tabellen- und Header SelectionEngine gewechselt wird,
Lines 414-419 void ScTabView::MarkCursor( SCCOL nCurX, SCROW nCurY, SCTAB nCurZ, Link Here
414	aHdrFunc.SetAnchorFlag( FALSE );	408	aHdrFunc.SetAnchorFlag( FALSE );
415	}	409	}
416		410
		411	void ScTabView::GetPageMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, SCsCOL& rPageX, SCsROW& rPageY)
		412	{
		413	SCCOL nCurX;
		414	SCROW nCurY;
		415	aViewData.GetMoveCursor( nCurX,nCurY );
		416
		417	ScSplitPos eWhich = aViewData.GetActivePart();
		418	ScHSplitPos eWhichX = WhichH( eWhich );
		419	ScVSplitPos eWhichY = WhichV( eWhich );
		420
		421	SCsCOL nPageX;
		422	SCsROW nPageY;
		423	if (nMovX >= 0)
		424	nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, 1, eWhichX )) * nMovX;
		425	else
		426	nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, -1, eWhichX )) * nMovX;
		427
		428	if (nMovY >= 0)
		429	nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, 1, eWhichY )) * nMovY;
		430	else
		431	nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, -1, eWhichY )) * nMovY;
		432
		433	if (nMovX != 0 && nPageX == 0) nPageX = (nMovX>0) ? 1 : -1;
		434	if (nMovY != 0 && nPageY == 0) nPageY = (nMovY>0) ? 1 : -1;
		435
		436	rPageX = nPageX;
		437	rPageY = nPageY;
		438	}
		439
		440	void ScTabView::GetAreaMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode,
		441	SCsCOL& rAreaX, SCsROW& rAreaY, ScFollowMode& rMode)
		442	{
		443	SCCOL nNewX = -1;
		444	SCROW nNewY = -1;
		445	SCCOL nCurX = -1;
		446	SCROW nCurY = -1;
		447
		448	if (aViewData.IsRefMode())
		449	{
		450	nNewX = aViewData.GetRefEndX();
		451	nNewY = aViewData.GetRefEndY();
		452	}
		453	else if (IsBlockMode())
		454	{
		455	nNewX = nBlockEndX;
		456	nNewY = nBlockEndY;
		457	}
		458	else
		459	{
		460	nNewX = nCurX = aViewData.GetCurX();
		461	nNewY = nCurY = aViewData.GetCurY();
		462	}
		463
		464	ScDocument* pDoc = aViewData.GetDocument();
		465	SCTAB nTab = aViewData.GetTabNo();
		466
		467	// FindAreaPos kennt nur -1 oder 1 als Richtung
		468
		469	SCsCOLROW i;
		470	if ( nMovX > 0 )
		471	for ( i=0; i<nMovX; i++ )
		472	pDoc->FindAreaPos( nNewX, nNewY, nTab, 1, 0 );
		473	if ( nMovX < 0 )
		474	for ( i=0; i<-nMovX; i++ )
475	pDoc->FindAreaPos( nNewX, nNewY, nTab, -1, 0 );
476	if ( nMovY > 0 )
477	for ( i=0; i<nMovY; i++ )
478	pDoc->FindAreaPos( nNewX, nNewY, nTab, 0, 1 );
479	if ( nMovY < 0 )
480	for ( i=0; i<-nMovY; i++ )
481	pDoc->FindAreaPos( nNewX, nNewY, nTab, 0, -1 );
482
483	if (eMode==SC_FOLLOW_JUMP) // unten/rechts nicht zuviel grau anzeigen
484	{
485	if (nMovX != 0 && nNewX == MAXCOL)
486	eMode = SC_FOLLOW_LINE;
487	if (nMovY != 0 && nNewY == MAXROW)
488	eMode = SC_FOLLOW_LINE;
489	}
490
491	if (aViewData.IsRefMode())
492	{
493	rAreaX = nNewX - aViewData.GetRefEndX();
494	rAreaY = nNewY - aViewData.GetRefEndY();
495	}
496	else if (IsBlockMode())
497	{
498	rAreaX = nNewX - nBlockEndX;
499	rAreaY = nNewY - nBlockEndY;
500	}
501	else
502	{
503	rAreaX = nNewX - nCurX;
504	rAreaY = nNewY - nCurY;
505	}
506	rMode = eMode;
507	}
508
509	namespace {
510
511	bool lcl_isCellQualified(ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, bool bSelectLocked, bool bSelectUnlocked)
512	{
513	bool bCellProtected = pDoc->HasAttrib(
514	nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_PROTECTED);
515
516	if (bCellProtected && !bSelectLocked)
517	return false;
518
519	if (!bCellProtected && !bSelectUnlocked)
520	return false;
521
522	return true;
523	}
524
525	void lcl_moveCursorByProtRule(
526	SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY, SCTAB nTab, ScDocument* pDoc)
527	{
528	bool bSelectLocked = true;
529	bool bSelectUnlocked = true;
530	ScTableProtection* pTabProtection = pDoc->GetTabProtection(nTab);
531	if (pTabProtection && pTabProtection->isProtected())
532	{
533	bSelectLocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
534	bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
535	}
536
537	if (nMovX > 0)
538	{
539	if (rCol < MAXCOL)
540	{
541	for (SCCOL i = 0; i < nMovX; ++i)
542	{
543	if (!lcl_isCellQualified(pDoc, rCol+1, rRow, nTab, bSelectLocked, bSelectUnlocked))
544	break;
545	++rCol;
546	}
547	}
548	}
549	else if (nMovX < 0)
550	{
551	if (rCol > 0)
552	{
553	nMovX = -nMovX;
554	for (SCCOL i = 0; i < nMovX; ++i)
555	{
556	if (!lcl_isCellQualified(pDoc, rCol-1, rRow, nTab, bSelectLocked, bSelectUnlocked))
557	break;
558	--rCol;
559	}
560	}
561	}
562
563	if (nMovY > 0)
564	{
565	if (rRow < MAXROW)
566	{
567	for (SCROW i = 0; i < nMovY; ++i)
568	{
569	if (!lcl_isCellQualified(pDoc, rCol, rRow+1, nTab, bSelectLocked, bSelectUnlocked))
570	break;
571	++rRow;
572	}
573	}
574	}
575	else if (nMovY < 0)
576	{
577	if (rRow > 0)
578	{
579	nMovY = -nMovY;
580	for (SCROW i = 0; i < nMovY; ++i)
581	{
582	if (!lcl_isCellQualified(pDoc, rCol, rRow-1, nTab, bSelectLocked, bSelectUnlocked))
583	break;
584	--rRow;
585	}
586	}
587	}
588	}
589
590	}
591
592	void ScTabView::ExpandBlock(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode)
593	{
594	if (!nMovX && !nMovY)
595	// Nothing to do. Bail out.
596	return;
597
598	ScTabViewShell* pViewShell = aViewData.GetViewShell();
599	bool bRefInputMode = pViewShell && pViewShell->IsRefInputMode();
600	if (bRefInputMode && !aViewData.IsRefMode())
601	// initialize formula reference mode if it hasn't already.
602	InitRefMode(aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo(), SC_REFTYPE_REF);
603
604	ScDocument* pDoc = aViewData.GetDocument();
605
606	if (aViewData.IsRefMode())
607	{
608	// formula reference mode
609
610	SCCOL nNewX = aViewData.GetRefEndX();
611	SCROW nNewY = aViewData.GetRefEndY();
612	SCTAB nRefTab = aViewData.GetRefEndZ();
613
614	bool bSelectLocked = true;
615	bool bSelectUnlocked = true;
616	ScTableProtection* pTabProtection = pDoc->GetTabProtection(nRefTab);
617	if (pTabProtection && pTabProtection->isProtected())
618	{
619	bSelectLocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
620	bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
621	}
622
623	lcl_moveCursorByProtRule(nNewX, nNewY, nMovX, nMovY, nRefTab, pDoc);
624
625	if (nMovX)
626	{
627	SCCOL nTempX = nNewX;
628	while (pDoc->IsHorOverlapped(nTempX, nNewY, nRefTab))
629	{
630	if (nMovX > 0)
631	++nTempX;
632	else
633	--nTempX;
634	}
635	if (lcl_isCellQualified(pDoc, nTempX, nNewY, nRefTab, bSelectLocked, bSelectUnlocked))
636	nNewX = nTempX;
637	}
638
639	if (nMovY)
640	{
641	SCROW nTempY = nNewY;
642	while (pDoc->IsVerOverlapped(nNewX, nTempY, nRefTab))
643	{
644	if (nMovY > 0)
645	++nTempY;
646	else
647	--nTempY;
648	}
649	if (lcl_isCellQualified(pDoc, nNewX, nTempY, nRefTab, bSelectLocked, bSelectUnlocked))
650	nNewY = nTempY;
651	}
652
653	pDoc->SkipOverlapped(nNewX, nNewY, nRefTab);
654	UpdateRef(nNewX, nNewY, nRefTab);
655	AlignToCursor(nNewX, nNewY, eMode);
656	}
657	else
658	{
659	// normal selection mode
660
661	SCTAB nTab = aViewData.GetTabNo();
662
663	if (!IsBlockMode())
664	InitBlockMode(aViewData.GetCurX(), aViewData.GetCurY(), nTab, true);
665
666	lcl_moveCursorByProtRule(nBlockEndX, nBlockEndY, nMovX, nMovY, nTab, pDoc);
667
668	if (nBlockEndX < 0)
669	nBlockEndX = 0;
670	else if (nBlockEndX > MAXCOL)
671	nBlockEndX = MAXCOL;
672
673	if (nBlockEndY < 0)
674	nBlockEndY = 0;
675	else if (nBlockEndY > MAXROW)
676	nBlockEndY = MAXROW;
677
678	pDoc->SkipOverlapped(nBlockEndX, nBlockEndY, nTab);
679	MarkCursor(nBlockEndX, nBlockEndY, nTab, false, false, true);
680	AlignToCursor(nBlockEndX, nBlockEndY, eMode);
681	}
682	}
683
684	void ScTabView::ExpandBlockPage(SCsCOL nMovX, SCsROW nMovY)
685	{
686	SCsCOL nPageX;
687	SCsROW nPageY;
688	GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
689	ExpandBlock(nPageX, nPageY, SC_FOLLOW_FIX);
690	}
691
692	void ScTabView::ExpandBlockArea(SCsCOL nMovX, SCsROW nMovY)
693	{
694	SCsCOL nAreaX;
695	SCsROW nAreaY;
696	ScFollowMode eMode;
697	GetAreaMoveEndPosition(nMovX, nMovY, SC_FOLLOW_JUMP, nAreaX, nAreaY, eMode);
698	ExpandBlock(nAreaX, nAreaY, eMode);
699	}
700
417	void ScTabView::UpdateSelectionOverlay()	701	void ScTabView::UpdateSelectionOverlay()
418	{	702	{
419	for (USHORT i=0; i<4; i++)	703	for (USHORT i=0; i<4; i++)