xref: /aoo41x/main/sc/source/core/data/markarr.cxx (revision b3f79822)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



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



// INCLUDE ---------------------------------------------------------------

#include <tools/debug.hxx>

#include "markarr.hxx"
#include "global.hxx"
#include "address.hxx"

// STATIC DATA -----------------------------------------------------------

//------------------------------------------------------------------------

ScMarkArray::ScMarkArray() :
    nCount( 0 ),
    nLimit( 0 ),
    pData( NULL )
{
    // special case "no marks" with pData = NULL
}

//------------------------------------------------------------------------

ScMarkArray::~ScMarkArray()
{
    delete[] pData;
}

//------------------------------------------------------------------------

void ScMarkArray::Reset( sal_Bool bMarked )
{
    // always create pData here
    // (or have separate method to ensure pData)

    delete[] pData;

    nCount = nLimit = 1;
    pData = new ScMarkEntry[1];
    pData[0].nRow = MAXROW;
    pData[0].bMarked = bMarked;
}

//------------------------------------------------------------------------

sal_Bool ScMarkArray::Search( SCROW nRow, SCSIZE& nIndex ) const
{
	long	nLo 		= 0;
	long	nHi 		= static_cast<long>(nCount) - 1;
	long	nStartRow	= 0;
	long	nEndRow 	= 0;
	long	i			= 0;
	sal_Bool	bFound		= (nCount == 1);
	if (pData)
	{
		while ( !bFound && nLo <= nHi )
		{
			i = (nLo + nHi) / 2;
			if (i > 0)
				nStartRow = (long) pData[i - 1].nRow;
			else
				nStartRow = -1;
			nEndRow = (long) pData[i].nRow;
			if (nEndRow < (long) nRow)
				nLo = ++i;
			else
				if (nStartRow >= (long) nRow)
					nHi = --i;
				else
					bFound = sal_True;
		}
	}
	else
		bFound = sal_False;

	if (bFound)
		nIndex=(SCSIZE)i;
	else
		nIndex=0;
	return bFound;
}

sal_Bool ScMarkArray::GetMark( SCROW nRow ) const
{
	SCSIZE i;
	if (Search( nRow, i ))
		return pData[i].bMarked;
	else
		return sal_False;

}

//------------------------------------------------------------------------

void ScMarkArray::SetMarkArea( SCROW nStartRow, SCROW nEndRow, sal_Bool bMarked )
{
	if (ValidRow(nStartRow) && ValidRow(nEndRow))
	{
		if ((nStartRow == 0) && (nEndRow == MAXROW))
		{
			Reset(bMarked);
		}
		else
		{
            if (!pData)
                Reset(sal_False);   // create pData for further processing - could use special case handling!

            SCSIZE nNeeded = nCount + 2;
            if ( nLimit < nNeeded )
            {
                nLimit += SC_MARKARRAY_DELTA;
                if ( nLimit < nNeeded )
                    nLimit = nNeeded;
                ScMarkEntry* pNewData = new ScMarkEntry[nLimit];
                memcpy( pNewData, pData, nCount*sizeof(ScMarkEntry) );
				delete[] pData;
				pData = pNewData;
            }

            SCSIZE ni;          // number of entries in beginning
            SCSIZE nInsert;     // insert position (MAXROW+1 := no insert)
            sal_Bool bCombined = sal_False;
            sal_Bool bSplit = sal_False;
            if ( nStartRow > 0 )
            {
                // skip beginning
                SCSIZE nIndex;
                Search( nStartRow, nIndex );
                ni = nIndex;

                nInsert = MAXROWCOUNT;
                if ( pData[ni].bMarked != bMarked )
                {
                    if ( ni == 0 || (pData[ni-1].nRow < nStartRow - 1) )
                    {   // may be a split or a simple insert or just a shrink,
                        // row adjustment is done further down
                        if ( pData[ni].nRow > nEndRow )
                            bSplit = sal_True;
                        ni++;
                        nInsert = ni;
                    }
                    else if ( ni > 0 && pData[ni-1].nRow == nStartRow - 1 )
                        nInsert = ni;
                }
                if ( ni > 0 && pData[ni-1].bMarked == bMarked )
                {   // combine
                    pData[ni-1].nRow = nEndRow;
                    nInsert = MAXROWCOUNT;
                    bCombined = sal_True;
                }
            }
            else
	    {
                nInsert = 0;
                ni = 0;
	    }

            SCSIZE nj = ni;     // stop position of range to replace
            while ( nj < nCount && pData[nj].nRow <= nEndRow )
                nj++;
            if ( !bSplit )
            {
                if ( nj < nCount && pData[nj].bMarked == bMarked )
                {   // combine
                    if ( ni > 0 )
                    {
                        if ( pData[ni-1].bMarked == bMarked )
                        {   // adjacent entries
                            pData[ni-1].nRow = pData[nj].nRow;
                            nj++;
                        }
                        else if ( ni == nInsert )
                            pData[ni-1].nRow = nStartRow - 1;   // shrink
                    }
                    nInsert = MAXROWCOUNT;
                    bCombined = sal_True;
                }
                else if ( ni > 0 && ni == nInsert )
                    pData[ni-1].nRow = nStartRow - 1;   // shrink
            }
            if ( ni < nj )
            {   // remove middle entries
                if ( !bCombined )
                {   // replace one entry
                    pData[ni].nRow = nEndRow;
                    pData[ni].bMarked = bMarked;
                    ni++;
                    nInsert = MAXROWCOUNT;
                }
                if ( ni < nj )
                {   // remove entries
                    memmove( pData + ni, pData + nj, (nCount - nj) * sizeof(ScMarkEntry) );
                    nCount -= nj - ni;
                }
            }

            if ( nInsert < sal::static_int_cast<SCSIZE>(MAXROWCOUNT) )
            {   // insert or append new entry
                if ( nInsert <= nCount )
                {
                    if ( !bSplit )
                        memmove( pData + nInsert + 1, pData + nInsert,
                            (nCount - nInsert) * sizeof(ScMarkEntry) );
                    else
                    {
                        memmove( pData + nInsert + 2, pData + nInsert,
                            (nCount - nInsert) * sizeof(ScMarkEntry) );
                        pData[nInsert+1] = pData[nInsert-1];
                        nCount++;
                    }
                }
                if ( nInsert )
                    pData[nInsert-1].nRow = nStartRow - 1;
                pData[nInsert].nRow = nEndRow;
                pData[nInsert].bMarked = bMarked;
                nCount++;
            }
		}
	}
//	InfoBox(0, String(nCount) + String(" Eintraege") ).Execute();
}

//UNUSED2009-05 void ScMarkArray::DeleteArea(SCROW nStartRow, SCROW nEndRow)
//UNUSED2009-05 {
//UNUSED2009-05     SetMarkArea(nStartRow, nEndRow, sal_False);
//UNUSED2009-05 }

sal_Bool ScMarkArray::IsAllMarked( SCROW nStartRow, SCROW nEndRow ) const
{
	SCSIZE nStartIndex;
	SCSIZE nEndIndex;

	if (Search( nStartRow, nStartIndex ))
		if (pData[nStartIndex].bMarked)
			if (Search( nEndRow, nEndIndex ))
				if (nEndIndex==nStartIndex)
					return sal_True;

	return sal_False;
}

sal_Bool ScMarkArray::HasOneMark( SCROW& rStartRow, SCROW& rEndRow ) const
{
	sal_Bool bRet = sal_False;
	if ( nCount == 1 )
	{
		if ( pData[0].bMarked )
		{
			rStartRow = 0;
			rEndRow = MAXROW;
			bRet = sal_True;
		}
	}
	else if ( nCount == 2 )
	{
		if ( pData[0].bMarked )
		{
			rStartRow = 0;
			rEndRow = pData[0].nRow;
		}
		else
		{
			rStartRow = pData[0].nRow + 1;
			rEndRow = MAXROW;
		}
		bRet = sal_True;
	}
	else if ( nCount == 3 )
	{
		if ( pData[1].bMarked )
		{
			rStartRow = pData[0].nRow + 1;
			rEndRow = pData[1].nRow;
			bRet = sal_True;
		}
	}
	return bRet;
}

void ScMarkArray::CopyMarksTo( ScMarkArray& rDestMarkArray ) const
{
	delete[] rDestMarkArray.pData;

	if (pData)
	{
		rDestMarkArray.pData = new ScMarkEntry[nCount];
		memmove( rDestMarkArray.pData, pData, nCount * sizeof(ScMarkEntry) );
	}
	else
		rDestMarkArray.pData = NULL;

    rDestMarkArray.nCount = rDestMarkArray.nLimit = nCount;
}

SCsROW ScMarkArray::GetNextMarked( SCsROW nRow, sal_Bool bUp ) const
{
    if (!pData)
        const_cast<ScMarkArray*>(this)->Reset(sal_False);   // create pData for further processing

	SCsROW nRet = nRow;
	if (VALIDROW(nRow))
	{
		SCSIZE nIndex;
		Search(nRow, nIndex);
		if (!pData[nIndex].bMarked)
		{
			if (bUp)
			{
				if (nIndex>0)
					nRet = pData[nIndex-1].nRow;
				else
					nRet = -1;
			}
			else
				nRet = pData[nIndex].nRow + 1;
		}
	}
	return nRet;
}

SCROW ScMarkArray::GetMarkEnd( SCROW nRow, sal_Bool bUp ) const
{
    if (!pData)
        const_cast<ScMarkArray*>(this)->Reset(sal_False);   // create pData for further processing

	SCROW nRet;
	SCSIZE nIndex;
	Search(nRow, nIndex);
	DBG_ASSERT( pData[nIndex].bMarked, "GetMarkEnd ohne bMarked" );
	if (bUp)
	{
		if (nIndex>0)
			nRet = pData[nIndex-1].nRow + 1;
		else
			nRet = 0;
	}
	else
		nRet = pData[nIndex].nRow;

	return nRet;
}

//
//	-------------- Iterator ----------------------------------------------
//

ScMarkArrayIter::ScMarkArrayIter( const ScMarkArray* pNewArray ) :
	pArray( pNewArray ),
	nPos( 0 )
{
}

ScMarkArrayIter::~ScMarkArrayIter()
{
}

sal_Bool ScMarkArrayIter::Next( SCROW& rTop, SCROW& rBottom )
{
	if ( nPos >= pArray->nCount )
		return sal_False;
	while (!pArray->pData[nPos].bMarked)
	{
		++nPos;
		if ( nPos >= pArray->nCount )
			return sal_False;
	}
	rBottom = pArray->pData[nPos].nRow;
	if (nPos==0)
		rTop = 0;
	else
		rTop = pArray->pData[nPos-1].nRow + 1;
	++nPos;
	return sal_True;
}