LCOV - code coverage report
Current view: top level - sc/source/ui/view - olinewin.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 532 0.0 %
Date: 2014-04-14 Functions: 0 61 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10