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