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