Attachment #62447 for issue #102151

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

Lines 830-835 public: Link Here

(-)sc/inc/document.hxx (+1 lines)
830	ScRange* pLastRange = NULL,	830	ScRange* pLastRange = NULL,
831	Rectangle* pLastMM = NULL ) const;	831	Rectangle* pLastMM = NULL ) const;
832		832
		833	void SkipOverlapped( SCCOL& rCol, SCROW& rRow, SCTAB nTab ) const;
833	BOOL IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;	834	BOOL IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
834	BOOL IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;	835	BOOL IsVerOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const;
835		836

Lines 4356-4361 BOOL ScDocument::RefreshAutoFilter( SCCOL nStartCol, SCROW nStartRow, Link Here

(-)sc/source/core/data/document.cxx (+7 lines)
4356	return bChange;	4356	return bChange;
4357	}	4357	}
4358		4358
		4359	void ScDocument::SkipOverlapped( SCCOL& rCol, SCROW& rRow, SCTAB nTab ) const
		4360	{
		4361	while (IsHorOverlapped(rCol, rRow, nTab))
		4362	--rCol;
		4363	while (IsVerOverlapped(rCol, rRow, nTab))
		4364	--rRow;
		4365	}
4359		4366
4360	BOOL ScDocument::IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const	4367	BOOL ScDocument::IsHorOverlapped( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
4361	{	4368	{

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 )
{
    const SfxItemSet*   pReqArgs = rReq.GetArgs();
    sal_uInt16          nSlotId  = rReq.GetSlot();
    short               nRepeat = 1;
    ScViewData* pData = GetViewData();
    ScTabViewShell* pViewShell = pData->GetViewShell();

    sal_uInt16 nLocked = pViewShell->GetLockedModifiers();
    bool bAddSel = (nLocked & KEY_MOD1);

    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:
            ;
    }
}

void ScCellShell::ExecuteMove( SfxRequest& rReq )

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


Lines 668-674 BOOL ScViewFunctionSet::SetCursorAtCell( SCsCOL nPosX, SCsROW nPosY, BOOL bScrol Link Here

(-)sc/source/ui/view/select.cxx (-1 / +4 lines)
668	}	668	}
669	}	669	}
670	if (bStarted)	670	if (bStarted)
		671	// If the selection is already started, don't set the cursor.
671	pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab, FALSE, FALSE, TRUE );	672	pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab, FALSE, FALSE, TRUE );
		673	else
		674	pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
672	}	675	}
673	else	676	else
674	{	677	{
Lines 704-712 BOOL ScViewFunctionSet::SetCursorAtCell( SCsCOL nPosX, SCsROW nPosY, BOOL bScrol Link Here
704		707
705	bStarted = TRUE;	708	bStarted = TRUE;
706	}	709	}
		710	pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
707	}	711	}
708		712
709	pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
710	pViewData->SetRefStart( nPosX, nPosY, nTab );	713	pViewData->SetRefStart( nPosX, nPosY, nTab );
711	if (bHideCur)	714	if (bHideCur)
712	pView->ShowAllCursors();	715	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)
    {
        for (SCCOL i = 0; i < nMovX; ++i)
        {
            if (!lcl_isCellQualified(pDoc, rCol+1, rRow, nTab, bSelectLocked, bSelectUnlocked))
                break;
            ++rCol;
        }
    }
    else if (nMovX < 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)
    {
        for (SCROW i = 0; i < nMovY; ++i)
        {
            if (!lcl_isCellQualified(pDoc, rCol, rRow+1, nTab, bSelectLocked, bSelectUnlocked))
                break;
            ++rRow;
        }
    }
    else if (nMovY < 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;

    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);
    }
    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 )
{
    SCsCOL nPageX;
    SCsROW nPageY;
    GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);

	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;

	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 (-34 / +97 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	const SfxItemSet* pReqArgs = rReq.GetArgs();
176	USHORT nSlotId = rReq.GetSlot();	222	sal_uInt16 nSlotId = rReq.GetSlot();
177	short nRepeat = 1;	223	short nRepeat = 1;
178		224	ScViewData* pData = GetViewData();
179	if ( pReqArgs != NULL )	225	ScTabViewShell* pViewShell = pData->GetViewShell();
180	{	226
181	const SfxPoolItem* pItem;	227	sal_uInt16 nLocked = pViewShell->GetLockedModifiers();
182	if( IS_AVAILABLE( FN_PARAM_1, &pItem ) )	228	bool bAddSel = (nLocked & KEY_MOD1);
183	nRepeat = ((const SfxInt16Item*)pItem)->GetValue();	229
184	}	230	switch (nSlotId)
185		231	{
186	switch ( nSlotId )	232	case SID_CURSORDOWN_SEL:
187	{	233	pViewShell->ExpandBlock(0, 1, SC_FOLLOW_LINE);
188	case SID_CURSORDOWN_SEL: rReq.SetSlot( SID_CURSORDOWN ); break;	234	break;
189	case SID_CURSORBLKDOWN_SEL: rReq.SetSlot( SID_CURSORBLKDOWN ); break;	235	case SID_CURSORUP_SEL:
190	case SID_CURSORUP_SEL: rReq.SetSlot( SID_CURSORUP ); break;	236	pViewShell->ExpandBlock(0, -1, SC_FOLLOW_LINE);
191	case SID_CURSORBLKUP_SEL: rReq.SetSlot( SID_CURSORBLKUP ); break;	237	break;
192	case SID_CURSORLEFT_SEL: rReq.SetSlot( SID_CURSORLEFT ); break;	238	case SID_CURSORRIGHT_SEL:
193	case SID_CURSORBLKLEFT_SEL: rReq.SetSlot( SID_CURSORBLKLEFT ); break;	239	pViewShell->ExpandBlock(1, 0, SC_FOLLOW_LINE);
194	case SID_CURSORRIGHT_SEL: rReq.SetSlot( SID_CURSORRIGHT ); break;	240	break;
195	case SID_CURSORBLKRIGHT_SEL: rReq.SetSlot( SID_CURSORBLKRIGHT ); break;	241	case SID_CURSORLEFT_SEL:
196	case SID_CURSORPAGEDOWN_SEL: rReq.SetSlot( SID_CURSORPAGEDOWN ); break;	242	pViewShell->ExpandBlock(-1, 0, SC_FOLLOW_LINE);
197	case SID_CURSORPAGEUP_SEL: rReq.SetSlot( SID_CURSORPAGEUP ); break;	243	break;
198	case SID_CURSORPAGERIGHT_SEL: rReq.SetSlot( SID_CURSORPAGERIGHT_ ); break;	244	case SID_CURSORPAGEUP_SEL:
199	case SID_CURSORPAGELEFT_SEL: rReq.SetSlot( SID_CURSORPAGELEFT_ ); break;	245	pViewShell->ExpandBlockPage(0, -1);
200	default:	246	break;
201	DBG_ERROR("Unbekannte Message bei ViewShell (CursorSel)");	247	case SID_CURSORPAGEDOWN_SEL:
202	return;	248	pViewShell->ExpandBlockPage(0, 1);
203	}	249	break;
204	rReq.AppendItem( SfxInt16Item(FN_PARAM_1, nRepeat ) );	250	case SID_CURSORPAGERIGHT_SEL:
205	rReq.AppendItem( SfxBoolItem(FN_PARAM_2, TRUE) );	251	pViewShell->ExpandBlockPage(1, 0);
206	ExecuteSlot( rReq, GetInterface() );	252	break;
		253	case SID_CURSORPAGELEFT_SEL:
		254	pViewShell->ExpandBlockPage(-1, 0);
		255	break;
		256	case SID_CURSORBLKDOWN_SEL:
		257	pViewShell->ExpandBlockArea(0, 1);
		258	break;
		259	case SID_CURSORBLKUP_SEL:
		260	pViewShell->ExpandBlockArea(0, -1);
		261	break;
		262	case SID_CURSORBLKRIGHT_SEL:
		263	pViewShell->ExpandBlockArea(1, 0);
		264	break;
		265	case SID_CURSORBLKLEFT_SEL:
		266	pViewShell->ExpandBlockArea(-1, 0);
		267	break;
		268	default:
		269	;
		270	}
207	}	271	}
208		272
209	void ScCellShell::ExecuteMove( SfxRequest& rReq )	273	void ScCellShell::ExecuteMove( SfxRequest& rReq )
Lines 348-354 void ScCellShell::ExecutePage( SfxRequest& rReq ) Link Here
348	{	412	{
349	// ADD mode: keep the selection, start a new block when marking with shift again	413	// ADD mode: keep the selection, start a new block when marking with shift again
350	bKeep = TRUE;	414	bKeep = TRUE;
351	pTabViewShell->SetNewStartIfMarking();
352	}	415	}
353	}	416	}
354		417

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

(-)sc/source/ui/view/tabview3.cxx (-80 / +31 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;	1094	SCsCOL nPageX;
1084	SCROW nCurY;	1095	SCsROW nPageY;
1085	aViewData.GetMoveCursor( nCurX,nCurY );	1096	GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
1086
1087	ScSplitPos eWhich = aViewData.GetActivePart();
1088	ScHSplitPos eWhichX = WhichH( eWhich );
1089	ScVSplitPos eWhichY = WhichV( eWhich );
1090
1091	SCsCOL nPageX;
1092	SCsROW nPageY;
1093	if (nMovX >= 0)
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 1883-1894 BOOL ScViewData::GetPosFromPixel( long nClickX, long nClickY, ScSplitPos eWhich, Link Here

(-)sc/source/ui/view/viewdata.cxx (-6 / +5 lines)
1883	{	1883	{
1884	//! public Methode um Position anzupassen	1884	//! public Methode um Position anzupassen
1885		1885
1886	BOOL bHOver = FALSE;	1886	SCCOL nOrigX = rPosX;
1887	while (pDoc->IsHorOverlapped( rPosX, rPosY, nTabNo ))	1887	SCROW nOrigY = rPosY;
1888	{ --rPosX; bHOver=TRUE; }	1888	pDoc->SkipOverlapped(rPosX, rPosY, nTabNo);
1889	BOOL bVOver = FALSE;	1889	bool bHOver = (nOrigX != rPosX);
1890	while (pDoc->IsVerOverlapped( rPosX, rPosY, nTabNo ))	1890	bool bVOver = (nOrigY != rPosY);
1891	{ --rPosY; bVOver=TRUE; }
1892		1891
1893	if ( bRepair && ( bHOver \|\| bVOver ) )	1892	if ( bRepair && ( bHOver \|\| bVOver ) )
1894	{	1893	{

Lines 62-67 Link Here

(-)sc/source/ui/view/tabview2.cxx (-7 / +272 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	for (SCCOL i = 0; i < nMovX; ++i)
540	{
541	if (!lcl_isCellQualified(pDoc, rCol+1, rRow, nTab, bSelectLocked, bSelectUnlocked))
542	break;
543	++rCol;
544	}
545	}
546	else if (nMovX < 0)
547	{
548	nMovX = -nMovX;
549	for (SCCOL i = 0; i < nMovX; ++i)
550	{
551	if (!lcl_isCellQualified(pDoc, rCol-1, rRow, nTab, bSelectLocked, bSelectUnlocked))
552	break;
553	--rCol;
554	}
555	}
556
557	if (nMovY > 0)
558	{
559	for (SCROW i = 0; i < nMovY; ++i)
560	{
561	if (!lcl_isCellQualified(pDoc, rCol, rRow+1, nTab, bSelectLocked, bSelectUnlocked))
562	break;
563	++rRow;
564	}
565	}
566	else if (nMovY < 0)
567	{
568	nMovY = -nMovY;
569	for (SCROW i = 0; i < nMovY; ++i)
570	{
571	if (!lcl_isCellQualified(pDoc, rCol, rRow-1, nTab, bSelectLocked, bSelectUnlocked))
572	break;
573	--rRow;
574	}
575	}
576	}
577
578	}
579
580	void ScTabView::ExpandBlock(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode)
581	{
582	if (!nMovX && !nMovY)
583	// Nothing to do. Bail out.
584	return;
585
586	ScDocument* pDoc = aViewData.GetDocument();
587
588	if (aViewData.IsRefMode())
589	{
590	// formula reference mode
591
592	SCCOL nNewX = aViewData.GetRefEndX();
593	SCROW nNewY = aViewData.GetRefEndY();
594	SCTAB nRefTab = aViewData.GetRefEndZ();
595
596	bool bSelectLocked = true;
597	bool bSelectUnlocked = true;
598	ScTableProtection* pTabProtection = pDoc->GetTabProtection(nRefTab);
599	if (pTabProtection && pTabProtection->isProtected())
600	{
601	bSelectLocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
602	bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
603	}
604
605	lcl_moveCursorByProtRule(nNewX, nNewY, nMovX, nMovY, nRefTab, pDoc);
606
607	if (nMovX)
608	{
609	SCCOL nTempX = nNewX;
610	while (pDoc->IsHorOverlapped(nTempX, nNewY, nRefTab))
611	{
612	if (nMovX > 0)
613	++nTempX;
614	else
615	--nTempX;
616	}
617	if (lcl_isCellQualified(pDoc, nTempX, nNewY, nRefTab, bSelectLocked, bSelectUnlocked))
618	nNewX = nTempX;
619	}
620
621	if (nMovY)
622	{
623	SCROW nTempY = nNewY;
624	while (pDoc->IsVerOverlapped(nNewX, nTempY, nRefTab))
625	{
626	if (nMovY > 0)
627	++nTempY;
628	else
629	--nTempY;
630	}
631	if (lcl_isCellQualified(pDoc, nNewX, nTempY, nRefTab, bSelectLocked, bSelectUnlocked))
632	nNewY = nTempY;
633	}
634
635	pDoc->SkipOverlapped(nNewX, nNewY, nRefTab);
636	UpdateRef(nNewX, nNewY, nRefTab);
637	}
638	else
639	{
640	// normal selection mode
641
642	SCTAB nTab = aViewData.GetTabNo();
643
644	if (!IsBlockMode())
645	InitBlockMode(aViewData.GetCurX(), aViewData.GetCurY(), nTab, true);
646
647	lcl_moveCursorByProtRule(nBlockEndX, nBlockEndY, nMovX, nMovY, nTab, pDoc);
648
649	if (nBlockEndX < 0)
650	nBlockEndX = 0;
651	else if (nBlockEndX > MAXCOL)
652	nBlockEndX = MAXCOL;
653
654	if (nBlockEndY < 0)
655	nBlockEndY = 0;
656	else if (nBlockEndY > MAXROW)
657	nBlockEndY = MAXROW;
658
659	pDoc->SkipOverlapped(nBlockEndX, nBlockEndY, nTab);
660	MarkCursor(nBlockEndX, nBlockEndY, nTab, false, false, true);
661	AlignToCursor(nBlockEndX, nBlockEndY, eMode);
662	}
663	}
664
665	void ScTabView::ExpandBlockPage(SCsCOL nMovX, SCsROW nMovY)
666	{
667	SCsCOL nPageX;
668	SCsROW nPageY;
669	GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
670	ExpandBlock(nPageX, nPageY, SC_FOLLOW_FIX);
671	}
672
673	void ScTabView::ExpandBlockArea(SCsCOL nMovX, SCsROW nMovY)
674	{
675	SCsCOL nAreaX;
676	SCsROW nAreaY;
677	ScFollowMode eMode;
678	GetAreaMoveEndPosition(nMovX, nMovY, SC_FOLLOW_JUMP, nAreaX, nAreaY, eMode);
679	ExpandBlock(nAreaX, nAreaY, eMode);
680	}
681
417	void ScTabView::UpdateSelectionOverlay()	682	void ScTabView::UpdateSelectionOverlay()
418	{	683	{
419	for (USHORT i=0; i<4; i++)	684	for (USHORT i=0; i<4; i++)