/* -*- 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 <scitems.hxx>

#include <editeng/brushitem.hxx>

#include <svtools/colorcfg.hxx>

#include <svx/rotmodit.hxx>

#include <svx/svdocapt.hxx>

#include <editeng/shaditem.hxx>

#include <editeng/svxfont.hxx>

#include <tools/poly.hxx>

#include <vcl/svapp.hxx>

#include <vcl/pdfextoutdevdata.hxx>

#include <svx/framelinkarray.hxx>

#include <drawinglayer/geometry/viewinformation2d.hxx>

#include <drawinglayer/processor2d/baseprocessor2d.hxx>

#include <drawinglayer/processor2d/processor2dtools.hxx>

#include <officecfg/Office/Common.hxx>

#include <officecfg/Office/Calc.hxx>

#include <vcl/lineinfo.hxx>

#include <vcl/gradient.hxx>

#include <vcl/settings.hxx>

#include <vcl/pdf/PDFNote.hxx>

#include <svx/unoapi.hxx>

#include <sal/log.hxx>

#include <comphelper/lok.hxx>

#include <o3tl/unit_conversion.hxx>

#include <basegfx/matrix/b2dhommatrix.hxx>

#include <output.hxx>

#include <document.hxx>

#include <drwlayer.hxx>

#include <formulacell.hxx>

#include <attrib.hxx>

#include <patattr.hxx>

#include <progress.hxx>

#include <pagedata.hxx>

#include <chgtrack.hxx>

#include <chgviset.hxx>

#include <viewutil.hxx>

#include <gridmerg.hxx>

#include <fillinfo.hxx>

#include <scmod.hxx>

#include <appoptio.hxx>

#include <postit.hxx>

#include <validat.hxx>

#include <detfunc.hxx>

#include <editutil.hxx>

#include <SparklineRenderer.hxx>

#include <colorscale.hxx>

#include <math.h>

#include <memory>

using namespace com::sun::star;

// Static Data

// color for ChangeTracking "by author" as in the writer (swmodul1.cxx)

#define SC_AUTHORCOLORCOUNT     9

const Color nAuthorColor[ SC_AUTHORCOLORCOUNT ] = {

                    COL_LIGHTRED,       COL_LIGHTBLUE,      COL_LIGHTMAGENTA,

                    COL_GREEN,          COL_RED,            COL_BLUE,

                    COL_BROWN,          COL_MAGENTA,        COL_CYAN };

// Helper class for color assignment to avoid repeated lookups for the same user

ScActionColorChanger::ScActionColorChanger( const ScChangeTrack& rTrack ) :

    rOpt( ScModule::get()->GetAppOptions() ),

    rUsers( rTrack.GetUserCollection() ),

    nLastUserIndex( 0 ),

    nColor( COL_BLACK )

{

}

void ScActionColorChanger::Update( const ScChangeAction& rAction )

{

    Color nSetColor;

    switch (rAction.GetType())

    {

        case SC_CAT_INSERT_COLS:

        case SC_CAT_INSERT_ROWS:

        case SC_CAT_INSERT_TABS:

            nSetColor = rOpt.GetTrackInsertColor();

            break;

        case SC_CAT_DELETE_COLS:

        case SC_CAT_DELETE_ROWS:

        case SC_CAT_DELETE_TABS:

            nSetColor = rOpt.GetTrackDeleteColor();

            break;

        case SC_CAT_MOVE:

            nSetColor = rOpt.GetTrackMoveColor();

            break;

        default:

            nSetColor = rOpt.GetTrackContentColor();

            break;

    }

    if ( nSetColor != COL_TRANSPARENT )     // color assigned

        nColor = nSetColor;

    else                                    // by author

    {

        if (aLastUserName != rAction.GetUser())

        {

            aLastUserName = rAction.GetUser();

            std::set<OUString>::const_iterator it = rUsers.find(aLastUserName);

            if (it == rUsers.end())

            {

                // empty string is possible if a name wasn't found while saving a 5.0 file

                SAL_INFO_IF( aLastUserName.isEmpty(), "sc.ui", "Author not found" );

                nLastUserIndex = 0;

            }

            else

            {

                size_t nPos = std::distance(rUsers.begin(), it);

                nLastUserIndex = nPos % SC_AUTHORCOLORCOUNT;

            }

        }

        nColor = nAuthorColor[nLastUserIndex];

    }

}

ScOutputData::ScOutputData( OutputDevice* pNewDev, ScOutputType eNewType,

                            ScTableInfo& rTabInfo, ScDocument* pNewDoc,

                            SCTAB nNewTab, tools::Long nNewScrX, tools::Long nNewScrY,

                            SCCOL nNewX1, SCROW nNewY1, SCCOL nNewX2, SCROW nNewY2,

                            double nPixelPerTwipsX, double nPixelPerTwipsY,

                            const Fraction* pZoomX, const Fraction* pZoomY ) :

    mpOriginalTargetDevice( pNewDev ),

    mpDev( pNewDev ),

    mpRefDevice( pNewDev ),      // default is output device

    pFmtDevice( pNewDev ),      // default is output device

    mrTabInfo( rTabInfo ),

    mpRowInfo( rTabInfo.mpRowInfo.get() ),

    mnArrCount( rTabInfo.mnArrCount ),

    mpDoc( pNewDoc ),

    mnTab( nNewTab ),

    mnScrX( nNewScrX ),

    mnScrY( nNewScrY ),

    mnX1( nNewX1 ),

    mnY1( nNewY1 ),

    mnX2( nNewX2 ),

    mnY2( nNewY2 ),

    meType( eNewType ),

    mnPPTX( nPixelPerTwipsX ),

    mnPPTY( nPixelPerTwipsY ),

    mpViewShell( nullptr ),

    mpDrawView( nullptr ),

    mbEditMode( false ),

    mnEditCol( 0 ),

    mnEditRow( 0 ),

    mbMetaFile( false ),

    mbPagebreakMode( false ),

    mbSolidBackground( false ),

    mbUseStyleColor( false ),

    mbForceAutoColor( officecfg::Office::Common::Accessibility::IsAutomaticFontColor::get() ),

    mbSyntaxMode( false ),

    maGridColor( COL_BLACK ),

    mbShowNullValues( true ),

    mbShowFormulas( false ),

    mbShowSpellErrors( false ),

    mbMarkClipped( false ), // sal_False for printer/metafile etc.

    mbSnapPixel( false ),

    mbAnyClipped( false ),

    mbVertical(false),

    mpTargetPaintWindow(nullptr), // #i74769# use SdrPaintWindow direct

    mpSpellCheckCxt(nullptr)

{

    if (pZoomX)

        maZoomX = *pZoomX;

    else

        maZoomX = Fraction(1,1);

    if (pZoomY)

        maZoomY = *pZoomY;

    else

        maZoomY = Fraction(1,1);

    mnVisX1 = mnX1;

    mnVisY1 = mnY1;

    mnVisX2 = mnX2;

    mnVisY2 = mnY2;

    mpDoc->StripHidden( mnVisX1, mnVisY1, mnVisX2, mnVisY2, mnTab );

    mnScrW = 0;

    for (SCCOL nX=mnVisX1; nX<=mnVisX2; nX++)

        mnScrW += mpRowInfo[0].basicCellInfo(nX).nWidth;

    mnMirrorW = mnScrW;

    mnScrH = 0;

    for (SCSIZE nArrY=1; nArrY+1<mnArrCount; nArrY++)

        mnScrH += mpRowInfo[nArrY].nHeight;

    mbTabProtected = mpDoc->IsTabProtected( mnTab );

    mbLayoutRTL = mpDoc->IsLayoutRTL( mnTab );

    // always needed, so call at the end of the constructor

    SetCellRotations();

    InitOutputEditEngine();

}

ScOutputData::~ScOutputData()

{

}

void ScOutputData::SetSpellCheckContext( const sc::SpellCheckContext* pCxt )

{

    mpSpellCheckCxt = pCxt;

}

void ScOutputData::SetContentDevice( OutputDevice* pContentDev )

{

    // use pContentDev instead of pDev where used

    if ( mpRefDevice == mpDev )

        mpRefDevice = pContentDev;

    if ( pFmtDevice == mpDev )

        pFmtDevice = pContentDev;

    mpDev = pContentDev;

}

void ScOutputData::SetMirrorWidth( tools::Long nNew )

{

    mnMirrorW = nNew;

}

void ScOutputData::SetGridColor( const Color& rColor )

{

    maGridColor = rColor;

}

void ScOutputData::SetMarkClipped( bool bSet )

{

    mbMarkClipped = bSet;

}

void ScOutputData::SetShowNullValues( bool bSet )

{

    mbShowNullValues = bSet;

}

void ScOutputData::SetShowFormulas( bool bSet )

{

    mbShowFormulas = bSet;

}

void ScOutputData::SetShowSpellErrors( bool bSet )

{

    mbShowSpellErrors = bSet;

    // reset EditEngine because it depends on bShowSpellErrors

    mxOutputEditEngine.reset();

}

void ScOutputData::SetSnapPixel()

{

    mbSnapPixel = true;

}

void ScOutputData::SetEditCell( SCCOL nCol, SCROW nRow )

{

    mnEditCol = nCol;

    mnEditRow = nRow;

    mbEditMode = true;

}

void ScOutputData::SetMetaFileMode( bool bNewMode )

{

    mbMetaFile = bNewMode;

}

void ScOutputData::SetSyntaxMode( bool bNewMode )

{

    mbSyntaxMode = bNewMode;

    if ( bNewMode && !mxValueColor )

    {

        const svtools::ColorConfig& rColorCfg = ScModule::get()->GetColorConfig();

        mxValueColor = rColorCfg.GetColorValue( svtools::CALCVALUE ).nColor;

        mxTextColor = rColorCfg.GetColorValue( svtools::CALCTEXT ).nColor;

        mxFormulaColor = rColorCfg.GetColorValue( svtools::CALCFORMULA ).nColor;

    }

}

bool ScOutputData::ReopenPDFStructureElement(vcl::pdf::StructElement aType, SCROW nRow, SCCOL nCol)

{

    bool bReopenTag = false;

    vcl::PDFExtOutDevData* pPDF = dynamic_cast<vcl::PDFExtOutDevData*>(mpDev->GetExtOutDevData());

    if (pPDF)

    {

        if (aType == vcl::pdf::StructElement::Part) // Worksheet

        {

            if (pPDF->GetScPDFState()->m_WorksheetId != -1)

            {

                sal_Int32 nId = pPDF->GetScPDFState()->m_WorksheetId;

                pPDF->BeginStructureElement(nId);

                bReopenTag = true;

            }

        }

        else if (aType == vcl::pdf::StructElement::TableRow)

        {

            const auto aIter = pPDF->GetScPDFState()->m_TableRowMap.find(nRow);

            if (aIter != pPDF->GetScPDFState()->m_TableRowMap.end() && nRow == aIter->first)

            {

                sal_Int32 nId = (*aIter).second;

                pPDF->BeginStructureElement(nId);

                bReopenTag = true;

            }

        }

        else if (aType == vcl::pdf::StructElement::TableData)

        {

            const std::pair<SCROW, SCCOL> keyToFind = std::make_pair(nRow, nCol);

            const auto aIter = pPDF->GetScPDFState()->m_TableDataMap.find(keyToFind);

            if (aIter != pPDF->GetScPDFState()->m_TableDataMap.end() && keyToFind == aIter->first)

            {

                sal_Int32 nId = (*aIter).second;

                pPDF->BeginStructureElement(nId);

                bReopenTag = true;

            }

        }

    }

    return bReopenTag;

}

void ScOutputData::DrawGrid(vcl::RenderContext& rRenderContext, bool bGrid, bool bPage, bool bMergeCover)

{

    // bMergeCover : Draw lines in sheet bgcolor to cover lok client grid lines in merged cell areas.

    // When scNoGridBackground is set in lok mode, bMergeCover is set to true and bGrid to false.

    SCCOL nX;

    SCROW nY;

    tools::Long nPosX;

    tools::Long nPosY;

    SCSIZE nArrY;

    ScBreakType nBreak    = ScBreakType::NONE;

    ScBreakType nBreakOld = ScBreakType::NONE;

    bool bDashed = false;

    Color aPageColor;

    Color aManualColor;

    if (mbPagebreakMode)

        bPage = false;          // no "normal" breaks over the whole width/height

    // It is a big mess to distinguish when we are using pixels and when logic

    // units for drawing.  Ultimately we want to work only in the logic units,

    // but until that happens, we need to special-case:

    //

    //   * metafile

    //   * drawing to the screen - everything is internally counted in pixels there

    //

    // 'Internally' in the above means the pCellInfo[...].nWidth and

    // mpRowInfo[...]->nHeight:

    //

    //   * when bWorksInPixels is true: these are in pixels

    //   * when bWorksInPixels is false: these are in the logic units

    //

    // This is where all the confusion comes from, ultimately we want them

    // always in the logic units (100th of millimeters), but we need to get

    // there gradually (get rid of setting MapUnit::MapPixel first), otherwise we'd

    // break all the drawing by one change.

    // So until that happens, we need to special case.

    bool bWorksInPixels = mbMetaFile;

    const svtools::ColorConfig& rColorCfg = ScModule::get()->GetColorConfig();

    Color aSheetBGColor = rColorCfg.GetColorValue(::svtools::DOCCOLOR).nColor;

    if ( meType == OUTTYPE_WINDOW )

    {

        bWorksInPixels = true;

        aPageColor = rColorCfg.GetColorValue(svtools::CALCPAGEBREAKAUTOMATIC).nColor;

        aManualColor = rColorCfg.GetColorValue(svtools::CALCPAGEBREAKMANUAL).nColor;

    }

    else

    {

        aPageColor = maGridColor;

        aManualColor = maGridColor;

    }

    tools::Long nOneX = 1;

    tools::Long nOneY = 1;

    if (!bWorksInPixels)

    {

        Size aOnePixel = rRenderContext.PixelToLogic(Size(1,1));

        nOneX = aOnePixel.Width();

        nOneY = aOnePixel.Height();

    }

    tools::Long nLayoutSign = mbLayoutRTL ? -1 : 1;

    tools::Long nSignedOneX = nOneX * nLayoutSign;

    rRenderContext.SetLineColor(bMergeCover ? aSheetBGColor : maGridColor);

    ScGridMerger aGrid(&rRenderContext, nOneX, nOneY);

    // vertical lines

    nPosX = mnScrX;

    if ( mbLayoutRTL )

        nPosX += mnMirrorW - nOneX;

    for (nX=mnX1; nX<=mnX2; nX++)

    {

        sal_uInt16 nWidth = mpRowInfo[0].basicCellInfo(nX).nWidth;

        if (nWidth)

        {

            nPosX += nWidth * nLayoutSign;

            if ( bPage )

            {

                // Search also in hidden part for page breaks

                SCCOL nCol = nX + 1;

                while (nCol <= mpDoc->MaxCol())

                {

                    nBreak = mpDoc->HasColBreak(nCol, mnTab);

                    bool bHidden = mpDoc->ColHidden(nCol, mnTab);

                    if ( nBreak != ScBreakType::NONE || !bHidden )

                        break;

                    ++nCol;

                }

                if (nBreak != nBreakOld)

                {

                    aGrid.Flush();

                    if (static_cast<int>(nBreak))

                    {

                        rRenderContext.SetLineColor( (nBreak & ScBreakType::Manual) ? aManualColor :

                                                        aPageColor );

                        bDashed = true;

                    }

                    else

                    {

                        rRenderContext.SetLineColor(bMergeCover ? aSheetBGColor : maGridColor);

                        bDashed = false;

                    }

                    nBreakOld = nBreak;

                }

            }

            bool bDraw = bGrid || nBreakOld != ScBreakType::NONE || bMergeCover; // simple grid only if set that way

            sal_uInt16 nWidthXplus1 = mpRowInfo[0].basicCellInfo(nX+1).nWidth;

            bool bSingle = false; //! get into Fillinfo !!!!!

            if ( nX<mpDoc->MaxCol() )

            {

                bSingle = ( nWidthXplus1 == 0 );

                for (nArrY=1; nArrY+1<mnArrCount && !bSingle; nArrY++)

                {

                    if (mpRowInfo[nArrY].cellInfo(nX+1).bHOverlapped)

                        bSingle = true;

                    if (mpRowInfo[nArrY].cellInfo(nX).bHideGrid)

                        bSingle = true;

                }

            }

            if (bDraw)

            {

                if ( nX<mpDoc->MaxCol() && bSingle )

                {

                    SCCOL nVisX = nX + 1;

                    while ( nVisX < mpDoc->MaxCol() && !mpDoc->GetColWidth(nVisX,mnTab) )

                        ++nVisX;

                    nPosY = mnScrY;

                    for (nArrY=1; nArrY+1<mnArrCount; nArrY++)

                    {

                        RowInfo* pThisRowInfo = &mpRowInfo[nArrY];

                        const tools::Long nNextY = nPosY + pThisRowInfo->nHeight;

                        bool bHOver = pThisRowInfo->cellInfo(nX).bHideGrid;

                        if (!bHOver)

                        {

                            if (nWidthXplus1)

                                bHOver = pThisRowInfo->cellInfo(nX+1).bHOverlapped;

                            else

                            {

                                if (nVisX <= mnX2)

                                    bHOver = pThisRowInfo->cellInfo(nVisX).bHOverlapped;

                                else

                                    bHOver = mpDoc->GetAttr(

                                                nVisX,pThisRowInfo->nRowNo,mnTab,ATTR_MERGE_FLAG)

                                                .IsHorOverlapped();

                                if (bHOver)

                                    bHOver = mpDoc->GetAttr(

                                                nX + 1,pThisRowInfo->nRowNo,mnTab,ATTR_MERGE_FLAG)

                                                .IsHorOverlapped();

                            }

                        }

                        if ((pThisRowInfo->bChanged && !bHOver && !bMergeCover) || (bHOver && bMergeCover))

                        {

                            aGrid.AddVerLine(bWorksInPixels, nPosX-nSignedOneX, nPosY, nNextY-nOneY, bDashed);

                        }

                        nPosY = nNextY;

                    }

                }

                else if (!bMergeCover)

                {

                    aGrid.AddVerLine(bWorksInPixels, nPosX-nSignedOneX, mnScrY, mnScrY+mnScrH-nOneY, bDashed);

                }

            }

        }

    }

    // horizontal lines

    bool bHiddenRow = true;

    SCROW nHiddenEndRow = -1;

    nPosY = mnScrY;

    for (nArrY=1; nArrY+1<mnArrCount; nArrY++)

    {

        SCSIZE nArrYplus1 = nArrY+1;

        nY = mpRowInfo[nArrY].nRowNo;

        SCROW nYplus1 = nY+1;

        nPosY += mpRowInfo[nArrY].nHeight;

        if (mpRowInfo[nArrY].bChanged)

        {

            if ( bPage )

            {

                for (SCROW i = nYplus1; i <= mpDoc->MaxRow(); ++i)

                {

                    if (i > nHiddenEndRow)

                        bHiddenRow = mpDoc->RowHidden(i, mnTab, nullptr, &nHiddenEndRow);

                    /* TODO: optimize the row break thing for large hidden

                     * segments where HasRowBreak() has to be called

                     * nevertheless for each row, as a row break is drawn also

                     * for hidden rows, above them. This needed to be done only

                     * once per hidden segment, maybe giving manual breaks

                     * priority. Something like GetNextRowBreak() and

                     * GetNextManualRowBreak(). */

                    nBreak = mpDoc->HasRowBreak(i, mnTab);

                    if (!bHiddenRow || nBreak != ScBreakType::NONE)

                        break;

                }

                if (nBreakOld != nBreak)

                {

                    aGrid.Flush();

                    if (static_cast<int>(nBreak))

                    {

                        rRenderContext.SetLineColor( (nBreak & ScBreakType::Manual) ? aManualColor :

                                                        aPageColor );

                        bDashed = true;

                    }

                    else

                    {

                        rRenderContext.SetLineColor(bMergeCover ? aSheetBGColor : maGridColor);

                        bDashed = false;

                    }

                    nBreakOld = nBreak;

                }

            }

            bool bDraw = bGrid || nBreakOld != ScBreakType::NONE || bMergeCover;    // simple grid only if set so

            bool bNextYisNextRow = (mpRowInfo[nArrYplus1].nRowNo == nYplus1);

            bool bSingle = !bNextYisNextRow;             // Hidden

            for (SCCOL i=mnX1; i<=mnX2 && !bSingle; i++)

            {

                if (mpRowInfo[nArrYplus1].cellInfo(i).bVOverlapped)

                    bSingle = true;

            }

            if (bDraw)

            {

                if ( bSingle && nY<mpDoc->MaxRow() )

                {

                    SCROW nVisY = mpRowInfo[nArrYplus1].nRowNo;

                    nPosX = mnScrX;

                    if ( mbLayoutRTL )

                        nPosX += mnMirrorW - nOneX;

                    for (SCCOL i=mnX1; i<=mnX2; i++)

                    {

                        const tools::Long nNextX = nPosX + mpRowInfo[0].basicCellInfo(i).nWidth * nLayoutSign;

                        if (nNextX != nPosX)                                // visible

                        {

                            bool bVOver;

                            if ( bNextYisNextRow )

                                bVOver = mpRowInfo[nArrYplus1].cellInfo(i).bVOverlapped;

                            else

                            {

                                bVOver = mpDoc->GetAttr(

                                            i,nYplus1,mnTab,ATTR_MERGE_FLAG)

                                            .IsVerOverlapped()

                                    &&   mpDoc->GetAttr(

                                            i,nVisY,mnTab,ATTR_MERGE_FLAG)

                                            .IsVerOverlapped();

                                    //! nVisY from Array ??

                            }

                            if ((!bVOver && !bMergeCover) || (bVOver && bMergeCover))

                            {

                                aGrid.AddHorLine(bWorksInPixels, nPosX, nNextX-nSignedOneX, nPosY-nOneY, bDashed);

                            }

                        }

                        nPosX = nNextX;

                    }

                }

                else if (!bMergeCover)

                {

                    aGrid.AddHorLine(bWorksInPixels, mnScrX, mnScrX+mnScrW-nOneX, nPosY-nOneY, bDashed);

                }

            }

        }

    }

}

void ScOutputData::SetPagebreakMode( ScPageBreakData* pPageData )

{

    mbPagebreakMode = true;

    if (!pPageData)

        return;                     // not yet initialized -> everything "not printed"

    // mark printed range

    // (everything in FillInfo is already initialized to sal_False)

    sal_uInt16 nRangeCount = sal::static_int_cast<sal_uInt16>(pPageData->GetCount());

    for (sal_uInt16 nPos=0; nPos<nRangeCount; nPos++)

    {

        ScRange aRange = pPageData->GetData( nPos ).GetPrintRange();

        SCCOL nStartX = std::max( aRange.aStart.Col(), mnX1 );

        SCCOL nEndX   = std::min( aRange.aEnd.Col(),   mnX2 );

        SCROW nStartY = std::max( aRange.aStart.Row(), mnY1 );

        SCROW nEndY   = std::min( aRange.aEnd.Row(),   mnY2 );

        for (SCSIZE nArrY=1; nArrY+1<mnArrCount; nArrY++)

        {

            RowInfo* pThisRowInfo = &mpRowInfo[nArrY];

            if ( pThisRowInfo->bChanged && pThisRowInfo->nRowNo >= nStartY &&

                                           pThisRowInfo->nRowNo <= nEndY )

            {

                for (SCCOL nX=nStartX; nX<=nEndX; nX++)

                    pThisRowInfo->cellInfo(nX).bPrinted = true;

            }

        }

    }

}

void ScOutputData::SetCellRotations()

{

    //! save nRotMax

    SCCOL nRotMax = mnX2;

    for (SCSIZE nRotY=0; nRotY<mnArrCount; nRotY++)

        if (mpRowInfo[nRotY].nRotMaxCol != SC_ROTMAX_NONE && mpRowInfo[nRotY].nRotMaxCol > nRotMax)

            nRotMax = mpRowInfo[nRotY].nRotMaxCol;

    for (SCSIZE nArrY=1; nArrY<mnArrCount; nArrY++)

    {

        RowInfo* pThisRowInfo = &mpRowInfo[nArrY];

        if ( pThisRowInfo->nRotMaxCol != SC_ROTMAX_NONE &&

             ( pThisRowInfo->bChanged || mpRowInfo[nArrY-1].bChanged ||

               ( nArrY+1<mnArrCount && mpRowInfo[nArrY+1].bChanged ) ) )

        {

            SCROW nY = pThisRowInfo->nRowNo;

            for (SCCOL nX=0; nX<=nRotMax; nX++)

            {

                ScCellInfo* pInfo = &pThisRowInfo->cellInfo(nX);

                const ScPatternAttr* pPattern = pInfo->pPatternAttr;

                const SfxItemSet* pCondSet = pInfo->pConditionSet;

                if ( !pPattern && !mpDoc->ColHidden(nX, mnTab) )

                {

                    pPattern = mpDoc->GetPattern( nX, nY, mnTab );

                    pCondSet = mpDoc->GetCondResult( nX, nY, mnTab );

                }

                if ( pPattern )     // column isn't hidden

                {

                    ScRotateDir nDir = pPattern->GetRotateDir( pCondSet );

                    if (nDir != ScRotateDir::NONE)

                    {

                        // Needed for ScCellInfo internal decisions (bg fill, ...)

                        pInfo->nRotateDir = nDir;

                        // create target coordinates

                        const SCCOL nTargetX(nX - mnVisX1 + 1);

                        const SCROW nTargetY(nY - mnVisY1 + 1);

                        // Check for values - below in SetCellRotation these will

                        // be converted to size_t and thus may not be negative

                        // tdf#168023: also do not rotate if the cell is empty

                        if(nTargetX >= 0 && nTargetY >= 0 && !pInfo->maCell.hasEmptyValue())

                        {

                            // add rotation info to Array information

                            const Degree100 nAttrRotate(pPattern->GetRotateVal(pCondSet));

                            const SvxRotateMode eRotMode(pPattern->GetItem(ATTR_ROTATE_MODE, pCondSet).GetValue());

                            const double fOrient((mbLayoutRTL ? -1.0 : 1.0) * toRadians(nAttrRotate)); // 1/100th degrees -> [0..2PI]

                            svx::frame::Array& rArray = mrTabInfo.maArray;

                            rArray.SetCellRotation(nTargetX, nTargetY, eRotMode, fOrient);

                        }

                    }

                }

            }

        }

    }

}

static ScRotateDir lcl_GetRotateDir( const ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB mnTab )

{

    const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, mnTab );

    const SfxItemSet* pCondSet = pDoc->GetCondResult( nCol, nRow, mnTab );

    ScRotateDir nRet = ScRotateDir::NONE;

    Degree100 nAttrRotate = pPattern->GetRotateVal( pCondSet );

    if ( nAttrRotate )

    {

        SvxRotateMode eRotMode =

                    pPattern->GetItem(ATTR_ROTATE_MODE, pCondSet).GetValue();

        if ( eRotMode == SVX_ROTATE_MODE_STANDARD )

            nRet = ScRotateDir::Standard;

        else if ( eRotMode == SVX_ROTATE_MODE_CENTER )

            nRet = ScRotateDir::Center;

        else if ( eRotMode == SVX_ROTATE_MODE_TOP || eRotMode == SVX_ROTATE_MODE_BOTTOM )

        {

            tools::Long nRot180 = nAttrRotate.get() % 18000;     // 1/100 degree

            if ( nRot180 == 9000 )

                nRet = ScRotateDir::Center;

            else if ( ( eRotMode == SVX_ROTATE_MODE_TOP && nRot180 < 9000 ) ||

                      ( eRotMode == SVX_ROTATE_MODE_BOTTOM && nRot180 > 9000 ) )

                nRet = ScRotateDir::Left;

            else

                nRet = ScRotateDir::Right;

        }

    }

    return nRet;

}

static const SvxBrushItem* lcl_FindBackground( const ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB mnTab )

{

    const ScPatternAttr* pPattern = pDoc->GetPattern( nCol, nRow, mnTab );

    const SfxItemSet* pCondSet = pDoc->GetCondResult( nCol, nRow, mnTab );

    const SvxBrushItem* pBackground =

                            &pPattern->GetItem( ATTR_BACKGROUND, pCondSet );

    ScRotateDir nDir = lcl_GetRotateDir( pDoc, nCol, nRow, mnTab );

    // treat CENTER like RIGHT

    if ( nDir == ScRotateDir::Right || nDir == ScRotateDir::Center )

    {

        // text goes to the right -> take background from the left

        while ( nCol > 0 && lcl_GetRotateDir( pDoc, nCol, nRow, mnTab ) == nDir &&

                            pBackground->GetColor().GetAlpha() != 0 )

        {

            --nCol;

            pPattern = pDoc->GetPattern( nCol, nRow, mnTab );

            pCondSet = pDoc->GetCondResult( nCol, nRow, mnTab );

            pBackground = &pPattern->GetItem( ATTR_BACKGROUND, pCondSet );

        }

    }

    else if ( nDir == ScRotateDir::Left )

    {

        // text goes to the left -> take background from the right

        while ( nCol < pDoc->MaxCol() && lcl_GetRotateDir( pDoc, nCol, nRow, mnTab ) == nDir &&

                            pBackground->GetColor().GetAlpha() != 0 )

        {

            ++nCol;

            pPattern = pDoc->GetPattern( nCol, nRow, mnTab );

            pCondSet = pDoc->GetCondResult( nCol, nRow, mnTab );

            pBackground = &pPattern->GetItem( ATTR_BACKGROUND, pCondSet );

        }

    }

    return pBackground;

}

static bool lcl_EqualBack( const RowInfo& rFirst, const RowInfo& rOther,

                    SCCOL mnX1, SCCOL mnX2, bool bShowProt, bool bPagebreakMode )

{

    if ( rFirst.bChanged   != rOther.bChanged ||

         rFirst.bEmptyBack != rOther.bEmptyBack )

        return false;

    SCCOL nX;

    if ( bShowProt )

    {

        for ( nX=mnX1; nX<=mnX2; nX++ )

        {

            const ScPatternAttr* pPat1 = rFirst.cellInfo(nX).pPatternAttr;

            const ScPatternAttr* pPat2 = rOther.cellInfo(nX).pPatternAttr;

            if ( !pPat1 || !pPat2 ||

                    !SfxPoolItem::areSame(pPat1->GetItem(ATTR_PROTECTION), pPat2->GetItem(ATTR_PROTECTION) ) )

                return false;

        }

    }

    else

    {

        for ( nX=mnX1; nX<=mnX2; nX++ )

            if ( !SfxPoolItem::areSame(rFirst.cellInfo(nX).maBackground.getItem(), rOther.cellInfo(nX).maBackground.getItem() ) )

                return false;

    }

    if ( rFirst.nRotMaxCol != SC_ROTMAX_NONE || rOther.nRotMaxCol != SC_ROTMAX_NONE )

        for ( nX=mnX1; nX<=mnX2; nX++ )

            if ( rFirst.cellInfo(nX).nRotateDir != rOther.cellInfo(nX).nRotateDir )

                return false;

    if ( bPagebreakMode )

        for ( nX=mnX1; nX<=mnX2; nX++ )

            if ( rFirst.cellInfo(nX).bPrinted != rOther.cellInfo(nX).bPrinted )

                return false;

    for ( nX=mnX1; nX<=mnX2; nX++ )

    {

        std::optional<Color> const & pCol1 = rFirst.cellInfo(nX).mxColorScale;

        std::optional<Color> const & pCol2 = rOther.cellInfo(nX).mxColorScale;

        if( (pCol1 && !pCol2) || (!pCol1 && pCol2) )

            return false;

        if (pCol1 && (*pCol1 != *pCol2))

            return false;

        const ScDataBarInfo* pInfo1 = rFirst.cellInfo(nX).pDataBar;

        const ScDataBarInfo* pInfo2 = rOther.cellInfo(nX).pDataBar;

        if( (pInfo1 && !pInfo2) || (!pInfo1 && pInfo2) )

            return false;

        if (pInfo1 && (*pInfo1 != *pInfo2))

            return false;

        // each cell with an icon set should be painted the same way

        const ScIconSetInfo* pIconSet1 = rFirst.cellInfo(nX).pIconSet;

        const ScIconSetInfo* pIconSet2 = rOther.cellInfo(nX).pIconSet;

        if(pIconSet1 || pIconSet2)

            return false;

    }

    return true;

}

void ScOutputData::DrawDocumentBackground()

{

    if ( !mbSolidBackground )

        return;

    Color aBgColor(ScModule::get()->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor);

    mpDev->SetLineColor(aBgColor);

    mpDev->SetFillColor(aBgColor);