/**************************************************************
 * 
 * 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 "markdata.hxx"
#include "markarr.hxx"
#include "rangelst.hxx"

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

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

ScMarkData::ScMarkData() :
	pMultiSel( NULL )
{
	for (SCTAB i=0; i<=MAXTAB; i++)
		bTabMarked[i] = sal_False;

	ResetMark();
}

ScMarkData::ScMarkData(const ScMarkData& rData) :
	aMarkRange( rData.aMarkRange ),
	aMultiRange( rData.aMultiRange ),
	pMultiSel( NULL )
{
	bMarked		 = rData.bMarked;
	bMultiMarked = rData.bMultiMarked;
	bMarking	 = rData.bMarking;
	bMarkIsNeg	 = rData.bMarkIsNeg;

	for (SCTAB i=0; i<=MAXTAB; i++)
		bTabMarked[i] = rData.bTabMarked[i];

	if (rData.pMultiSel)
	{
		pMultiSel = new ScMarkArray[MAXCOLCOUNT];
		for (SCCOL j=0; j<MAXCOLCOUNT; j++)
			rData.pMultiSel[j].CopyMarksTo( pMultiSel[j] );
	}
}

ScMarkData&	ScMarkData::operator=(const ScMarkData& rData)
{
	if ( &rData == this )
		return *this;

	delete[] pMultiSel;
	pMultiSel = NULL;

	aMarkRange	 = rData.aMarkRange;
	aMultiRange  = rData.aMultiRange;
	bMarked		 = rData.bMarked;
	bMultiMarked = rData.bMultiMarked;
	bMarking	 = rData.bMarking;
	bMarkIsNeg	 = rData.bMarkIsNeg;

	for (SCTAB i=0; i<=MAXTAB; i++)
		bTabMarked[i] = rData.bTabMarked[i];

	if (rData.pMultiSel)
	{
		pMultiSel = new ScMarkArray[MAXCOLCOUNT];
		for (SCCOL j=0; j<MAXCOLCOUNT; j++)
			rData.pMultiSel[j].CopyMarksTo( pMultiSel[j] );
	}

	return *this;
}

ScMarkData::~ScMarkData()
{
	delete[] pMultiSel;
}

void ScMarkData::ResetMark()
{
	delete[] pMultiSel;
	pMultiSel = NULL;

	bMarked = bMultiMarked = sal_False;
	bMarking = bMarkIsNeg = sal_False;
}

void ScMarkData::SetMarkArea( const ScRange& rRange )
{
	aMarkRange = rRange;
	aMarkRange.Justify();
	if ( !bMarked )
	{
		// #77987# Upon creation of a document ScFormatShell GetTextAttrState
		// may query (default) attributes although no sheet is marked yet.
		// => mark that one.
		if ( !GetSelectCount() )
			bTabMarked[ aMarkRange.aStart.Tab() ] = sal_True;
		bMarked = sal_True;
	}
}

void ScMarkData::GetMarkArea( ScRange& rRange ) const
{
	rRange = aMarkRange;		//! inline ?
}

void ScMarkData::GetMultiMarkArea( ScRange& rRange ) const
{
	rRange = aMultiRange;
}

void ScMarkData::SetMultiMarkArea( const ScRange& rRange, sal_Bool bMark )
{
	if (!pMultiSel)
	{
		pMultiSel = new ScMarkArray[MAXCOL+1];

		// if simple mark range is set, copy to multi marks
		if ( bMarked && !bMarkIsNeg )
		{
			bMarked = sal_False;
			SetMultiMarkArea( aMarkRange, sal_True );
		}
	}

	SCCOL nStartCol = rRange.aStart.Col();
	SCROW nStartRow = rRange.aStart.Row();
	SCCOL nEndCol = rRange.aEnd.Col();
	SCROW nEndRow = rRange.aEnd.Row();
	PutInOrder( nStartRow, nEndRow );
	PutInOrder( nStartCol, nEndCol );

	SCCOL nCol;
	for (nCol=nStartCol; nCol<=nEndCol; nCol++)
		pMultiSel[nCol].SetMarkArea( nStartRow, nEndRow, bMark );

	if ( bMultiMarked )					// aMultiRange updaten
	{
		if ( nStartCol < aMultiRange.aStart.Col() )
			aMultiRange.aStart.SetCol( nStartCol );
		if ( nStartRow < aMultiRange.aStart.Row() )
			aMultiRange.aStart.SetRow( nStartRow );
		if ( nEndCol > aMultiRange.aEnd.Col() )
			aMultiRange.aEnd.SetCol( nEndCol );
		if ( nEndRow > aMultiRange.aEnd.Row() )
			aMultiRange.aEnd.SetRow( nEndRow );
	}
	else
	{
		aMultiRange = rRange;			// neu
		bMultiMarked = sal_True;
	}
}

void ScMarkData::SetAreaTab( SCTAB nTab )
{
	aMarkRange.aStart.SetTab(nTab);
	aMarkRange.aEnd.SetTab(nTab);
	aMultiRange.aStart.SetTab(nTab);
	aMultiRange.aEnd.SetTab(nTab);
}

void ScMarkData::SelectOneTable( SCTAB nTab )
{
	for (SCTAB i=0; i<=MAXTAB; i++)
		bTabMarked[i] = ( nTab == i );
}

SCTAB ScMarkData::GetSelectCount() const
{
	SCTAB nCount = 0;
	for (SCTAB i=0; i<=MAXTAB; i++)
		if (bTabMarked[i])
			++nCount;

	return nCount;
}

SCTAB ScMarkData::GetFirstSelected() const
{
	for (SCTAB i=0; i<=MAXTAB; i++)
		if (bTabMarked[i])
			return i;

	DBG_ERROR("GetFirstSelected: keine markiert");
	return 0;
}

void ScMarkData::MarkToMulti()
{
	if ( bMarked && !bMarking )
	{
		SetMultiMarkArea( aMarkRange, !bMarkIsNeg );
		bMarked = sal_False;

		//	check if all multi mark ranges have been removed
		if ( bMarkIsNeg && !HasAnyMultiMarks() )
			ResetMark();
	}
}

void ScMarkData::MarkToSimple()
{
	if ( bMarking )
		return;

	if ( bMultiMarked && bMarked )
		MarkToMulti();					// may result in bMarked and bMultiMarked reset

	if ( bMultiMarked )
	{
		DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");

		ScRange aNew = aMultiRange;

		sal_Bool bOk = sal_False;
		SCCOL nStartCol = aNew.aStart.Col();
		SCCOL nEndCol   = aNew.aEnd.Col();

		while ( nStartCol < nEndCol && !pMultiSel[nStartCol].HasMarks() )
			++nStartCol;
		while ( nStartCol < nEndCol && !pMultiSel[nEndCol].HasMarks() )
			--nEndCol;

		//	Zeilen werden nur aus MarkArray genommen
		SCROW nStartRow, nEndRow;
		if ( pMultiSel[nStartCol].HasOneMark( nStartRow, nEndRow ) )
		{
			bOk = sal_True;
			SCROW nCmpStart, nCmpEnd;
			for (SCCOL nCol=nStartCol+1; nCol<=nEndCol && bOk; nCol++)
				if ( !pMultiSel[nCol].HasOneMark( nCmpStart, nCmpEnd )
						|| nCmpStart != nStartRow || nCmpEnd != nEndRow )
					bOk = sal_False;
		}

		if (bOk)
		{
			aNew.aStart.SetCol(nStartCol);
			aNew.aStart.SetRow(nStartRow);
			aNew.aEnd.SetCol(nEndCol);
			aNew.aEnd.SetRow(nEndRow);

			ResetMark();
			aMarkRange = aNew;
			bMarked = sal_True;
			bMarkIsNeg = sal_False;
		}
	}
}

sal_Bool ScMarkData::IsCellMarked( SCCOL nCol, SCROW nRow, sal_Bool bNoSimple ) const
{
	if ( bMarked && !bNoSimple && !bMarkIsNeg )
		if ( aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol &&
			 aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow )
			return sal_True;

	if (bMultiMarked)
	{
		//!	hier auf negative Markierung testen ?

		DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
		return pMultiSel[nCol].GetMark( nRow );
	}

	return sal_False;
}

sal_Bool ScMarkData::IsColumnMarked( SCCOL nCol ) const
{
	//	bMarkIsNeg inzwischen auch fuer Spaltenkoepfe
	//!	GetMarkColumnRanges fuer komplett markierte Spalten

	if ( bMarked && !bMarkIsNeg &&
					aMarkRange.aStart.Col() <= nCol && aMarkRange.aEnd.Col() >= nCol &&
					aMarkRange.aStart.Row() == 0	&& aMarkRange.aEnd.Row() == MAXROW )
		return sal_True;

	if ( bMultiMarked && pMultiSel[nCol].IsAllMarked(0,MAXROW) )
		return sal_True;

	return sal_False;
}

sal_Bool ScMarkData::IsRowMarked( SCROW nRow ) const
{
	//	bMarkIsNeg inzwischen auch fuer Zeilenkoepfe
	//!	GetMarkRowRanges fuer komplett markierte Zeilen

	if ( bMarked && !bMarkIsNeg &&
					aMarkRange.aStart.Col() == 0	&& aMarkRange.aEnd.Col() == MAXCOL &&
					aMarkRange.aStart.Row() <= nRow && aMarkRange.aEnd.Row() >= nRow )
		return sal_True;

	if ( bMultiMarked )
	{
		DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");
		for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
			if (!pMultiSel[nCol].GetMark(nRow))
				return sal_False;
		return sal_True;
	}

	return sal_False;
}

void ScMarkData::MarkFromRangeList( const ScRangeList& rList, sal_Bool bReset )
{
	if (bReset)
	{
		for (SCTAB i=0; i<=MAXTAB; i++)
			bTabMarked[i] = sal_False;				// Tabellen sind nicht in ResetMark
		ResetMark();
	}

	sal_uLong nCount = rList.Count();
	if ( nCount == 1 && !bMarked && !bMultiMarked )
	{
		ScRange aRange = *rList.GetObject(0);
		SetMarkArea( aRange );
		SelectTable( aRange.aStart.Tab(), sal_True );
	}
	else
	{
		for (sal_uLong i=0; i<nCount; i++)
		{
			ScRange aRange = *rList.GetObject(i);
			SetMultiMarkArea( aRange, sal_True );
			SelectTable( aRange.aStart.Tab(), sal_True );
		}
	}
}

void ScMarkData::FillRangeListWithMarks( ScRangeList* pList, sal_Bool bClear ) const
{
	if (!pList)
		return;

	if (bClear)
		pList->RemoveAll();

	//!		bei mehreren selektierten Tabellen mehrere Ranges eintragen !!!

	if ( bMultiMarked )
	{
		DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");

		SCTAB nTab = aMultiRange.aStart.Tab();

		SCCOL nStartCol = aMultiRange.aStart.Col();
		SCCOL nEndCol = aMultiRange.aEnd.Col();
		for (SCCOL nCol=nStartCol; nCol<=nEndCol; nCol++)
			if (pMultiSel[nCol].HasMarks())
			{
				SCROW nTop, nBottom;
				ScRange aRange( nCol, 0, nTab );
				ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
				while ( aMarkIter.Next( nTop, nBottom ) )
				{
					aRange.aStart.SetRow( nTop );
					aRange.aEnd.SetRow( nBottom );
					pList->Join( aRange );
				}
			}
	}

	if ( bMarked )
		pList->Append( aMarkRange );
}

void ScMarkData::ExtendRangeListTables( ScRangeList* pList ) const
{
	if (!pList)
		return;

	ScRangeList aOldList(*pList);
	pList->RemoveAll();					//!	oder die vorhandenen unten weglassen

	for (SCTAB nTab=0; nTab<=MAXTAB; nTab++)
		if (bTabMarked[nTab])
		{
			sal_uLong nCount = aOldList.Count();
			for (sal_uLong i=0; i<nCount; i++)
			{
				ScRange aRange = *aOldList.GetObject(i);
				aRange.aStart.SetTab(nTab);
				aRange.aEnd.SetTab(nTab);
				pList->Append( aRange );
			}
		}
}

SCCOLROW ScMarkData::GetMarkColumnRanges( SCCOLROW* pRanges )
{
	if (bMarked)
		MarkToMulti();

	if (!bMultiMarked)
		return 0;

	DBG_ASSERT(pMultiSel, "bMultiMarked, but pMultiSel == 0");

    const SCCOLROW nMultiStart = aMultiRange.aStart.Col();
    const SCCOLROW nMultiEnd = aMultiRange.aEnd.Col();
    if (nMultiStart == 0 && nMultiEnd == MAXCOL)
    {
        // One or more entire rows.
        pRanges[0] = 0;
        pRanges[1] = MAXCOL;
        return 1;
    }

	SCCOLROW nRangeCnt = 0;
	SCCOLROW nStart = nMultiStart;
	while (nStart <= nMultiEnd)
	{
		while (nStart < nMultiEnd && !pMultiSel[nStart].HasMarks())
			++nStart;
		if (pMultiSel[nStart].HasMarks())
		{
			SCCOLROW nEnd = nStart;
			while (nEnd < nMultiEnd && pMultiSel[nEnd].HasMarks())
				++nEnd;
			if (!pMultiSel[nEnd].HasMarks())
				--nEnd;
			pRanges[2*nRangeCnt  ] = nStart;
			pRanges[2*nRangeCnt+1] = nEnd;
			++nRangeCnt;
			nStart = nEnd+1;
		}
		else
			nStart = nMultiEnd+1;
	}

	return nRangeCnt;
}

SCCOLROW ScMarkData::GetMarkRowRanges( SCCOLROW* pRanges )
{
	if (bMarked)
		MarkToMulti();

	if (!bMultiMarked)
		return 0;

	DBG_ASSERT(pMultiSel, "bMultiMarked, but pMultiSel == 0");

    // Which rows are marked?

    // Optimized to not loop over MAXCOL*MAXROW as worst case, i.e. Ctrl+A

    const SCCOLROW nMultiStart = aMultiRange.aStart.Row();
    const SCCOLROW nMultiEnd = aMultiRange.aEnd.Row();

    sal_Bool*   bRowMarked = new sal_Bool[MAXROWCOUNT];
    memset( bRowMarked, 0, sizeof(sal_Bool) * MAXROWCOUNT);
	SCROW  nRow;
	SCCOL  nCol;

    SCROW nTop = -1, nBottom = -1;
    for (nCol = aMultiRange.aStart.Col(); nCol <= aMultiRange.aEnd.Col(); ++nCol)
    {
        ScMarkArrayIter aMarkIter( &pMultiSel[nCol] );
        while (aMarkIter.Next( nTop, nBottom ))
            for (nRow=nTop; nRow<=nBottom; nRow++)
                bRowMarked[nRow] = sal_True;
        if (nTop == nMultiStart && nBottom == nMultiEnd)
            break;  // for, all relevant rows marked
    }

    if (nTop == nMultiStart && nBottom == nMultiEnd)
    {
        pRanges[0] = nTop;
        pRanges[1] = nBottom;
        delete[] bRowMarked;
        return 1;
    }

    // Combine to ranges of rows.

    SCCOLROW nRangeCnt = 0;
    SCCOLROW nStart = nMultiStart;
    while (nStart <= nMultiEnd)
    {
        while (nStart < nMultiEnd && !bRowMarked[nStart])
            ++nStart;
        if (bRowMarked[nStart])
        {
            SCCOLROW nEnd = nStart;
            while (nEnd < nMultiEnd && bRowMarked[nEnd])
                ++nEnd;
            if (!bRowMarked[nEnd])
                --nEnd;
            pRanges[2*nRangeCnt  ] = nStart;
            pRanges[2*nRangeCnt+1] = nEnd;
            ++nRangeCnt;
            nStart = nEnd+1;
        }
        else
            nStart = nMultiEnd+1;
    }

	delete[] bRowMarked;
	return nRangeCnt;
}

sal_Bool ScMarkData::IsAllMarked( const ScRange& rRange ) const
{
	if ( !bMultiMarked )
		return sal_False;

	DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");

	SCCOL nStartCol = rRange.aStart.Col();
	SCROW nStartRow = rRange.aStart.Row();
	SCCOL nEndCol = rRange.aEnd.Col();
	SCROW nEndRow = rRange.aEnd.Row();
	sal_Bool bOk = sal_True;
	for (SCCOL nCol=nStartCol; nCol<=nEndCol && bOk; nCol++)
		if ( !pMultiSel[nCol].IsAllMarked( nStartRow, nEndRow ) )
			bOk = sal_False;

	return bOk;
}

SCsROW ScMarkData::GetNextMarked( SCCOL nCol, SCsROW nRow, sal_Bool bUp ) const
{
	if ( !bMultiMarked )
		return nRow;

	DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");

	return pMultiSel[nCol].GetNextMarked( nRow, bUp );
}

sal_Bool ScMarkData::HasMultiMarks( SCCOL nCol ) const
{
	if ( !bMultiMarked )
		return sal_False;

	DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");

	return pMultiSel[nCol].HasMarks();
}

sal_Bool ScMarkData::HasAnyMultiMarks() const
{
	if ( !bMultiMarked )
		return sal_False;

	DBG_ASSERT(pMultiSel, "bMultiMarked, aber pMultiSel == 0");

	for (SCCOL nCol=0; nCol<=MAXCOL; nCol++)
		if ( pMultiSel[nCol].HasMarks() )
			return sal_True;

	return sal_False;		// nix
}

void ScMarkData::InsertTab( SCTAB nTab )
{
	for (SCTAB i=MAXTAB; i>nTab; i--)
		bTabMarked[i] = bTabMarked[i-1];
	bTabMarked[nTab] = sal_False;
}

void ScMarkData::DeleteTab( SCTAB nTab )
{
	for (SCTAB i=nTab; i<MAXTAB; i++)
		bTabMarked[i] = bTabMarked[i+1];
	bTabMarked[MAXTAB] = sal_False;
}