sc/source/ui/view/olinewin.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/svapp.hxx>
  21 #include <vcl/taskpanelist.hxx>
  22 #include <vcl/settings.hxx>
  23
  24 #include <olinewin.hxx>
  25 #include <olinetab.hxx>
  26 #include <document.hxx>
  27 #include <dbfunc.hxx>
  28 #include <strings.hrc>
  29 #include <scresid.hxx>
  30 #include <bitmaps.hlst>
  31
  32 const long SC_OL_BITMAPSIZE                 = 12;
  33 const long SC_OL_POSOFFSET                  = 2;
  34
  35 const size_t SC_OL_NOLEVEL                  = static_cast< size_t >( -1 );
  36 const size_t SC_OL_HEADERENTRY              = static_cast< size_t >( -1 );
  37
  38 ScOutlineWindow::ScOutlineWindow( vcl::Window* pParent, ScOutlineMode eMode, ScViewData* pViewData, ScSplitPos eWhich ) :
  39     Window( pParent ),
  40     mrViewData( *pViewData ),
  41     meWhich( eWhich ),
  42     mbHoriz( eMode == SC_OUTLINE_HOR ),
  43     mbMirrorEntries( false ),           // updated in SetHeaderSize
  44     mbMirrorLevels( false ),            // updated in SetHeaderSize
  45     maLineColor( COL_BLACK ),
  46     mnHeaderSize( 0 ),
  47     mnHeaderPos( 0 ),
  48     mnMainFirstPos( 0 ),
  49     mnMainLastPos( 0 ),
  50     mbMTActive( false ),
  51     mbMTPressed( false ),
  52     mnFocusLevel( 0 ),
  53     mnFocusEntry( SC_OL_HEADERENTRY ),
  54     mbDontDrawFocus( false )
  55 {
  56     EnableRTL( false );                 // mirroring is done manually
  57
  58     InitSettings();
  59     maFocusRect.SetEmpty();
  60     SetHeaderSize( 0 );
  61
  62     // insert the window into task pane list for "F6 cycling"
  63     if( SystemWindow* pSysWin = GetSystemWindow() )
  64         if( TaskPaneList* pTaskPaneList = pSysWin->GetTaskPaneList() )
  65             pTaskPaneList->AddWindow( this );
  66 }
  67
  68 ScOutlineWindow::~ScOutlineWindow()
  69 {
  70     disposeOnce();
  71 }
  72
  73 void ScOutlineWindow::dispose()
  74 {
  75     // remove the window from task pane list
  76     if( SystemWindow* pSysWin = GetSystemWindow() )
  77         if( TaskPaneList* pTaskPaneList = pSysWin->GetTaskPaneList() )
  78             pTaskPaneList->RemoveWindow( this );
  79     vcl::Window::dispose();
  80 }
  81
  82 void ScOutlineWindow::SetHeaderSize( long nNewSize )
  83 {
  84     bool bLayoutRTL = GetDoc().IsLayoutRTL( GetTab() );
  85     mbMirrorEntries = bLayoutRTL && mbHoriz;
  86     mbMirrorLevels = bLayoutRTL && !mbHoriz;
  87
  88     bool bNew = (nNewSize != mnHeaderSize);
  89     mnHeaderSize = nNewSize;
  90     mnHeaderPos = mbMirrorEntries ? (GetOutputSizeEntry() - mnHeaderSize) : 0;
  91     mnMainFirstPos = mbMirrorEntries ? 0 : mnHeaderSize;
  92     mnMainLastPos = GetOutputSizeEntry() - (mbMirrorEntries ? mnHeaderSize : 0) - 1;
  93     if ( bNew )
  94         Invalidate();
  95 }
  96
  97 long ScOutlineWindow::GetDepthSize() const
  98 {
  99     long nSize = GetLevelCount() * SC_OL_BITMAPSIZE;
 100     if ( nSize > 0 )
 101         nSize += 2 * SC_OL_POSOFFSET + 1;
 102     return nSize;
 103 }
 104
 105 void ScOutlineWindow::ScrollPixel( long nDiff )
 106 {
 107     HideFocus();
 108     mbDontDrawFocus = true;
 109
 110     long nStart = mnMainFirstPos;
 111     long nEnd = mnMainLastPos;
 112
 113     long nInvStart, nInvEnd;
 114     if (nDiff < 0)
 115     {
 116         nStart -= nDiff;
 117         nInvStart = nEnd + nDiff;
 118         nInvEnd = nEnd;
 119     }
 120     else
 121     {
 122         nEnd -= nDiff;
 123         nInvStart = nStart;
 124         nInvEnd = nStart + nDiff;
 125     }
 126
 127     ScrollRel( nDiff, nStart, nEnd );
 128     Invalidate( GetRectangle( 0, nInvStart, GetOutputSizeLevel() - 1, nInvEnd ) );
 129     Update();
 130
 131     // if focus becomes invisible, move it to next visible button
 132     ImplMoveFocusToVisible( nDiff < 0 );
 133
 134     mbDontDrawFocus = false;
 135     ShowFocus();
 136 }
 137
 138 void ScOutlineWindow::ScrollRel( long nEntryDiff, long nEntryStart, long nEntryEnd )
 139 {
 140     tools::Rectangle aRect( GetRectangle( 0, nEntryStart, GetOutputSizeLevel() - 1, nEntryEnd ) );
 141     if ( mbHoriz )
 142         Scroll( nEntryDiff, 0, aRect );
 143     else
 144         Scroll( 0, nEntryDiff, aRect );
 145 }
 146
 147 // internal -------------------------------------------------------------------
 148
 149 void ScOutlineWindow::InitSettings()
 150 {
 151     const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
 152     SetBackground( rStyleSettings.GetFaceColor() );
 153     maLineColor = rStyleSettings.GetButtonTextColor();
 154     Invalidate();
 155 }
 156
 157 const ScOutlineArray* ScOutlineWindow::GetOutlineArray() const
 158 {
 159     const ScOutlineTable* pTable = GetDoc().GetOutlineTable( GetTab() );
 160     if ( !pTable ) return nullptr;
 161     return mbHoriz ? &pTable->GetColArray() : &pTable->GetRowArray();
 162 }
 163
 164 const ScOutlineEntry* ScOutlineWindow::GetOutlineEntry( size_t nLevel, size_t nEntry ) const
 165 {
 166     const ScOutlineArray* pArray = GetOutlineArray();
 167     return pArray ? pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel), sal::static_int_cast<sal_uInt16>(nEntry) ) : nullptr;
 168 }
 169
 170 bool ScOutlineWindow::IsHidden( SCCOLROW nColRowIndex ) const
 171 {
 172     return mbHoriz ?
 173         GetDoc().ColHidden(static_cast<SCCOL>(nColRowIndex), GetTab()) :
 174         GetDoc().RowHidden(static_cast<SCROW>(nColRowIndex), GetTab());
 175 }
 176
 177 bool ScOutlineWindow::IsFiltered( SCCOLROW nColRowIndex ) const
 178 {
 179     // columns cannot be filtered
 180     return !mbHoriz && GetDoc().RowFiltered( static_cast<SCROW>(nColRowIndex), GetTab() );
 181 }
 182
 183 bool ScOutlineWindow::IsFirstVisible( SCCOLROW nColRowIndex ) const
 184 {
 185     bool bAllHidden = true;
 186     for ( SCCOLROW nPos = 0; (nPos < nColRowIndex) && bAllHidden; ++nPos )
 187         bAllHidden = IsHidden( nPos );
 188     return bAllHidden;
 189 }
 190
 191 void ScOutlineWindow::GetVisibleRange( SCCOLROW& rnColRowStart, SCCOLROW& rnColRowEnd ) const
 192 {
 193     if ( mbHoriz )
 194     {
 195         rnColRowStart = mrViewData.GetPosX( WhichH( meWhich ) );
 196         rnColRowEnd = rnColRowStart + mrViewData.VisibleCellsX( WhichH( meWhich ) );
 197     }
 198     else
 199     {
 200         rnColRowStart = mrViewData.GetPosY( WhichV( meWhich ) );
 201         rnColRowEnd = rnColRowStart + mrViewData.VisibleCellsY( WhichV( meWhich ) );
 202     }
 203
 204     // include collapsed columns/rows in front of visible range
 205     while ( (rnColRowStart > 0) && IsHidden( rnColRowStart - 1 ) )
 206         --rnColRowStart;
 207 }
 208
 209 Point ScOutlineWindow::GetPoint( long nLevelPos, long nEntryPos ) const
 210 {
 211     return mbHoriz ? Point( nEntryPos, nLevelPos ) : Point( nLevelPos, nEntryPos );
 212 }
 213
 214 tools::Rectangle ScOutlineWindow::GetRectangle(
 215         long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd ) const
 216 {
 217     return tools::Rectangle( GetPoint( nLevelStart, nEntryStart ), GetPoint( nLevelEnd, nEntryEnd ) );
 218 }
 219
 220 long ScOutlineWindow::GetOutputSizeLevel() const
 221 {
 222     Size aSize( GetOutputSizePixel() );
 223     return mbHoriz ? aSize.Height() : aSize.Width();
 224 }
 225
 226 long ScOutlineWindow::GetOutputSizeEntry() const
 227 {
 228     Size aSize( GetOutputSizePixel() );
 229     return mbHoriz ? aSize.Width() : aSize.Height();
 230 }
 231
 232 size_t ScOutlineWindow::GetLevelCount() const
 233 {
 234     const ScOutlineArray* pArray = GetOutlineArray();
 235     size_t nLevelCount = pArray ? pArray->GetDepth() : 0;
 236     return nLevelCount ? (nLevelCount + 1) : 0;
 237 }
 238
 239 long ScOutlineWindow::GetLevelPos( size_t nLevel ) const
 240 {
 241     // #i51970# must always return the *left* edge of the area used by a level
 242     long nPos = static_cast< long >( SC_OL_POSOFFSET + nLevel * SC_OL_BITMAPSIZE );
 243     return mbMirrorLevels ? (GetOutputSizeLevel() - nPos - SC_OL_BITMAPSIZE) : nPos;
 244 }
 245
 246 size_t ScOutlineWindow::GetLevelFromPos( long nLevelPos ) const
 247 {
 248     if( mbMirrorLevels ) nLevelPos = GetOutputSizeLevel() - nLevelPos - 1;
 249     long nStart = SC_OL_POSOFFSET;
 250     if ( nLevelPos < nStart ) return SC_OL_NOLEVEL;
 251     size_t nLevel = static_cast< size_t >( (nLevelPos - nStart) / SC_OL_BITMAPSIZE );
 252     return (nLevel < GetLevelCount()) ? nLevel : SC_OL_NOLEVEL;
 253 }
 254
 255 long ScOutlineWindow::GetColRowPos( SCCOLROW nColRowIndex ) const
 256 {
 257     long nDocPos = mbHoriz ?
 258         mrViewData.GetScrPos( static_cast<SCCOL>(nColRowIndex), 0, meWhich, true ).X() :
 259         mrViewData.GetScrPos( 0, static_cast<SCROW>(nColRowIndex), meWhich, true ).Y();
 260     return mnMainFirstPos + nDocPos;
 261 }
 262
 263 long ScOutlineWindow::GetHeaderEntryPos() const
 264 {
 265     return mnHeaderPos + (mnHeaderSize - SC_OL_BITMAPSIZE) / 2;
 266 }
 267
 268 bool ScOutlineWindow::GetEntryPos(
 269         size_t nLevel, size_t nEntry,
 270         long& rnStartPos, long& rnEndPos, long& rnImagePos ) const
 271 {
 272     const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 273     if ( !pEntry || !pEntry->IsVisible() )
 274         return false;
 275
 276     SCCOLROW nStart = pEntry->GetStart();
 277     SCCOLROW nEnd = pEntry->GetEnd();
 278
 279     long nEntriesSign = mbMirrorEntries ? -1 : 1;
 280
 281     // --- common calculation ---
 282
 283     rnStartPos = GetColRowPos( nStart );
 284     rnEndPos = GetColRowPos( nEnd + 1 );
 285
 286     bool bHidden = IsHidden( nStart );
 287     rnImagePos = bHidden ?
 288                 (rnStartPos - ( SC_OL_BITMAPSIZE / 2 ) * nEntriesSign) :
 289                 rnStartPos + nEntriesSign;
 290     long nCenter = (rnStartPos + rnEndPos - SC_OL_BITMAPSIZE * nEntriesSign +
 291                         ( mbMirrorEntries ? 1 : 0 )) / 2;
 292     rnImagePos = mbMirrorEntries ? std::max( rnImagePos, nCenter ) : std::min( rnImagePos, nCenter );
 293
 294     // --- refinements ---
 295
 296     // do not cut leftmost/topmost image
 297     if ( bHidden && IsFirstVisible( nStart ) )
 298         rnImagePos = rnStartPos;
 299
 300     // do not cover previous collapsed image
 301     bool bDoNoCover = !bHidden && nEntry;
 302     const ScOutlineEntry* pPrevEntry = bDoNoCover ? GetOutlineEntry(nLevel, nEntry - 1) : nullptr;
 303     if (pPrevEntry)
 304     {
 305         SCCOLROW nPrevEnd = pPrevEntry->GetEnd();
 306         if ( (nPrevEnd + 1 == nStart) && IsHidden( nPrevEnd ) )
 307         {
 308             if ( IsFirstVisible( pPrevEntry->GetStart() ) )
 309                 rnStartPos += SC_OL_BITMAPSIZE * nEntriesSign;
 310             else
 311                 rnStartPos += ( SC_OL_BITMAPSIZE / 2 ) * nEntriesSign;
 312             rnImagePos = rnStartPos;
 313         }
 314     }
 315
 316     // restrict rnStartPos...rnEndPos to valid area
 317     rnStartPos = std::max( rnStartPos, mnMainFirstPos );
 318     rnEndPos = std::max( rnEndPos, mnMainFirstPos );
 319
 320     if ( mbMirrorEntries )
 321         rnImagePos -= SC_OL_BITMAPSIZE - 1;     // start pos aligns with right edge of bitmap
 322
 323     // --- all rows filtered? ---
 324
 325     bool bVisible = true;
 326     if ( !mbHoriz )
 327     {
 328         bVisible = false;
 329         for ( SCCOLROW nRow = nStart; (nRow <= nEnd) && !bVisible; ++nRow )
 330             bVisible = !IsFiltered( nRow );
 331     }
 332     return bVisible;
 333 }
 334
 335 bool ScOutlineWindow::GetImagePos( size_t nLevel, size_t nEntry, Point& rPos ) const
 336 {
 337     bool bRet = nLevel < GetLevelCount();
 338     if ( bRet )
 339     {
 340         long nLevelPos = GetLevelPos( nLevel );
 341         if ( nEntry == SC_OL_HEADERENTRY )
 342             rPos = GetPoint( nLevelPos, GetHeaderEntryPos() );
 343         else
 344         {
 345             long nStartPos, nEndPos, nImagePos;
 346             bRet = GetEntryPos( nLevel, nEntry, nStartPos, nEndPos, nImagePos );
 347             rPos = GetPoint( nLevelPos, nImagePos );
 348         }
 349     }
 350     return bRet;
 351 }
 352
 353 bool ScOutlineWindow::IsButtonVisible( size_t nLevel, size_t nEntry ) const
 354 {
 355     bool bRet = false;
 356     if ( nEntry == SC_OL_HEADERENTRY )
 357         bRet = (mnHeaderSize > 0) && (nLevel < GetLevelCount());
 358     else
 359     {
 360         const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 361         if ( pEntry && pEntry->IsVisible() )
 362         {
 363             SCCOLROW nStart, nEnd;
 364             GetVisibleRange( nStart, nEnd );
 365             bRet = (nStart <= pEntry->GetStart()) && (pEntry->GetStart() <= nEnd);
 366         }
 367     }
 368     return bRet;
 369 }
 370
 371 bool ScOutlineWindow::ItemHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry, bool& rbButton ) const
 372 {
 373     const ScOutlineArray* pArray = GetOutlineArray();
 374     if ( !pArray ) return false;
 375
 376     SCCOLROW nStartIndex, nEndIndex;
 377     GetVisibleRange( nStartIndex, nEndIndex );
 378
 379     size_t nLevel = GetLevelFromPos( mbHoriz ? rPos.Y() : rPos.X() );
 380     if ( nLevel == SC_OL_NOLEVEL )
 381         return false;
 382
 383     long nEntryMousePos = mbHoriz ? rPos.X() : rPos.Y();
 384
 385     // --- level buttons ---
 386
 387     if ( mnHeaderSize > 0 )
 388     {
 389         long nImagePos = GetHeaderEntryPos();
 390         if ( (nImagePos <= nEntryMousePos) && (nEntryMousePos < nImagePos + SC_OL_BITMAPSIZE) )
 391         {
 392             rnLevel = nLevel;
 393             rnEntry = SC_OL_HEADERENTRY;
 394             rbButton = true;
 395             return true;
 396         }
 397     }
 398
 399     // --- expand/collapse buttons and expanded lines ---
 400
 401     // search outline entries backwards
 402     size_t nEntry = pArray->GetCount( sal::static_int_cast<sal_uInt16>(nLevel) );
 403     while ( nEntry )
 404     {
 405         --nEntry;
 406
 407         const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel),
 408                                                          sal::static_int_cast<sal_uInt16>(nEntry) );
 409         SCCOLROW nStart = pEntry->GetStart();
 410         SCCOLROW nEnd = pEntry->GetEnd();
 411
 412         if ( (nEnd >= nStartIndex) && (nStart <= nEndIndex) )
 413         {
 414             long nStartPos, nEndPos, nImagePos;
 415             if ( GetEntryPos( nLevel, nEntry, nStartPos, nEndPos, nImagePos ) )
 416             {
 417                 rnLevel = nLevel;
 418                 rnEntry = nEntry;
 419
 420                 // button?
 421                 if ( (nStart >= nStartIndex) && (nImagePos <= nEntryMousePos) && (nEntryMousePos < nImagePos + SC_OL_BITMAPSIZE) )
 422                 {
 423                     rbButton = true;
 424                     return true;
 425                 }
 426
 427                 // line?
 428                 if ( mbMirrorEntries )
 429                     ::std::swap( nStartPos, nEndPos );      // in RTL mode, nStartPos is the larger value
 430                 if ( (nStartPos <= nEntryMousePos) && (nEntryMousePos <= nEndPos) )
 431                 {
 432                     rbButton = false;
 433                     return true;
 434                 }
 435             }
 436         }
 437     }
 438
 439     return false;
 440 }
 441
 442 bool ScOutlineWindow::ButtonHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry ) const
 443 {
 444     bool bButton;
 445     bool bRet = ItemHit( rPos, rnLevel, rnEntry, bButton );
 446     return bRet && bButton;
 447 }
 448
 449 bool ScOutlineWindow::LineHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry ) const
 450 {
 451     bool bButton;
 452     bool bRet = ItemHit( rPos, rnLevel, rnEntry, bButton );
 453     return bRet && !bButton;
 454 }
 455
 456 void ScOutlineWindow::DoFunction( size_t nLevel, size_t nEntry ) const
 457 {
 458     ScDBFunc& rFunc = *mrViewData.GetView();
 459     if ( nEntry == SC_OL_HEADERENTRY )
 460         rFunc.SelectLevel( mbHoriz, sal::static_int_cast<sal_uInt16>(nLevel) );
 461     else
 462     {
 463         const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 464         if ( pEntry )
 465         {
 466             if ( pEntry->IsHidden() )
 467                 rFunc.ShowOutline( mbHoriz, sal::static_int_cast<sal_uInt16>(nLevel), sal::static_int_cast<sal_uInt16>(nEntry) );
 468             else
 469                 rFunc.HideOutline( mbHoriz, sal::static_int_cast<sal_uInt16>(nLevel), sal::static_int_cast<sal_uInt16>(nEntry) );
 470         }
 471     }
 472 }
 473
 474 void ScOutlineWindow::DoExpand( size_t nLevel, size_t nEntry ) const
 475 {
 476     const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 477     if ( pEntry && pEntry->IsHidden() )
 478         DoFunction( nLevel, nEntry );
 479 }
 480
 481 void ScOutlineWindow::DoCollapse( size_t nLevel, size_t nEntry ) const
 482 {
 483     const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry );
 484     if ( pEntry && !pEntry->IsHidden() )
 485         DoFunction( nLevel, nEntry );
 486 }
 487
 488 void ScOutlineWindow::Resize()
 489 {
 490     Window::Resize();
 491     SetHeaderSize( mnHeaderSize );  // recalculates header/group positions
 492     if ( !IsFocusButtonVisible() )
 493     {
 494         HideFocus();
 495         ShowFocus();    // calculates valid position
 496     }
 497 }
 498
 499 void ScOutlineWindow::DataChanged( const DataChangedEvent& rDCEvt )
 500 {
 501     if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 502          (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
 503     {
 504         InitSettings();
 505         Invalidate();
 506     }
 507     Window::DataChanged( rDCEvt );
 508 }
 509
 510 // drawing --------------------------------------------------------------------
 511
 512 void ScOutlineWindow::SetEntryAreaClipRegion()
 513 {
 514     SetClipRegion( vcl::Region(tools::Rectangle(
 515         GetPoint( 0, mnMainFirstPos ),
 516         GetPoint( GetOutputSizeLevel() - 1, mnMainLastPos ))));
 517 }
 518
 519 void ScOutlineWindow::DrawLineRel(
 520         long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd )
 521 {
 522     DrawLine( GetPoint( nLevelStart, nEntryStart ), GetPoint( nLevelEnd, nEntryEnd ) );
 523 }
 524
 525 void ScOutlineWindow::DrawRectRel(
 526         long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd )
 527 {
 528     DrawRect( GetRectangle( nLevelStart, nEntryStart, nLevelEnd, nEntryEnd ) );
 529 }
 530
 531 namespace
 532 {
 533     Image GetImage(const OUString& rId)
 534     {
 535         return Image(BitmapEx(rId));
 536     }
 537 }
 538
 539 void ScOutlineWindow::DrawImageRel(long nLevelPos, long nEntryPos, const OUString& rId)
 540 {
 541     const Image& rImage = GetImage(rId);
 542     SetLineColor();
 543     SetFillColor( GetBackground().GetColor() );
 544     Point aPos( GetPoint( nLevelPos, nEntryPos ) );
 545     DrawRect( tools::Rectangle( aPos, rImage.GetSizePixel() ) );
 546     DrawImage( aPos, rImage );
 547 }
 548
 549 void ScOutlineWindow::DrawBorderRel( size_t nLevel, size_t nEntry, bool bPressed )
 550 {
 551     Point aPos;
 552     if ( GetImagePos( nLevel, nEntry, aPos ) )
 553     {
 554         OUString sId = bPressed ? OUString(RID_BMP_PRESSED) : OUString(RID_BMP_NOTPRESSED);
 555         bool bClip = (nEntry != SC_OL_HEADERENTRY);
 556         if ( bClip )
 557             SetEntryAreaClipRegion();
 558         DrawImage(aPos, GetImage(sId));
 559         if ( bClip )
 560             SetClipRegion();
 561     }
 562     mbMTPressed = bPressed;
 563 }
 564
 565 void ScOutlineWindow::ShowFocus()
 566 {
 567     if ( HasFocus() )
 568     {
 569         // first move to a visible position
 570         ImplMoveFocusToVisible( true );
 571
 572         if ( IsFocusButtonVisible() )
 573         {
 574             Point aPos;
 575             if ( GetImagePos( mnFocusLevel, mnFocusEntry, aPos ) )
 576             {
 577                 aPos += Point( 1, 1 );
 578                 maFocusRect = tools::Rectangle( aPos, Size( SC_OL_BITMAPSIZE - 2, SC_OL_BITMAPSIZE - 2 ) );
 579                 bool bClip = (mnFocusEntry != SC_OL_HEADERENTRY);
 580                 if ( bClip )
 581                     SetEntryAreaClipRegion();
 582                 InvertTracking( maFocusRect, ShowTrackFlags::Small | ShowTrackFlags::TrackWindow );
 583                 if ( bClip )
 584                     SetClipRegion();
 585             }
 586         }
 587     }
 588 }
 589
 590 void ScOutlineWindow::HideFocus()
 591 {
 592     if ( !maFocusRect.IsEmpty() )
 593     {
 594         bool bClip = (mnFocusEntry != SC_OL_HEADERENTRY);
 595         if ( bClip )
 596             SetEntryAreaClipRegion();
 597         InvertTracking( maFocusRect, ShowTrackFlags::Small | ShowTrackFlags::TrackWindow );
 598         if ( bClip )
 599             SetClipRegion();
 600         maFocusRect.SetEmpty();
 601     }
 602 }
 603
 604 static const OUStringLiteral aLevelBmps[]=
 605 {
 606     RID_BMP_LEVEL1,
 607     RID_BMP_LEVEL2,
 608     RID_BMP_LEVEL3,
 609     RID_BMP_LEVEL4,
 610     RID_BMP_LEVEL5,
 611     RID_BMP_LEVEL6,
 612     RID_BMP_LEVEL7,
 613     RID_BMP_LEVEL8
 614 };
 615
 616 void ScOutlineWindow::Paint( vcl::RenderContext& /*rRenderContext*/, const tools::Rectangle& /* rRect */ )
 617 {
 618     long nEntriesSign = mbMirrorEntries ? -1 : 1;
 619     long nLevelsSign  = mbMirrorLevels  ? -1 : 1;
 620
 621     Size aSize = GetOutputSizePixel();
 622     long nLevelEnd = (mbHoriz ? aSize.Height() : aSize.Width()) - 1;
 623     long nEntryEnd = (mbHoriz ? aSize.Width() : aSize.Height()) - 1;
 624
 625     SetLineColor( maLineColor );
 626     long nBorderPos = mbMirrorLevels ? 0 : nLevelEnd;
 627     DrawLineRel( nBorderPos, 0, nBorderPos, nEntryEnd );
 628
 629     const ScOutlineArray* pArray = GetOutlineArray();
 630     if ( !pArray ) return;
 631
 632     size_t nLevelCount = GetLevelCount();
 633
 634     // --- draw header images ---
 635
 636     if ( mnHeaderSize > 0 )
 637     {
 638         long nEntryPos = GetHeaderEntryPos();
 639         for ( size_t nLevel = 0; nLevel < nLevelCount; ++nLevel )
 640             DrawImageRel(GetLevelPos(nLevel), nEntryPos, aLevelBmps[nLevel]);
 641
 642         SetLineColor( maLineColor );
 643         long nLinePos = mnHeaderPos + (mbMirrorEntries ? 0 : (mnHeaderSize - 1));
 644         DrawLineRel( 0, nLinePos, nLevelEnd, nLinePos );
 645     }
 646
 647     // --- draw lines & collapse/expand images ---
 648
 649     SetEntryAreaClipRegion();
 650
 651     SCCOLROW nStartIndex, nEndIndex;
 652     GetVisibleRange( nStartIndex, nEndIndex );
 653
 654     for ( size_t nLevel = 0; nLevel + 1 < nLevelCount; ++nLevel )
 655     {
 656         long nLevelPos = GetLevelPos( nLevel );
 657         long nEntryPos1 = 0, nEntryPos2 = 0, nImagePos = 0;
 658
 659         size_t nEntryCount = pArray->GetCount( sal::static_int_cast<sal_uInt16>(nLevel) );
 660         size_t nEntry;
 661
 662         // first draw all lines in the current level
 663         SetLineColor();
 664         SetFillColor( maLineColor );
 665         for ( nEntry = 0; nEntry < nEntryCount; ++nEntry )
 666         {
 667             const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel),
 668                                                              sal::static_int_cast<sal_uInt16>(nEntry) );
 669             SCCOLROW nStart = pEntry->GetStart();
 670             SCCOLROW nEnd = pEntry->GetEnd();
 671
 672             // visible range?
 673             bool bDraw = (nEnd >= nStartIndex) && (nStart <= nEndIndex);
 674             // find output coordinates
 675             if ( bDraw )
 676                 bDraw = GetEntryPos( nLevel, nEntry, nEntryPos1, nEntryPos2, nImagePos );
 677             // draw, if not collapsed
 678             if ( bDraw && !pEntry->IsHidden() )
 679             {
 680                 if ( nStart >= nStartIndex )
 681                     nEntryPos1 += nEntriesSign;
 682                 nEntryPos2 -= 2 * nEntriesSign;
 683                 long nLinePos = nLevelPos;
 684                 if ( mbMirrorLevels )
 685                     nLinePos += SC_OL_BITMAPSIZE - 1;   // align with right edge of bitmap
 686                 DrawRectRel( nLinePos, nEntryPos1, nLinePos + nLevelsSign, nEntryPos2 );
 687
 688                 if ( nEnd <= nEndIndex )
 689                     DrawRectRel( nLinePos, nEntryPos2 - nEntriesSign,
 690                                  nLinePos + ( SC_OL_BITMAPSIZE / 3 ) * nLevelsSign, nEntryPos2 );
 691             }
 692         }
 693
 694         // draw all images in the level from last to first
 695         nEntry = nEntryCount;
 696         while ( nEntry )
 697         {
 698             --nEntry;
 699
 700             const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel),
 701                                                              sal::static_int_cast<sal_uInt16>(nEntry) );
 702             SCCOLROW nStart = pEntry->GetStart();
 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                 OUString sImageId = pEntry->IsHidden() ? OUString(RID_BMP_PLUS) : OUString(RID_BMP_MINUS);
 713                 DrawImageRel(nLevelPos, nImagePos, sImageId);
 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 static bool lcl_RotateValue( size_t& rnValue, size_t nMin, size_t nMax, bool bForward )
 729 {
 730     OSL_ENSURE( nMin <= nMax, "lcl_RotateValue - invalid range" );
 731     OSL_ENSURE( 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<sal_uInt16>(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(
 820             mnFocusLevel, mnFocusEntry);
 821
 822         if ( pEntry )
 823         {
 824             SCCOLROW nStart = pEntry->GetStart();
 825             SCCOLROW nEnd = pEntry->GetEnd();
 826             size_t nNewLevel = mnFocusLevel;
 827             size_t nNewEntry = 0;
 828
 829             bool bFound = false;
 830             if ( bForward && (mnFocusLevel + 2 < nLevelCount) )
 831             {
 832                 // next level -> find first child entry
 833                 nNewLevel = mnFocusLevel + 1;
 834                 bFound = pArray->GetEntryIndexInRange(nNewLevel, nStart, nEnd, nNewEntry);
 835             }
 836             else if ( !bForward && (mnFocusLevel > 0) )
 837             {
 838                 // previous level -> find parent entry
 839                 nNewLevel = mnFocusLevel - 1;
 840                 bFound = pArray->GetEntryIndex(nNewLevel, nStart, nNewEntry);
 841             }
 842
 843             if ( bFound && IsButtonVisible( nNewLevel, nNewEntry ) )
 844             {
 845                 mnFocusLevel = nNewLevel;
 846                 mnFocusEntry = nNewEntry;
 847             }
 848         }
 849     }
 850
 851     return bWrapped;
 852 }
 853
 854 bool ScOutlineWindow::ImplMoveFocusByTabOrder( bool bForward )
 855 {
 856     bool bRet = false;
 857     size_t nOldLevel = mnFocusLevel;
 858     size_t nOldEntry = mnFocusEntry;
 859
 860     do
 861     {
 862         /*  one level up, if backward from left header,
 863             or one level down, if forward from right header */
 864         if ( (!bForward) && (mnFocusEntry == SC_OL_HEADERENTRY) )
 865             bRet |= ImplMoveFocusByLevel( bForward );
 866         // move to next/previous entry
 867         bool bWrapInLevel = ImplMoveFocusByEntry( bForward, false );
 868         bRet |= bWrapInLevel;
 869         /*  one level up, if wrapped backward to right header,
 870             or one level down, if wrapped forward to right header */
 871         if ( bForward && bWrapInLevel )
 872             bRet |= ImplMoveFocusByLevel( bForward );
 873     }
 874     while ( !IsFocusButtonVisible() && ((nOldLevel != mnFocusLevel) || (nOldEntry != mnFocusEntry)) );
 875
 876     return bRet;
 877 }
 878
 879 void ScOutlineWindow::ImplMoveFocusToVisible( bool bForward )
 880 {
 881     // first try to find an entry in the same level
 882     if ( !IsFocusButtonVisible() )
 883         ImplMoveFocusByEntry( bForward, true );
 884     // then try to find any other entry
 885     if ( !IsFocusButtonVisible() )
 886         ImplMoveFocusByTabOrder( bForward );
 887 }
 888
 889 void ScOutlineWindow::MoveFocusByEntry( bool bForward )
 890 {
 891     HideFocus();
 892     ImplMoveFocusByEntry( bForward, true );
 893     ShowFocus();
 894 }
 895
 896 void ScOutlineWindow::MoveFocusByLevel( bool bForward )
 897 {
 898     HideFocus();
 899     ImplMoveFocusByLevel( bForward );
 900     ShowFocus();
 901 }
 902
 903 void ScOutlineWindow::MoveFocusByTabOrder( bool bForward )
 904 {
 905     HideFocus();
 906     ImplMoveFocusByTabOrder( bForward );
 907     ShowFocus();
 908 }
 909
 910 void ScOutlineWindow::GetFocus()
 911 {
 912     Window::GetFocus();
 913     ShowFocus();
 914 }
 915
 916 void ScOutlineWindow::LoseFocus()
 917 {
 918     HideFocus();
 919     Window::LoseFocus();
 920 }
 921
 922 // mouse ----------------------------------------------------------------------
 923
 924 void ScOutlineWindow::StartMouseTracking( size_t nLevel, size_t nEntry )
 925 {
 926     mbMTActive = true;
 927     mnMTLevel = nLevel;
 928     mnMTEntry = nEntry;
 929     DrawBorderRel( nLevel, nEntry, true );
 930 }
 931
 932 void ScOutlineWindow::EndMouseTracking()
 933 {
 934     if ( mbMTPressed )
 935         DrawBorderRel( mnMTLevel, mnMTEntry, false );
 936     mbMTActive = false;
 937 }
 938
 939 void ScOutlineWindow::MouseMove( const MouseEvent& rMEvt )
 940 {
 941     if ( IsMouseTracking() )
 942     {
 943         size_t nLevel, nEntry;
 944         bool bHit = false;
 945
 946         if ( ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry ) )
 947             bHit = (nLevel == mnMTLevel) && (nEntry == mnMTEntry);
 948
 949         if ( bHit != mbMTPressed )
 950             DrawBorderRel( mnMTLevel, mnMTEntry, bHit );
 951     }
 952 }
 953
 954 void ScOutlineWindow::MouseButtonUp( const MouseEvent& rMEvt )
 955 {
 956     if ( IsMouseTracking() )
 957     {
 958         EndMouseTracking();
 959
 960         size_t nLevel, nEntry;
 961         if ( ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry ) )
 962             if ( (nLevel == mnMTLevel) && (nEntry == mnMTEntry) )
 963                 DoFunction( nLevel, nEntry );
 964     }
 965 }
 966
 967 void ScOutlineWindow::MouseButtonDown( const MouseEvent& rMEvt )
 968 {
 969     size_t nLevel, nEntry;
 970     bool bHit = ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry );
 971     if ( bHit )
 972         StartMouseTracking( nLevel, nEntry );
 973     else if ( rMEvt.GetClicks() == 2 )
 974     {
 975         bHit = LineHit( rMEvt.GetPosPixel(), nLevel, nEntry );
 976         if ( bHit )
 977             DoFunction( nLevel, nEntry );
 978     }
 979
 980     // if an item has been hit and window is focused, move focus to this item
 981     if ( bHit && HasFocus() )
 982     {
 983         HideFocus();
 984         mnFocusLevel = nLevel;
 985         mnFocusEntry = nEntry;
 986         ShowFocus();
 987     }
 988 }
 989
 990 // keyboard -------------------------------------------------------------------
 991
 992 void ScOutlineWindow::KeyInput( const KeyEvent& rKEvt )
 993 {
 994     const vcl::KeyCode& rKCode = rKEvt.GetKeyCode();
 995     bool bNoMod = !rKCode.GetModifier();
 996     bool bShift = (rKCode.GetModifier() == KEY_SHIFT);
 997     bool bCtrl = (rKCode.GetModifier() == KEY_MOD1);
 998
 999     sal_uInt16 nCode = rKCode.GetCode();
1000     bool bUpDownKey = (nCode == KEY_UP) || (nCode == KEY_DOWN);
1001     bool bLeftRightKey = (nCode == KEY_LEFT) || (nCode == KEY_RIGHT);
1002
1003     // TAB key
1004     if ( (nCode == KEY_TAB) && (bNoMod || bShift) )
1005         // move forward without SHIFT key
1006         MoveFocusByTabOrder( bNoMod );      // TAB uses logical order, regardless of mirroring
1007
1008     // LEFT/RIGHT/UP/DOWN keys
1009     else if ( bNoMod && (bUpDownKey || bLeftRightKey) )
1010     {
1011         bool bForward = (nCode == KEY_DOWN) || (nCode == KEY_RIGHT);
1012         if ( mbHoriz == bLeftRightKey )
1013             // move inside level with LEFT/RIGHT in horizontal and with UP/DOWN in vertical
1014             MoveFocusByEntry( bForward != mbMirrorEntries );
1015         else
1016             // move to next/prev level with LEFT/RIGHT in vertical and with UP/DOWN in horizontal
1017             MoveFocusByLevel( bForward != mbMirrorLevels );
1018     }
1019
1020     // CTRL + number
1021     else if ( bCtrl && (nCode >= KEY_1) && (nCode <= KEY_9) )
1022     {
1023         size_t nLevel = static_cast< size_t >( nCode - KEY_1 );
1024         if ( nLevel < GetLevelCount() )
1025             DoFunction( nLevel, SC_OL_HEADERENTRY );
1026     }
1027
1028     // other key codes
1029     else switch ( rKCode.GetFullCode() )
1030     {
1031         case KEY_ADD:       DoExpand( mnFocusLevel, mnFocusEntry );     break;
1032         case KEY_SUBTRACT:  DoCollapse( mnFocusLevel, mnFocusEntry );   break;
1033         case KEY_SPACE:
1034         case KEY_RETURN:    DoFunction( mnFocusLevel, mnFocusEntry );   break;
1035         default:            Window::KeyInput( rKEvt );
1036     }
1037 }
1038
1039 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */