/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   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 .

 */

#include <svx/framelinkarray.hxx>

#include <math.h>

#include <vector>

#include <unordered_set>

#include <algorithm>

#include <o3tl/hash_combine.hxx>

#include <sal/log.hxx>

#include <tools/debug.hxx>

#include <tools/gen.hxx>

#include <vcl/canvastools.hxx>

#include <svx/sdr/primitive2d/sdrframeborderprimitive2d.hxx>

#include <basegfx/matrix/b2dhommatrixtools.hxx>

#include <basegfx/polygon/b2dpolypolygon.hxx>

#include <basegfx/polygon/b2dpolygonclipper.hxx>

#include <basegfx/polygon/b2dpolygon.hxx>

//#define OPTICAL_CHECK_CLIPRANGE_FOR_MERGED_CELL

#ifdef OPTICAL_CHECK_CLIPRANGE_FOR_MERGED_CELL

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx>

#endif

namespace svx::frame {

namespace {

class Cell final

{

private:

    Style               maLeft;

    Style               maRight;

    Style               maTop;

    Style               maBottom;

    Style               maTLBR;

    Style               maBLTR;

    basegfx::B2DHomMatrix HelperCreateB2DHomMatrixFromB2DRange(

        const basegfx::B2DRange& rRange ) const;

public:

    sal_Int32                mnAddLeft;

    sal_Int32                mnAddRight;

    sal_Int32                mnAddTop;

    sal_Int32                mnAddBottom;

    SvxRotateMode       meRotMode;

    double              mfOrientation;

    bool                mbMergeOrig;

    bool                mbOverlapX;

    bool                mbOverlapY;

public:

    explicit Cell();

    explicit Cell(const Cell&) = default;

    bool operator==( const Cell& ) const;

    size_t hashCode() const;

    void SetStyleLeft(const Style& rStyle) { maLeft = rStyle; }

    void SetStyleRight(const Style& rStyle) { maRight = rStyle; }

    void SetStyleTop(const Style& rStyle) { maTop = rStyle; }

    void SetStyleBottom(const Style& rStyle) { maBottom = rStyle; }

    void SetStyleTLBR(const Style& rStyle) { maTLBR = rStyle; }

    void SetStyleBLTR(const Style& rStyle) { maBLTR = rStyle; }

    const Style& GetStyleLeft() const { return maLeft; }

    const Style& GetStyleRight() const { return maRight; }

    const Style& GetStyleTop() const { return maTop; }

    const Style& GetStyleBottom() const { return maBottom; }

    const Style& GetStyleTLBR() const { return maTLBR; }

    const Style& GetStyleBLTR() const { return maBLTR; }

    bool                IsMerged() const { return mbMergeOrig || mbOverlapX || mbOverlapY; }

    bool                IsRotated() const { return mfOrientation != 0.0; }

    void                MirrorSelfX();

    basegfx::B2DHomMatrix CreateCoordinateSystemSingleCell(

        const Array& rArray, sal_Int32 nCol, sal_Int32 nRow ) const;

    basegfx::B2DHomMatrix CreateCoordinateSystemMergedCell(

        const Array& rArray, sal_Int32 nColLeft, sal_Int32 nRowTop, sal_Int32 nColRight, sal_Int32 nRowBottom ) const;

};

}

typedef std::vector< const Cell* >     CellVec;

basegfx::B2DHomMatrix Cell::HelperCreateB2DHomMatrixFromB2DRange(

    const basegfx::B2DRange& rRange ) const

{

    if( rRange.isEmpty() )

        return basegfx::B2DHomMatrix();

    basegfx::B2DPoint aOrigin(rRange.getMinimum());

    basegfx::B2DVector aX(rRange.getWidth(), 0.0);

    basegfx::B2DVector aY(0.0, rRange.getHeight());

    if (IsRotated() && SvxRotateMode::SVX_ROTATE_MODE_STANDARD != meRotMode )

    {

        // tdf#143377 We need to limit applying Skew to geometry since the closer

        // we get to 0.0 or PI the more sin(mfOrientation) will get to zero and the

        // huger the Skew effect will be. For that, use an epsilon-radius of 1/2

        // degree around the dangerous points 0.0 and PI.

        // Snap to modulo to [0.0 .. 2PI[ to make compare easier

        const double fSnapped(::basegfx::snapToZeroRange(mfOrientation, M_PI * 2.0));

        // As a compromise, allow up to 1/2 degree

        static const double fMinAng(M_PI/360.0);

        // Check if Skew makes sense or would be too huge

        const bool bForbidSkew(

            fSnapped < fMinAng || // range [0.0 .. fMinAng]

            fSnapped > (M_PI * 2.0) - fMinAng || // range [PI-fMinAng .. 2PI[

            fabs(fSnapped - M_PI) < fMinAng); // range [PI-fMinAng .. PI+fMinAng]

        if(!bForbidSkew)

        {

            // when rotated, adapt values. Get Skew (cos/sin == 1/tan)

            const double fSkew(aY.getY() * (cos(mfOrientation) / sin(mfOrientation)));

            switch (meRotMode)

            {

            case SvxRotateMode::SVX_ROTATE_MODE_TOP:

                // shear Y-Axis

                aY.setX(-fSkew);

                break;

            case SvxRotateMode::SVX_ROTATE_MODE_CENTER:

                // shear origin half, Y full

                aOrigin.setX(aOrigin.getX() + (fSkew * 0.5));

                aY.setX(-fSkew);

                break;

            case SvxRotateMode::SVX_ROTATE_MODE_BOTTOM:

                // shear origin full, Y full

                aOrigin.setX(aOrigin.getX() + fSkew);

                aY.setX(-fSkew);

                break;

            default: // SvxRotateMode::SVX_ROTATE_MODE_STANDARD, already excluded above

                break;

            }

        }

    }

    // use column vectors as coordinate axes, homogen column for translation

    return basegfx::utils::createCoordinateSystemTransform( aOrigin, aX, aY );

}

basegfx::B2DHomMatrix Cell::CreateCoordinateSystemSingleCell(

    const Array& rArray, sal_Int32 nCol, sal_Int32 nRow) const

{

    const Point aPoint( rArray.GetColPosition( nCol ), rArray.GetRowPosition( nRow ) );

    const Size aSize( rArray.GetColWidth( nCol, nCol ) + 1, rArray.GetRowHeight( nRow, nRow ) + 1 );

    const basegfx::B2DRange aRange( vcl::unotools::b2DRectangleFromRectangle( tools::Rectangle( aPoint, aSize ) ) );

    return HelperCreateB2DHomMatrixFromB2DRange( aRange );

}

basegfx::B2DHomMatrix Cell::CreateCoordinateSystemMergedCell(

    const Array& rArray, sal_Int32 nColLeft, sal_Int32 nRowTop, sal_Int32 nColRight, sal_Int32 nRowBottom) const

{

    basegfx::B2DRange aRange( rArray.GetB2DRange(

        nColLeft, nRowTop, nColRight, nRowBottom ) );

    // adjust rectangle for partly visible merged cells

    if( IsMerged() )

    {

        // not *sure* what exactly this is good for,

        // it is just a hard set extension at merged cells,

        // probably *should* be included in the above extended

        // GetColPosition/GetColWidth already. This might be

        // added due to GetColPosition/GetColWidth not working

        // correctly over PageChanges (if used), but not sure.

        aRange.expand(

            basegfx::B2DRange(

                aRange.getMinX() - mnAddLeft,

                aRange.getMinY() - mnAddTop,

                aRange.getMaxX() + mnAddRight,

                aRange.getMaxY() + mnAddBottom ) );

    }

    return HelperCreateB2DHomMatrixFromB2DRange( aRange );

}

Cell::Cell() :

    mnAddLeft( 0 ),

    mnAddRight( 0 ),

    mnAddTop( 0 ),

    mnAddBottom( 0 ),

    meRotMode(SvxRotateMode::SVX_ROTATE_MODE_STANDARD ),

    mfOrientation( 0.0 ),

    mbMergeOrig( false ),

    mbOverlapX( false ),

    mbOverlapY( false )

{

}

bool Cell::operator==(const Cell& rOther) const

{

    if (this == &rOther)

        // ptr compare (same instance)

        return true;

    return maLeft == rOther.maLeft

        && maRight == rOther.maRight

        && maTop == rOther.maTop

        && maBottom == rOther.maBottom

        && maTLBR == rOther.maTLBR

        && maBLTR == rOther.maBLTR

        && mnAddLeft == rOther.mnAddLeft

        && mnAddRight == rOther.mnAddRight

        && mnAddTop == rOther.mnAddTop

        && mnAddBottom == rOther.mnAddBottom

        && meRotMode == rOther.meRotMode

        && mfOrientation == rOther.mfOrientation

        && mbMergeOrig == rOther.mbMergeOrig

        && mbOverlapX == rOther.mbOverlapX

        && mbOverlapY == rOther.mbOverlapY;

}

size_t Cell::hashCode() const

{

    std::size_t seed = 0;

    o3tl::hash_combine(seed, maLeft.hashCode());

    o3tl::hash_combine(seed, maRight.hashCode());

    o3tl::hash_combine(seed, maTop.hashCode());

    o3tl::hash_combine(seed, maBottom.hashCode());

    o3tl::hash_combine(seed, maTLBR.hashCode());

    o3tl::hash_combine(seed, maBLTR.hashCode());

    o3tl::hash_combine(seed, mnAddLeft);

    o3tl::hash_combine(seed, mnAddRight);

    o3tl::hash_combine(seed, mnAddTop);

    o3tl::hash_combine(seed, mnAddBottom);

    o3tl::hash_combine(seed, meRotMode);

    o3tl::hash_combine(seed, mfOrientation);

    o3tl::hash_combine(seed, mbMergeOrig);

    o3tl::hash_combine(seed, mbOverlapX);

    o3tl::hash_combine(seed, mbOverlapY);

    return seed;

}

void Cell::MirrorSelfX()

{

    std::swap( maLeft, maRight );

    std::swap( mnAddLeft, mnAddRight );

    maLeft.MirrorSelf();

    maRight.MirrorSelf();

    mfOrientation = -mfOrientation;

}

static void lclRecalcCoordVec( std::vector<sal_Int32>& rCoords, const std::vector<sal_Int32>& rSizes )

{

    DBG_ASSERT( rCoords.size() == rSizes.size() + 1, "lclRecalcCoordVec - inconsistent vectors" );

    auto aCIt = rCoords.begin();

    for( const auto& rSize : rSizes )

    {

        *(aCIt + 1) = *aCIt + rSize;

        ++aCIt;

    }

}

const Style OBJ_STYLE_NONE;

const Cell OBJ_CELL_NONE;

/** use hashing to speed up finding duplicates */

namespace

{

struct RegisteredCellHash

{

    size_t operator()(const Cell* pCell) const

    {

        return pCell->hashCode();

    }

};

struct RegisteredCellEquals

{

    bool operator()(const Cell* pCell1, const Cell* pCell2) const

    {

        return *pCell1 == *pCell2;

    }

};

}

struct ArrayImpl

{

    std::unordered_set<Cell*, RegisteredCellHash, RegisteredCellEquals> maRegisteredCells;

    CellVec             maCells;

    std::vector<sal_Int32>   maWidths;

    std::vector<sal_Int32>   maHeights;

    mutable std::vector<sal_Int32>     maXCoords;

    mutable std::vector<sal_Int32>     maYCoords;

    sal_Int32           mnWidth;

    sal_Int32           mnHeight;

    sal_Int32           mnFirstClipCol;

    sal_Int32           mnFirstClipRow;

    sal_Int32           mnLastClipCol;

    sal_Int32           mnLastClipRow;

    mutable bool        mbXCoordsDirty;

    mutable bool        mbYCoordsDirty;

    bool                mbMayHaveCellRotation;

    bool mbXMirrored = false;

    explicit            ArrayImpl( sal_Int32 nWidth, sal_Int32 nHeight );

    ~ArrayImpl();

    bool         IsValidPos( sal_Int32 nCol, sal_Int32 nRow ) const

                            { return (nCol < mnWidth) && (nRow < mnHeight); }

    sal_Int32       GetIndex( sal_Int32 nCol, sal_Int32 nRow ) const

                            { return nRow * mnWidth + nCol; }

    const Cell*         GetCell( sal_Int32 nCol, sal_Int32 nRow ) const;

    void                PutCell( sal_Int32 nCol, sal_Int32 nRow, const Cell& );

    sal_Int32              GetMergedFirstCol( sal_Int32 nCol, sal_Int32 nRow ) const;

    sal_Int32              GetMergedFirstRow( sal_Int32 nCol, sal_Int32 nRow ) const;

    sal_Int32              GetMergedLastCol( sal_Int32 nCol, sal_Int32 nRow ) const;

    sal_Int32              GetMergedLastRow( sal_Int32 nCol, sal_Int32 nRow ) const;

    const Cell* GetMergedStyleSourceCell(sal_Int32 nCol, sal_Int32 nRow) const;

    bool                IsMergedOverlappedLeft( sal_Int32 nCol, sal_Int32 nRow ) const;

    bool                IsMergedOverlappedRight( sal_Int32 nCol, sal_Int32 nRow ) const;

    bool                IsMergedOverlappedTop( sal_Int32 nCol, sal_Int32 nRow ) const;

    bool                IsMergedOverlappedBottom( sal_Int32 nCol, sal_Int32 nRow ) const;

    bool                IsInClipRange( sal_Int32 nCol, sal_Int32 nRow ) const;

    bool                IsColInClipRange( sal_Int32 nCol ) const;

    bool                IsRowInClipRange( sal_Int32 nRow ) const;

    bool                OverlapsClipRange( sal_Int32 nFirstCol, sal_Int32 nFirstRow, sal_Int32 nLastCol, sal_Int32 nLastRow ) const;

    sal_Int32           GetMirrorCol( sal_Int32 nCol ) const { return mnWidth - nCol - 1; }

    sal_Int32           GetColPosition( sal_Int32 nCol ) const;

    sal_Int32           GetRowPosition( sal_Int32 nRow ) const;

    bool                HasCellRotation() const;

    const Cell* createOrFind(const Cell& rCell);

};

static void lclSetMergedRange( ArrayImpl& rImpl, CellVec& rCells, sal_Int32 nWidth, sal_Int32 nFirstCol, sal_Int32 nFirstRow, sal_Int32 nLastCol, sal_Int32 nLastRow )

{

    for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol )

    {

        for( sal_Int32 nRow = nFirstRow; nRow <= nLastRow; ++nRow )

        {

            const Cell* pCell = rCells[ nRow * nWidth + nCol ];

            Cell aTempCell(*pCell);

            aTempCell.mbMergeOrig = false;

            aTempCell.mbOverlapX = nCol > nFirstCol;

            aTempCell.mbOverlapY = nRow > nFirstRow;

            rCells[ nRow * nWidth + nCol ] = rImpl.createOrFind(aTempCell);

        }

    }

    Cell aTempCell(*rCells[ nFirstRow * nWidth + nFirstCol ]);

    aTempCell.mbMergeOrig = true;

    rCells[ nFirstRow * nWidth + nFirstCol ] = rImpl.createOrFind(aTempCell);

}

ArrayImpl::ArrayImpl( sal_Int32 nWidth, sal_Int32 nHeight ) :

    maRegisteredCells(),

    mnWidth( nWidth ),

    mnHeight( nHeight ),

    mnFirstClipCol( 0 ),

    mnFirstClipRow( 0 ),

    mnLastClipCol( nWidth - 1 ),

    mnLastClipRow( nHeight - 1 ),

    mbXCoordsDirty( false ),

    mbYCoordsDirty( false ),

    mbMayHaveCellRotation( false )

{

    const Cell* pDefaultCell = createOrFind(Cell());

    // default-construct all vectors

    maCells.resize( mnWidth * mnHeight, pDefaultCell );

    maWidths.resize( mnWidth, 0 );

    maHeights.resize( mnHeight, 0 );

    maXCoords.resize( mnWidth + 1, 0 );

    maYCoords.resize( mnHeight + 1, 0 );

}

ArrayImpl::~ArrayImpl()

{

    for (auto* pCell : maRegisteredCells)

        delete pCell;

}

const Cell* ArrayImpl::createOrFind(const Cell& rCell)

{

    auto it = maRegisteredCells.find(const_cast<Cell*>(&rCell));

    if (it != maRegisteredCells.end())

        return *it;

    Cell* pRetval(new Cell(rCell));

    maRegisteredCells.insert(pRetval);

    return pRetval;

}

const Cell* ArrayImpl::GetCell( sal_Int32 nCol, sal_Int32 nRow ) const

{

    return IsValidPos( nCol, nRow ) ? maCells[ GetIndex( nCol, nRow ) ] : &OBJ_CELL_NONE;

}

void ArrayImpl::PutCell( sal_Int32 nCol, sal_Int32 nRow, const Cell & rCell )

{

    if (IsValidPos( nCol, nRow ))

        maCells[ GetIndex( nCol, nRow ) ] = createOrFind(rCell);

}

sal_Int32 ArrayImpl::GetMergedFirstCol( sal_Int32 nCol, sal_Int32 nRow ) const

{

    sal_Int32 nFirstCol = nCol;

    while( (nFirstCol > 0) && GetCell( nFirstCol, nRow )->mbOverlapX ) --nFirstCol;

    return nFirstCol;

}

sal_Int32 ArrayImpl::GetMergedFirstRow( sal_Int32 nCol, sal_Int32 nRow ) const

{

    sal_Int32 nFirstRow = nRow;

    while( (nFirstRow > 0) && GetCell( nCol, nFirstRow )->mbOverlapY ) --nFirstRow;

    return nFirstRow;

}

sal_Int32 ArrayImpl::GetMergedLastCol( sal_Int32 nCol, sal_Int32 nRow ) const

{

    sal_Int32 nLastCol = nCol + 1;

    while( (nLastCol < mnWidth) && GetCell( nLastCol, nRow )->mbOverlapX ) ++nLastCol;

    return nLastCol - 1;

}

sal_Int32 ArrayImpl::GetMergedLastRow( sal_Int32 nCol, sal_Int32 nRow ) const

{

    sal_Int32 nLastRow = nRow + 1;

    while( (nLastRow < mnHeight) && GetCell( nCol, nLastRow )->mbOverlapY ) ++nLastRow;

    return nLastRow - 1;

}

const Cell* ArrayImpl::GetMergedStyleSourceCell(sal_Int32 nCol, sal_Int32 nRow) const

{

    if (mbXMirrored)

    {

        return GetCell(GetMergedLastCol(nCol, nRow), GetMergedFirstRow(nCol, nRow));

    }

    return GetCell(GetMergedFirstCol(nCol, nRow), GetMergedFirstRow(nCol, nRow));

}

bool ArrayImpl::IsMergedOverlappedLeft( sal_Int32 nCol, sal_Int32 nRow ) const

{

    const Cell* pCell(GetCell( nCol, nRow ));

    return pCell->mbOverlapX || (pCell->mnAddLeft > 0);

}

bool ArrayImpl::IsMergedOverlappedRight( sal_Int32 nCol, sal_Int32 nRow ) const

{

    return GetCell( nCol + 1, nRow )->mbOverlapX || (GetCell( nCol, nRow )->mnAddRight > 0);

}

bool ArrayImpl::IsMergedOverlappedTop( sal_Int32 nCol, sal_Int32 nRow ) const

{

    const Cell* pCell(GetCell( nCol, nRow ));

    return pCell->mbOverlapY || (pCell->mnAddTop > 0);

}

bool ArrayImpl::IsMergedOverlappedBottom( sal_Int32 nCol, sal_Int32 nRow ) const

{

    return GetCell( nCol, nRow + 1 )->mbOverlapY || (GetCell( nCol, nRow )->mnAddBottom > 0);

}

bool ArrayImpl::IsColInClipRange( sal_Int32 nCol ) const

{

    return (mnFirstClipCol <= nCol) && (nCol <= mnLastClipCol);

}

bool ArrayImpl::IsRowInClipRange( sal_Int32 nRow ) const

{

    return (mnFirstClipRow <= nRow) && (nRow <= mnLastClipRow);

}

bool ArrayImpl::OverlapsClipRange( sal_Int32 nFirstCol, sal_Int32 nFirstRow, sal_Int32 nLastCol, sal_Int32 nLastRow ) const

{

    if(nLastCol < mnFirstClipCol)

        return false;

    if(nFirstCol > mnLastClipCol)

        return false;

    if(nLastRow < mnFirstClipRow)

        return false;

    if(nFirstRow > mnLastClipRow)

        return false;

    return true;

}

bool ArrayImpl::IsInClipRange( sal_Int32 nCol, sal_Int32 nRow ) const

{

    return IsColInClipRange( nCol ) && IsRowInClipRange( nRow );

}

sal_Int32 ArrayImpl::GetColPosition( sal_Int32 nCol ) const

{

    if( mbXCoordsDirty )

    {

        lclRecalcCoordVec( maXCoords, maWidths );

        mbXCoordsDirty = false;

    }

    return maXCoords[ nCol ];

}

sal_Int32 ArrayImpl::GetRowPosition( sal_Int32 nRow ) const

{

    if( mbYCoordsDirty )

    {

        lclRecalcCoordVec( maYCoords, maHeights );

        mbYCoordsDirty = false;

    }

    return maYCoords[ nRow ];

}

bool ArrayImpl::HasCellRotation() const

{

    // check cell array

    for (const auto& aCell : maCells)

    {

        if (aCell->IsRotated())

        {

            return true;

        }

    }

    return false;

}

namespace {

class MergedCellIterator

{

public:

    explicit            MergedCellIterator( const Array& rArray, sal_Int32 nCol, sal_Int32 nRow );

    bool         Is() const { return (mnCol <= mnLastCol) && (mnRow <= mnLastRow); }

    sal_Int32       Col() const { return mnCol; }

    sal_Int32       Row() const { return mnRow; }

    MergedCellIterator& operator++();

private:

    sal_Int32              mnFirstCol;

    sal_Int32              mnFirstRow;

    sal_Int32              mnLastCol;

    sal_Int32              mnLastRow;

    sal_Int32              mnCol;

    sal_Int32              mnRow;

};

}

MergedCellIterator::MergedCellIterator( const Array& rArray, sal_Int32 nCol, sal_Int32 nRow )

{

    rArray.GetMergedRange( mnFirstCol, mnFirstRow, mnLastCol, mnLastRow, nCol, nRow );

    mnCol = mnFirstCol;

    mnRow = mnFirstRow;

}

MergedCellIterator& MergedCellIterator::operator++()

{

    DBG_ASSERT( Is(), "svx::frame::MergedCellIterator::operator++() - already invalid" );

    if( ++mnCol > mnLastCol )

    {

        mnCol = mnFirstCol;

        ++mnRow;

    }

    return *this;

}

#define DBG_FRAME_CHECK( cond, funcname, error )        DBG_ASSERT( cond, "svx::frame::Array::" funcname " - " error )

#define DBG_FRAME_CHECK_COL( col, funcname )            DBG_FRAME_CHECK( (col) < GetColCount(), funcname, "invalid column index" )

#define DBG_FRAME_CHECK_ROW( row, funcname )            DBG_FRAME_CHECK( (row) < GetRowCount(), funcname, "invalid row index" )

#define DBG_FRAME_CHECK_COLROW( col, row, funcname )    DBG_FRAME_CHECK( ((col) < GetColCount()) && ((row) < GetRowCount()), funcname, "invalid cell index" )

#define DBG_FRAME_CHECK_COL_1( col, funcname )          DBG_FRAME_CHECK( (col) <= GetColCount(), funcname, "invalid column index" )

#define DBG_FRAME_CHECK_ROW_1( row, funcname )          DBG_FRAME_CHECK( (row) <= GetRowCount(), funcname, "invalid row index" )

Array::Array()

{

    Initialize( 0, 0 );

}

Array::~Array()

{

}

// array size and column/row indexes

void Array::Initialize( sal_Int32 nWidth, sal_Int32 nHeight )

{

    mxImpl.reset( new ArrayImpl( nWidth, nHeight ) );

}

sal_Int32 Array::GetColCount() const

{

    return mxImpl->mnWidth;

}

sal_Int32 Array::GetRowCount() const

{

    return mxImpl->mnHeight;

}

sal_Int32 Array::GetCellCount() const

{

    return mxImpl->maCells.size();

}

sal_Int32 Array::GetCellIndex( sal_Int32 nCol, sal_Int32 nRow, bool bRTL ) const

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetCellIndex" );

    if (bRTL)

        nCol = mxImpl->GetMirrorCol(nCol);

    return mxImpl->GetIndex( nCol, nRow );

}

// cell border styles

void Array::SetCellStyleLeft( sal_Int32 nCol, sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleLeft" );

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->GetStyleLeft() == rStyle)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.SetStyleLeft(rStyle);

    mxImpl->PutCell( nCol, nRow, aTempCell );

}

void Array::SetCellStyleRight( sal_Int32 nCol, sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleRight" );

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->GetStyleRight() == rStyle)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.SetStyleRight(rStyle);

    mxImpl->PutCell( nCol, nRow, aTempCell );

}

void Array::SetCellStyleTop( sal_Int32 nCol, sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTop" );

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->GetStyleTop() == rStyle)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.SetStyleTop(rStyle);

    mxImpl->PutCell( nCol, nRow, aTempCell );

}

void Array::SetCellStyleBottom( sal_Int32 nCol, sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBottom" );

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->GetStyleBottom() == rStyle)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.SetStyleBottom(rStyle);

    mxImpl->PutCell( nCol, nRow, aTempCell );

}

void Array::SetCellStyleTLBR( sal_Int32 nCol, sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTLBR" );

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->GetStyleTLBR() == rStyle)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.SetStyleTLBR(rStyle);

    mxImpl->PutCell( nCol, nRow, aTempCell );

}

void Array::SetCellStyleBLTR( sal_Int32 nCol, sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBLTR" );

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->GetStyleBLTR() == rStyle)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.SetStyleBLTR(rStyle);

    mxImpl->PutCell( nCol, nRow, aTempCell );

}

void Array::SetCellStyleDiag( sal_Int32 nCol, sal_Int32 nRow, const Style& rTLBR, const Style& rBLTR )

{

    DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleDiag" );

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->GetStyleTLBR() == rTLBR && pTempCell->GetStyleBLTR() == rBLTR)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.SetStyleTLBR(rTLBR);

    aTempCell.SetStyleBLTR(rBLTR);

    mxImpl->PutCell( nCol, nRow, aTempCell );

}

void Array::SetColumnStyleLeft( sal_Int32 nCol, const Style& rStyle )

{

    DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleLeft" );

    for( sal_Int32 nRow = 0; nRow < mxImpl->mnHeight; ++nRow )

        SetCellStyleLeft( nCol, nRow, rStyle );

}

void Array::SetColumnStyleRight( sal_Int32 nCol, const Style& rStyle )

{

    DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleRight" );

    for( sal_Int32 nRow = 0; nRow < mxImpl->mnHeight; ++nRow )

        SetCellStyleRight( nCol, nRow, rStyle );

}

void Array::SetRowStyleTop( sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleTop" );

    for( sal_Int32 nCol = 0; nCol < mxImpl->mnWidth; ++nCol )

        SetCellStyleTop( nCol, nRow, rStyle );

}

void Array::SetRowStyleBottom( sal_Int32 nRow, const Style& rStyle )

{

    DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleBottom" );

    for( sal_Int32 nCol = 0; nCol < mxImpl->mnWidth; ++nCol )

        SetCellStyleBottom( nCol, nRow, rStyle );

}

void Array::SetCellRotation(sal_Int32 nCol, sal_Int32 nRow, SvxRotateMode eRotMode, double fOrientation)

{

    DBG_FRAME_CHECK_COLROW(nCol, nRow, "SetCellRotation");

    const Cell* pTempCell(mxImpl->GetCell(nCol, nRow));

    if (pTempCell->meRotMode == eRotMode && pTempCell->mfOrientation == fOrientation)

        return;

    Cell aTempCell(*pTempCell);

    aTempCell.meRotMode = eRotMode;

    aTempCell.mfOrientation = fOrientation;

    mxImpl->PutCell( nCol, nRow, aTempCell );

    if (!mxImpl->mbMayHaveCellRotation)

    {

        // activate once when a cell gets actually rotated to allow fast

        // answering HasCellRotation() calls

        mxImpl->mbMayHaveCellRotation = aTempCell.IsRotated();

    }

}

bool Array::HasCellRotation() const

{

    if (!mxImpl->mbMayHaveCellRotation)

    {

        // never set, no need to check

        return false;

    }

    return mxImpl->HasCellRotation();

}

const Style& Array::GetCellStyleLeft( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // outside clipping rows or overlapped in merged cells: invisible

    if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedLeft( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // left clipping border: always own left style

    if( nCol == mxImpl->mnFirstClipCol )

        return mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleLeft();

    // right clipping border: always right style of left neighbor cell

    if( nCol == mxImpl->mnLastClipCol + 1 )

        return mxImpl->GetMergedStyleSourceCell(nCol - 1, nRow)->GetStyleRight();

    // outside clipping columns: invisible

    if( !mxImpl->IsColInClipRange( nCol ) )

        return OBJ_STYLE_NONE;

    // inside clipping range: maximum of own left style and right style of left neighbor cell

    return std::max(mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleLeft(),

                    mxImpl->GetMergedStyleSourceCell(nCol - 1, nRow)->GetStyleRight());

}

const Style& Array::GetCellStyleRight( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // outside clipping rows or overlapped in merged cells: invisible

    if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedRight( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // left clipping border: always left style of right neighbor cell

    if( nCol + 1 == mxImpl->mnFirstClipCol )

        return mxImpl->GetMergedStyleSourceCell(nCol + 1, nRow)->GetStyleLeft();

    // right clipping border: always own right style

    if( nCol == mxImpl->mnLastClipCol )

        return mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleRight();

    // outside clipping columns: invisible

    if( !mxImpl->IsColInClipRange( nCol ) )

        return OBJ_STYLE_NONE;

    // inside clipping range: maximum of own right style and left style of right neighbor cell

    return std::max(mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleRight(),

                    mxImpl->GetMergedStyleSourceCell(nCol + 1, nRow)->GetStyleLeft());

}

const Style& Array::GetCellStyleTop( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // outside clipping columns or overlapped in merged cells: invisible

    if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedTop( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // top clipping border: always own top style

    if( nRow == mxImpl->mnFirstClipRow )

        return mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleTop();

    // bottom clipping border: always bottom style of top neighbor cell

    if( nRow == mxImpl->mnLastClipRow + 1 )

        return mxImpl->GetMergedStyleSourceCell(nCol, nRow - 1)->GetStyleBottom();

    // outside clipping rows: invisible

    if( !mxImpl->IsRowInClipRange( nRow ) )

        return OBJ_STYLE_NONE;

    // inside clipping range: maximum of own top style and bottom style of top neighbor cell

    return std::max(mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleTop(),

                    mxImpl->GetMergedStyleSourceCell(nCol, nRow - 1)->GetStyleBottom());

}

const Style& Array::GetCellStyleBottom( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // outside clipping columns or overlapped in merged cells: invisible

    if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedBottom( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // top clipping border: always top style of bottom neighbor cell

    if( nRow + 1 == mxImpl->mnFirstClipRow )

        return mxImpl->GetMergedStyleSourceCell(nCol, nRow + 1)->GetStyleTop();

    // bottom clipping border: always own bottom style

    if( nRow == mxImpl->mnLastClipRow )

        return mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleBottom();

    // outside clipping rows: invisible

    if( !mxImpl->IsRowInClipRange( nRow ) )

        return OBJ_STYLE_NONE;

    // inside clipping range: maximum of own bottom style and top style of bottom neighbor cell

    return std::max(mxImpl->GetMergedStyleSourceCell(nCol, nRow)->GetStyleBottom(),

                    mxImpl->GetMergedStyleSourceCell(nCol, nRow + 1)->GetStyleTop());

}

const Style& Array::GetCellStyleTLBR( sal_Int32 nCol, sal_Int32 nRow ) const

{

    return mxImpl->GetCell( nCol, nRow )->GetStyleTLBR();

}

const Style& Array::GetCellStyleBLTR( sal_Int32 nCol, sal_Int32 nRow ) const

{

    return mxImpl->GetCell( nCol, nRow )->GetStyleBLTR();

}

const Style& Array::GetCellStyleTL( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // not in clipping range: always invisible

    if( !mxImpl->IsInClipRange( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // return style only for top-left cell

    sal_Int32 nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );

    sal_Int32 nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );

    return ((nCol == nFirstCol) && (nRow == nFirstRow)) ?

        mxImpl->GetCell( nFirstCol, nFirstRow )->GetStyleTLBR() : OBJ_STYLE_NONE;

}

const Style& Array::GetCellStyleBR( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // not in clipping range: always invisible

    if( !mxImpl->IsInClipRange( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // return style only for bottom-right cell

    sal_Int32 nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );

    sal_Int32 nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );

    return ((nCol == nLastCol) && (nRow == nLastRow)) ?

        mxImpl->GetCell( mxImpl->GetMergedFirstCol( nCol, nRow ), mxImpl->GetMergedFirstRow( nCol, nRow ) )->GetStyleTLBR() : OBJ_STYLE_NONE;

}

const Style& Array::GetCellStyleBL( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // not in clipping range: always invisible

    if( !mxImpl->IsInClipRange( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // return style only for bottom-left cell

    sal_Int32 nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow );

    sal_Int32 nLastRow = mxImpl->GetMergedLastRow( nCol, nRow );

    return ((nCol == nFirstCol) && (nRow == nLastRow)) ?

        mxImpl->GetCell( nFirstCol, mxImpl->GetMergedFirstRow( nCol, nRow ) )->GetStyleBLTR() : OBJ_STYLE_NONE;

}

const Style& Array::GetCellStyleTR( sal_Int32 nCol, sal_Int32 nRow ) const

{

    // not in clipping range: always invisible

    if( !mxImpl->IsInClipRange( nCol, nRow ) )

        return OBJ_STYLE_NONE;

    // return style only for top-right cell

    sal_Int32 nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow );

    sal_Int32 nLastCol = mxImpl->GetMergedLastCol( nCol, nRow );

    return ((nCol == nLastCol) && (nRow == nFirstRow)) ?

        mxImpl->GetCell( mxImpl->GetMergedFirstCol( nCol, nRow ), nFirstRow )->GetStyleBLTR() : OBJ_STYLE_NONE;

}

// cell merging

void Array::SetMergedRange( sal_Int32 nFirstCol, sal_Int32 nFirstRow, sal_Int32 nLastCol, sal_Int32 nLastRow )

{

    DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "SetMergedRange" );

    DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "SetMergedRange" );

#if OSL_DEBUG_LEVEL >= 2

    {

        bool bFound = false;

        for( sal_Int32 nCurrCol = nFirstCol; !bFound && (nCurrCol <= nLastCol); ++nCurrCol )

            for( sal_Int32 nCurrRow = nFirstRow; !bFound && (nCurrRow <= nLastRow); ++nCurrRow )

                bFound = mxImpl->GetCell( nCurrCol, nCurrRow )->IsMerged();