sc/source/ui/view/prevloc.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <prevloc.hxx>
  21 #include <document.hxx>
  22
  23 #include <vcl/outdev.hxx>
  24
  25 #include <o3tl/make_unique.hxx>
  26
  27 enum ScPreviewLocationType
  28 {
  29     SC_PLOC_CELLRANGE,
  30     SC_PLOC_COLHEADER,
  31     SC_PLOC_ROWHEADER,
  32     SC_PLOC_LEFTHEADER,
  33     SC_PLOC_RIGHTHEADER,
  34     SC_PLOC_LEFTFOOTER,
  35     SC_PLOC_RIGHTFOOTER,
  36     SC_PLOC_NOTEMARK,
  37     SC_PLOC_NOTETEXT
  38 };
  39
  40 struct ScPreviewLocationEntry
  41 {
  42     ScPreviewLocationType   eType;
  43     tools::Rectangle               aPixelRect;
  44     ScRange                 aCellRange;
  45     bool                    bRepeatCol;
  46     bool                    bRepeatRow;
  47
  48     ScPreviewLocationEntry( ScPreviewLocationType eNewType, const tools::Rectangle& rPixel, const ScRange& rRange,
  49                             bool bRepCol, bool bRepRow ) :
  50         eType( eNewType ),
  51         aPixelRect( rPixel ),
  52         aCellRange( rRange ),
  53         bRepeatCol( bRepCol ),
  54         bRepeatRow( bRepRow )
  55     {
  56     }
  57 };
  58
  59 ScPreviewTableInfo::ScPreviewTableInfo() :
  60     nTab(0),
  61     nCols(0),
  62     nRows(0),
  63     pColInfo(nullptr),
  64     pRowInfo(nullptr)
  65 {
  66 }
  67
  68 ScPreviewTableInfo::~ScPreviewTableInfo()
  69 {
  70 }
  71
  72 void ScPreviewTableInfo::SetTab( SCTAB nNewTab )
  73 {
  74     nTab = nNewTab;
  75 }
  76
  77 void ScPreviewTableInfo::SetColInfo( SCCOL nCount, ScPreviewColRowInfo* pNewInfo )
  78 {
  79     pColInfo.reset(pNewInfo);
  80     nCols = nCount;
  81 }
  82
  83 void ScPreviewTableInfo::SetRowInfo( SCROW nCount, ScPreviewColRowInfo* pNewInfo )
  84 {
  85     pRowInfo.reset(pNewInfo);
  86     nRows = nCount;
  87 }
  88
  89 void ScPreviewTableInfo::LimitToArea( const tools::Rectangle& rPixelArea )
  90 {
  91     if ( pColInfo )
  92     {
  93         //  cells completely left of the visible area
  94         SCCOL nStart = 0;
  95         while ( nStart < nCols && pColInfo[nStart].nPixelEnd < rPixelArea.Left() )
  96             ++nStart;
  97
  98         //  cells completely right of the visible area
  99         SCCOL nEnd = nCols;
 100         while ( nEnd > 0 && pColInfo[nEnd-1].nPixelStart > rPixelArea.Right() )
 101             --nEnd;
 102
 103         if ( nStart > 0 || nEnd < nCols )
 104         {
 105             if ( nEnd > nStart )
 106             {
 107                 SCCOL nNewCount = nEnd - nStart;
 108                 ScPreviewColRowInfo* pNewInfo = new ScPreviewColRowInfo[nNewCount];
 109                 for (SCCOL i=0; i<nNewCount; i++)
 110                     pNewInfo[i] = pColInfo[nStart + i];
 111                 SetColInfo( nNewCount, pNewInfo );
 112             }
 113             else
 114                 SetColInfo( 0, nullptr );      // all invisible
 115         }
 116     }
 117
 118     if ( pRowInfo )
 119     {
 120         //  cells completely above the visible area
 121         SCROW nStart = 0;
 122         while ( nStart < nRows && pRowInfo[nStart].nPixelEnd < rPixelArea.Top() )
 123             ++nStart;
 124
 125         //  cells completely below the visible area
 126         SCROW nEnd = nRows;
 127         while ( nEnd > 0 && pRowInfo[nEnd-1].nPixelStart > rPixelArea.Bottom() )
 128             --nEnd;
 129
 130         if ( nStart > 0 || nEnd < nRows )
 131         {
 132             if ( nEnd > nStart )
 133             {
 134                 SCROW nNewCount = nEnd - nStart;
 135                 ScPreviewColRowInfo* pNewInfo = new ScPreviewColRowInfo[nNewCount];
 136                 for (SCROW i=0; i<nNewCount; i++)
 137                     pNewInfo[i] = pRowInfo[nStart + i];
 138                 SetRowInfo( nNewCount, pNewInfo );
 139             }
 140             else
 141                 SetRowInfo( 0, nullptr );      // all invisible
 142         }
 143     }
 144 }
 145
 146 ScPreviewLocationData::ScPreviewLocationData( ScDocument* pDocument, OutputDevice* pWin ) :
 147     pWindow( pWin ),
 148     pDoc( pDocument ),
 149     nDrawRanges( 0 ),
 150     nPrintTab( 0 )
 151 {
 152 }
 153
 154 ScPreviewLocationData::~ScPreviewLocationData()
 155 {
 156     Clear();
 157 }
 158
 159 void ScPreviewLocationData::SetCellMapMode( const MapMode& rMapMode )
 160 {
 161     aCellMapMode = rMapMode;
 162 }
 163
 164 void ScPreviewLocationData::SetPrintTab( SCTAB nNew )
 165 {
 166     nPrintTab = nNew;
 167 }
 168
 169 void ScPreviewLocationData::Clear()
 170 {
 171     m_Entries.clear();
 172
 173     nDrawRanges = 0;
 174 }
 175
 176 void ScPreviewLocationData::AddCellRange( const tools::Rectangle& rRect, const ScRange& rRange, bool bRepCol, bool bRepRow,
 177                                             const MapMode& rDrawMap )
 178 {
 179     tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
 180     m_Entries.push_front( o3tl::make_unique<ScPreviewLocationEntry>(SC_PLOC_CELLRANGE, aPixelRect, rRange, bRepCol, bRepRow) );
 181
 182     OSL_ENSURE( nDrawRanges < SC_PREVIEW_MAXRANGES, "too many ranges" );
 183
 184     if ( nDrawRanges < SC_PREVIEW_MAXRANGES )
 185     {
 186         aDrawRectangle[nDrawRanges] = aPixelRect;
 187         aDrawMapMode[nDrawRanges] = rDrawMap;
 188
 189         if (bRepCol)
 190         {
 191             if (bRepRow)
 192                 aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_EDGE;
 193             else
 194                 aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_REPCOL;
 195         }
 196         else
 197         {
 198             if (bRepRow)
 199                 aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_REPROW;
 200             else
 201                 aDrawRangeId[nDrawRanges] = SC_PREVIEW_RANGE_TAB;
 202         }
 203
 204         ++nDrawRanges;
 205     }
 206 }
 207
 208 void ScPreviewLocationData::AddColHeaders( const tools::Rectangle& rRect, SCCOL nStartCol, SCCOL nEndCol, bool bRepCol )
 209 {
 210     SCTAB nTab = 0; //! ?
 211     ScRange aRange( nStartCol, 0, nTab, nEndCol, 0, nTab );
 212     tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
 213
 214     m_Entries.push_front( o3tl::make_unique<ScPreviewLocationEntry>(SC_PLOC_COLHEADER, aPixelRect, aRange, bRepCol, false) );
 215 }
 216
 217 void ScPreviewLocationData::AddRowHeaders( const tools::Rectangle& rRect, SCROW nStartRow, SCROW nEndRow, bool bRepRow )
 218 {
 219     SCTAB nTab = 0; //! ?
 220     ScRange aRange( 0, nStartRow, nTab, 0, nEndRow, nTab );
 221     tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
 222
 223     m_Entries.push_front( o3tl::make_unique<ScPreviewLocationEntry>(SC_PLOC_ROWHEADER, aPixelRect, aRange, false, bRepRow) );
 224 }
 225
 226 void ScPreviewLocationData::AddHeaderFooter( const tools::Rectangle& rRect, bool bHeader, bool bLeft )
 227 {
 228     ScRange aRange;     //! ?
 229     tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
 230
 231     ScPreviewLocationType eType = bHeader ?
 232                 ( bLeft ? SC_PLOC_LEFTHEADER : SC_PLOC_RIGHTHEADER ) :
 233                 ( bLeft ? SC_PLOC_LEFTFOOTER : SC_PLOC_RIGHTFOOTER );
 234
 235     m_Entries.push_front( o3tl::make_unique<ScPreviewLocationEntry>(eType, aPixelRect, aRange, false, false) );
 236 }
 237
 238 void ScPreviewLocationData::AddNoteMark( const tools::Rectangle& rRect, const ScAddress& rPos )
 239 {
 240     ScRange aRange( rPos );
 241     tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
 242
 243     m_Entries.push_front( o3tl::make_unique<ScPreviewLocationEntry>(SC_PLOC_NOTEMARK, aPixelRect, aRange, false, false) );
 244 }
 245
 246 void ScPreviewLocationData::AddNoteText( const tools::Rectangle& rRect, const ScAddress& rPos )
 247 {
 248     ScRange aRange( rPos );
 249     tools::Rectangle aPixelRect( pWindow->LogicToPixel( rRect ) );
 250
 251     m_Entries.push_front( o3tl::make_unique<ScPreviewLocationEntry>(SC_PLOC_NOTETEXT, aPixelRect, aRange, false, false) );
 252 }
 253
 254 void ScPreviewLocationData::GetDrawRange( sal_uInt16 nPos, tools::Rectangle& rPixelRect, MapMode& rMapMode, sal_uInt8& rRangeId ) const
 255 {
 256     OSL_ENSURE( nPos < nDrawRanges, "wrong position" );
 257     if ( nPos < nDrawRanges )
 258     {
 259         rPixelRect = aDrawRectangle[nPos];
 260         rMapMode = aDrawMapMode[nPos];
 261         rRangeId = aDrawRangeId[nPos];
 262     }
 263 }
 264
 265 static ScPreviewLocationEntry* lcl_GetEntryByAddress(
 266         ScPreviewLocationData::Entries_t const& rEntries,
 267         const ScAddress& rPos, ScPreviewLocationType const eType)
 268 {
 269     for (auto const& it : rEntries)
 270     {
 271         if ( it->eType == eType && it->aCellRange.In( rPos ) )
 272             return it.get();
 273     }
 274
 275     return nullptr;
 276 }
 277
 278 tools::Rectangle ScPreviewLocationData::GetOffsetPixel( const ScAddress& rCellPos, const ScRange& rRange ) const
 279 {
 280     const double nScaleX = HMM_PER_TWIPS;
 281     const double nScaleY = HMM_PER_TWIPS;
 282     SCTAB nTab = rRange.aStart.Tab();
 283
 284     long nPosX = 0;
 285     SCCOL nEndCol = rCellPos.Col();
 286     for (SCCOL nCol = rRange.aStart.Col(); nCol < nEndCol; nCol++)
 287     {
 288         sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nTab );
 289         if (nDocW)
 290             nPosX += (long) (nDocW * nScaleX);
 291     }
 292     long nSizeX = (long) ( pDoc->GetColWidth( nEndCol, nTab ) * nScaleX );
 293
 294     SCROW nEndRow = rCellPos.Row();
 295     long nPosY = (long) pDoc->GetScaledRowHeight( rRange.aStart.Row(),
 296             nEndRow, nTab, nScaleY);
 297     long nSizeY = (long) ( pDoc->GetRowHeight( nEndRow, nTab ) * nScaleY );
 298
 299     Size aOffsetLogic( nPosX, nPosY );
 300     Size aSizeLogic( nSizeX, nSizeY );
 301     Size aOffsetPixel = pWindow->LogicToPixel( aOffsetLogic, aCellMapMode );
 302     Size aSizePixel = pWindow->LogicToPixel( aSizeLogic, aCellMapMode );
 303
 304     return tools::Rectangle( Point( aOffsetPixel.Width(), aOffsetPixel.Height() ), aSizePixel );
 305 }
 306
 307 void ScPreviewLocationData::GetCellPosition( const ScAddress& rCellPos, tools::Rectangle& rCellRect ) const
 308 {
 309     ScPreviewLocationEntry* pEntry = lcl_GetEntryByAddress( m_Entries, rCellPos, SC_PLOC_CELLRANGE );
 310     if ( pEntry )
 311     {
 312         tools::Rectangle aOffsetRect = GetOffsetPixel( rCellPos, pEntry->aCellRange );
 313         rCellRect = tools::Rectangle( aOffsetRect.Left() + pEntry->aPixelRect.Left(),
 314                                aOffsetRect.Top() + pEntry->aPixelRect.Top(),
 315                                aOffsetRect.Right() + pEntry->aPixelRect.Left(),
 316                                aOffsetRect.Bottom() + pEntry->aPixelRect.Top() );
 317     }
 318 }
 319
 320 bool ScPreviewLocationData::HasCellsInRange( const tools::Rectangle& rVisiblePixel ) const
 321 {
 322     for (auto const& it : m_Entries)
 323     {
 324         if ( it->eType == SC_PLOC_CELLRANGE || it->eType == SC_PLOC_COLHEADER || it->eType == SC_PLOC_ROWHEADER )
 325             if ( it->aPixelRect.IsOver( rVisiblePixel ) )
 326                 return true;
 327     }
 328
 329     return false;
 330 }
 331
 332 bool ScPreviewLocationData::GetHeaderPosition( tools::Rectangle& rRect ) const
 333 {
 334     for (auto const& it : m_Entries)
 335     {
 336         if ( it->eType == SC_PLOC_LEFTHEADER || it->eType == SC_PLOC_RIGHTHEADER )
 337         {
 338             rRect = it->aPixelRect;
 339             return true;
 340         }
 341     }
 342
 343     return false;
 344 }
 345
 346 bool ScPreviewLocationData::GetFooterPosition( tools::Rectangle& rRect ) const
 347 {
 348     for (auto const& it : m_Entries)
 349     {
 350         if ( it->eType == SC_PLOC_LEFTFOOTER || it->eType == SC_PLOC_RIGHTFOOTER )
 351         {
 352             rRect = it->aPixelRect;
 353             return true;
 354         }
 355     }
 356
 357     return false;
 358 }
 359
 360 bool ScPreviewLocationData::IsHeaderLeft() const
 361 {
 362     for (auto const& it : m_Entries)
 363     {
 364         if ( it->eType == SC_PLOC_LEFTHEADER )
 365             return true;
 366
 367         if ( it->eType == SC_PLOC_RIGHTHEADER )
 368             return false;
 369     }
 370
 371     return false;
 372 }
 373
 374 bool ScPreviewLocationData::IsFooterLeft() const
 375 {
 376     for (auto const& it : m_Entries)
 377     {
 378         if ( it->eType == SC_PLOC_LEFTFOOTER )
 379             return true;
 380
 381         if ( it->eType == SC_PLOC_RIGHTFOOTER )
 382             return false;
 383     }
 384
 385     return false;
 386 }
 387
 388 long ScPreviewLocationData::GetNoteCountInRange( const tools::Rectangle& rVisiblePixel, bool bNoteMarks ) const
 389 {
 390     ScPreviewLocationType eType = bNoteMarks ? SC_PLOC_NOTEMARK : SC_PLOC_NOTETEXT;
 391
 392     sal_uLong nRet = 0;
 393     for (auto const& it : m_Entries)
 394     {
 395         if ( it->eType == eType && it->aPixelRect.IsOver( rVisiblePixel ) )
 396             ++nRet;
 397     }
 398
 399     return nRet;
 400 }
 401
 402 bool ScPreviewLocationData::GetNoteInRange( const tools::Rectangle& rVisiblePixel, long nIndex, bool bNoteMarks,
 403                                             ScAddress& rCellPos, tools::Rectangle& rNoteRect ) const
 404 {
 405     ScPreviewLocationType eType = bNoteMarks ? SC_PLOC_NOTEMARK : SC_PLOC_NOTETEXT;
 406
 407     sal_uLong nPos = 0;
 408     for (auto const& it : m_Entries)
 409     {
 410         if ( it->eType == eType && it->aPixelRect.IsOver( rVisiblePixel ) )
 411         {
 412             if ( nPos == sal::static_int_cast<sal_uLong>(nIndex) )
 413             {
 414                 rCellPos = it->aCellRange.aStart;
 415                 rNoteRect = it->aPixelRect;
 416                 return true;
 417             }
 418             ++nPos;
 419         }
 420     }
 421
 422     return false;
 423 }
 424
 425 tools::Rectangle ScPreviewLocationData::GetNoteInRangeOutputRect(const tools::Rectangle& rVisiblePixel, bool bNoteMarks, const ScAddress& aCellPos) const
 426 {
 427     ScPreviewLocationType eType = bNoteMarks ? SC_PLOC_NOTEMARK : SC_PLOC_NOTETEXT;
 428
 429     sal_uLong nPos = 0;
 430     for (auto const& it : m_Entries)
 431     {
 432         if ( it->eType == eType && it->aPixelRect.IsOver( rVisiblePixel ) )
 433         {
 434             if ( aCellPos == it->aCellRange.aStart )
 435                 return it->aPixelRect;
 436             ++nPos;
 437         }
 438     }
 439
 440     return tools::Rectangle();
 441 }
 442
 443 void ScPreviewLocationData::GetTableInfo( const tools::Rectangle& rVisiblePixel, ScPreviewTableInfo& rInfo ) const
 444 {
 445     const double nScaleX = HMM_PER_TWIPS;
 446     const double nScaleY = HMM_PER_TWIPS;
 447
 448     // from left to right:
 449     bool bHasHeaderCol = false;
 450     bool bHasRepCols   = false;
 451     bool bHasMainCols  = false;
 452     SCCOL nRepeatColStart = 0;
 453     SCCOL nRepeatColEnd   = 0;
 454     SCCOL nMainColStart   = 0;
 455     SCCOL nMainColEnd     = 0;
 456
 457     // from top to bottom:
 458     bool bHasHeaderRow = false;
 459     bool bHasRepRows   = false;
 460     bool bHasMainRows  = false;
 461     SCROW nRepeatRowStart = 0;
 462     SCROW nRepeatRowEnd   = 0;
 463     SCROW nMainRowStart   = 0;
 464     SCROW nMainRowEnd     = 0;
 465
 466     tools::Rectangle aHeaderRect, aRepeatRect, aMainRect;
 467     SCTAB nTab = 0;
 468
 469     for (auto const& it : m_Entries)
 470     {
 471         if ( it->eType == SC_PLOC_CELLRANGE )
 472         {
 473             if ( it->bRepeatCol )
 474             {
 475                 bHasRepCols = true;
 476                 nRepeatColStart = it->aCellRange.aStart.Col();
 477                 nRepeatColEnd = it->aCellRange.aEnd.Col();
 478                 aRepeatRect.Left() = it->aPixelRect.Left();
 479                 aRepeatRect.Right() = it->aPixelRect.Right();
 480             }
 481             else
 482             {
 483                 bHasMainCols = true;
 484                 nMainColStart = it->aCellRange.aStart.Col();
 485                 nMainColEnd = it->aCellRange.aEnd.Col();
 486                 aMainRect.Left() = it->aPixelRect.Left();
 487                 aMainRect.Right() = it->aPixelRect.Right();
 488             }
 489             if ( it->bRepeatRow )
 490             {
 491                 bHasRepRows = true;
 492                 nRepeatRowStart = it->aCellRange.aStart.Row();
 493                 nRepeatRowEnd = it->aCellRange.aEnd.Row();
 494                 aRepeatRect.Top() = it->aPixelRect.Top();
 495                 aRepeatRect.Bottom() = it->aPixelRect.Bottom();
 496             }
 497             else
 498             {
 499                 bHasMainRows = true;
 500                 nMainRowStart = it->aCellRange.aStart.Row();
 501                 nMainRowEnd = it->aCellRange.aEnd.Row();
 502                 aMainRect.Top() = it->aPixelRect.Top();
 503                 aMainRect.Bottom() = it->aPixelRect.Bottom();
 504             }
 505             nTab = it->aCellRange.aStart.Tab();     //! store separately?
 506         }
 507         else if ( it->eType == SC_PLOC_ROWHEADER )
 508         {
 509             // row headers result in an additional column
 510             bHasHeaderCol = true;
 511             aHeaderRect.Left() = it->aPixelRect.Left();
 512             aHeaderRect.Right() = it->aPixelRect.Right();
 513         }
 514         else if ( it->eType == SC_PLOC_COLHEADER )
 515         {
 516             // column headers result in an additional row
 517             bHasHeaderRow = true;
 518             aHeaderRect.Top() = it->aPixelRect.Top();
 519             aHeaderRect.Bottom() = it->aPixelRect.Bottom();
 520         }
 521     }
 522
 523     //  get column info
 524
 525     SCCOL nColCount = 0;
 526     SCCOL nCol;
 527     if ( bHasHeaderCol )
 528         ++nColCount;
 529     if ( bHasRepCols )
 530         for ( nCol=nRepeatColStart; nCol<=nRepeatColEnd; nCol++ )
 531             if (!pDoc->ColHidden(nCol, nTab))
 532                 ++nColCount;
 533     if ( bHasMainCols )
 534         for ( nCol=nMainColStart; nCol<=nMainColEnd; nCol++ )
 535             if (!pDoc->ColHidden(nCol, nTab))
 536                 ++nColCount;
 537
 538     if ( nColCount > 0 )
 539     {
 540         ScPreviewColRowInfo* pColInfo = new ScPreviewColRowInfo[ nColCount ];
 541         SCCOL nColPos = 0;
 542
 543         if ( bHasHeaderCol )
 544         {
 545             pColInfo[nColPos].Set( true, 0, aHeaderRect.Left(), aHeaderRect.Right() );
 546             ++nColPos;
 547         }
 548         if ( bHasRepCols )
 549         {
 550             long nPosX = 0;
 551             for ( nCol=nRepeatColStart; nCol<=nRepeatColEnd; nCol++ )
 552                 if (!pDoc->ColHidden(nCol, nTab))
 553                 {
 554                     sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nTab );
 555                     long nNextX = nPosX + (long) (nDocW * nScaleX);
 556
 557                     long nPixelStart = pWindow->LogicToPixel( Size( nPosX, 0 ), aCellMapMode ).Width();
 558                     long nPixelEnd = pWindow->LogicToPixel( Size( nNextX, 0 ), aCellMapMode ).Width() - 1;
 559                     pColInfo[nColPos].Set( false, nCol,
 560                                                 aRepeatRect.Left() + nPixelStart,
 561                                                 aRepeatRect.Left() + nPixelEnd );
 562
 563                     nPosX = nNextX;
 564                     ++nColPos;
 565                 }
 566         }
 567         if ( bHasMainCols )
 568         {
 569             long nPosX = 0;
 570             for ( nCol=nMainColStart; nCol<=nMainColEnd; nCol++ )
 571                 if (!pDoc->ColHidden(nCol, nTab))
 572                 {
 573                     sal_uInt16 nDocW = pDoc->GetColWidth( nCol, nTab );
 574                     long nNextX = nPosX + (long) (nDocW * nScaleX);
 575
 576                     long nPixelStart = pWindow->LogicToPixel( Size( nPosX, 0 ), aCellMapMode ).Width();
 577                     long nPixelEnd = pWindow->LogicToPixel( Size( nNextX, 0 ), aCellMapMode ).Width() - 1;
 578                     pColInfo[nColPos].Set( false, nCol,
 579                                                 aMainRect.Left() + nPixelStart,
 580                                                 aMainRect.Left() + nPixelEnd );
 581
 582                     nPosX = nNextX;
 583                     ++nColPos;
 584                 }
 585         }
 586         rInfo.SetColInfo( nColCount, pColInfo );
 587     }
 588     else
 589         rInfo.SetColInfo( 0, nullptr );
 590
 591     //  get row info
 592
 593     SCROW nRowCount = 0;
 594     if ( bHasHeaderRow )
 595         ++nRowCount;
 596     if ( bHasRepRows )
 597         nRowCount += pDoc->CountVisibleRows(nRepeatRowStart, nRepeatRowEnd, nTab);
 598     if ( bHasMainRows )
 599         nRowCount += pDoc->CountVisibleRows(nMainRowStart, nMainRowEnd, nTab);
 600
 601     if ( nRowCount > 0 )
 602     {
 603         ScPreviewColRowInfo* pRowInfo = new ScPreviewColRowInfo[ nRowCount ];
 604         SCROW nRowPos = 0;
 605
 606         if ( bHasHeaderRow )
 607         {
 608             pRowInfo[nRowPos].Set( true, 0, aHeaderRect.Top(), aHeaderRect.Bottom() );
 609             ++nRowPos;
 610         }
 611         if ( bHasRepRows )
 612         {
 613             long nPosY = 0;
 614             for (SCROW nRow = nRepeatRowStart; nRow <= nRepeatRowEnd; ++nRow)
 615             {
 616                 if (pDoc->RowHidden(nRow, nTab))
 617                     continue;
 618
 619                 sal_uInt16 nDocH = pDoc->GetOriginalHeight( nRow, nTab );
 620                 long nNextY = nPosY + (long) (nDocH * nScaleY);
 621
 622                 long nPixelStart = pWindow->LogicToPixel( Size( 0, nPosY ), aCellMapMode ).Height();
 623                 long nPixelEnd = pWindow->LogicToPixel( Size( 0, nNextY ), aCellMapMode ).Height() - 1;
 624                 pRowInfo[nRowPos].Set( false, nRow,
 625                         aRepeatRect.Top() + nPixelStart,
 626                         aRepeatRect.Top() + nPixelEnd );
 627
 628                 nPosY = nNextY;
 629                 ++nRowPos;
 630             }
 631         }
 632         if ( bHasMainRows )
 633         {
 634             long nPosY = 0;
 635             for (SCROW nRow = nMainRowStart; nRow <= nMainRowEnd; ++nRow)
 636             {
 637                 if (pDoc->RowHidden(nRow, nTab))
 638                     continue;
 639
 640                 sal_uInt16 nDocH = pDoc->GetOriginalHeight( nRow, nTab );
 641                 long nNextY = nPosY + (long) (nDocH * nScaleY);
 642
 643                 long nPixelStart = pWindow->LogicToPixel( Size( 0, nPosY ), aCellMapMode ).Height();
 644                 long nPixelEnd = pWindow->LogicToPixel( Size( 0, nNextY ), aCellMapMode ).Height() - 1;
 645                 pRowInfo[nRowPos].Set( false, nRow,
 646                         aMainRect.Top() + nPixelStart,
 647                         aMainRect.Top() + nPixelEnd );
 648
 649                 nPosY = nNextY;
 650                 ++nRowPos;
 651             }
 652         }
 653         rInfo.SetRowInfo( nRowCount, pRowInfo );
 654     }
 655     else
 656         rInfo.SetRowInfo( 0, nullptr );
 657
 658     //  limit to visible area
 659
 660     rInfo.SetTab( nTab );
 661     rInfo.LimitToArea( rVisiblePixel );
 662 }
 663
 664 tools::Rectangle ScPreviewLocationData::GetHeaderCellOutputRect(const tools::Rectangle& rVisRect, const ScAddress& rCellPos, bool bColHeader) const
 665 {
 666     // first a stupid implementation
 667     // NN says here should be done more
 668     tools::Rectangle aClipRect;
 669     ScPreviewTableInfo aTableInfo;
 670     GetTableInfo( rVisRect, aTableInfo );
 671
 672     if ( (rCellPos.Col() >= 0) &&
 673         (rCellPos.Row() >= 0) && (rCellPos.Col() < aTableInfo.GetCols()) &&
 674         (rCellPos.Row() < aTableInfo.GetRows()) )
 675     {
 676         SCCOL nCol(0);
 677         SCROW nRow(0);
 678         if (bColHeader)
 679             nCol = rCellPos.Col();
 680         else
 681             nRow = rCellPos.Row();
 682         const ScPreviewColRowInfo& rColInfo = aTableInfo.GetColInfo()[nCol];
 683         const ScPreviewColRowInfo& rRowInfo = aTableInfo.GetRowInfo()[nRow];
 684
 685         if ( rColInfo.bIsHeader || rRowInfo.bIsHeader )
 686             aClipRect = tools::Rectangle( rColInfo.nPixelStart, rRowInfo.nPixelStart, rColInfo.nPixelEnd, rRowInfo.nPixelEnd );
 687     }
 688     return aClipRect;
 689 }
 690
 691 tools::Rectangle ScPreviewLocationData::GetCellOutputRect(const ScAddress& rCellPos) const
 692 {
 693     // first a stupid implementation
 694     // NN says here should be done more
 695     tools::Rectangle aRect;
 696     GetCellPosition(rCellPos, aRect);
 697     return aRect;
 698 }
 699
 700 // GetMainCellRange is used for links in PDF export
 701
 702 bool ScPreviewLocationData::GetMainCellRange( ScRange& rRange, tools::Rectangle& rPixRect ) const
 703 {
 704     for (auto const& it : m_Entries)
 705     {
 706         if ( it->eType == SC_PLOC_CELLRANGE && !it->bRepeatCol && !it->bRepeatRow )
 707         {
 708             rRange = it->aCellRange;
 709             rPixRect = it->aPixelRect;
 710             return true;
 711         }
 712     }
 713
 714     return false;
 715 }
 716
 717 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */