| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| #include <vcl/svapp.hxx> |
| #include <vcl/taskpanelist.hxx> |
| |
| #include "olinewin.hxx" |
| #include "olinetab.hxx" |
| #include "document.hxx" |
| #include "dbfunc.hxx" |
| #include "sc.hrc" |
| |
| // ============================================================================ |
| |
| const long SC_OL_BITMAPSIZE = 12; |
| const long SC_OL_POSOFFSET = 2; |
| |
| const size_t SC_OL_NOLEVEL = static_cast< size_t >( -1 ); |
| const size_t SC_OL_HEADERENTRY = static_cast< size_t >( -1 ); |
| |
| const sal_uInt16 SC_OL_IMAGE_PLUS = 9; |
| const sal_uInt16 SC_OL_IMAGE_MINUS = SC_OL_IMAGE_PLUS + 1; |
| const sal_uInt16 SC_OL_IMAGE_NOTPRESSED = SC_OL_IMAGE_MINUS + 1; |
| const sal_uInt16 SC_OL_IMAGE_PRESSED = SC_OL_IMAGE_NOTPRESSED + 1; |
| |
| // ============================================================================ |
| |
| ScOutlineWindow::ScOutlineWindow( Window* pParent, ScOutlineMode eMode, ScViewData* pViewData, ScSplitPos eWhich ) : |
| Window( pParent ), |
| mrViewData( *pViewData ), |
| meWhich( eWhich ), |
| mbHoriz( eMode == SC_OUTLINE_HOR ), |
| mbMirrorEntries( false ), // updated in SetHeaderSize |
| mbMirrorLevels( false ), // updated in SetHeaderSize |
| mpSymbols( NULL ), |
| maLineColor( COL_BLACK ), |
| mnHeaderSize( 0 ), |
| mnHeaderPos( 0 ), |
| mnMainFirstPos( 0 ), |
| mnMainLastPos( 0 ), |
| mbMTActive( false ), |
| mbMTPressed( false ), |
| mnFocusLevel( 0 ), |
| mnFocusEntry( SC_OL_HEADERENTRY ), |
| mbDontDrawFocus( false ) |
| { |
| EnableRTL( sal_False ); // mirroring is done manually |
| |
| InitSettings(); |
| maFocusRect.SetEmpty(); |
| SetHeaderSize( 0 ); |
| |
| // insert the window into task pane list for "F6 cycling" |
| if( SystemWindow* pSysWin = GetSystemWindow() ) |
| if( TaskPaneList* pTaskPaneList = pSysWin->GetTaskPaneList() ) |
| pTaskPaneList->AddWindow( this ); |
| } |
| |
| ScOutlineWindow::~ScOutlineWindow() |
| { |
| // remove the window from task pane list |
| if( SystemWindow* pSysWin = GetSystemWindow() ) |
| if( TaskPaneList* pTaskPaneList = pSysWin->GetTaskPaneList() ) |
| pTaskPaneList->RemoveWindow( this ); |
| } |
| |
| void ScOutlineWindow::SetHeaderSize( long nNewSize ) |
| { |
| sal_Bool bLayoutRTL = GetDoc().IsLayoutRTL( GetTab() ); |
| mbMirrorEntries = bLayoutRTL && mbHoriz; |
| mbMirrorLevels = bLayoutRTL && !mbHoriz; |
| |
| bool bNew = (nNewSize != mnHeaderSize); |
| mnHeaderSize = nNewSize; |
| mnHeaderPos = mbMirrorEntries ? (GetOutputSizeEntry() - mnHeaderSize) : 0; |
| mnMainFirstPos = mbMirrorEntries ? 0 : mnHeaderSize; |
| mnMainLastPos = GetOutputSizeEntry() - (mbMirrorEntries ? mnHeaderSize : 0) - 1; |
| if ( bNew ) |
| Invalidate(); |
| } |
| |
| long ScOutlineWindow::GetDepthSize() const |
| { |
| long nSize = GetLevelCount() * SC_OL_BITMAPSIZE; |
| if ( nSize > 0 ) |
| nSize += 2 * SC_OL_POSOFFSET + 1; |
| return nSize; |
| } |
| |
| void ScOutlineWindow::ScrollPixel( long nDiff ) |
| { |
| HideFocus(); |
| mbDontDrawFocus = true; |
| |
| long nStart = mnMainFirstPos; |
| long nEnd = mnMainLastPos; |
| |
| long nInvStart, nInvEnd; |
| if (nDiff < 0) |
| { |
| nStart -= nDiff; |
| nInvStart = nEnd + nDiff; |
| nInvEnd = nEnd; |
| } |
| else |
| { |
| nEnd -= nDiff; |
| nInvStart = nStart; |
| nInvEnd = nStart + nDiff; |
| } |
| |
| ScrollRel( nDiff, nStart, nEnd ); |
| Invalidate( GetRectangle( 0, nInvStart, GetOutputSizeLevel() - 1, nInvEnd ) ); |
| Update(); |
| |
| // if focus becomes invisible, move it to next visible button |
| ImplMoveFocusToVisible( nDiff < 0 ); |
| |
| mbDontDrawFocus = false; |
| ShowFocus(); |
| } |
| |
| void ScOutlineWindow::ScrollRel( long nEntryDiff, long nEntryStart, long nEntryEnd ) |
| { |
| Rectangle aRect( GetRectangle( 0, nEntryStart, GetOutputSizeLevel() - 1, nEntryEnd ) ); |
| if ( mbHoriz ) |
| Scroll( nEntryDiff, 0, aRect ); |
| else |
| Scroll( 0, nEntryDiff, aRect ); |
| } |
| |
| // internal ------------------------------------------------------------------- |
| |
| void ScOutlineWindow::InitSettings() |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| SetBackground( rStyleSettings.GetFaceColor() ); |
| maLineColor = rStyleSettings.GetButtonTextColor(); |
| mpSymbols = ScGlobal::GetOutlineSymbols( rStyleSettings.GetHighContrastMode() ); |
| Invalidate(); |
| } |
| |
| const ScOutlineArray* ScOutlineWindow::GetOutlineArray() const |
| { |
| const ScOutlineTable* pTable = GetDoc().GetOutlineTable( GetTab() ); |
| if ( !pTable ) return NULL; |
| return mbHoriz ? pTable->GetColArray() : pTable->GetRowArray(); |
| } |
| |
| const ScOutlineEntry* ScOutlineWindow::GetOutlineEntry( size_t nLevel, size_t nEntry ) const |
| { |
| const ScOutlineArray* pArray = GetOutlineArray(); |
| return pArray ? pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel), sal::static_int_cast<sal_uInt16>(nEntry) ) : NULL; |
| } |
| |
| bool ScOutlineWindow::IsHidden( SCCOLROW nColRowIndex ) const |
| { |
| return mbHoriz ? |
| GetDoc().ColHidden(static_cast<SCCOL>(nColRowIndex), GetTab()) : |
| GetDoc().RowHidden(static_cast<SCROW>(nColRowIndex), GetTab()); |
| } |
| |
| bool ScOutlineWindow::IsFiltered( SCCOLROW nColRowIndex ) const |
| { |
| // columns cannot be filtered |
| return !mbHoriz && GetDoc().RowFiltered( static_cast<SCROW>(nColRowIndex), GetTab() ); |
| } |
| |
| bool ScOutlineWindow::IsFirstVisible( SCCOLROW nColRowIndex ) const |
| { |
| bool bAllHidden = true; |
| for ( SCCOLROW nPos = 0; (nPos < nColRowIndex) && bAllHidden; ++nPos ) |
| bAllHidden = IsHidden( nPos ); |
| return bAllHidden; |
| } |
| |
| void ScOutlineWindow::GetVisibleRange( SCCOLROW& rnColRowStart, SCCOLROW& rnColRowEnd ) const |
| { |
| if ( mbHoriz ) |
| { |
| rnColRowStart = mrViewData.GetPosX( WhichH( meWhich ) ); |
| rnColRowEnd = rnColRowStart + mrViewData.VisibleCellsX( WhichH( meWhich ) ); |
| } |
| else |
| { |
| rnColRowStart = mrViewData.GetPosY( WhichV( meWhich ) ); |
| rnColRowEnd = rnColRowStart + mrViewData.VisibleCellsY( WhichV( meWhich ) ); |
| } |
| |
| // include collapsed columns/rows in front of visible range |
| while ( (rnColRowStart > 0) && IsHidden( rnColRowStart - 1 ) ) |
| --rnColRowStart; |
| } |
| |
| Point ScOutlineWindow::GetPoint( long nLevelPos, long nEntryPos ) const |
| { |
| return mbHoriz ? Point( nEntryPos, nLevelPos ) : Point( nLevelPos, nEntryPos ); |
| } |
| |
| Rectangle ScOutlineWindow::GetRectangle( |
| long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd ) const |
| { |
| return Rectangle( GetPoint( nLevelStart, nEntryStart ), GetPoint( nLevelEnd, nEntryEnd ) ); |
| } |
| |
| long ScOutlineWindow::GetOutputSizeLevel() const |
| { |
| Size aSize( GetOutputSizePixel() ); |
| return mbHoriz ? aSize.Height() : aSize.Width(); |
| } |
| |
| long ScOutlineWindow::GetOutputSizeEntry() const |
| { |
| Size aSize( GetOutputSizePixel() ); |
| return mbHoriz ? aSize.Width() : aSize.Height(); |
| } |
| |
| size_t ScOutlineWindow::GetLevelCount() const |
| { |
| const ScOutlineArray* pArray = GetOutlineArray(); |
| size_t nLevelCount = pArray ? pArray->GetDepth() : 0; |
| return nLevelCount ? (nLevelCount + 1) : 0; |
| } |
| |
| long ScOutlineWindow::GetLevelPos( size_t nLevel ) const |
| { |
| // #i51970# must always return the *left* edge of the area used by a level |
| long nPos = static_cast< long >( SC_OL_POSOFFSET + nLevel * SC_OL_BITMAPSIZE ); |
| return mbMirrorLevels ? (GetOutputSizeLevel() - nPos - SC_OL_BITMAPSIZE) : nPos; |
| } |
| |
| size_t ScOutlineWindow::GetLevelFromPos( long nLevelPos ) const |
| { |
| if( mbMirrorLevels ) nLevelPos = GetOutputSizeLevel() - nLevelPos - 1; |
| long nStart = SC_OL_POSOFFSET; |
| if ( nLevelPos < nStart ) return SC_OL_NOLEVEL; |
| size_t nLevel = static_cast< size_t >( (nLevelPos - nStart) / SC_OL_BITMAPSIZE ); |
| return (nLevel < GetLevelCount()) ? nLevel : SC_OL_NOLEVEL; |
| } |
| |
| long ScOutlineWindow::GetColRowPos( SCCOLROW nColRowIndex ) const |
| { |
| long nDocPos = mbHoriz ? |
| mrViewData.GetScrPos( static_cast<SCCOL>(nColRowIndex), 0, meWhich, sal_True ).X() : |
| mrViewData.GetScrPos( 0, static_cast<SCROW>(nColRowIndex), meWhich, sal_True ).Y(); |
| return mnMainFirstPos + nDocPos; |
| } |
| |
| long ScOutlineWindow::GetHeaderEntryPos() const |
| { |
| return mnHeaderPos + (mnHeaderSize - SC_OL_BITMAPSIZE) / 2; |
| } |
| |
| bool ScOutlineWindow::GetEntryPos( |
| size_t nLevel, size_t nEntry, |
| long& rnStartPos, long& rnEndPos, long& rnImagePos ) const |
| { |
| const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry ); |
| if ( !pEntry || !pEntry->IsVisible() ) |
| return false; |
| |
| SCCOLROW nStart = pEntry->GetStart(); |
| SCCOLROW nEnd = pEntry->GetEnd(); |
| |
| long nEntriesSign = mbMirrorEntries ? -1 : 1; |
| |
| // --- common calculation --- |
| |
| rnStartPos = GetColRowPos( nStart ); |
| rnEndPos = GetColRowPos( nEnd + 1 ); |
| |
| bool bHidden = IsHidden( nStart ); |
| rnImagePos = bHidden ? |
| (rnStartPos - ( SC_OL_BITMAPSIZE / 2 ) * nEntriesSign) : |
| rnStartPos + nEntriesSign; |
| long nCenter = (rnStartPos + rnEndPos - SC_OL_BITMAPSIZE * nEntriesSign + |
| ( mbMirrorEntries ? 1 : 0 )) / 2L; |
| rnImagePos = mbMirrorEntries ? Max( rnImagePos, nCenter ) : Min( rnImagePos, nCenter ); |
| |
| // --- refinements --- |
| |
| // do not cut leftmost/topmost image |
| if ( bHidden && IsFirstVisible( nStart ) ) |
| rnImagePos = rnStartPos; |
| |
| // do not cover previous collapsed image |
| if ( !bHidden && nEntry ) |
| { |
| const ScOutlineEntry* pPrevEntry = GetOutlineEntry( nLevel, nEntry - 1 ); |
| SCCOLROW nPrevEnd = pPrevEntry->GetEnd(); |
| if ( (nPrevEnd + 1 == nStart) && IsHidden( nPrevEnd ) ) |
| { |
| if ( IsFirstVisible( pPrevEntry->GetStart() ) ) |
| rnStartPos += SC_OL_BITMAPSIZE * nEntriesSign; |
| else |
| rnStartPos += ( SC_OL_BITMAPSIZE / 2 ) * nEntriesSign; |
| rnImagePos = rnStartPos; |
| } |
| } |
| |
| // restrict rnStartPos...rnEndPos to valid area |
| rnStartPos = std::max( rnStartPos, mnMainFirstPos ); |
| rnEndPos = std::max( rnEndPos, mnMainFirstPos ); |
| |
| if ( mbMirrorEntries ) |
| rnImagePos -= SC_OL_BITMAPSIZE - 1; // start pos aligns with right edge of bitmap |
| |
| // --- all rows filtered? --- |
| |
| bool bVisible = true; |
| if ( !mbHoriz ) |
| { |
| bVisible = false; |
| for ( SCCOLROW nRow = nStart; (nRow <= nEnd) && !bVisible; ++nRow ) |
| bVisible = !IsFiltered( nRow ); |
| } |
| return bVisible; |
| } |
| |
| bool ScOutlineWindow::GetImagePos( size_t nLevel, size_t nEntry, Point& rPos ) const |
| { |
| bool bRet = nLevel < GetLevelCount(); |
| if ( bRet ) |
| { |
| long nLevelPos = GetLevelPos( nLevel ); |
| if ( nEntry == SC_OL_HEADERENTRY ) |
| rPos = GetPoint( nLevelPos, GetHeaderEntryPos() ); |
| else |
| { |
| long nStartPos, nEndPos, nImagePos; |
| bRet = GetEntryPos( nLevel, nEntry, nStartPos, nEndPos, nImagePos ); |
| rPos = GetPoint( nLevelPos, nImagePos ); |
| } |
| } |
| return bRet; |
| } |
| |
| bool ScOutlineWindow::IsButtonVisible( size_t nLevel, size_t nEntry ) const |
| { |
| bool bRet = false; |
| if ( nEntry == SC_OL_HEADERENTRY ) |
| bRet = (mnHeaderSize > 0) && (nLevel < GetLevelCount()); |
| else |
| { |
| const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry ); |
| if ( pEntry && pEntry->IsVisible() ) |
| { |
| SCCOLROW nStart, nEnd; |
| GetVisibleRange( nStart, nEnd ); |
| bRet = (nStart <= pEntry->GetStart()) && (pEntry->GetStart() <= nEnd); |
| } |
| } |
| return bRet; |
| } |
| |
| bool ScOutlineWindow::ItemHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry, bool& rbButton ) const |
| { |
| const ScOutlineArray* pArray = GetOutlineArray(); |
| if ( !pArray ) return false; |
| |
| SCCOLROW nStartIndex, nEndIndex; |
| GetVisibleRange( nStartIndex, nEndIndex ); |
| |
| size_t nLevel = GetLevelFromPos( mbHoriz ? rPos.Y() : rPos.X() ); |
| if ( nLevel == SC_OL_NOLEVEL ) |
| return false; |
| |
| // long nLevelPos = GetLevelPos( nLevel ); |
| long nEntryMousePos = mbHoriz ? rPos.X() : rPos.Y(); |
| |
| // --- level buttons --- |
| |
| if ( mnHeaderSize > 0 ) |
| { |
| long nImagePos = GetHeaderEntryPos(); |
| if ( (nImagePos <= nEntryMousePos) && (nEntryMousePos < nImagePos + SC_OL_BITMAPSIZE) ) |
| { |
| rnLevel = nLevel; |
| rnEntry = SC_OL_HEADERENTRY; |
| rbButton = true; |
| return true; |
| } |
| } |
| |
| // --- expand/collapse buttons and expanded lines --- |
| |
| // search outline entries backwards |
| size_t nEntry = pArray->GetCount( sal::static_int_cast<sal_uInt16>(nLevel) ); |
| while ( nEntry ) |
| { |
| --nEntry; |
| |
| const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel), |
| sal::static_int_cast<sal_uInt16>(nEntry) ); |
| SCCOLROW nStart = pEntry->GetStart(); |
| SCCOLROW nEnd = pEntry->GetEnd(); |
| |
| if ( (nEnd >= nStartIndex) && (nStart <= nEndIndex) ) |
| { |
| long nStartPos, nEndPos, nImagePos; |
| if ( GetEntryPos( nLevel, nEntry, nStartPos, nEndPos, nImagePos ) ) |
| { |
| rnLevel = nLevel; |
| rnEntry = nEntry; |
| |
| // button? |
| if ( (nStart >= nStartIndex) && (nImagePos <= nEntryMousePos) && (nEntryMousePos < nImagePos + SC_OL_BITMAPSIZE) ) |
| { |
| rbButton = true; |
| return true; |
| } |
| |
| // line? |
| if ( mbMirrorEntries ) |
| ::std::swap( nStartPos, nEndPos ); // in RTL mode, nStartPos is the larger value |
| if ( (nStartPos <= nEntryMousePos) && (nEntryMousePos <= nEndPos) ) |
| { |
| rbButton = false; |
| return true; |
| } |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| bool ScOutlineWindow::ButtonHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry ) const |
| { |
| bool bButton; |
| bool bRet = ItemHit( rPos, rnLevel, rnEntry, bButton ); |
| return bRet && bButton; |
| } |
| |
| bool ScOutlineWindow::LineHit( const Point& rPos, size_t& rnLevel, size_t& rnEntry ) const |
| { |
| bool bButton; |
| bool bRet = ItemHit( rPos, rnLevel, rnEntry, bButton ); |
| return bRet && !bButton; |
| } |
| |
| void ScOutlineWindow::DoFunction( size_t nLevel, size_t nEntry ) const |
| { |
| ScDBFunc& rFunc = *mrViewData.GetView(); |
| if ( nEntry == SC_OL_HEADERENTRY ) |
| rFunc.SelectLevel( mbHoriz, sal::static_int_cast<sal_uInt16>(nLevel) ); |
| else |
| { |
| const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry ); |
| if ( pEntry ) |
| { |
| if ( pEntry->IsHidden() ) |
| rFunc.ShowOutline( mbHoriz, sal::static_int_cast<sal_uInt16>(nLevel), sal::static_int_cast<sal_uInt16>(nEntry) ); |
| else |
| rFunc.HideOutline( mbHoriz, sal::static_int_cast<sal_uInt16>(nLevel), sal::static_int_cast<sal_uInt16>(nEntry) ); |
| } |
| } |
| } |
| |
| void ScOutlineWindow::DoExpand( size_t nLevel, size_t nEntry ) const |
| { |
| const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry ); |
| if ( pEntry && pEntry->IsHidden() ) |
| DoFunction( nLevel, nEntry ); |
| } |
| |
| void ScOutlineWindow::DoCollapse( size_t nLevel, size_t nEntry ) const |
| { |
| const ScOutlineEntry* pEntry = GetOutlineEntry( nLevel, nEntry ); |
| if ( pEntry && !pEntry->IsHidden() ) |
| DoFunction( nLevel, nEntry ); |
| } |
| |
| void ScOutlineWindow::Resize() |
| { |
| Window::Resize(); |
| SetHeaderSize( mnHeaderSize ); // recalculates header/group positions |
| if ( !IsFocusButtonVisible() ) |
| { |
| HideFocus(); |
| ShowFocus(); // calculates valid position |
| } |
| } |
| |
| void ScOutlineWindow::DataChanged( const DataChangedEvent& rDCEvt ) |
| { |
| if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && |
| (rDCEvt.GetFlags() & SETTINGS_STYLE) ) |
| { |
| InitSettings(); |
| Invalidate(); |
| } |
| Window::DataChanged( rDCEvt ); |
| } |
| |
| // drawing -------------------------------------------------------------------- |
| |
| void ScOutlineWindow::SetEntryAreaClipRegion() |
| { |
| SetClipRegion( Rectangle( |
| GetPoint( 0, mnMainFirstPos ), |
| GetPoint( GetOutputSizeLevel() - 1, mnMainLastPos ) ) ); |
| } |
| |
| void ScOutlineWindow::DrawLineRel( |
| long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd ) |
| { |
| DrawLine( GetPoint( nLevelStart, nEntryStart ), GetPoint( nLevelEnd, nEntryEnd ) ); |
| } |
| |
| void ScOutlineWindow::DrawRectRel( |
| long nLevelStart, long nEntryStart, long nLevelEnd, long nEntryEnd ) |
| { |
| DrawRect( GetRectangle( nLevelStart, nEntryStart, nLevelEnd, nEntryEnd ) ); |
| } |
| |
| void ScOutlineWindow::DrawImageRel( long nLevelPos, long nEntryPos, sal_uInt16 nId ) |
| { |
| DBG_ASSERT( mpSymbols, "ScOutlineWindow::DrawImageRel - no images" ); |
| const Image& rImage = mpSymbols->GetImage( nId ); |
| SetLineColor(); |
| SetFillColor( GetBackground().GetColor() ); |
| Point aPos( GetPoint( nLevelPos, nEntryPos ) ); |
| DrawRect( Rectangle( aPos, rImage.GetSizePixel() ) ); |
| DrawImage( aPos, rImage ); |
| } |
| |
| void ScOutlineWindow::DrawBorderRel( size_t nLevel, size_t nEntry, bool bPressed ) |
| { |
| Point aPos; |
| if ( GetImagePos( nLevel, nEntry, aPos ) ) |
| { |
| DBG_ASSERT( mpSymbols, "ScOutlineWindow::DrawBorderRel - no images" ); |
| sal_uInt16 nId = bPressed ? SC_OL_IMAGE_PRESSED : SC_OL_IMAGE_NOTPRESSED; |
| bool bClip = (nEntry != SC_OL_HEADERENTRY); |
| if ( bClip ) |
| SetEntryAreaClipRegion(); |
| DrawImage( aPos, mpSymbols->GetImage( nId ) ); |
| if ( bClip ) |
| SetClipRegion(); |
| } |
| mbMTPressed = bPressed; |
| } |
| |
| void ScOutlineWindow::ShowFocus() |
| { |
| if ( HasFocus() ) |
| { |
| // first move to a visible position |
| ImplMoveFocusToVisible( true ); |
| |
| if ( IsFocusButtonVisible() ) |
| { |
| Point aPos; |
| if ( GetImagePos( mnFocusLevel, mnFocusEntry, aPos ) ) |
| { |
| aPos += Point( 1, 1 ); |
| maFocusRect = Rectangle( aPos, Size( SC_OL_BITMAPSIZE - 2, SC_OL_BITMAPSIZE - 2 ) ); |
| bool bClip = (mnFocusEntry != SC_OL_HEADERENTRY); |
| if ( bClip ) |
| SetEntryAreaClipRegion(); |
| InvertTracking( maFocusRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW ); |
| if ( bClip ) |
| SetClipRegion(); |
| } |
| } |
| } |
| } |
| |
| void ScOutlineWindow::HideFocus() |
| { |
| if ( !maFocusRect.IsEmpty() ) |
| { |
| bool bClip = (mnFocusEntry != SC_OL_HEADERENTRY); |
| if ( bClip ) |
| SetEntryAreaClipRegion(); |
| InvertTracking( maFocusRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW ); |
| if ( bClip ) |
| SetClipRegion(); |
| maFocusRect.SetEmpty(); |
| } |
| } |
| |
| void ScOutlineWindow::Paint( const Rectangle& /* rRect */ ) |
| { |
| long nEntriesSign = mbMirrorEntries ? -1 : 1; |
| long nLevelsSign = mbMirrorLevels ? -1 : 1; |
| |
| Size aSize = GetOutputSizePixel(); |
| long nLevelEnd = (mbHoriz ? aSize.Height() : aSize.Width()) - 1; |
| long nEntryEnd = (mbHoriz ? aSize.Width() : aSize.Height()) - 1; |
| |
| SetLineColor( maLineColor ); |
| long nBorderPos = mbMirrorLevels ? 0 : nLevelEnd; |
| DrawLineRel( nBorderPos, 0, nBorderPos, nEntryEnd ); |
| |
| const ScOutlineArray* pArray = GetOutlineArray(); |
| if ( !pArray ) return; |
| |
| size_t nLevelCount = GetLevelCount(); |
| |
| // --- draw header images --- |
| |
| if ( mnHeaderSize > 0 ) |
| { |
| long nEntryPos = GetHeaderEntryPos(); |
| for ( size_t nLevel = 0; nLevel < nLevelCount; ++nLevel ) |
| DrawImageRel( GetLevelPos( nLevel ), nEntryPos, static_cast< sal_uInt16 >( nLevel + 1 ) ); |
| |
| SetLineColor( maLineColor ); |
| long nLinePos = mnHeaderPos + (mbMirrorEntries ? 0 : (mnHeaderSize - 1)); |
| DrawLineRel( 0, nLinePos, nLevelEnd, nLinePos ); |
| } |
| |
| // --- draw lines & collapse/expand images --- |
| |
| SetEntryAreaClipRegion(); |
| |
| SCCOLROW nStartIndex, nEndIndex; |
| GetVisibleRange( nStartIndex, nEndIndex ); |
| |
| for ( size_t nLevel = 0; nLevel + 1 < nLevelCount; ++nLevel ) |
| { |
| long nLevelPos = GetLevelPos( nLevel ); |
| long nEntryPos1 = 0, nEntryPos2 = 0, nImagePos = 0; |
| |
| size_t nEntryCount = pArray->GetCount( sal::static_int_cast<sal_uInt16>(nLevel) ); |
| size_t nEntry; |
| |
| // first draw all lines in the current level |
| SetLineColor(); |
| SetFillColor( maLineColor ); |
| for ( nEntry = 0; nEntry < nEntryCount; ++nEntry ) |
| { |
| const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel), |
| sal::static_int_cast<sal_uInt16>(nEntry) ); |
| SCCOLROW nStart = pEntry->GetStart(); |
| SCCOLROW nEnd = pEntry->GetEnd(); |
| |
| // visible range? |
| bool bDraw = (nEnd >= nStartIndex) && (nStart <= nEndIndex); |
| // find output coordinates |
| if ( bDraw ) |
| bDraw = GetEntryPos( nLevel, nEntry, nEntryPos1, nEntryPos2, nImagePos ); |
| // draw, if not collapsed |
| if ( bDraw && !pEntry->IsHidden() ) |
| { |
| if ( nStart >= nStartIndex ) |
| nEntryPos1 += nEntriesSign; |
| nEntryPos2 -= 2 * nEntriesSign; |
| long nLinePos = nLevelPos; |
| if ( mbMirrorLevels ) |
| nLinePos += SC_OL_BITMAPSIZE - 1; // align with right edge of bitmap |
| DrawRectRel( nLinePos, nEntryPos1, nLinePos + nLevelsSign, nEntryPos2 ); |
| |
| if ( nEnd <= nEndIndex ) |
| DrawRectRel( nLinePos, nEntryPos2 - nEntriesSign, |
| nLinePos + ( SC_OL_BITMAPSIZE / 3 ) * nLevelsSign, nEntryPos2 ); |
| } |
| } |
| |
| // draw all images in the level from last to first |
| nEntry = nEntryCount; |
| while ( nEntry ) |
| { |
| --nEntry; |
| |
| const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<sal_uInt16>(nLevel), |
| sal::static_int_cast<sal_uInt16>(nEntry) ); |
| SCCOLROW nStart = pEntry->GetStart(); |
| // SCCOLROW nEnd = pEntry->GetEnd(); |
| |
| // visible range? |
| bool bDraw = (nStartIndex <= nStart) && (nStart <= nEndIndex + 1); |
| // find output coordinates |
| if ( bDraw ) |
| bDraw = GetEntryPos( nLevel, nEntry, nEntryPos1, nEntryPos2, nImagePos ); |
| // draw, if not hidden by higher levels |
| if ( bDraw ) |
| { |
| sal_uInt16 nImageId = pEntry->IsHidden() ? SC_OL_IMAGE_PLUS : SC_OL_IMAGE_MINUS; |
| DrawImageRel( nLevelPos, nImagePos, nImageId ); |
| } |
| } |
| } |
| |
| SetClipRegion(); |
| |
| if ( !mbDontDrawFocus ) |
| ShowFocus(); |
| } |
| |
| // focus ---------------------------------------------------------------------- |
| |
| /** Increments or decrements a value and wraps at the specified limits. |
| @return true = value wrapped. */ |
| bool lcl_RotateValue( size_t& rnValue, size_t nMin, size_t nMax, bool bForward ) |
| { |
| DBG_ASSERT( nMin <= nMax, "lcl_RotateValue - invalid range" ); |
| DBG_ASSERT( nMax < static_cast< size_t >( -1 ), "lcl_RotateValue - range overflow" ); |
| bool bWrap = false; |
| if ( bForward ) |
| { |
| if ( rnValue < nMax ) |
| ++rnValue; |
| else |
| { |
| rnValue = nMin; |
| bWrap = true; |
| } |
| } |
| else |
| { |
| if ( rnValue > nMin ) |
| --rnValue; |
| else |
| { |
| rnValue = nMax; |
| bWrap = true; |
| } |
| } |
| return bWrap; |
| } |
| |
| bool ScOutlineWindow::IsFocusButtonVisible() const |
| { |
| return IsButtonVisible( mnFocusLevel, mnFocusEntry ); |
| } |
| |
| bool ScOutlineWindow::ImplMoveFocusByEntry( bool bForward, bool bFindVisible ) |
| { |
| const ScOutlineArray* pArray = GetOutlineArray(); |
| if ( !pArray ) |
| return false; |
| |
| bool bWrapped = false; |
| size_t nEntryCount = pArray->GetCount( sal::static_int_cast<sal_uInt16>(mnFocusLevel) ); |
| // #i29530# entry count may be decreased after changing active sheet |
| if( mnFocusEntry >= nEntryCount ) |
| mnFocusEntry = SC_OL_HEADERENTRY; |
| size_t nOldEntry = mnFocusEntry; |
| |
| do |
| { |
| if ( mnFocusEntry == SC_OL_HEADERENTRY ) |
| { |
| // move from header to first or last entry |
| if ( nEntryCount > 0 ) |
| mnFocusEntry = bForward ? 0 : (nEntryCount - 1); |
| /* wrapped, if forward from right header to first entry, |
| or if backward from left header to last entry */ |
| // Header and entries are now always in consistent order, |
| // so there's no need to check for mirroring here. |
| if ( !nEntryCount || !bForward ) |
| bWrapped = true; |
| } |
| else if ( lcl_RotateValue( mnFocusEntry, 0, nEntryCount - 1, bForward ) ) |
| { |
| // lcl_RotateValue returns true -> wrapped the entry range -> move to header |
| mnFocusEntry = SC_OL_HEADERENTRY; |
| /* wrapped, if forward from last entry to left header, |
| or if backward from first entry to right header */ |
| if ( bForward ) |
| bWrapped = true; |
| } |
| } |
| while ( bFindVisible && !IsFocusButtonVisible() && (nOldEntry != mnFocusEntry) ); |
| |
| return bWrapped; |
| } |
| |
| bool ScOutlineWindow::ImplMoveFocusByLevel( bool bForward ) |
| { |
| const ScOutlineArray* pArray = GetOutlineArray(); |
| if ( !pArray ) |
| return false; |
| |
| bool bWrapped = false; |
| size_t nLevelCount = GetLevelCount(); |
| |
| if ( mnFocusEntry == SC_OL_HEADERENTRY ) |
| { |
| if ( nLevelCount > 0 ) |
| bWrapped = lcl_RotateValue( mnFocusLevel, 0, nLevelCount - 1, bForward ); |
| } |
| else |
| { |
| const ScOutlineEntry* pEntry = pArray->GetEntry( sal::static_int_cast<sal_uInt16>(mnFocusLevel), |
| sal::static_int_cast<sal_uInt16>(mnFocusEntry) ); |
| if ( pEntry ) |
| { |
| SCCOLROW nStart = pEntry->GetStart(); |
| SCCOLROW nEnd = pEntry->GetEnd(); |
| size_t nNewLevel = mnFocusLevel; |
| size_t nNewEntry = 0; |
| |
| bool bFound = false; |
| if ( bForward && (mnFocusLevel + 2 < nLevelCount) ) |
| { |
| // next level -> find first child entry |
| nNewLevel = mnFocusLevel + 1; |
| // TODO - change ScOutlineArray interface to size_t usage |
| sal_uInt16 nTmpEntry = 0; |
| bFound = pArray->GetEntryIndexInRange( sal::static_int_cast<sal_uInt16>(nNewLevel), nStart, nEnd, nTmpEntry ); |
| nNewEntry = nTmpEntry; |
| } |
| else if ( !bForward && (mnFocusLevel > 0) ) |
| { |
| // previous level -> find parent entry |
| nNewLevel = mnFocusLevel - 1; |
| // TODO - change ScOutlineArray interface to size_t usage |
| sal_uInt16 nTmpEntry = 0; |
| bFound = pArray->GetEntryIndex( sal::static_int_cast<sal_uInt16>(nNewLevel), nStart, nTmpEntry ); |
| nNewEntry = nTmpEntry; |
| } |
| |
| if ( bFound && IsButtonVisible( nNewLevel, nNewEntry ) ) |
| { |
| mnFocusLevel = nNewLevel; |
| mnFocusEntry = nNewEntry; |
| } |
| } |
| } |
| |
| return bWrapped; |
| } |
| |
| bool ScOutlineWindow::ImplMoveFocusByTabOrder( bool bForward, bool bFindVisible ) |
| { |
| bool bRet = false; |
| size_t nOldLevel = mnFocusLevel; |
| size_t nOldEntry = mnFocusEntry; |
| |
| do |
| { |
| /* one level up, if backward from left header, |
| or one level down, if forward from right header */ |
| if ( (!bForward) && (mnFocusEntry == SC_OL_HEADERENTRY) ) |
| bRet |= ImplMoveFocusByLevel( bForward ); |
| // move to next/previous entry |
| bool bWrapInLevel = ImplMoveFocusByEntry( bForward, false ); |
| bRet |= bWrapInLevel; |
| /* one level up, if wrapped backward to right header, |
| or one level down, if wrapped forward to right header */ |
| if ( bForward && bWrapInLevel ) |
| bRet |= ImplMoveFocusByLevel( bForward ); |
| } |
| while ( bFindVisible && !IsFocusButtonVisible() && ((nOldLevel != mnFocusLevel) || (nOldEntry != mnFocusEntry)) ); |
| |
| return bRet; |
| } |
| |
| void ScOutlineWindow::ImplMoveFocusToVisible( bool bForward ) |
| { |
| // first try to find an entry in the same level |
| if ( !IsFocusButtonVisible() ) |
| ImplMoveFocusByEntry( bForward, true ); |
| // then try to find any other entry |
| if ( !IsFocusButtonVisible() ) |
| ImplMoveFocusByTabOrder( bForward, true ); |
| } |
| |
| void ScOutlineWindow::MoveFocusByEntry( bool bForward ) |
| { |
| HideFocus(); |
| ImplMoveFocusByEntry( bForward, true ); |
| ShowFocus(); |
| } |
| |
| void ScOutlineWindow::MoveFocusByLevel( bool bForward ) |
| { |
| HideFocus(); |
| ImplMoveFocusByLevel( bForward ); |
| ShowFocus(); |
| } |
| |
| void ScOutlineWindow::MoveFocusByTabOrder( bool bForward ) |
| { |
| HideFocus(); |
| ImplMoveFocusByTabOrder( bForward, true ); |
| ShowFocus(); |
| } |
| |
| void ScOutlineWindow::GetFocus() |
| { |
| Window::GetFocus(); |
| ShowFocus(); |
| } |
| |
| void ScOutlineWindow::LoseFocus() |
| { |
| HideFocus(); |
| Window::LoseFocus(); |
| } |
| |
| |
| // mouse ---------------------------------------------------------------------- |
| |
| void ScOutlineWindow::StartMouseTracking( size_t nLevel, size_t nEntry ) |
| { |
| mbMTActive = true; |
| mnMTLevel = nLevel; |
| mnMTEntry = nEntry; |
| DrawBorderRel( nLevel, nEntry, true ); |
| } |
| |
| void ScOutlineWindow::EndMouseTracking() |
| { |
| if ( mbMTPressed ) |
| DrawBorderRel( mnMTLevel, mnMTEntry, false ); |
| mbMTActive = false; |
| } |
| |
| void ScOutlineWindow::MouseMove( const MouseEvent& rMEvt ) |
| { |
| if ( IsMouseTracking() ) |
| { |
| size_t nLevel, nEntry; |
| bool bHit = false; |
| |
| if ( ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry ) ) |
| bHit = (nLevel == mnMTLevel) && (nEntry == mnMTEntry); |
| |
| if ( bHit != mbMTPressed ) |
| DrawBorderRel( mnMTLevel, mnMTEntry, bHit ); |
| } |
| } |
| |
| void ScOutlineWindow::MouseButtonUp( const MouseEvent& rMEvt ) |
| { |
| if ( IsMouseTracking() ) |
| { |
| EndMouseTracking(); |
| |
| size_t nLevel, nEntry; |
| if ( ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry ) ) |
| if ( (nLevel == mnMTLevel) && (nEntry == mnMTEntry) ) |
| DoFunction( nLevel, nEntry ); |
| } |
| } |
| |
| void ScOutlineWindow::MouseButtonDown( const MouseEvent& rMEvt ) |
| { |
| size_t nLevel, nEntry; |
| bool bHit = ButtonHit( rMEvt.GetPosPixel(), nLevel, nEntry ); |
| if ( bHit ) |
| StartMouseTracking( nLevel, nEntry ); |
| else if ( rMEvt.GetClicks() == 2 ) |
| { |
| bHit = LineHit( rMEvt.GetPosPixel(), nLevel, nEntry ); |
| if ( bHit ) |
| DoFunction( nLevel, nEntry ); |
| } |
| |
| // if an item has been hit and window is focused, move focus to this item |
| if ( bHit && HasFocus() ) |
| { |
| HideFocus(); |
| mnFocusLevel = nLevel; |
| mnFocusEntry = nEntry; |
| ShowFocus(); |
| } |
| } |
| |
| |
| // keyboard ------------------------------------------------------------------- |
| |
| void ScOutlineWindow::KeyInput( const KeyEvent& rKEvt ) |
| { |
| const KeyCode& rKCode = rKEvt.GetKeyCode(); |
| bool bNoMod = !rKCode.GetModifier(); |
| bool bShift = (rKCode.GetModifier() == KEY_SHIFT); |
| bool bCtrl = (rKCode.GetModifier() == KEY_MOD1); |
| |
| sal_uInt16 nCode = rKCode.GetCode(); |
| bool bUpDownKey = (nCode == KEY_UP) || (nCode == KEY_DOWN); |
| bool bLeftRightKey = (nCode == KEY_LEFT) || (nCode == KEY_RIGHT); |
| |
| // TAB key |
| if ( (nCode == KEY_TAB) && (bNoMod || bShift) ) |
| // move forward without SHIFT key |
| MoveFocusByTabOrder( bNoMod ); // TAB uses logical order, regardless of mirroring |
| |
| // LEFT/RIGHT/UP/DOWN keys |
| else if ( bNoMod && (bUpDownKey || bLeftRightKey) ) |
| { |
| bool bForward = (nCode == KEY_DOWN) || (nCode == KEY_RIGHT); |
| if ( mbHoriz == bLeftRightKey ) |
| // move inside level with LEFT/RIGHT in horizontal and with UP/DOWN in vertical |
| MoveFocusByEntry( bForward != mbMirrorEntries ); |
| else |
| // move to next/prev level with LEFT/RIGHT in vertical and with UP/DOWN in horizontal |
| MoveFocusByLevel( bForward != mbMirrorLevels ); |
| } |
| |
| // CTRL + number |
| else if ( bCtrl && (nCode >= KEY_1) && (nCode <= KEY_9) ) |
| { |
| size_t nLevel = static_cast< size_t >( nCode - KEY_1 ); |
| if ( nLevel < GetLevelCount() ) |
| DoFunction( nLevel, SC_OL_HEADERENTRY ); |
| } |
| |
| // other key codes |
| else switch ( rKCode.GetFullCode() ) |
| { |
| case KEY_ADD: DoExpand( mnFocusLevel, mnFocusEntry ); break; |
| case KEY_SUBTRACT: DoCollapse( mnFocusLevel, mnFocusEntry ); break; |
| case KEY_SPACE: |
| case KEY_RETURN: DoFunction( mnFocusLevel, mnFocusEntry ); break; |
| default: Window::KeyInput( rKEvt ); |
| } |
| } |
| |
| |
| // ============================================================================ |
| |
