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