sc/source/ui/view/olinewin.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: olinewin.cxx,v $
  10  * $Revision: 1.15.32.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35 #include <vcl/svapp.hxx>
  36 #include <vcl/taskpanelist.hxx>
  37
  38 #include "olinewin.hxx"
  39 #include "olinetab.hxx"
  40 #include "document.hxx"
  41 #include "dbfunc.hxx"
  42 #include "sc.hrc"
  43
  44 // ============================================================================
  45
  46 const long SC_OL_BITMAPSIZE                 = 12;
  47 const long SC_OL_POSOFFSET                  = 2;
  48
  49 const size_t SC_OL_NOLEVEL                  = static_cast< size_t >( -1 );
  50 const size_t SC_OL_HEADERENTRY              = static_cast< size_t >( -1 );
  51
  52 const USHORT SC_OL_IMAGE_PLUS               = 9;
  53 const USHORT SC_OL_IMAGE_MINUS              = SC_OL_IMAGE_PLUS + 1;
  54 const USHORT SC_OL_IMAGE_NOTPRESSED         = SC_OL_IMAGE_MINUS + 1;
  55 const USHORT SC_OL_IMAGE_PRESSED            = SC_OL_IMAGE_NOTPRESSED + 1;
  56
  57 // ============================================================================
  58
  59 ScOutlineWindow::ScOutlineWindow( Window* pParent, ScOutlineMode eMode, ScViewData* pViewData, ScSplitPos eWhich ) :
  60     Window( pParent ),
  61     mrViewData( *pViewData ),
  62     meWhich( eWhich ),
  63     mbHoriz( eMode == SC_OUTLINE_HOR ),
  64     mbMirrorEntries( false ),           // updated in SetHeaderSize
  65     mbMirrorLevels( false ),            // updated in SetHeaderSize
  66     mpSymbols( NULL ),
  67     maLineColor( COL_BLACK ),
  68     mnHeaderSize( 0 ),
  69     mnHeaderPos( 0 ),
  70     mnMainFirstPos( 0 ),
  71     mnMainLastPos( 0 ),
  72     mbMTActive( false ),
  73     mbMTPressed( false ),
  74     mnFocusLevel( 0 ),
  75     mnFocusEntry( SC_OL_HEADERENTRY ),
  76     mbDontDrawFocus( false )
  77 {
  78     EnableRTL( FALSE );                 // mirroring is done manually
  79
  80     InitSettings();
  81     maFocusRect.SetEmpty();
  82     SetHeaderSize( 0 );
  83
  84     // insert the window into task pane list for "F6 cycling"
  85     if( SystemWindow* pSysWin = GetSystemWindow() )
  86         if( TaskPaneList* pTaskPaneList = pSysWin->GetTaskPaneList() )
  87             pTaskPaneList->AddWindow( this );
  88 }
  89
  90 ScOutlineWindow::~ScOutlineWindow()
  91 {
  92     // remove the window from task pane list
  93     if( SystemWindow* pSysWin = GetSystemWindow() )
  94         if( TaskPaneList* pTaskPaneList = pSysWin->GetTaskPaneList() )
  95             pTaskPaneList->RemoveWindow( this );
  96 }
  97
  98 void ScOutlineWindow::SetHeaderSize( long nNewSize )
  99 {
 100     BOOL bLayoutRTL = GetDoc().IsLayoutRTL( GetTab() );
 101     mbMirrorEntries = bLayoutRTL && mbHoriz;
 102     mbMirrorLevels = bLayoutRTL && !mbHoriz;
 103
 104     bool bNew = (nNewSize != mnHeaderSize);
 105     mnHeaderSize = nNewSize;
 106     mnHeaderPos = mbMirrorEntries ? (GetOutputSizeEntry() - mnHeaderSize) : 0;
 107     mnMainFirstPos = mbMirrorEntries ? 0 : mnHeaderSize;
 108     mnMainLastPos = GetOutputSizeEntry() - (mbMirrorEntries ? mnHeaderSize : 0) - 1;
 109     if ( bNew )
 110         Invalidate();
 111 }
 112
 113 long ScOutlineWindow::GetDepthSize() const
 114 {
 115     long nSize = GetLevelCount() * SC_OL_BITMAPSIZE;
 116     if ( nSize > 0 )
 117         nSize += 2 * SC_OL_POSOFFSET + 1;
 118     return nSize;
 119 }
 120
 121 void ScOutlineWindow::ScrollPixel( long nDiff )
 122 {
 123     HideFocus();
 124     mbDontDrawFocus = true;
 125
 126     long nStart = mnMainFirstPos;
 127     long nEnd = mnMainLastPos;
 128
 129     long nInvStart, nInvEnd;
 130     if (nDiff < 0)
 131     {
 132         nStart -= nDiff;
 133         nInvStart = nEnd + nDiff;
 134         nInvEnd = nEnd;
 135     }
 136     else
 137     {
 138         nEnd -= nDiff;
 139         nInvStart = nStart;
 140         nInvEnd = nStart + nDiff;
 141     }
 142
 143     ScrollRel( nDiff, nStart, nEnd );
 144     Invalidate( GetRectangle( 0, nInvStart, GetOutputSizeLevel() - 1, nInvEnd ) );
 145     Update();
 146
 147     // if focus becomes invisible, move it to next visible button
 148     ImplMoveFocusToVisible( nDiff < 0 );
 149
 150     mbDontDrawFocus = false;
 151     ShowFocus();
 152 }
 153
 154 void ScOutlineWindow::ScrollRel( long nEntryDiff, long nEntryStart, long nEntryEnd )
 155 {
 156     Rectangle aRect( GetRectangle( 0, nEntryStart, GetOutputSizeLevel() - 1, nEntryEnd ) );
 157     if ( mbHoriz )
 158         Scroll( nEntryDiff, 0, aRect );
 159     else
 160         Scroll( 0, nEntryDiff, aRect );
 161 }
 162
 163 // internal -------------------------------------------------------------------
 164
 165 void ScOutlineWindow::InitSettings()
 166 {
 167     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 168     SetBackground( rStyleSettings.GetFaceColor() );
 169     maLineColor = rStyleSettings.GetButtonTextColor();
 170     mpSymbols = ScGlobal::GetOutlineSymbols( !!GetBackground().GetColor().IsDark() );
 171     Invalidate();
 172 }
 173
 174 const ScOutlineArray* ScOutlineWindow::GetOutlineArray() const
 175 {
 176     const ScOutlineTable* pTable = GetDoc().GetOutlineTable( GetTab() );
 177     if ( !pTable ) return NULL;
 178     return mbHoriz ? pTable->GetColArray() : pTable->GetRowArray();
 179 }
 180
 181 const ScOutlineEntry* ScOutlineWindow::GetOutlineEntry( size_t nLevel, size_t nEntry ) const
 182 {
 183     const ScOutlineArray* pArray = GetOutlineArray();
 184     return pArray ? pArray->GetEntry( sal::static_int_cast<USHORT>(nLevel), sal::static_int_cast<USHORT>(nEntry) ) : NULL;
 185 }
 186
 187 bool ScOutlineWindow::IsHidden( SCCOLROW nColRowIndex ) const
 188 {
 189     return mbHoriz ?
 190         GetDoc().ColHidden(static_cast<SCCOL>(nColRowIndex), GetTab()) :
 191         GetDoc().RowHidden(static_cast<SCROW>(nColRowIndex), GetTab());
 192 }
 193
 194 bool ScOutlineWindow::IsFiltered( SCCOLROW nColRowIndex ) const
 195 {
 196     // columns cannot be filtered
 197     return !mbHoriz && GetDoc().RowFiltered( static_cast<SCROW>(nColRowIndex), GetTab() );
 198 }
 199
 200 bool ScOutlineWindow::IsFirstVisible( SCCOLROW nColRowIndex ) const
 201 {
 202     bool bAllHidden = true;
 203     for ( SCCOLROW nPos = 0; (nPos < nColRowIndex) && bAllHidden; ++nPos )
 204         bAllHidden = IsHidden( nPos );
 205     return bAllHidden;
 206 }
 207
 208 void ScOutlineWindow::GetVisibleRange( SCCOLROW& rnColRowStart, SCCOLROW& rnColRowEnd ) const
 209 {
 210     if ( mbHoriz )
 211     {
 212         rnColRowStart = mrViewData.GetPosX( WhichH( meWhich ) );
 213         rnColRowEnd = rnColRowStart + mrViewData.VisibleCellsX( WhichH( meWhich ) );
 214     }
 215     else
 216     {
 217         rnColRowStart = mrViewData.GetPosY( WhichV( meWhich ) );
 218         rnColRowEnd = rnColRowStart + mrViewData.VisibleCellsY( WhichV( meWhich ) );
 219     }
 220
 221     // include collapsed columns/rows in front of visible range
 222     while ( (rnColRowStart > 0) && IsHidden( rnColRowStart - 1 ) )
 223         --rnColRowStart;
 224 }
 225
 226 Point ScOutlineWindow::GetPoint( long nLevelPos, long nEntryPos ) const
 227 {
 228     return mbHoriz ? Point( nEntryPos, nLevelPos ) : Point( nLevelPos, nEntryPos );
 229 }
 230
 231 Rectangle ScOutlineWindow::GetRectangle(
 232         long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd ) const
 233 {
 234     return Rectangle( GetPoint( nLevelStart, nEntryStart ), GetPoint( nLevelEnd, nEntryEnd ) );
 235 }
 236
 237 long ScOutlineWindow::GetOutputSizeLevel() const
 238 {
 239     Size aSize( GetOutputSizePixel() );
 240     return mbHoriz ? aSize.Height() : aSize.Width();
 241 }
 242
 243 long ScOutlineWindow::GetOutputSizeEntry() const
 244 {
 245     Size aSize( GetOutputSizePixel() );
 246     return mbHoriz ? aSize.Width() : aSize.Height();
 247 }
 248
 249 size_t ScOutlineWindow::GetLevelCount() const
 250 {
 251     const ScOutlineArray* pArray = GetOutlineArray();
 252     size_t nLevelCount = pArray ? pArray->GetDepth() : 0;
 253     return nLevelCount ? (nLevelCount + 1) : 0;
 254 }
 255
 256 long ScOutlineWindow::GetLevelPos( size_t nLevel ) const
 257 {
 258     // #i51970# must always return the *left* edge of the area used by a level
 259     long nPos = static_cast< long >( SC_OL_POSOFFSET + nLevel * SC_OL_BITMAPSIZE );
 260     return mbMirrorLevels ? (GetOutputSizeLevel() - nPos - SC_OL_BITMAPSIZE) : nPos;
 261 }
 262
 263 size_t ScOutlineWindow::GetLevelFromPos( long nLevelPos ) const
 264 {
 265     if( mbMirrorLevels ) nLevelPos = GetOutputSizeLevel() - nLevelPos - 1;
 266     long nStart = SC_OL_POSOFFSET;
 267     if ( nLevelPos < nStart ) return SC_OL_NOLEVEL;
 268     size_t nLevel = static_cast< size_t >( (nLevelPos - nStart) / SC_OL_BITMAPSIZE );
 269     return (nLevel < GetLevelCount()) ? nLevel : SC_OL_NOLEVEL;
 270 }
 271
 272 long ScOutlineWindow::GetColRowPos( SCCOLROW nColRowIndex ) const
 273 {
 274     long nDocPos = mbHoriz ?
 275         mrViewData.GetScrPos( static_cast<SCCOL>(nColRowIndex), 0, meWhich, TRUE ).X() :
 276         mrViewData.GetScrPos( 0, static_cast<SCROW>(nColRowIndex), meWhich, TRUE ).Y();
 277     return mnMainFirstPos + nDocPos;
 278 }
 279
 280 long ScOutlineWindow::GetHeaderEntryPos() const
 281 {
 282     return mnHeaderPos + (mnHeaderSize - SC_OL_BITMAPSIZE) / 2;
 283 }
 284
 285 bool ScOutlineWindow::GetEntryPos(
 286         size_t nLevel, size_t nEntry,
 287         long& rnStartPos, long& rnEndPos, long& rnImagePos ) const
 288 {
 289     const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 290     if ( !pEntry || !pEntry->IsVisible() )
 291         return false;
 292
 293     SCCOLROW nStart = pEntry->GetStart();
 294     SCCOLROW nEnd = pEntry->GetEnd();
 295
 296     long nEntriesSign = mbMirrorEntries ? -1 : 1;
 297
 298     // --- common calculation ---
 299
 300     rnStartPos = GetColRowPos( nStart );
 301     rnEndPos = GetColRowPos( nEnd + 1 );
 302
 303     bool bHidden = IsHidden( nStart );
 304     rnImagePos = bHidden ?
 305                 (rnStartPos - ( SC_OL_BITMAPSIZE / 2 ) * nEntriesSign) :
 306                 rnStartPos + nEntriesSign;
 307     long nCenter = (rnStartPos + rnEndPos - SC_OL_BITMAPSIZE * nEntriesSign +
 308                         ( mbMirrorEntries ? 1 : 0 )) / 2L;
 309     rnImagePos = mbMirrorEntries ? Max( rnImagePos, nCenter ) : Min( rnImagePos, nCenter );
 310
 311     // --- refinements ---
 312
 313     // do not cut leftmost/topmost image
 314     if ( bHidden && IsFirstVisible( nStart ) )
 315         rnImagePos = rnStartPos;
 316
 317     // do not cover previous collapsed image
 318     if ( !bHidden && nEntry )
 319     {
 320         const ScOutlineEntry* pPrevEntry = GetOutlineEntry( nLevel, nEntry - 1 );
 321         SCCOLROW nPrevEnd = pPrevEntry->GetEnd();
 322         if ( (nPrevEnd + 1 == nStart) && IsHidden( nPrevEnd ) )
 323         {
 324             if ( IsFirstVisible( pPrevEntry->GetStart() ) )
 325                 rnStartPos += SC_OL_BITMAPSIZE * nEntriesSign;
 326             else
 327                 rnStartPos += ( SC_OL_BITMAPSIZE / 2 ) * nEntriesSign;
 328             rnImagePos = rnStartPos;
 329         }
 330     }
 331
 332     // restrict rnStartPos...rnEndPos to valid area
 333     rnStartPos = std::max( rnStartPos, mnMainFirstPos );
 334     rnEndPos = std::max( rnEndPos, mnMainFirstPos );
 335
 336     if ( mbMirrorEntries )
 337         rnImagePos -= SC_OL_BITMAPSIZE - 1;     // start pos aligns with right edge of bitmap
 338
 339     // --- all rows filtered? ---
 340
 341     bool bVisible = true;
 342     if ( !mbHoriz )
 343     {
 344         bVisible = false;
 345         for ( SCCOLROW nRow = nStart; (nRow <= nEnd) && !bVisible; ++nRow )
 346             bVisible = !IsFiltered( nRow );
 347     }
 348     return bVisible;
 349 }
 350
 351 bool ScOutlineWindow::GetImagePos( size_t nLevel, size_t nEntry, Point& rPos ) const
 352 {
 353     bool bRet = nLevel < GetLevelCount();
 354     if ( bRet )
 355     {
 356         long nLevelPos = GetLevelPos( nLevel );
 357         if ( nEntry == SC_OL_HEADERENTRY )
 358             rPos = GetPoint( nLevelPos, GetHeaderEntryPos() );
 359         else
 360         {
 361             long nStartPos, nEndPos, nImagePos;
 362             bRet = GetEntryPos( nLevel, nEntry, nStartPos, nEndPos, nImagePos );
 363             rPos = GetPoint( nLevelPos, nImagePos );
 364         }
 365     }
 366     return bRet;
 367 }
 368
 369 bool ScOutlineWindow::IsButtonVisible( size_t nLevel, size_t nEntry ) const
 370 {
 371     bool bRet = false;
 372     if ( nEntry == SC_OL_HEADERENTRY )
 373         bRet = (mnHeaderSize > 0) && (nLevel < GetLevelCount());
 374     else
 375     {
 376         const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 377         if ( pEntry && pEntry->IsVisible() )
 378         {
 379             SCCOLROW nStart, nEnd;
 380             GetVisibleRange( nStart, nEnd );
 381             bRet = (nStart <= pEntry->GetStart()) && (pEntry->GetStart() <= nEnd);
 382         }
 383     }
 384     return bRet;
 385 }
 386
 387 bool ScOutlineWindow::ItemHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry, bool& rbButton ) const
 388 {
 389     const ScOutlineArray* pArray = GetOutlineArray();
 390     if ( !pArray ) return false;
 391
 392     SCCOLROW nStartIndex, nEndIndex;
 393     GetVisibleRange( nStartIndex, nEndIndex );
 394
 395     size_t nLevel = GetLevelFromPos( mbHoriz ? rPos.Y() : rPos.X() );
 396     if ( nLevel == SC_OL_NOLEVEL )
 397         return false;
 398
 399 //    long nLevelPos = GetLevelPos( nLevel );
 400     long nEntryMousePos = mbHoriz ? rPos.X() : rPos.Y();
 401
 402     // --- level buttons ---
 403
 404     if ( mnHeaderSize > 0 )
 405     {
 406         long nImagePos = GetHeaderEntryPos();
 407         if ( (nImagePos <= nEntryMousePos) && (nEntryMousePos < nImagePos + SC_OL_BITMAPSIZE) )
 408         {
 409             rnLevel = nLevel;
 410             rnEntry = SC_OL_HEADERENTRY;
 411             rbButton = true;
 412             return true;
 413         }
 414     }
 415
 416     // --- expand/collapse buttons and expanded lines ---
 417
 418     // search outline entries backwards
 419     size_t nEntry = pArray->GetCount( sal::static_int_cast<USHORT>(nLevel) );
 420     while ( nEntry )
 421     {
 422         --nEntry;
 423
 424         const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<USHORT>(nLevel),
 425                                                          sal::static_int_cast<USHORT>(nEntry) );
 426         SCCOLROW nStart = pEntry->GetStart();
 427         SCCOLROW nEnd = pEntry->GetEnd();
 428
 429         if ( (nEnd >= nStartIndex) && (nStart <= nEndIndex) )
 430         {
 431             long nStartPos, nEndPos, nImagePos;
 432             if ( GetEntryPos( nLevel, nEntry, nStartPos, nEndPos, nImagePos ) )
 433             {
 434                 rnLevel = nLevel;
 435                 rnEntry = nEntry;
 436
 437                 // button?
 438                 if ( (nStart >= nStartIndex) && (nImagePos <= nEntryMousePos) && (nEntryMousePos < nImagePos + SC_OL_BITMAPSIZE) )
 439                 {
 440                     rbButton = true;
 441                     return true;
 442                 }
 443
 444                 // line?
 445                 if ( mbMirrorEntries )
 446                     ::std::swap( nStartPos, nEndPos );      // in RTL mode, nStartPos is the larger value
 447                 if ( (nStartPos <= nEntryMousePos) && (nEntryMousePos <= nEndPos) )
 448                 {
 449                     rbButton = false;
 450                     return true;
 451                 }
 452             }
 453         }
 454     }
 455
 456     return false;
 457 }
 458
 459 bool ScOutlineWindow::ButtonHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry ) const
 460 {
 461     bool bButton;
 462     bool bRet = ItemHit( rPos, rnLevel, rnEntry, bButton );
 463     return bRet && bButton;
 464 }
 465
 466 bool ScOutlineWindow::LineHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry ) const
 467 {
 468     bool bButton;
 469     bool bRet = ItemHit( rPos, rnLevel, rnEntry, bButton );
 470     return bRet && !bButton;
 471 }
 472
 473 void ScOutlineWindow::DoFunction( size_t nLevel, size_t nEntry ) const
 474 {
 475     ScDBFunc& rFunc = *mrViewData.GetView();
 476     if ( nEntry == SC_OL_HEADERENTRY )
 477         rFunc.SelectLevel( mbHoriz, sal::static_int_cast<USHORT>(nLevel) );
 478     else
 479     {
 480         const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 481         if ( pEntry )
 482         {
 483             if ( pEntry->IsHidden() )
 484                 rFunc.ShowOutline( mbHoriz, sal::static_int_cast<USHORT>(nLevel), sal::static_int_cast<USHORT>(nEntry) );
 485             else
 486                 rFunc.HideOutline( mbHoriz, sal::static_int_cast<USHORT>(nLevel), sal::static_int_cast<USHORT>(nEntry) );
 487         }
 488     }
 489 }
 490
 491 void ScOutlineWindow::DoExpand( size_t nLevel, size_t nEntry ) const
 492 {
 493     const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 494     if ( pEntry && pEntry->IsHidden() )
 495         DoFunction( nLevel, nEntry );
 496 }
 497
 498 void ScOutlineWindow::DoCollapse( size_t nLevel, size_t nEntry ) const
 499 {
 500     const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 501     if ( pEntry && !pEntry->IsHidden() )
 502         DoFunction( nLevel, nEntry );
 503 }
 504
 505 void ScOutlineWindow::Resize()
 506 {
 507     Window::Resize();
 508     SetHeaderSize( mnHeaderSize );  // recalculates header/group positions
 509     if ( !IsFocusButtonVisible() )
 510     {
 511         HideFocus();
 512         ShowFocus();    // calculates valid position
 513     }
 514 }
 515
 516 void ScOutlineWindow::DataChanged( const DataChangedEvent& rDCEvt )
 517 {
 518     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
 519          (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 520     {
 521         InitSettings();
 522         Invalidate();
 523     }
 524     Window::DataChanged( rDCEvt );
 525 }
 526
 527 // drawing --------------------------------------------------------------------
 528
 529 void ScOutlineWindow::SetEntryAreaClipRegion()
 530 {
 531     SetClipRegion( Rectangle(
 532         GetPoint( 0, mnMainFirstPos ),
 533         GetPoint( GetOutputSizeLevel() - 1, mnMainLastPos ) ) );
 534 }
 535
 536 void ScOutlineWindow::DrawLineRel(
 537         long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd )
 538 {
 539     DrawLine( GetPoint( nLevelStart, nEntryStart ), GetPoint( nLevelEnd, nEntryEnd ) );
 540 }
 541
 542 void ScOutlineWindow::DrawRectRel(
 543         long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd )
 544 {
 545     DrawRect( GetRectangle( nLevelStart, nEntryStart, nLevelEnd, nEntryEnd ) );
 546 }
 547
 548 void ScOutlineWindow::DrawImageRel( long nLevelPos, long nEntryPos, USHORT nId )
 549 {
 550     DBG_ASSERT( mpSymbols, "ScOutlineWindow::DrawImageRel - no images" );
 551     const Image& rImage = mpSymbols->GetImage( nId );
 552     SetLineColor();
 553     SetFillColor( GetBackground().GetColor() );
 554     Point aPos( GetPoint( nLevelPos, nEntryPos ) );
 555     DrawRect( Rectangle( aPos, rImage.GetSizePixel() ) );
 556     DrawImage( aPos, rImage );
 557 }
 558
 559 void ScOutlineWindow::DrawBorderRel( size_t nLevel, size_t nEntry, bool bPressed )
 560 {
 561     Point aPos;
 562     if ( GetImagePos( nLevel, nEntry, aPos ) )
 563     {
 564         DBG_ASSERT( mpSymbols, "ScOutlineWindow::DrawBorderRel - no images" );
 565         USHORT nId = bPressed ? SC_OL_IMAGE_PRESSED : SC_OL_IMAGE_NOTPRESSED;
 566         bool bClip = (nEntry != SC_OL_HEADERENTRY);
 567         if ( bClip )
 568             SetEntryAreaClipRegion();
 569         DrawImage( aPos, mpSymbols->GetImage( nId ) );
 570         if ( bClip )
 571             SetClipRegion();
 572     }
 573     mbMTPressed = bPressed;
 574 }
 575
 576 void ScOutlineWindow::ShowFocus()
 577 {
 578     if ( HasFocus() )
 579     {
 580         // first move to a visible position
 581         ImplMoveFocusToVisible( true );
 582
 583         if ( IsFocusButtonVisible() )
 584         {
 585             Point aPos;
 586             if ( GetImagePos( mnFocusLevel, mnFocusEntry, aPos ) )
 587             {
 588                 aPos += Point( 1, 1 );
 589                 maFocusRect = Rectangle( aPos, Size( SC_OL_BITMAPSIZE - 2, SC_OL_BITMAPSIZE - 2 ) );
 590                 bool bClip = (mnFocusEntry != SC_OL_HEADERENTRY);
 591                 if ( bClip )
 592                     SetEntryAreaClipRegion();
 593                 InvertTracking( maFocusRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW );
 594                 if ( bClip )
 595                     SetClipRegion();
 596             }
 597         }
 598     }
 599 }
 600
 601 void ScOutlineWindow::HideFocus()
 602 {
 603     if ( !maFocusRect.IsEmpty() )
 604     {
 605         bool bClip = (mnFocusEntry != SC_OL_HEADERENTRY);
 606         if ( bClip )
 607             SetEntryAreaClipRegion();
 608         InvertTracking( maFocusRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW );
 609         if ( bClip )
 610             SetClipRegion();
 611         maFocusRect.SetEmpty();
 612     }
 613 }
 614
 615 void ScOutlineWindow::Paint( const Rectangle& /* rRect */ )
 616 {
 617     long nEntriesSign = mbMirrorEntries ? -1 : 1;
 618     long nLevelsSign  = mbMirrorLevels  ? -1 : 1;
 619
 620     Size aSize = GetOutputSizePixel();
 621     long nLevelEnd = (mbHoriz ? aSize.Height() : aSize.Width()) - 1;
 622     long nEntryEnd = (mbHoriz ? aSize.Width() : aSize.Height()) - 1;
 623
 624     SetLineColor( maLineColor );
 625     long nBorderPos = mbMirrorLevels ? 0 : nLevelEnd;
 626     DrawLineRel( nBorderPos, 0, nBorderPos, nEntryEnd );
 627
 628     const ScOutlineArray* pArray = GetOutlineArray();
 629     if ( !pArray ) return;
 630
 631     size_t nLevelCount = GetLevelCount();
 632
 633     // --- draw header images ---
 634
 635     if ( mnHeaderSize > 0 )
 636     {
 637         long nEntryPos = GetHeaderEntryPos();
 638         for ( size_t nLevel = 0; nLevel < nLevelCount; ++nLevel )
 639             DrawImageRel( GetLevelPos( nLevel ), nEntryPos, static_cast< USHORT >( nLevel + 1 ) );
 640
 641         SetLineColor( maLineColor );
 642         long nLinePos = mnHeaderPos + (mbMirrorEntries ? 0 : (mnHeaderSize - 1));
 643         DrawLineRel( 0, nLinePos, nLevelEnd, nLinePos );
 644     }
 645
 646     // --- draw lines & collapse/expand images ---
 647
 648     SetEntryAreaClipRegion();
 649
 650     SCCOLROW nStartIndex, nEndIndex;
 651     GetVisibleRange( nStartIndex, nEndIndex );
 652
 653     for ( size_t nLevel = 0; nLevel + 1 < nLevelCount; ++nLevel )
 654     {
 655         long nLevelPos = GetLevelPos( nLevel );
 656         long nEntryPos1 = 0, nEntryPos2 = 0, nImagePos = 0;
 657
 658         size_t nEntryCount = pArray->GetCount( sal::static_int_cast<USHORT>(nLevel) );
 659         size_t nEntry;
 660
 661         // first draw all lines in the current level
 662         SetLineColor();
 663         SetFillColor( maLineColor );
 664         for ( nEntry = 0; nEntry < nEntryCount; ++nEntry )
 665         {
 666             const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<USHORT>(nLevel),
 667                                                              sal::static_int_cast<USHORT>(nEntry) );
 668             SCCOLROW nStart = pEntry->GetStart();
 669             SCCOLROW nEnd = pEntry->GetEnd();
 670
 671             // visible range?
 672             bool bDraw = (nEnd >= nStartIndex) && (nStart <= nEndIndex);
 673             // find output coordinates
 674             if ( bDraw )
 675                 bDraw = GetEntryPos( nLevel, nEntry, nEntryPos1, nEntryPos2, nImagePos );
 676             // draw, if not collapsed
 677             if ( bDraw && !pEntry->IsHidden() )
 678             {
 679                 if ( nStart >= nStartIndex )
 680                     nEntryPos1 += nEntriesSign;
 681                 nEntryPos2 -= 2 * nEntriesSign;
 682                 long nLinePos = nLevelPos;
 683                 if ( mbMirrorLevels )
 684                     nLinePos += SC_OL_BITMAPSIZE - 1;   // align with right edge of bitmap
 685                 DrawRectRel( nLinePos, nEntryPos1, nLinePos + nLevelsSign, nEntryPos2 );
 686
 687                 if ( nEnd <= nEndIndex )
 688                     DrawRectRel( nLinePos, nEntryPos2 - nEntriesSign,
 689                                  nLinePos + ( SC_OL_BITMAPSIZE / 3 ) * nLevelsSign, nEntryPos2 );
 690             }
 691         }
 692
 693         // draw all images in the level from last to first
 694         nEntry = nEntryCount;
 695         while ( nEntry )
 696         {
 697             --nEntry;
 698
 699             const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<USHORT>(nLevel),
 700                                                              sal::static_int_cast<USHORT>(nEntry) );
 701             SCCOLROW nStart = pEntry->GetStart();
 702 //            SCCOLROW nEnd = pEntry->GetEnd();
 703
 704             // visible range?
 705             bool bDraw = (nStartIndex <= nStart) && (nStart <= nEndIndex + 1);
 706             // find output coordinates
 707             if ( bDraw )
 708                 bDraw = GetEntryPos( nLevel, nEntry, nEntryPos1, nEntryPos2, nImagePos );
 709             // draw, if not hidden by higher levels
 710             if ( bDraw )
 711             {
 712                 USHORT nImageId = pEntry->IsHidden() ? SC_OL_IMAGE_PLUS : SC_OL_IMAGE_MINUS;
 713                 DrawImageRel( nLevelPos, nImagePos, nImageId );
 714             }
 715         }
 716     }
 717
 718     SetClipRegion();
 719
 720     if ( !mbDontDrawFocus )
 721         ShowFocus();
 722 }
 723
 724 // focus ----------------------------------------------------------------------
 725
 726 /** Increments or decrements a value and wraps at the specified limits.
 727     @return  true = value wrapped. */
 728 bool lcl_RotateValue( size_t& rnValue, size_t nMin, size_t nMax, bool bForward )
 729 {
 730     DBG_ASSERT( nMin <= nMax, "lcl_RotateValue - invalid range" );
 731     DBG_ASSERT( nMax < static_cast< size_t >( -1 ), "lcl_RotateValue - range overflow" );
 732     bool bWrap = false;
 733     if ( bForward )
 734     {
 735         if ( rnValue < nMax )
 736             ++rnValue;
 737         else
 738         {
 739             rnValue = nMin;
 740             bWrap = true;
 741         }
 742     }
 743     else
 744     {
 745         if ( rnValue > nMin )
 746             --rnValue;
 747         else
 748         {
 749             rnValue = nMax;
 750             bWrap = true;
 751         }
 752     }
 753     return bWrap;
 754 }
 755
 756 bool ScOutlineWindow::IsFocusButtonVisible() const
 757 {
 758     return IsButtonVisible( mnFocusLevel, mnFocusEntry );
 759 }
 760
 761 bool ScOutlineWindow::ImplMoveFocusByEntry( bool bForward, bool bFindVisible )
 762 {
 763     const ScOutlineArray* pArray = GetOutlineArray();
 764     if ( !pArray )
 765         return false;
 766
 767     bool bWrapped = false;
 768     size_t nEntryCount = pArray->GetCount( sal::static_int_cast<USHORT>(mnFocusLevel) );
 769     // #i29530# entry count may be decreased after changing active sheet
 770     if( mnFocusEntry >= nEntryCount )
 771         mnFocusEntry = SC_OL_HEADERENTRY;
 772     size_t nOldEntry = mnFocusEntry;
 773
 774     do
 775     {
 776         if ( mnFocusEntry == SC_OL_HEADERENTRY )
 777         {
 778             // move from header to first or last entry
 779             if ( nEntryCount > 0 )
 780                 mnFocusEntry = bForward ? 0 : (nEntryCount - 1);
 781             /*  wrapped, if forward from right header to first entry,
 782                 or if backward from left header to last entry */
 783             // Header and entries are now always in consistent order,
 784             // so there's no need to check for mirroring here.
 785             if ( !nEntryCount || !bForward )
 786                 bWrapped = true;
 787         }
 788         else if ( lcl_RotateValue( mnFocusEntry, 0, nEntryCount - 1, bForward ) )
 789         {
 790             // lcl_RotateValue returns true -> wrapped the entry range -> move to header
 791             mnFocusEntry = SC_OL_HEADERENTRY;
 792             /*  wrapped, if forward from last entry to left header,
 793                 or if backward from first entry to right header */
 794             if ( bForward )
 795                 bWrapped = true;
 796         }
 797     }
 798     while ( bFindVisible && !IsFocusButtonVisible() && (nOldEntry != mnFocusEntry) );
 799
 800     return bWrapped;
 801 }
 802
 803 bool ScOutlineWindow::ImplMoveFocusByLevel( bool bForward )
 804 {
 805     const ScOutlineArray* pArray = GetOutlineArray();
 806     if ( !pArray )
 807         return false;
 808
 809     bool bWrapped = false;
 810     size_t nLevelCount = GetLevelCount();
 811
 812     if ( mnFocusEntry == SC_OL_HEADERENTRY )
 813     {
 814         if ( nLevelCount > 0 )
 815             bWrapped = lcl_RotateValue( mnFocusLevel, 0, nLevelCount - 1, bForward );
 816     }
 817     else
 818     {
 819         const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<USHORT>(mnFocusLevel),
 820                                                          sal::static_int_cast<USHORT>(mnFocusEntry) );
 821         if ( pEntry )
 822         {
 823             SCCOLROW nStart = pEntry->GetStart();
 824             SCCOLROW nEnd = pEntry->GetEnd();
 825             size_t nNewLevel = mnFocusLevel;
 826             size_t nNewEntry = 0;
 827
 828             bool bFound = false;
 829             if ( bForward && (mnFocusLevel + 2 < nLevelCount) )
 830             {
 831                 // next level -> find first child entry
 832                 nNewLevel = mnFocusLevel + 1;
 833                 // TODO - change ScOutlineArray interface to size_t usage
 834                 USHORT nTmpEntry = 0;
 835                 bFound = pArray->GetEntryIndexInRange( sal::static_int_cast<USHORT>(nNewLevel), nStart, nEnd, nTmpEntry );
 836                 nNewEntry = nTmpEntry;
 837             }
 838             else if ( !bForward && (mnFocusLevel > 0) )
 839             {
 840                 // previous level -> find parent entry
 841                 nNewLevel = mnFocusLevel - 1;
 842                 // TODO - change ScOutlineArray interface to size_t usage
 843                 USHORT nTmpEntry = 0;
 844                 bFound = pArray->GetEntryIndex( sal::static_int_cast<USHORT>(nNewLevel), nStart, nTmpEntry );
 845                 nNewEntry = nTmpEntry;
 846             }
 847
 848             if ( bFound && IsButtonVisible( nNewLevel, nNewEntry ) )
 849             {
 850                 mnFocusLevel = nNewLevel;
 851                 mnFocusEntry = nNewEntry;
 852             }
 853         }
 854     }
 855
 856     return bWrapped;
 857 }
 858
 859 bool ScOutlineWindow::ImplMoveFocusByTabOrder( bool bForward, bool bFindVisible )
 860 {
 861     bool bRet = false;
 862     size_t nOldLevel = mnFocusLevel;
 863     size_t nOldEntry = mnFocusEntry;
 864
 865     do
 866     {
 867         /*  one level up, if backward from left header,
 868             or one level down, if forward from right header */
 869         if ( (!bForward) && (mnFocusEntry == SC_OL_HEADERENTRY) )
 870             bRet |= ImplMoveFocusByLevel( bForward );
 871         // move to next/previous entry
 872         bool bWrapInLevel = ImplMoveFocusByEntry( bForward, false );
 873         bRet |= bWrapInLevel;
 874         /*  one level up, if wrapped backward to right header,
 875             or one level down, if wrapped forward to right header */
 876         if ( bForward && bWrapInLevel )
 877             bRet |= ImplMoveFocusByLevel( bForward );
 878     }
 879     while ( bFindVisible && !IsFocusButtonVisible() && ((nOldLevel != mnFocusLevel) || (nOldEntry != mnFocusEntry)) );
 880
 881     return bRet;
 882 }
 883
 884 void ScOutlineWindow::ImplMoveFocusToVisible( bool bForward )
 885 {
 886     // first try to find an entry in the same level
 887     if ( !IsFocusButtonVisible() )
 888         ImplMoveFocusByEntry( bForward, true );
 889     // then try to find any other entry
 890     if ( !IsFocusButtonVisible() )
 891         ImplMoveFocusByTabOrder( bForward, true );
 892 }
 893
 894 void ScOutlineWindow::MoveFocusByEntry( bool bForward )
 895 {
 896     HideFocus();
 897     ImplMoveFocusByEntry( bForward, true );
 898     ShowFocus();
 899 }
 900
 901 void ScOutlineWindow::MoveFocusByLevel( bool bForward )
 902 {
 903     HideFocus();
 904     ImplMoveFocusByLevel( bForward );
 905     ShowFocus();
 906 }
 907
 908 void ScOutlineWindow::MoveFocusByTabOrder( bool bForward )
 909 {
 910     HideFocus();
 911     ImplMoveFocusByTabOrder( bForward, true );
 912     ShowFocus();
 913 }
 914
 915 void ScOutlineWindow::GetFocus()
 916 {
 917     Window::GetFocus();
 918     ShowFocus();
 919 }
 920
 921 void ScOutlineWindow::LoseFocus()
 922 {
 923     HideFocus();
 924     Window::LoseFocus();
 925 }
 926
 927
 928 // mouse ----------------------------------------------------------------------
 929
 930 void ScOutlineWindow::StartMouseTracking( size_t nLevel, size_t nEntry )
 931 {
 932     mbMTActive = true;
 933     mnMTLevel = nLevel;
 934     mnMTEntry = nEntry;
 935     DrawBorderRel( nLevel, nEntry, true );
 936 }
 937
 938 void ScOutlineWindow::EndMouseTracking()
 939 {
 940     if ( mbMTPressed )
 941         DrawBorderRel( mnMTLevel, mnMTEntry, false );
 942     mbMTActive = false;
 943 }
 944
 945 void ScOutlineWindow::MouseMove( const MouseEvent& rMEvt )
 946 {
 947     if ( IsMouseTracking() )
 948     {
 949         size_t nLevel, nEntry;
 950         bool bHit = false;
 951
 952         if ( ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry ) )
 953             bHit = (nLevel == mnMTLevel) && (nEntry == mnMTEntry);
 954
 955         if ( bHit != mbMTPressed )
 956             DrawBorderRel( mnMTLevel, mnMTEntry, bHit );
 957     }
 958 }
 959
 960 void ScOutlineWindow::MouseButtonUp( const MouseEvent& rMEvt )
 961 {
 962     if ( IsMouseTracking() )
 963     {
 964         EndMouseTracking();
 965
 966         size_t nLevel, nEntry;
 967         if ( ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry ) )
 968             if ( (nLevel == mnMTLevel) && (nEntry == mnMTEntry) )
 969                 DoFunction( nLevel, nEntry );
 970     }
 971 }
 972
 973 void ScOutlineWindow::MouseButtonDown( const MouseEvent& rMEvt )
 974 {
 975     size_t nLevel, nEntry;
 976     bool bHit = ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry );
 977     if ( bHit )
 978         StartMouseTracking( nLevel, nEntry );
 979     else if ( rMEvt.GetClicks() == 2 )
 980     {
 981         bHit = LineHit( rMEvt.GetPosPixel(), nLevel, nEntry );
 982         if ( bHit )
 983             DoFunction( nLevel, nEntry );
 984     }
 985
 986     // if an item has been hit and window is focused, move focus to this item
 987     if ( bHit && HasFocus() )
 988     {
 989         HideFocus();
 990         mnFocusLevel = nLevel;
 991         mnFocusEntry = nEntry;
 992         ShowFocus();
 993     }
 994 }
 995
 996
 997 // keyboard -------------------------------------------------------------------
 998
 999 void ScOutlineWindow::KeyInput( const KeyEvent& rKEvt )
1000 {
1001     const KeyCode& rKCode = rKEvt.GetKeyCode();
1002     bool bNoMod = !rKCode.GetModifier();
1003     bool bShift = (rKCode.GetModifier() == KEY_SHIFT);
1004     bool bCtrl = (rKCode.GetModifier() == KEY_MOD1);
1005
1006     USHORT nCode = rKCode.GetCode();
1007     bool bUpDownKey = (nCode == KEY_UP) || (nCode == KEY_DOWN);
1008     bool bLeftRightKey = (nCode == KEY_LEFT) || (nCode == KEY_RIGHT);
1009
1010     // TAB key
1011     if ( (nCode == KEY_TAB) && (bNoMod || bShift) )
1012         // move forward without SHIFT key
1013         MoveFocusByTabOrder( bNoMod );      // TAB uses logical order, regardless of mirroring
1014
1015     // LEFT/RIGHT/UP/DOWN keys
1016     else if ( bNoMod && (bUpDownKey || bLeftRightKey) )
1017     {
1018         bool bForward = (nCode == KEY_DOWN) || (nCode == KEY_RIGHT);
1019         if ( mbHoriz == bLeftRightKey )
1020             // move inside level with LEFT/RIGHT in horizontal and with UP/DOWN in vertical
1021             MoveFocusByEntry( bForward != mbMirrorEntries );
1022         else
1023             // move to next/prev level with LEFT/RIGHT in vertical and with UP/DOWN in horizontal
1024             MoveFocusByLevel( bForward != mbMirrorLevels );
1025     }
1026
1027     // CTRL + number
1028     else if ( bCtrl && (nCode >= KEY_1) && (nCode <= KEY_9) )
1029     {
1030         size_t nLevel = static_cast< size_t >( nCode - KEY_1 );
1031         if ( nLevel < GetLevelCount() )
1032             DoFunction( nLevel, SC_OL_HEADERENTRY );
1033     }
1034
1035     // other key codes
1036     else switch ( rKCode.GetFullCode() )
1037     {
1038         case KEY_ADD:       DoExpand( mnFocusLevel, mnFocusEntry );     break;
1039         case KEY_SUBTRACT:  DoCollapse( mnFocusLevel, mnFocusEntry );   break;
1040         case KEY_SPACE:
1041         case KEY_RETURN:    DoFunction( mnFocusLevel, mnFocusEntry );   break;
1042         default:            Window::KeyInput( rKEvt );
1043     }
1044 }
1045
1046
1047 // ============================================================================
1048