718 lines
23 KiB
C++
718 lines
23 KiB
C++
/* -*- 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 <prevloc.hxx>
|
|
#include <document.hxx>
|
|
|
|
#include <o3tl/unit_conversion.hxx>
|
|
#include <osl/diagnose.h>
|
|
#include <vcl/outdev.hxx>
|
|
|
|
namespace {
|
|
|
|
enum ScPreviewLocationType : sal_uInt8
|
|
{
|
|
SC_PLOC_CELLRANGE,
|
|
SC_PLOC_COLHEADER,
|
|
SC_PLOC_ROWHEADER,
|
|
SC_PLOC_LEFTHEADER,
|
|
SC_PLOC_RIGHTHEADER,
|
|
SC_PLOC_LEFTFOOTER,
|
|
SC_PLOC_RIGHTFOOTER,
|
|
SC_PLOC_NOTEMARK,
|
|
SC_PLOC_NOTETEXT
|
|
};
|
|
|
|
}
|
|
|
|
struct ScPreviewLocationEntry
|
|
{
|
|
tools::Rectangle aPixelRect;
|
|
ScRange aCellRange;
|
|
ScPreviewLocationType eType;
|
|
bool bRepeatCol;
|
|
bool bRepeatRow;
|
|
|
|
ScPreviewLocationEntry( ScPreviewLocationType eNewType, const tools::Rectangle& rPixel, const ScRange& rRange,
|
|
bool bRepCol, bool bRepRow ) :
|
|
aPixelRect( rPixel ),
|
|
aCellRange( rRange ),
|
|
eType( eNewType ),
|
|
bRepeatCol( bRepCol ),
|
|
bRepeatRow( bRepRow )
|
|
{
|
|
}
|
|
};
|
|
|
|
ScPreviewTableInfo::ScPreviewTableInfo() :
|
|
nTab(0),
|
|
nCols(0),
|
|
nRows(0)
|
|
{
|
|
}
|
|
|
|
ScPreviewTableInfo::~ScPreviewTableInfo()
|
|
{
|
|
}
|
|
|
|
void ScPreviewTableInfo::SetTab( SCTAB nNewTab )
|
|
{
|
|
nTab = nNewTab;
|
|
}
|
|
|
|
void ScPreviewTableInfo::SetColInfo( SCCOL nCount, ScPreviewColRowInfo* pNewInfo )
|
|
{
|
|
pColInfo.reset(pNewInfo);
|
|
nCols = nCount;
|
|
}
|
|
|
|
void ScPreviewTableInfo::SetRowInfo( SCROW nCount, ScPreviewColRowInfo* pNewInfo )
|
|
{
|
|
pRowInfo.reset(pNewInfo);
|
|
nRows = nCount;
|
|
}
|
|
|
|
void ScPreviewTableInfo::LimitToArea( const tools::Rectangle& rPixelArea )
|
|
{
|
|
if ( pColInfo )
|
|
{
|
|
// cells completely left of the visible area
|
|
SCCOL nStart = 0;
|
|
while ( nStart < nCols && pColInfo[nStart].nPixelEnd < rPixelArea.Left() )
|
|
++nStart;
|
|
|
|
// cells completely right of the visible area
|
|
SCCOL nEnd = nCols;
|
|
while ( nEnd > 0 && pColInfo[nEnd-1].nPixelStart > rPixelArea.Right() )
|
|
--nEnd;
|
|
|
|
if ( nStart > 0 || nEnd < nCols )
|
|
{
|
|
if ( nEnd > nStart )
|
|
{
|
|
SCCOL nNewCount = nEnd - nStart;
|
|
ScPreviewColRowInfo* pNewInfo = new ScPreviewColRowInfo[nNewCount];
|
|
for (SCCOL i=0; i<nNewCount; i++)
|
|
pNewInfo[i] = pColInfo[nStart + i];
|
|
SetColInfo( nNewCount, pNewInfo );
|
|
}
|
|
else
|
|
SetColInfo( 0, nullptr ); // all invisible
|
|
}
|
|
}
|
|
|
|
if ( !pRowInfo )
|
|
return;
|
|
|
|
// cells completely above the visible area
|
|
SCROW nStart = 0;
|
|
while ( nStart < nRows && pRowInfo[nStart].nPixelEnd < rPixelArea.Top() )
|
|
++nStart;
|
|
|
|
// cells completely below the visible area
|
|
SCROW nEnd = nRows;
|
|
while ( nEnd > 0 && pRowInfo[nEnd-1].nPixelStart > rPixelArea.Bottom() )
|
|
--nEnd;
|
|
|
|
if ( nStart <= 0 && nEnd >= nRows )
|
|
return;
|
|
|
|
if ( nEnd > nStart )
|
|
{
|
|
SCROW nNewCount = nEnd - nStart;
|
|
ScPreviewColRowInfo* pNewInfo = new ScPreviewColRowInfo[nNewCount];
|
|
for (SCROW i=0; i<nNewCount; i++)
|
|
pNewInfo[i] = pRowInfo[nStart + i];
|
|
SetRowInfo( nNewCount, pNewInfo );
|
|
}
|
|
else
|
|
SetRowInfo( 0, nullptr ); // all invisible
|
|
}
|
|
|
|
ScPreviewLocationData::ScPreviewLocationData( ScDocument* pDocument, OutputDevice* pWin ) :
|
|
pWindow( pWin ),
|
|
pDoc( pDocument ),
|
|
nDrawRanges( 0 ),
|
|
nPrintTab( 0 )
|
|
{
|
|
}
|
|
|
|
ScPreviewLocationData::~ScPreviewLocationData()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void ScPreviewLocationData::SetCellMapMode( const MapMode& rMapMode )
|
|
{
|
|
aCellMapMode = rMapMode;
|
|
}
|
|
|
|
void ScPreviewLocationData::SetPrintTab( SCTAB nNew )
|
|
{
|
|
nPrintTab = nNew;
|
|
}
|
|
|
|
void ScPreviewLocationData::Clear()
|
|
{
|
|
m_Entries.clear();
|
|
|
|
nDrawRanges = 0;
|
|
}
|
|
|
|
void ScPreviewLocationData::AddCellRange( const tools::Rectangle& rRect, const ScRange& rRange, bool bRepCol, bool bRepRow,
|
|
const MapMode& rDrawMap )
|
|
{
|
|
tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
|
|
m_Entries.push_front( std::make_unique<ScPreviewLocationEntry>(SC_PLOC_CELLRANGE, aPixelRect, rRange, bRepCol, bRepRow) );
|
|
|
|
OSL_ENSURE( nDrawRanges < SC_PREVIEW_MAXRANGES, "too many ranges" );
|
|
|
|
if ( nDrawRanges >= SC_PREVIEW_MAXRANGES )
|
|
return;
|
|
|
|
aDrawRectangle[nDrawRanges] = aPixelRect;
|
|
aDrawMapMode[nDrawRanges] = rDrawMap;
|
|
|
|
if (bRepCol)
|
|
{
|
|
if (bRepRow)
|
|
aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_EDGE;
|
|
else
|
|
aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_REPCOL;
|
|
}
|
|
else
|
|
{
|
|
if (bRepRow)
|
|
aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_REPROW;
|
|
else
|
|
aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_TAB;
|
|
}
|
|
|
|
++nDrawRanges;
|
|
}
|
|
|
|
void ScPreviewLocationData::AddColHeaders( const tools::Rectangle& rRect, SCCOL nStartCol, SCCOL nEndCol, bool bRepCol )
|
|
{
|
|
SCTAB nTab = 0; //! ?
|
|
ScRange aRange( nStartCol, 0, nTab, nEndCol, 0, nTab );
|
|
tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
|
|
|
|
m_Entries.push_front( std::make_unique<ScPreviewLocationEntry>(SC_PLOC_COLHEADER, aPixelRect, aRange, bRepCol, false) );
|
|
}
|
|
|
|
void ScPreviewLocationData::AddRowHeaders( const tools::Rectangle& rRect, SCROW nStartRow, SCROW nEndRow, bool bRepRow )
|
|
{
|
|
SCTAB nTab = 0; //! ?
|
|
ScRange aRange( 0, nStartRow, nTab, 0, nEndRow, nTab );
|
|
tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
|
|
|
|
m_Entries.push_front( std::make_unique<ScPreviewLocationEntry>(SC_PLOC_ROWHEADER, aPixelRect, aRange, false, bRepRow) );
|
|
}
|
|
|
|
void ScPreviewLocationData::AddHeaderFooter( const tools::Rectangle& rRect, bool bHeader, bool bLeft )
|
|
{
|
|
ScRange aRange; //! ?
|
|
tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
|
|
|
|
ScPreviewLocationType eType = bHeader ?
|
|
( bLeft ? SC_PLOC_LEFTHEADER : SC_PLOC_RIGHTHEADER ) :
|
|
( bLeft ? SC_PLOC_LEFTFOOTER : SC_PLOC_RIGHTFOOTER );
|
|
|
|
m_Entries.push_front( std::make_unique<ScPreviewLocationEntry>(eType, aPixelRect, aRange, false, false) );
|
|
}
|
|
|
|
void ScPreviewLocationData::AddNoteMark( const tools::Rectangle& rRect, const ScAddress& rPos )
|
|
{
|
|
ScRange aRange( rPos );
|
|
tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
|
|
|
|
m_Entries.push_front( std::make_unique<ScPreviewLocationEntry>(SC_PLOC_NOTEMARK, aPixelRect, aRange, false, false) );
|
|
}
|
|
|
|
void ScPreviewLocationData::AddNoteText( const tools::Rectangle& rRect, const ScAddress& rPos )
|
|
{
|
|
ScRange aRange( rPos );
|
|
tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
|
|
|
|
m_Entries.push_front( std::make_unique<ScPreviewLocationEntry>(SC_PLOC_NOTETEXT, aPixelRect, aRange, false, false) );
|
|
}
|
|
|
|
void ScPreviewLocationData::GetDrawRange( sal_uInt16 nPos, tools::Rectangle& rPixelRect, MapMode& rMapMode, sal_uInt8& rRangeId ) const
|
|
{
|
|
OSL_ENSURE( nPos < nDrawRanges, "wrong position" );
|
|
if ( nPos < nDrawRanges )
|
|
{
|
|
rPixelRect = aDrawRectangle[nPos];
|
|
rMapMode = aDrawMapMode[nPos];
|
|
rRangeId = aDrawRangeId[nPos];
|
|
}
|
|
}
|
|
|
|
static ScPreviewLocationEntry* lcl_GetEntryByAddress(
|
|
ScPreviewLocationData::Entries_t const& rEntries,
|
|
const ScAddress& rPos, ScPreviewLocationType const eType)
|
|
{
|
|
for (auto const& it : rEntries)
|
|
{
|
|
if ( it->eType == eType && it->aCellRange.Contains( rPos ) )
|
|
return it.get();
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
tools::Rectangle ScPreviewLocationData::GetOffsetPixel( const ScAddress& rCellPos, const ScRange& rRange ) const
|
|
{
|
|
SCTAB nTab = rRange.aStart.Tab();
|
|
|
|
tools::Long nPosX = 0;
|
|
SCCOL nEndCol = rCellPos.Col();
|
|
for (SCCOL nCol = rRange.aStart.Col(); nCol < nEndCol; nCol++)
|
|
{
|
|
sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nTab );
|
|
if (nDocW)
|
|
nPosX += o3tl::convert(nDocW, o3tl::Length::twip, o3tl::Length::mm100);
|
|
}
|
|
const tools::Long nSizeX
|
|
= o3tl::convert(pDoc->GetColWidth(nEndCol, nTab), o3tl::Length::twip, o3tl::Length::mm100);
|
|
|
|
SCROW nEndRow = rCellPos.Row();
|
|
tools::Long nPosY = o3tl::convert(pDoc->GetRowHeight(rRange.aStart.Row(), nEndRow, nTab),
|
|
o3tl::Length::twip, o3tl::Length::mm100);
|
|
tools::Long nSizeY
|
|
= o3tl::convert(pDoc->GetRowHeight(nEndRow, nTab), o3tl::Length::twip, o3tl::Length::mm100);
|
|
|
|
Size aOffsetLogic( nPosX, nPosY );
|
|
Size aSizeLogic( nSizeX, nSizeY );
|
|
Size aOffsetPixel = pWindow->LogicToPixel( aOffsetLogic, aCellMapMode );
|
|
Size aSizePixel = pWindow->LogicToPixel( aSizeLogic, aCellMapMode );
|
|
|
|
return tools::Rectangle( Point( aOffsetPixel.Width(), aOffsetPixel.Height() ), aSizePixel );
|
|
}
|
|
|
|
void ScPreviewLocationData::GetCellPosition( const ScAddress& rCellPos, tools::Rectangle& rCellRect ) const
|
|
{
|
|
ScPreviewLocationEntry* pEntry = lcl_GetEntryByAddress( m_Entries, rCellPos, SC_PLOC_CELLRANGE );
|
|
if ( pEntry )
|
|
{
|
|
tools::Rectangle aOffsetRect = GetOffsetPixel( rCellPos, pEntry->aCellRange );
|
|
rCellRect = tools::Rectangle( aOffsetRect.Left() + pEntry->aPixelRect.Left(),
|
|
aOffsetRect.Top() + pEntry->aPixelRect.Top(),
|
|
aOffsetRect.Right() + pEntry->aPixelRect.Left(),
|
|
aOffsetRect.Bottom() + pEntry->aPixelRect.Top() );
|
|
}
|
|
}
|
|
|
|
bool ScPreviewLocationData::HasCellsInRange( const tools::Rectangle& rVisiblePixel ) const
|
|
{
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == SC_PLOC_CELLRANGE || it->eType == SC_PLOC_COLHEADER || it->eType == SC_PLOC_ROWHEADER )
|
|
if ( it->aPixelRect.Overlaps( rVisiblePixel ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ScPreviewLocationData::GetHeaderPosition( tools::Rectangle& rRect ) const
|
|
{
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == SC_PLOC_LEFTHEADER || it->eType == SC_PLOC_RIGHTHEADER )
|
|
{
|
|
rRect = it->aPixelRect;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ScPreviewLocationData::GetFooterPosition( tools::Rectangle& rRect ) const
|
|
{
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == SC_PLOC_LEFTFOOTER || it->eType == SC_PLOC_RIGHTFOOTER )
|
|
{
|
|
rRect = it->aPixelRect;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ScPreviewLocationData::IsHeaderLeft() const
|
|
{
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == SC_PLOC_LEFTHEADER )
|
|
return true;
|
|
|
|
if ( it->eType == SC_PLOC_RIGHTHEADER )
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ScPreviewLocationData::IsFooterLeft() const
|
|
{
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == SC_PLOC_LEFTFOOTER )
|
|
return true;
|
|
|
|
if ( it->eType == SC_PLOC_RIGHTFOOTER )
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
tools::Long ScPreviewLocationData::GetNoteCountInRange( const tools::Rectangle& rVisiblePixel, bool bNoteMarks ) const
|
|
{
|
|
ScPreviewLocationType eType = bNoteMarks ? SC_PLOC_NOTEMARK : SC_PLOC_NOTETEXT;
|
|
|
|
sal_uLong nRet = 0;
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == eType && it->aPixelRect.Overlaps( rVisiblePixel ) )
|
|
++nRet;
|
|
}
|
|
|
|
return nRet;
|
|
}
|
|
|
|
bool ScPreviewLocationData::GetNoteInRange( const tools::Rectangle& rVisiblePixel, tools::Long nIndex, bool bNoteMarks,
|
|
ScAddress& rCellPos, tools::Rectangle& rNoteRect ) const
|
|
{
|
|
ScPreviewLocationType eType = bNoteMarks ? SC_PLOC_NOTEMARK : SC_PLOC_NOTETEXT;
|
|
|
|
sal_uLong nPos = 0;
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == eType && it->aPixelRect.Overlaps( rVisiblePixel ) )
|
|
{
|
|
if ( nPos == sal::static_int_cast<sal_uLong>(nIndex) )
|
|
{
|
|
rCellPos = it->aCellRange.aStart;
|
|
rNoteRect = it->aPixelRect;
|
|
return true;
|
|
}
|
|
++nPos;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
tools::Rectangle ScPreviewLocationData::GetNoteInRangeOutputRect(const tools::Rectangle& rVisiblePixel, bool bNoteMarks, const ScAddress& aCellPos) const
|
|
{
|
|
ScPreviewLocationType eType = bNoteMarks ? SC_PLOC_NOTEMARK : SC_PLOC_NOTETEXT;
|
|
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == eType && it->aPixelRect.Overlaps( rVisiblePixel ) )
|
|
{
|
|
if ( aCellPos == it->aCellRange.aStart )
|
|
return it->aPixelRect;
|
|
}
|
|
}
|
|
|
|
return tools::Rectangle();
|
|
}
|
|
|
|
void ScPreviewLocationData::GetTableInfo( const tools::Rectangle& rVisiblePixel, ScPreviewTableInfo& rInfo ) const
|
|
{
|
|
// from left to right:
|
|
bool bHasHeaderCol = false;
|
|
bool bHasRepCols = false;
|
|
bool bHasMainCols = false;
|
|
SCCOL nRepeatColStart = 0;
|
|
SCCOL nRepeatColEnd = 0;
|
|
SCCOL nMainColStart = 0;
|
|
SCCOL nMainColEnd = 0;
|
|
|
|
// from top to bottom:
|
|
bool bHasHeaderRow = false;
|
|
bool bHasRepRows = false;
|
|
bool bHasMainRows = false;
|
|
SCROW nRepeatRowStart = 0;
|
|
SCROW nRepeatRowEnd = 0;
|
|
SCROW nMainRowStart = 0;
|
|
SCROW nMainRowEnd = 0;
|
|
|
|
tools::Rectangle aHeaderRect, aRepeatRect, aMainRect;
|
|
SCTAB nTab = 0;
|
|
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == SC_PLOC_CELLRANGE )
|
|
{
|
|
if ( it->bRepeatCol )
|
|
{
|
|
bHasRepCols = true;
|
|
nRepeatColStart = it->aCellRange.aStart.Col();
|
|
nRepeatColEnd = it->aCellRange.aEnd.Col();
|
|
aRepeatRect.SetLeft( it->aPixelRect.Left() );
|
|
aRepeatRect.SetRight( it->aPixelRect.Right() );
|
|
}
|
|
else
|
|
{
|
|
bHasMainCols = true;
|
|
nMainColStart = it->aCellRange.aStart.Col();
|
|
nMainColEnd = it->aCellRange.aEnd.Col();
|
|
aMainRect.SetLeft( it->aPixelRect.Left() );
|
|
aMainRect.SetRight( it->aPixelRect.Right() );
|
|
}
|
|
if ( it->bRepeatRow )
|
|
{
|
|
bHasRepRows = true;
|
|
nRepeatRowStart = it->aCellRange.aStart.Row();
|
|
nRepeatRowEnd = it->aCellRange.aEnd.Row();
|
|
aRepeatRect.SetTop( it->aPixelRect.Top() );
|
|
aRepeatRect.SetBottom( it->aPixelRect.Bottom() );
|
|
}
|
|
else
|
|
{
|
|
bHasMainRows = true;
|
|
nMainRowStart = it->aCellRange.aStart.Row();
|
|
nMainRowEnd = it->aCellRange.aEnd.Row();
|
|
aMainRect.SetTop( it->aPixelRect.Top() );
|
|
aMainRect.SetBottom( it->aPixelRect.Bottom() );
|
|
}
|
|
nTab = it->aCellRange.aStart.Tab(); //! store separately?
|
|
}
|
|
else if ( it->eType == SC_PLOC_ROWHEADER )
|
|
{
|
|
// row headers result in an additional column
|
|
bHasHeaderCol = true;
|
|
aHeaderRect.SetLeft( it->aPixelRect.Left() );
|
|
aHeaderRect.SetRight( it->aPixelRect.Right() );
|
|
}
|
|
else if ( it->eType == SC_PLOC_COLHEADER )
|
|
{
|
|
// column headers result in an additional row
|
|
bHasHeaderRow = true;
|
|
aHeaderRect.SetTop( it->aPixelRect.Top() );
|
|
aHeaderRect.SetBottom( it->aPixelRect.Bottom() );
|
|
}
|
|
}
|
|
|
|
// get column info
|
|
|
|
SCCOL nColCount = 0;
|
|
SCCOL nCol;
|
|
if ( bHasHeaderCol )
|
|
++nColCount;
|
|
if ( bHasRepCols )
|
|
for ( nCol=nRepeatColStart; nCol<=nRepeatColEnd; nCol++ )
|
|
if (!pDoc->ColHidden(nCol, nTab))
|
|
++nColCount;
|
|
if ( bHasMainCols )
|
|
for ( nCol=nMainColStart; nCol<=nMainColEnd; nCol++ )
|
|
if (!pDoc->ColHidden(nCol, nTab))
|
|
++nColCount;
|
|
|
|
if ( nColCount > 0 )
|
|
{
|
|
ScPreviewColRowInfo* pColInfo = new ScPreviewColRowInfo[ nColCount ];
|
|
SCCOL nColPos = 0;
|
|
|
|
if ( bHasHeaderCol )
|
|
{
|
|
pColInfo[nColPos].Set( true, 0, aHeaderRect.Left(), aHeaderRect.Right() );
|
|
++nColPos;
|
|
}
|
|
if ( bHasRepCols )
|
|
{
|
|
tools::Long nPosX = 0;
|
|
for ( nCol=nRepeatColStart; nCol<=nRepeatColEnd; nCol++ )
|
|
if (!pDoc->ColHidden(nCol, nTab))
|
|
{
|
|
sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nTab );
|
|
tools::Long nNextX
|
|
= nPosX + o3tl::convert(nDocW, o3tl::Length::twip, o3tl::Length::mm100);
|
|
|
|
tools::Long nPixelStart = pWindow->LogicToPixel( Size( nPosX, 0 ), aCellMapMode ).Width();
|
|
tools::Long nPixelEnd = pWindow->LogicToPixel( Size( nNextX, 0 ), aCellMapMode ).Width() - 1;
|
|
pColInfo[nColPos].Set( false, nCol,
|
|
aRepeatRect.Left() + nPixelStart,
|
|
aRepeatRect.Left() + nPixelEnd );
|
|
|
|
nPosX = nNextX;
|
|
++nColPos;
|
|
}
|
|
}
|
|
if ( bHasMainCols )
|
|
{
|
|
tools::Long nPosX = 0;
|
|
for ( nCol=nMainColStart; nCol<=nMainColEnd; nCol++ )
|
|
if (!pDoc->ColHidden(nCol, nTab))
|
|
{
|
|
sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nTab );
|
|
tools::Long nNextX
|
|
= nPosX + o3tl::convert(nDocW, o3tl::Length::twip, o3tl::Length::mm100);
|
|
|
|
tools::Long nPixelStart = pWindow->LogicToPixel( Size( nPosX, 0 ), aCellMapMode ).Width();
|
|
tools::Long nPixelEnd = pWindow->LogicToPixel( Size( nNextX, 0 ), aCellMapMode ).Width() - 1;
|
|
pColInfo[nColPos].Set( false, nCol,
|
|
aMainRect.Left() + nPixelStart,
|
|
aMainRect.Left() + nPixelEnd );
|
|
|
|
nPosX = nNextX;
|
|
++nColPos;
|
|
}
|
|
}
|
|
rInfo.SetColInfo( nColCount, pColInfo );
|
|
}
|
|
else
|
|
rInfo.SetColInfo( 0, nullptr );
|
|
|
|
// get row info
|
|
|
|
SCROW nRowCount = 0;
|
|
if ( bHasHeaderRow )
|
|
++nRowCount;
|
|
if ( bHasRepRows )
|
|
nRowCount += pDoc->CountVisibleRows(nRepeatRowStart, nRepeatRowEnd, nTab);
|
|
if ( bHasMainRows )
|
|
nRowCount += pDoc->CountVisibleRows(nMainRowStart, nMainRowEnd, nTab);
|
|
|
|
if ( nRowCount > 0 )
|
|
{
|
|
ScPreviewColRowInfo* pRowInfo = new ScPreviewColRowInfo[ nRowCount ];
|
|
SCROW nRowPos = 0;
|
|
|
|
if ( bHasHeaderRow )
|
|
{
|
|
pRowInfo[nRowPos].Set( true, 0, aHeaderRect.Top(), aHeaderRect.Bottom() );
|
|
++nRowPos;
|
|
}
|
|
if ( bHasRepRows )
|
|
{
|
|
tools::Long nPosY = 0;
|
|
for (SCROW nRow = nRepeatRowStart; nRow <= nRepeatRowEnd; ++nRow)
|
|
{
|
|
if (pDoc->RowHidden(nRow, nTab))
|
|
continue;
|
|
|
|
sal_uInt16 nDocH = pDoc->GetOriginalHeight( nRow, nTab );
|
|
tools::Long nNextY
|
|
= nPosY + o3tl::convert(nDocH, o3tl::Length::twip, o3tl::Length::mm100);
|
|
|
|
tools::Long nPixelStart = pWindow->LogicToPixel( Size( 0, nPosY ), aCellMapMode ).Height();
|
|
tools::Long nPixelEnd = pWindow->LogicToPixel( Size( 0, nNextY ), aCellMapMode ).Height() - 1;
|
|
pRowInfo[nRowPos].Set( false, nRow,
|
|
aRepeatRect.Top() + nPixelStart,
|
|
aRepeatRect.Top() + nPixelEnd );
|
|
|
|
nPosY = nNextY;
|
|
++nRowPos;
|
|
}
|
|
}
|
|
if ( bHasMainRows )
|
|
{
|
|
tools::Long nPosY = 0;
|
|
for (SCROW nRow = nMainRowStart; nRow <= nMainRowEnd; ++nRow)
|
|
{
|
|
if (pDoc->RowHidden(nRow, nTab))
|
|
continue;
|
|
|
|
sal_uInt16 nDocH = pDoc->GetOriginalHeight( nRow, nTab );
|
|
tools::Long nNextY
|
|
= nPosY + o3tl::convert(nDocH, o3tl::Length::twip, o3tl::Length::mm100);
|
|
|
|
tools::Long nPixelStart = pWindow->LogicToPixel( Size( 0, nPosY ), aCellMapMode ).Height();
|
|
tools::Long nPixelEnd = pWindow->LogicToPixel( Size( 0, nNextY ), aCellMapMode ).Height() - 1;
|
|
pRowInfo[nRowPos].Set( false, nRow,
|
|
aMainRect.Top() + nPixelStart,
|
|
aMainRect.Top() + nPixelEnd );
|
|
|
|
nPosY = nNextY;
|
|
++nRowPos;
|
|
}
|
|
}
|
|
rInfo.SetRowInfo( nRowCount, pRowInfo );
|
|
}
|
|
else
|
|
rInfo.SetRowInfo( 0, nullptr );
|
|
|
|
// limit to visible area
|
|
|
|
rInfo.SetTab( nTab );
|
|
rInfo.LimitToArea( rVisiblePixel );
|
|
}
|
|
|
|
tools::Rectangle ScPreviewLocationData::GetHeaderCellOutputRect(const tools::Rectangle& rVisRect, const ScAddress& rCellPos, bool bColHeader) const
|
|
{
|
|
// first a stupid implementation
|
|
// NN says here should be done more
|
|
tools::Rectangle aClipRect;
|
|
ScPreviewTableInfo aTableInfo;
|
|
GetTableInfo( rVisRect, aTableInfo );
|
|
|
|
if ( (rCellPos.Col() >= 0) &&
|
|
(rCellPos.Row() >= 0) && (rCellPos.Col() < aTableInfo.GetCols()) &&
|
|
(rCellPos.Row() < aTableInfo.GetRows()) )
|
|
{
|
|
SCCOL nCol(0);
|
|
SCROW nRow(0);
|
|
if (bColHeader)
|
|
nCol = rCellPos.Col();
|
|
else
|
|
nRow = rCellPos.Row();
|
|
const ScPreviewColRowInfo& rColInfo = aTableInfo.GetColInfo()[nCol];
|
|
const ScPreviewColRowInfo& rRowInfo = aTableInfo.GetRowInfo()[nRow];
|
|
|
|
if ( rColInfo.bIsHeader || rRowInfo.bIsHeader )
|
|
aClipRect = tools::Rectangle( rColInfo.nPixelStart, rRowInfo.nPixelStart, rColInfo.nPixelEnd, rRowInfo.nPixelEnd );
|
|
}
|
|
return aClipRect;
|
|
}
|
|
|
|
tools::Rectangle ScPreviewLocationData::GetCellOutputRect(const ScAddress& rCellPos) const
|
|
{
|
|
// first a stupid implementation
|
|
// NN says here should be done more
|
|
tools::Rectangle aRect;
|
|
GetCellPosition(rCellPos, aRect);
|
|
return aRect;
|
|
}
|
|
|
|
// GetMainCellRange is used for links in PDF export
|
|
|
|
bool ScPreviewLocationData::GetMainCellRange( ScRange& rRange, tools::Rectangle& rPixRect ) const
|
|
{
|
|
for (auto const& it : m_Entries)
|
|
{
|
|
if ( it->eType == SC_PLOC_CELLRANGE && !it->bRepeatCol && !it->bRepeatRow )
|
|
{
|
|
rRange = it->aCellRange;
|
|
rPixRect = it->aPixelRect;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|