Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <vcl/svapp.hxx>
21 : #include <vcl/salnativewidgets.hxx>
22 : #include <vcl/help.hxx>
23 : #include <vcl/settings.hxx>
24 :
25 : #include <cstdlib>
26 : #include <stack>
27 :
28 : #include <svtools/treelistbox.hxx>
29 : #include <svtools/svlbitm.hxx>
30 : #include <svimpbox.hxx>
31 : #include <rtl/instance.hxx>
32 : #include <svtools/svtresid.hxx>
33 : #include <tools/wintypes.hxx>
34 : #include <svtools/svtools.hrc>
35 : #include <comphelper/processfactory.hxx>
36 : #include <comphelper/string.hxx>
37 :
38 : #include "svtools/treelistentry.hxx"
39 : #include "svtools/viewdataentry.hxx"
40 :
41 : #define NODE_BMP_TABDIST_NOTVALID -2000000
42 : #define FIRST_ENTRY_TAB 1
43 :
44 : // #i27063# (pl), #i32300# (pb) never access VCL after DeInitVCL - also no destructors
45 : Image* SvImpLBox::s_pDefCollapsed = NULL;
46 : Image* SvImpLBox::s_pDefExpanded = NULL;
47 : sal_Int32 SvImpLBox::s_nImageRefCount = 0;
48 :
49 0 : SvImpLBox::SvImpLBox( SvTreeListBox* pLBView, SvTreeList* pLBTree, WinBits nWinStyle)
50 : : aVerSBar(pLBView, WB_DRAG | WB_VSCROLL)
51 : , aHorSBar(pLBView, WB_DRAG | WB_HSCROLL)
52 : , aScrBarBox(pLBView)
53 : , aOutputSize(0, 0)
54 : , aSelEng(pLBView, (FunctionSet*)0)
55 : , aFctSet(this, &aSelEng, pLBView)
56 : , nNextVerVisSize(0)
57 : , nExtendedWinBits(0)
58 : , bAreChildrenTransient(true)
59 0 : , m_pStringSorter(NULL)
60 : {
61 0 : osl_atomic_increment(&s_nImageRefCount);
62 0 : pView = pLBView;
63 0 : pTree = pLBTree;
64 0 : aSelEng.SetFunctionSet( (FunctionSet*)&aFctSet );
65 0 : aSelEng.ExpandSelectionOnMouseMove( false );
66 0 : SetStyle( nWinStyle );
67 0 : SetSelectionMode( SINGLE_SELECTION );
68 0 : SetDragDropMode( 0 );
69 :
70 0 : aVerSBar.SetScrollHdl( LINK( this, SvImpLBox, ScrollUpDownHdl ) );
71 0 : aHorSBar.SetScrollHdl( LINK( this, SvImpLBox, ScrollLeftRightHdl ) );
72 0 : aHorSBar.SetEndScrollHdl( LINK( this, SvImpLBox, EndScrollHdl ) );
73 0 : aVerSBar.SetEndScrollHdl( LINK( this, SvImpLBox, EndScrollHdl ) );
74 0 : aVerSBar.SetRange( Range(0,0) );
75 0 : aVerSBar.Hide();
76 0 : aHorSBar.SetRange( Range(0,0) );
77 0 : aHorSBar.SetPageSize( 24 ); // pixels
78 0 : aHorSBar.SetLineSize( 8 ); // pixels
79 :
80 0 : nHorSBarHeight = (short)aHorSBar.GetSizePixel().Height();
81 0 : nVerSBarWidth = (short)aVerSBar.GetSizePixel().Width();
82 :
83 0 : pStartEntry = 0;
84 0 : pCursor = 0;
85 0 : pAnchor = 0;
86 0 : nVisibleCount = 0; // number of rows of data in control
87 0 : nNodeBmpTabDistance = NODE_BMP_TABDIST_NOTVALID;
88 0 : nYoffsNodeBmp = 0;
89 0 : nNodeBmpWidth = 0;
90 :
91 0 : bAsyncBeginDrag = false;
92 0 : aAsyncBeginDragTimer.SetTimeout( 0 );
93 0 : aAsyncBeginDragTimer.SetTimeoutHdl( LINK(this,SvImpLBox,BeginDragHdl));
94 : // button animation in listbox
95 0 : pActiveButton = 0;
96 0 : pActiveEntry = 0;
97 0 : pActiveTab = 0;
98 :
99 0 : nFlags = 0;
100 0 : nCurTabPos = FIRST_ENTRY_TAB;
101 :
102 0 : aEditTimer.SetTimeout( 800 );
103 0 : aEditTimer.SetTimeoutHdl( LINK(this,SvImpLBox,EditTimerCall) );
104 :
105 0 : nMostRight = -1;
106 0 : pMostRightEntry = 0;
107 0 : nCurUserEvent = 0xffffffff;
108 :
109 0 : bUpdateMode = true;
110 0 : bInVScrollHdl = false;
111 0 : nFlags |= F_FILLING;
112 :
113 0 : bSubLstOpRet = bSubLstOpLR = bContextMenuHandling = bIsCellFocusEnabled = false;
114 0 : }
115 :
116 0 : SvImpLBox::~SvImpLBox()
117 : {
118 0 : aEditTimer.Stop();
119 0 : StopUserEvent();
120 :
121 0 : delete m_pStringSorter;
122 0 : if ( osl_atomic_decrement(&s_nImageRefCount) == 0 )
123 : {
124 0 : DELETEZ(s_pDefCollapsed);
125 0 : DELETEZ(s_pDefExpanded);
126 : }
127 0 : }
128 :
129 0 : void SvImpLBox::UpdateStringSorter()
130 : {
131 0 : const ::com::sun::star::lang::Locale& rNewLocale = Application::GetSettings().GetLanguageTag().getLocale();
132 :
133 0 : if( m_pStringSorter )
134 : {
135 : // different Locale from the older one, drop it and force recreate
136 0 : const ::com::sun::star::lang::Locale &aLocale = m_pStringSorter->getLocale();
137 0 : if( aLocale.Language != rNewLocale.Language ||
138 0 : aLocale.Country != rNewLocale.Country ||
139 0 : aLocale.Variant != rNewLocale.Variant )
140 : {
141 0 : delete m_pStringSorter;
142 0 : m_pStringSorter = NULL;
143 : }
144 : }
145 :
146 0 : if( !m_pStringSorter )
147 : {
148 : m_pStringSorter = new comphelper::string::NaturalStringSorter(
149 : ::comphelper::getProcessComponentContext(),
150 0 : rNewLocale);
151 : }
152 0 : }
153 :
154 : // #97680# ----------------------
155 0 : short SvImpLBox::UpdateContextBmpWidthVector( SvTreeListEntry* pEntry, short nWidth )
156 : {
157 : DBG_ASSERT( pView->pModel, "View and Model aren't valid!" );
158 :
159 0 : sal_uInt16 nDepth = pView->pModel->GetDepth( pEntry );
160 : // initialize vector if necessary
161 0 : std::vector< short >::size_type nSize = aContextBmpWidthVector.size();
162 0 : while ( nDepth > nSize )
163 : {
164 0 : aContextBmpWidthVector.resize( nSize + 1 );
165 0 : aContextBmpWidthVector.at( nSize ) = nWidth;
166 0 : ++nSize;
167 : }
168 0 : if( aContextBmpWidthVector.size() == nDepth )
169 : {
170 0 : aContextBmpWidthVector.resize( nDepth + 1 );
171 0 : aContextBmpWidthVector.at( nDepth ) = 0;
172 : }
173 0 : short nContextBmpWidth = aContextBmpWidthVector[ nDepth ];
174 0 : if( nContextBmpWidth < nWidth )
175 : {
176 0 : aContextBmpWidthVector.at( nDepth ) = nWidth;
177 0 : return nWidth;
178 : }
179 : else
180 0 : return nContextBmpWidth;
181 : }
182 :
183 0 : void SvImpLBox::UpdateContextBmpWidthVectorFromMovedEntry( SvTreeListEntry* pEntry )
184 : {
185 : DBG_ASSERT( pEntry, "Moved Entry is invalid!" );
186 :
187 0 : SvLBoxContextBmp* pBmpItem = static_cast< SvLBoxContextBmp* >( pEntry->GetFirstItem( SV_ITEM_ID_LBOXCONTEXTBMP ) );
188 0 : short nExpWidth = (short)pBmpItem->GetBitmap1().GetSizePixel().Width();
189 0 : short nColWidth = (short)pBmpItem->GetBitmap2().GetSizePixel().Width();
190 0 : short nMax = std::max(nExpWidth, nColWidth);
191 0 : UpdateContextBmpWidthVector( pEntry, nMax );
192 :
193 0 : if( pEntry->HasChildren() ) // recursive call, whether expanded or not
194 : {
195 0 : SvTreeListEntry* pChild = pView->FirstChild( pEntry );
196 : DBG_ASSERT( pChild, "The first child is invalid!" );
197 0 : do
198 : {
199 0 : UpdateContextBmpWidthVectorFromMovedEntry( pChild );
200 0 : pChild = pView->Next( pChild );
201 : } while ( pChild );
202 : }
203 0 : }
204 :
205 0 : void SvImpLBox::UpdateContextBmpWidthMax( SvTreeListEntry* pEntry )
206 : {
207 0 : sal_uInt16 nDepth = pView->pModel->GetDepth( pEntry );
208 0 : if( aContextBmpWidthVector.size() < 1 )
209 0 : return;
210 0 : short nWidth = aContextBmpWidthVector[ nDepth ];
211 0 : if( nWidth != pView->nContextBmpWidthMax ) {
212 0 : pView->nContextBmpWidthMax = nWidth;
213 0 : nFlags |= F_IGNORE_CHANGED_TABS;
214 0 : pView->SetTabs();
215 0 : nFlags &= ~F_IGNORE_CHANGED_TABS;
216 : }
217 : }
218 :
219 0 : void SvImpLBox::CalcCellFocusRect( SvTreeListEntry* pEntry, Rectangle& rRect )
220 : {
221 0 : if ( pEntry && bIsCellFocusEnabled )
222 : {
223 0 : if ( nCurTabPos > FIRST_ENTRY_TAB )
224 : {
225 0 : SvLBoxItem* pItem = pCursor->GetItem( nCurTabPos );
226 0 : rRect.Left() = pView->GetTab( pCursor, pItem )->GetPos();
227 : }
228 0 : if (pCursor->ItemCount() > static_cast<size_t>(nCurTabPos+1))
229 : {
230 0 : SvLBoxItem* pNextItem = pCursor->GetItem( nCurTabPos + 1 );
231 0 : long nRight = pView->GetTab( pCursor, pNextItem )->GetPos() - 1;
232 0 : if ( nRight < rRect.Right() )
233 0 : rRect.Right() = nRight;
234 : }
235 : }
236 0 : }
237 :
238 0 : void SvImpLBox::SetStyle( WinBits i_nWinStyle )
239 : {
240 0 : m_nStyle = i_nWinStyle;
241 0 : if ( ( m_nStyle & WB_SIMPLEMODE) && ( aSelEng.GetSelectionMode() == MULTIPLE_SELECTION ) )
242 0 : aSelEng.AddAlways( true );
243 0 : }
244 :
245 0 : void SvImpLBox::SetExtendedWindowBits( ExtendedWinBits _nBits )
246 : {
247 0 : nExtendedWinBits = _nBits;
248 0 : }
249 :
250 : // don't touch the model any more
251 0 : void SvImpLBox::Clear()
252 : {
253 0 : StopUserEvent();
254 0 : pStartEntry = 0;
255 0 : pAnchor = 0;
256 :
257 0 : pActiveButton = 0;
258 0 : pActiveEntry = 0;
259 0 : pActiveTab = 0;
260 :
261 0 : nMostRight = -1;
262 0 : pMostRightEntry = 0;
263 :
264 : // don't touch the cursor any more
265 0 : if( pCursor )
266 : {
267 0 : if( pView->HasFocus() )
268 0 : pView->HideFocus();
269 0 : pCursor = 0;
270 : }
271 0 : aVerSBar.Hide();
272 0 : aVerSBar.SetThumbPos( 0 );
273 0 : Range aRange( 0, 0 );
274 0 : aVerSBar.SetRange( aRange );
275 0 : aOutputSize = pView->Control::GetOutputSizePixel();
276 0 : nFlags &= ~(F_VER_SBARSIZE_WITH_HBAR | F_HOR_SBARSIZE_WITH_VBAR );
277 0 : aHorSBar.Hide();
278 0 : aHorSBar.SetThumbPos( 0 );
279 0 : MapMode aMapMode( pView->GetMapMode());
280 0 : aMapMode.SetOrigin( Point(0,0) );
281 0 : pView->Control::SetMapMode( aMapMode );
282 0 : aHorSBar.SetRange( aRange );
283 0 : aHorSBar.SetSizePixel(Size(aOutputSize.Width(),nHorSBarHeight));
284 0 : pView->SetClipRegion();
285 0 : if( GetUpdateMode() )
286 0 : pView->Invalidate( GetVisibleArea() );
287 0 : nFlags |= F_FILLING;
288 0 : if( !aHorSBar.IsVisible() && !aVerSBar.IsVisible() )
289 0 : aScrBarBox.Hide();
290 :
291 0 : aContextBmpWidthVector.clear();
292 :
293 0 : CallEventListeners( VCLEVENT_LISTBOX_ITEMREMOVED, NULL );
294 0 : }
295 :
296 : // *********************************************************************
297 : // Paint, navigate, scroll
298 : // *********************************************************************
299 :
300 0 : IMPL_LINK_NOARG_INLINE_START(SvImpLBox, EndScrollHdl)
301 : {
302 0 : if( nFlags & F_ENDSCROLL_SET_VIS_SIZE )
303 : {
304 0 : aVerSBar.SetVisibleSize( nNextVerVisSize );
305 0 : nFlags &= ~F_ENDSCROLL_SET_VIS_SIZE;
306 : }
307 0 : EndScroll();
308 0 : return 0;
309 : }
310 0 : IMPL_LINK_NOARG_INLINE_END(SvImpLBox, EndScrollHdl)
311 :
312 :
313 : // handler for vertical scrollbar
314 :
315 0 : IMPL_LINK( SvImpLBox, ScrollUpDownHdl, ScrollBar *, pScrollBar )
316 : {
317 : DBG_ASSERT(!bInVScrollHdl,"Scroll handler out-paces itself!");
318 0 : long nDelta = pScrollBar->GetDelta();
319 0 : if( !nDelta )
320 0 : return 0;
321 :
322 0 : nFlags &= (~F_FILLING);
323 :
324 0 : bInVScrollHdl = true;
325 :
326 0 : if( pView->IsEditingActive() )
327 : {
328 0 : pView->EndEditing( true ); // Cancel
329 0 : pView->Update();
330 : }
331 0 : BeginScroll();
332 :
333 0 : if( nDelta > 0 )
334 : {
335 0 : if( nDelta == 1 )
336 0 : CursorDown();
337 : else
338 0 : PageDown( (sal_uInt16) nDelta );
339 : }
340 : else
341 : {
342 0 : nDelta *= (-1);
343 0 : if( nDelta == 1 )
344 0 : CursorUp();
345 : else
346 0 : PageUp( (sal_uInt16) nDelta );
347 : }
348 0 : bInVScrollHdl = false;
349 0 : return 0;
350 : }
351 :
352 :
353 0 : void SvImpLBox::CursorDown()
354 : {
355 0 : if (!pStartEntry)
356 0 : return;
357 :
358 0 : SvTreeListEntry* pNextFirstToDraw = pView->NextVisible(pStartEntry);
359 0 : if( pNextFirstToDraw )
360 : {
361 0 : nFlags &= (~F_FILLING);
362 0 : pView->NotifyScrolling( -1 );
363 0 : ShowCursor( false );
364 0 : pView->Update();
365 0 : pStartEntry = pNextFirstToDraw;
366 0 : Rectangle aArea( GetVisibleArea() );
367 0 : pView->Scroll( 0, -(pView->GetEntryHeight()), aArea, SCROLL_NOCHILDREN );
368 0 : pView->Update();
369 0 : ShowCursor( true );
370 0 : pView->NotifyScrolled();
371 : }
372 : }
373 :
374 0 : void SvImpLBox::CursorUp()
375 : {
376 0 : if (!pStartEntry)
377 0 : return;
378 :
379 0 : SvTreeListEntry* pPrevFirstToDraw = pView->PrevVisible(pStartEntry);
380 0 : if( pPrevFirstToDraw )
381 : {
382 0 : nFlags &= (~F_FILLING);
383 0 : long nEntryHeight = pView->GetEntryHeight();
384 0 : pView->NotifyScrolling( 1 );
385 0 : ShowCursor( false );
386 0 : pView->Update();
387 0 : pStartEntry = pPrevFirstToDraw;
388 0 : Rectangle aArea( GetVisibleArea() );
389 0 : aArea.Bottom() -= nEntryHeight;
390 0 : pView->Scroll( 0, nEntryHeight, aArea, SCROLL_NOCHILDREN );
391 0 : pView->Update();
392 0 : ShowCursor( true );
393 0 : pView->NotifyScrolled();
394 : }
395 : }
396 :
397 0 : void SvImpLBox::PageDown( sal_uInt16 nDelta )
398 : {
399 0 : sal_uInt16 nRealDelta = nDelta;
400 :
401 0 : if( !nDelta )
402 0 : return;
403 :
404 0 : if (!pStartEntry)
405 0 : return;
406 :
407 0 : SvTreeListEntry* pNext = pView->NextVisible(pStartEntry, nRealDelta);
408 0 : if( (sal_uLong)pNext == (sal_uLong)pStartEntry )
409 0 : return;
410 :
411 0 : ShowCursor( false );
412 :
413 0 : nFlags &= (~F_FILLING);
414 0 : pView->Update();
415 0 : pStartEntry = pNext;
416 :
417 0 : if( nRealDelta >= nVisibleCount )
418 : {
419 0 : pView->Invalidate( GetVisibleArea() );
420 0 : pView->Update();
421 : }
422 : else
423 : {
424 0 : long nScroll = nRealDelta * (-1);
425 0 : pView->NotifyScrolling( nScroll );
426 0 : Rectangle aArea( GetVisibleArea() );
427 0 : nScroll = pView->GetEntryHeight()*nRealDelta;
428 0 : nScroll = -nScroll;
429 0 : pView->Update();
430 0 : pView->Scroll( 0, nScroll, aArea, SCROLL_NOCHILDREN );
431 0 : pView->Update();
432 0 : pView->NotifyScrolled();
433 : }
434 :
435 0 : ShowCursor( true );
436 : }
437 :
438 0 : void SvImpLBox::PageUp( sal_uInt16 nDelta )
439 : {
440 0 : sal_uInt16 nRealDelta = nDelta;
441 0 : if( !nDelta )
442 0 : return;
443 :
444 0 : if (!pStartEntry)
445 0 : return;
446 :
447 0 : SvTreeListEntry* pPrev = pView->PrevVisible(pStartEntry, nRealDelta);
448 0 : if( (sal_uLong)pPrev == (sal_uLong)pStartEntry )
449 0 : return;
450 :
451 0 : nFlags &= (~F_FILLING);
452 0 : ShowCursor( false );
453 :
454 0 : pView->Update();
455 0 : pStartEntry = pPrev;
456 0 : if( nRealDelta >= nVisibleCount )
457 : {
458 0 : pView->Invalidate( GetVisibleArea() );
459 0 : pView->Update();
460 : }
461 : else
462 : {
463 0 : long nEntryHeight = pView->GetEntryHeight();
464 0 : pView->NotifyScrolling( (long)nRealDelta );
465 0 : Rectangle aArea( GetVisibleArea() );
466 0 : pView->Update();
467 0 : pView->Scroll( 0, nEntryHeight*nRealDelta, aArea, SCROLL_NOCHILDREN );
468 0 : pView->Update();
469 0 : pView->NotifyScrolled();
470 : }
471 :
472 0 : ShowCursor( true );
473 : }
474 :
475 0 : void SvImpLBox::KeyUp( bool bPageUp, bool bNotifyScroll )
476 : {
477 0 : if( !aVerSBar.IsVisible() )
478 0 : return;
479 :
480 : long nDelta;
481 0 : if( bPageUp )
482 0 : nDelta = aVerSBar.GetPageSize();
483 : else
484 0 : nDelta = 1;
485 :
486 0 : long nThumbPos = aVerSBar.GetThumbPos();
487 :
488 0 : if( nThumbPos < nDelta )
489 0 : nDelta = nThumbPos;
490 :
491 0 : if( nDelta <= 0 )
492 0 : return;
493 :
494 0 : nFlags &= (~F_FILLING);
495 0 : if( bNotifyScroll )
496 0 : BeginScroll();
497 :
498 0 : aVerSBar.SetThumbPos( nThumbPos - nDelta );
499 0 : if( bPageUp )
500 0 : PageUp( (short)nDelta );
501 : else
502 0 : CursorUp();
503 :
504 0 : if( bNotifyScroll )
505 0 : EndScroll();
506 : }
507 :
508 :
509 0 : void SvImpLBox::KeyDown( bool bPageDown, bool bNotifyScroll )
510 : {
511 0 : if( !aVerSBar.IsVisible() )
512 0 : return;
513 :
514 : long nDelta;
515 0 : if( bPageDown )
516 0 : nDelta = aVerSBar.GetPageSize();
517 : else
518 0 : nDelta = 1;
519 :
520 0 : long nThumbPos = aVerSBar.GetThumbPos();
521 0 : long nVisibleSize = aVerSBar.GetVisibleSize();
522 0 : long nRange = aVerSBar.GetRange().Len();
523 :
524 0 : long nTmp = nThumbPos+nVisibleSize;
525 0 : while( (nDelta > 0) && (nTmp+nDelta) >= nRange )
526 0 : nDelta--;
527 :
528 0 : if( nDelta <= 0 )
529 0 : return;
530 :
531 0 : nFlags &= (~F_FILLING);
532 0 : if( bNotifyScroll )
533 0 : BeginScroll();
534 :
535 0 : aVerSBar.SetThumbPos( nThumbPos+nDelta );
536 0 : if( bPageDown )
537 0 : PageDown( (short)nDelta );
538 : else
539 0 : CursorDown();
540 :
541 0 : if( bNotifyScroll )
542 0 : EndScroll();
543 : }
544 :
545 :
546 :
547 0 : void SvImpLBox::InvalidateEntriesFrom( long nY ) const
548 : {
549 0 : if( !(nFlags & F_IN_PAINT ))
550 : {
551 0 : Rectangle aRect( GetVisibleArea() );
552 0 : aRect.Top() = nY;
553 0 : pView->Invalidate( aRect );
554 : }
555 0 : }
556 :
557 0 : void SvImpLBox::InvalidateEntry( long nY ) const
558 : {
559 0 : if( !(nFlags & F_IN_PAINT ))
560 : {
561 0 : Rectangle aRect( GetVisibleArea() );
562 0 : long nMaxBottom = aRect.Bottom();
563 0 : aRect.Top() = nY;
564 0 : aRect.Bottom() = nY; aRect.Bottom() += pView->GetEntryHeight();
565 0 : if( aRect.Top() > nMaxBottom )
566 0 : return;
567 0 : if( aRect.Bottom() > nMaxBottom )
568 0 : aRect.Bottom() = nMaxBottom;
569 0 : pView->Invalidate( aRect );
570 : }
571 : }
572 :
573 0 : void SvImpLBox::InvalidateEntry( SvTreeListEntry* pEntry )
574 : {
575 0 : if( GetUpdateMode() )
576 : {
577 0 : long nPrev = nMostRight;
578 0 : SetMostRight( pEntry );
579 0 : if( nPrev < nMostRight )
580 0 : ShowVerSBar();
581 : }
582 0 : if( !(nFlags & F_IN_PAINT ))
583 : {
584 0 : bool bHasFocusRect = false;
585 0 : if( pEntry==pCursor && pView->HasFocus() )
586 : {
587 0 : bHasFocusRect = true;
588 0 : ShowCursor( false );
589 : }
590 0 : InvalidateEntry( GetEntryLine( pEntry ) );
591 0 : if( bHasFocusRect )
592 0 : ShowCursor( true );
593 : }
594 0 : }
595 :
596 :
597 0 : void SvImpLBox::RecalcFocusRect()
598 : {
599 0 : if( pView->HasFocus() && pCursor )
600 : {
601 0 : pView->HideFocus();
602 0 : long nY = GetEntryLine( pCursor );
603 0 : Rectangle aRect = pView->GetFocusRect( pCursor, nY );
604 0 : CalcCellFocusRect( pCursor, aRect );
605 0 : Region aOldClip( pView->GetClipRegion());
606 0 : Region aClipRegion( GetClipRegionRect() );
607 0 : pView->SetClipRegion( aClipRegion );
608 0 : pView->ShowFocus( aRect );
609 0 : pView->SetClipRegion( aOldClip );
610 : }
611 0 : }
612 :
613 :
614 : // Sets cursor. When using SingleSelection, the selection is adjusted.
615 :
616 :
617 0 : void SvImpLBox::SetCursor( SvTreeListEntry* pEntry, bool bForceNoSelect )
618 : {
619 0 : SvViewDataEntry* pViewDataNewCur = 0;
620 0 : if( pEntry )
621 0 : pViewDataNewCur= pView->GetViewDataEntry(pEntry);
622 0 : if( pEntry &&
623 0 : pEntry == pCursor &&
624 0 : pViewDataNewCur &&
625 0 : pViewDataNewCur->HasFocus() &&
626 0 : pViewDataNewCur->IsSelected())
627 : {
628 0 : return;
629 : }
630 :
631 : // if this cursor is not selectable, find first visible that is and use it
632 0 : while( pEntry && pViewDataNewCur && !pViewDataNewCur->IsSelectable() )
633 : {
634 0 : pEntry = pView->NextVisible(pEntry);
635 0 : pViewDataNewCur = pEntry ? pView->GetViewDataEntry(pEntry) : 0;
636 : }
637 :
638 0 : SvTreeListEntry* pOldCursor = pCursor;
639 0 : if( pCursor && pEntry != pCursor )
640 : {
641 0 : pView->SetEntryFocus( pCursor, false );
642 0 : if( bSimpleTravel )
643 0 : pView->Select( pCursor, false );
644 0 : pView->HideFocus();
645 : }
646 0 : pCursor = pEntry;
647 0 : if( pCursor )
648 : {
649 0 : if (pViewDataNewCur)
650 0 : pViewDataNewCur->SetFocus( true );
651 0 : if(!bForceNoSelect && bSimpleTravel && !(nFlags & F_DESEL_ALL) && GetUpdateMode())
652 : {
653 0 : pView->Select( pCursor, true );
654 0 : CallEventListeners( VCLEVENT_LISTBOX_TREEFOCUS, pCursor );
655 : }
656 : // multiple selection: select in cursor move if we're not in
657 : // Add mode (Ctrl-F8)
658 0 : else if( GetUpdateMode() &&
659 0 : pView->GetSelectionMode() == MULTIPLE_SELECTION &&
660 0 : !(nFlags & F_DESEL_ALL) && !aSelEng.IsAddMode() &&
661 0 : !bForceNoSelect )
662 : {
663 0 : pView->Select( pCursor, true );
664 0 : CallEventListeners( VCLEVENT_LISTBOX_TREEFOCUS, pCursor );
665 : }
666 : else
667 : {
668 0 : ShowCursor( true );
669 0 : if (bForceNoSelect && GetUpdateMode())
670 : {
671 0 : CallEventListeners( VCLEVENT_LISTBOX_TREEFOCUS, pCursor);
672 : }
673 : }
674 :
675 0 : if( pAnchor )
676 : {
677 : DBG_ASSERT(aSelEng.GetSelectionMode() != SINGLE_SELECTION,"Mode?");
678 0 : SetAnchorSelection( pOldCursor, pCursor );
679 : }
680 : }
681 0 : nFlags &= (~F_DESEL_ALL);
682 :
683 0 : pView->OnCurrentEntryChanged();
684 : }
685 :
686 0 : void SvImpLBox::ShowCursor( bool bShow )
687 : {
688 0 : if( !bShow || !pCursor || !pView->HasFocus() )
689 : {
690 0 : Region aOldClip( pView->GetClipRegion());
691 0 : Region aClipRegion( GetClipRegionRect() );
692 0 : pView->SetClipRegion( aClipRegion );
693 0 : pView->HideFocus();
694 0 : pView->SetClipRegion( aOldClip );
695 : }
696 : else
697 : {
698 0 : long nY = GetEntryLine( pCursor );
699 0 : Rectangle aRect = pView->GetFocusRect( pCursor, nY );
700 0 : CalcCellFocusRect( pCursor, aRect );
701 0 : Region aOldClip( pView->GetClipRegion());
702 0 : Region aClipRegion( GetClipRegionRect() );
703 0 : pView->SetClipRegion( aClipRegion );
704 0 : pView->ShowFocus( aRect );
705 0 : pView->SetClipRegion( aOldClip );
706 : }
707 0 : }
708 :
709 :
710 :
711 0 : void SvImpLBox::UpdateAll(
712 : bool bInvalidateCompleteView, bool bUpdateVerScrollBar )
713 : {
714 0 : if( bUpdateVerScrollBar )
715 0 : FindMostRight(0);
716 0 : aVerSBar.SetRange( Range(0, pView->GetVisibleCount()-1 ) );
717 0 : SyncVerThumb();
718 0 : FillView();
719 0 : ShowVerSBar();
720 0 : if( bSimpleTravel && pCursor && pView->HasFocus() )
721 0 : pView->Select( pCursor, true );
722 0 : ShowCursor( true );
723 0 : if( bInvalidateCompleteView )
724 0 : pView->Invalidate();
725 : else
726 0 : pView->Invalidate( GetVisibleArea() );
727 0 : }
728 :
729 0 : IMPL_LINK_INLINE_START( SvImpLBox, ScrollLeftRightHdl, ScrollBar *, pScrollBar )
730 : {
731 0 : long nDelta = pScrollBar->GetDelta();
732 0 : if( nDelta )
733 : {
734 0 : if( pView->IsEditingActive() )
735 : {
736 0 : pView->EndEditing( true ); // Cancel
737 0 : pView->Update();
738 : }
739 0 : pView->nFocusWidth = -1;
740 0 : KeyLeftRight( nDelta );
741 : }
742 0 : return 0;
743 : }
744 0 : IMPL_LINK_INLINE_END( SvImpLBox, ScrollLeftRightHdl, ScrollBar *, pScrollBar )
745 :
746 0 : void SvImpLBox::KeyLeftRight( long nDelta )
747 : {
748 0 : if( !(nFlags & F_IN_RESIZE) )
749 0 : pView->Update();
750 0 : BeginScroll();
751 0 : nFlags &= (~F_FILLING);
752 0 : pView->NotifyScrolling( 0 ); // 0 == horizontal scrolling
753 0 : ShowCursor( false );
754 :
755 : // neuen Origin berechnen
756 0 : long nPos = aHorSBar.GetThumbPos();
757 0 : Point aOrigin( -nPos, 0 );
758 :
759 0 : MapMode aMapMode( pView->GetMapMode() );
760 0 : aMapMode.SetOrigin( aOrigin );
761 0 : pView->SetMapMode( aMapMode );
762 :
763 0 : if( !(nFlags & F_IN_RESIZE) )
764 : {
765 0 : Rectangle aRect( GetVisibleArea() );
766 0 : pView->Scroll( -nDelta, 0, aRect, SCROLL_NOCHILDREN );
767 : }
768 : else
769 0 : pView->Invalidate();
770 0 : RecalcFocusRect();
771 0 : ShowCursor( true );
772 0 : pView->NotifyScrolled();
773 0 : }
774 :
775 :
776 : // returns the last entry if position is just past the last entry
777 0 : SvTreeListEntry* SvImpLBox::GetClickedEntry( const Point& rPoint ) const
778 : {
779 : DBG_ASSERT( pView->GetModel(), "SvImpLBox::GetClickedEntry: how can this ever happen? Please tell me (frank.schoenheit@sun.com) how to reproduce!" );
780 0 : if ( !pView->GetModel() )
781 : // this is quite impossible. Nevertheless, stack traces from the crash reporter
782 : // suggest it isn't. Okay, make it safe, and wait for somebody to reproduce it
783 : // reliably :-\ ....
784 : // #122359# / 2005-05-23 / frank.schoenheit@sun.com
785 0 : return NULL;
786 0 : if( pView->GetEntryCount() == 0 || !pStartEntry || !pView->GetEntryHeight())
787 0 : return 0;
788 :
789 0 : sal_uInt16 nClickedEntry = (sal_uInt16)(rPoint.Y() / pView->GetEntryHeight() );
790 0 : sal_uInt16 nTemp = nClickedEntry;
791 0 : SvTreeListEntry* pEntry = pView->NextVisible(pStartEntry, nTemp);
792 0 : return pEntry;
793 : }
794 :
795 :
796 : // checks if the entry was hit "the right way"
797 : // (Focusrect+ ContextBitmap bei TreeListBox)
798 :
799 0 : bool SvImpLBox::EntryReallyHit(SvTreeListEntry* pEntry, const Point& rPosPixel, long nLine)
800 : {
801 : bool bRet;
802 : // we are not too exact when it comes to "special" entries
803 : // (with CheckButtons etc.)
804 0 : if( pEntry->ItemCount() >= 3 )
805 0 : return true;
806 :
807 0 : Rectangle aRect( pView->GetFocusRect( pEntry, nLine ));
808 0 : aRect.Right() = GetOutputSize().Width() - pView->GetMapMode().GetOrigin().X();
809 :
810 0 : SvLBoxContextBmp* pBmp = (SvLBoxContextBmp*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXCONTEXTBMP));
811 0 : aRect.Left() -= pBmp->GetSize(pView,pEntry).Width();
812 0 : aRect.Left() -= 4; // a little tolerance
813 :
814 0 : Point aPos( rPosPixel );
815 0 : aPos -= pView->GetMapMode().GetOrigin();
816 0 : if( aRect.IsInside( aPos ) )
817 0 : bRet = true;
818 : else
819 0 : bRet = false;
820 0 : return bRet;
821 : }
822 :
823 :
824 : // returns 0 if position is just past the last entry
825 0 : SvTreeListEntry* SvImpLBox::GetEntry( const Point& rPoint ) const
826 : {
827 0 : if( (pView->GetEntryCount() == 0) || !pStartEntry ||
828 0 : (rPoint.Y() > aOutputSize.Height())
829 0 : || !pView->GetEntryHeight())
830 0 : return 0;
831 :
832 0 : sal_uInt16 nClickedEntry = (sal_uInt16)(rPoint.Y() / pView->GetEntryHeight() );
833 0 : sal_uInt16 nTemp = nClickedEntry;
834 0 : SvTreeListEntry* pEntry = pView->NextVisible(pStartEntry, nTemp);
835 0 : if( nTemp != nClickedEntry )
836 0 : pEntry = 0;
837 0 : return pEntry;
838 : }
839 :
840 :
841 0 : SvTreeListEntry* SvImpLBox::MakePointVisible(const Point& rPoint, bool bNotifyScroll)
842 : {
843 0 : if( !pCursor )
844 0 : return 0;
845 0 : long nY = rPoint.Y();
846 0 : SvTreeListEntry* pEntry = 0;
847 0 : long nMax = aOutputSize.Height();
848 0 : if( nY < 0 || nY >= nMax ) // aOutputSize.Height() )
849 : {
850 0 : if( nY < 0 )
851 0 : pEntry = pView->PrevVisible(pCursor);
852 : else
853 0 : pEntry = pView->NextVisible(pCursor);
854 :
855 0 : if( pEntry && pEntry != pCursor )
856 0 : pView->SetEntryFocus( pCursor, false );
857 :
858 0 : if( nY < 0 )
859 0 : KeyUp( false, bNotifyScroll );
860 : else
861 0 : KeyDown( false, bNotifyScroll );
862 : }
863 : else
864 : {
865 0 : pEntry = GetClickedEntry( rPoint );
866 0 : if( !pEntry )
867 : {
868 0 : sal_uInt16 nSteps = 0xFFFF;
869 : // TODO: LastVisible is not yet implemented!
870 0 : pEntry = pView->NextVisible(pStartEntry, nSteps);
871 : }
872 0 : if( pEntry )
873 : {
874 0 : if( pEntry != pCursor &&
875 0 : aSelEng.GetSelectionMode() == SINGLE_SELECTION
876 : )
877 0 : pView->Select( pCursor, false );
878 : }
879 : }
880 0 : return pEntry;
881 : }
882 :
883 0 : Rectangle SvImpLBox::GetClipRegionRect() const
884 : {
885 0 : Point aOrigin( pView->GetMapMode().GetOrigin() );
886 0 : aOrigin.X() *= -1; // conversion document coordinates
887 0 : Rectangle aClipRect( aOrigin, aOutputSize );
888 0 : aClipRect.Bottom()++;
889 0 : return aClipRect;
890 : }
891 :
892 :
893 0 : void SvImpLBox::Paint( const Rectangle& rRect )
894 : {
895 0 : if( !pView->GetVisibleCount() )
896 0 : return;
897 :
898 0 : nFlags |= F_IN_PAINT;
899 :
900 0 : if( nFlags & F_FILLING )
901 : {
902 0 : SvTreeListEntry* pFirst = pView->First();
903 0 : if( pFirst != pStartEntry )
904 : {
905 0 : ShowCursor( false );
906 0 : pStartEntry = pView->First();
907 0 : aVerSBar.SetThumbPos( 0 );
908 0 : StopUserEvent();
909 0 : ShowCursor( true );
910 0 : nCurUserEvent = Application::PostUserEvent(LINK(this,SvImpLBox,MyUserEvent),(void*)1);
911 0 : return;
912 : }
913 : }
914 :
915 0 : if( !pStartEntry )
916 : {
917 0 : pStartEntry = pView->First();
918 : }
919 :
920 0 : if( nNodeBmpTabDistance == NODE_BMP_TABDIST_NOTVALID )
921 0 : SetNodeBmpTabDistance();
922 :
923 0 : long nRectHeight = rRect.GetHeight();
924 0 : long nEntryHeight = pView->GetEntryHeight();
925 :
926 : // calculate area for the entries we want to draw
927 0 : sal_uInt16 nStartLine = (sal_uInt16)( rRect.Top() / nEntryHeight );
928 0 : sal_uInt16 nCount = (sal_uInt16)( nRectHeight / nEntryHeight );
929 0 : nCount += 2; // don't miss a row
930 :
931 0 : long nY = nStartLine * nEntryHeight;
932 0 : SvTreeListEntry* pEntry = pStartEntry;
933 0 : while( nStartLine && pEntry )
934 : {
935 0 : pEntry = pView->NextVisible(pEntry);
936 0 : nStartLine--;
937 : }
938 :
939 0 : Region aClipRegion( GetClipRegionRect() );
940 :
941 : // first draw the lines, then clip them!
942 0 : pView->SetClipRegion();
943 0 : if( m_nStyle & ( WB_HASLINES | WB_HASLINESATROOT ) )
944 0 : DrawNet();
945 :
946 0 : pView->SetClipRegion( aClipRegion );
947 :
948 0 : for( sal_uInt16 n=0; n< nCount && pEntry; n++ )
949 : {
950 : /*long nMaxRight=*/
951 0 : pView->PaintEntry1( pEntry, nY, 0xffff, true );
952 0 : nY += nEntryHeight;
953 0 : pEntry = pView->NextVisible(pEntry);
954 : }
955 :
956 0 : if ( !pCursor && ( ( nExtendedWinBits & EWB_NO_AUTO_CURENTRY ) == 0 ) )
957 : {
958 : // do not select if multiselection or explicit set
959 0 : bool bNotSelect = ( aSelEng.GetSelectionMode() == MULTIPLE_SELECTION )
960 0 : || ( ( m_nStyle & WB_NOINITIALSELECTION ) == WB_NOINITIALSELECTION );
961 0 : SetCursor( pStartEntry, bNotSelect );
962 : }
963 :
964 0 : nFlags &= (~F_DESEL_ALL);
965 0 : pView->SetClipRegion();
966 0 : if( !(nFlags & F_PAINTED) )
967 : {
968 0 : nFlags |= F_PAINTED;
969 0 : RepaintScrollBars();
970 : }
971 0 : nFlags &= (~F_IN_PAINT);
972 : }
973 :
974 0 : void SvImpLBox::MakeVisible( SvTreeListEntry* pEntry, bool bMoveToTop )
975 : {
976 0 : if( !pEntry )
977 0 : return;
978 :
979 0 : bool bInView = IsEntryInView( pEntry );
980 :
981 0 : if( bInView && (!bMoveToTop || pStartEntry == pEntry) )
982 0 : return; // is already visible
983 :
984 0 : if( pStartEntry || (m_nStyle & WB_FORCE_MAKEVISIBLE) )
985 0 : nFlags &= (~F_FILLING);
986 0 : if( !bInView )
987 : {
988 0 : if( !pView->IsEntryVisible(pEntry) ) // Parent(s) collapsed?
989 : {
990 0 : SvTreeListEntry* pParent = pView->GetParent( pEntry );
991 0 : while( pParent )
992 : {
993 0 : if( !pView->IsExpanded( pParent ) )
994 : {
995 : #ifdef DBG_UTIL
996 : bool bRet =
997 : #endif
998 0 : pView->Expand( pParent );
999 : DBG_ASSERT(bRet,"Not expanded!");
1000 : }
1001 0 : pParent = pView->GetParent( pParent );
1002 : }
1003 : // do the parent's children fit into the view or do we have to scroll?
1004 0 : if( IsEntryInView( pEntry ) && !bMoveToTop )
1005 0 : return; // no need to scroll
1006 : }
1007 : }
1008 :
1009 0 : pStartEntry = pEntry;
1010 0 : ShowCursor( false );
1011 0 : FillView();
1012 0 : aVerSBar.SetThumbPos( (long)(pView->GetVisiblePos( pStartEntry )) );
1013 0 : ShowCursor( true );
1014 0 : pView->Invalidate();
1015 : }
1016 :
1017 0 : void SvImpLBox::ScrollToAbsPos( long nPos )
1018 : {
1019 0 : if( pView->GetVisibleCount() == 0 )
1020 0 : return;
1021 0 : long nLastEntryPos = pView->GetAbsPos( pView->Last() );
1022 :
1023 0 : if( nPos < 0 )
1024 0 : nPos = 0;
1025 0 : else if( nPos > nLastEntryPos )
1026 0 : nPos = nLastEntryPos;
1027 :
1028 0 : SvTreeListEntry* pEntry = (SvTreeListEntry*)pView->GetEntryAtAbsPos( nPos );
1029 0 : if( !pEntry || pEntry == pStartEntry )
1030 0 : return;
1031 :
1032 0 : if( pStartEntry || (m_nStyle & WB_FORCE_MAKEVISIBLE) )
1033 0 : nFlags &= (~F_FILLING);
1034 :
1035 0 : if( pView->IsEntryVisible(pEntry) )
1036 : {
1037 0 : pStartEntry = pEntry;
1038 0 : ShowCursor( false );
1039 0 : aVerSBar.SetThumbPos( nPos );
1040 0 : ShowCursor( true );
1041 0 : if (GetUpdateMode())
1042 0 : pView->Invalidate();
1043 : }
1044 : }
1045 :
1046 0 : void SvImpLBox::DrawNet()
1047 : {
1048 0 : if( pView->GetVisibleCount() < 2 && !pStartEntry->HasChildrenOnDemand() &&
1049 0 : !pStartEntry->HasChildren() )
1050 0 : return;
1051 :
1052 : // for platforms that don't have nets, DrawNativeControl does nothing and returns true
1053 : // so that SvImpLBox::DrawNet() doesn't draw anything either
1054 0 : if(pView->IsNativeControlSupported( CTRL_LISTNET, PART_ENTIRE_CONTROL)) {
1055 0 : ImplControlValue aControlValue;
1056 0 : Point aTemp(0,0); // temporary needed for g++ 3.3.5
1057 0 : Rectangle aCtrlRegion( aTemp, Size( 0, 0 ) );
1058 0 : ControlState nState = CTRL_STATE_ENABLED;
1059 0 : if( pView->DrawNativeControl( CTRL_LISTNET, PART_ENTIRE_CONTROL,
1060 0 : aCtrlRegion, nState, aControlValue, OUString() ) )
1061 : {
1062 0 : return;
1063 0 : }
1064 :
1065 : }
1066 :
1067 0 : long nEntryHeight = pView->GetEntryHeight();
1068 0 : long nEntryHeightDIV2 = nEntryHeight / 2;
1069 0 : if( nEntryHeightDIV2 && !(nEntryHeight & 0x0001))
1070 0 : nEntryHeightDIV2--;
1071 :
1072 : SvTreeListEntry* pChild;
1073 0 : SvTreeListEntry* pEntry = pStartEntry;
1074 :
1075 0 : SvLBoxTab* pFirstDynamicTab = pView->GetFirstDynamicTab();
1076 0 : while( pTree->GetDepth( pEntry ) > 0 )
1077 0 : pEntry = pView->GetParent( pEntry );
1078 0 : sal_uInt16 nOffs = (sal_uInt16)(pView->GetVisiblePos( pStartEntry ) -
1079 0 : pView->GetVisiblePos( pEntry ));
1080 0 : long nY = 0;
1081 0 : nY -= ( nOffs * nEntryHeight );
1082 :
1083 : DBG_ASSERT(pFirstDynamicTab,"No Tree!");
1084 :
1085 0 : Color aOldLineColor = pView->GetLineColor();
1086 0 : const StyleSettings& rStyleSettings = pView->GetSettings().GetStyleSettings();
1087 0 : Color aCol= rStyleSettings.GetFaceColor();
1088 :
1089 0 : if( aCol.IsRGBEqual( pView->GetBackground().GetColor()) )
1090 0 : aCol = rStyleSettings.GetShadowColor();
1091 0 : pView->SetLineColor( aCol );
1092 0 : Point aPos1, aPos2;
1093 : sal_uInt16 nDistance;
1094 0 : sal_uLong nMax = nVisibleCount + nOffs + 1;
1095 :
1096 0 : const Image& rExpandedNodeBitmap = GetExpandedNodeBmp();
1097 :
1098 0 : for( sal_uLong n=0; n< nMax && pEntry; n++ )
1099 : {
1100 0 : if( pView->IsExpanded(pEntry) )
1101 : {
1102 0 : aPos1.X() = pView->GetTabPos(pEntry, pFirstDynamicTab);
1103 : // if it is not a context bitmap, go a little to the right below the
1104 : // first text (node bitmap, too)
1105 0 : if( !pView->nContextBmpWidthMax )
1106 0 : aPos1.X() += rExpandedNodeBitmap.GetSizePixel().Width() / 2;
1107 :
1108 0 : aPos1.Y() = nY;
1109 0 : aPos1.Y() += nEntryHeightDIV2;
1110 :
1111 0 : pChild = pView->FirstChild( pEntry );
1112 : DBG_ASSERT(pChild,"Child?");
1113 0 : pChild = pTree->LastSibling( pChild );
1114 0 : nDistance = (sal_uInt16)(pView->GetVisiblePos(pChild) -
1115 0 : pView->GetVisiblePos(pEntry));
1116 0 : aPos2 = aPos1;
1117 0 : aPos2.Y() += nDistance * nEntryHeight;
1118 0 : pView->DrawLine( aPos1, aPos2 );
1119 : }
1120 : // visible in control?
1121 0 : if( n>= nOffs && ((m_nStyle & WB_HASLINESATROOT) || !pTree->IsAtRootDepth(pEntry)))
1122 : {
1123 : // can we recycle aPos1?
1124 0 : if( !pView->IsExpanded(pEntry) )
1125 : {
1126 : // nope
1127 0 : aPos1.X() = pView->GetTabPos(pEntry, pFirstDynamicTab);
1128 : // if it is not a context bitmap, go a little to the right below
1129 : // the first text (node bitmap, too)
1130 0 : if( !pView->nContextBmpWidthMax )
1131 0 : aPos1.X() += rExpandedNodeBitmap.GetSizePixel().Width() / 2;
1132 0 : aPos1.Y() = nY;
1133 0 : aPos1.Y() += nEntryHeightDIV2;
1134 0 : aPos2.X() = aPos1.X();
1135 : }
1136 0 : aPos2.Y() = aPos1.Y();
1137 0 : aPos2.X() -= pView->GetIndent();
1138 0 : pView->DrawLine( aPos1, aPos2 );
1139 : }
1140 0 : nY += nEntryHeight;
1141 0 : pEntry = pView->NextVisible(pEntry);
1142 : }
1143 0 : if( m_nStyle & WB_HASLINESATROOT )
1144 : {
1145 0 : pEntry = pView->First();
1146 0 : aPos1.X() = pView->GetTabPos( pEntry, pFirstDynamicTab);
1147 : // if it is not a context bitmap, go a little to the right below the
1148 : // first text (node bitmap, too)
1149 0 : if( !pView->nContextBmpWidthMax )
1150 0 : aPos1.X() += rExpandedNodeBitmap.GetSizePixel().Width() / 2;
1151 0 : aPos1.X() -= pView->GetIndent();
1152 0 : aPos1.Y() = GetEntryLine( pEntry );
1153 0 : aPos1.Y() += nEntryHeightDIV2;
1154 0 : pChild = pTree->LastSibling( pEntry );
1155 0 : aPos2.X() = aPos1.X();
1156 0 : aPos2.Y() = GetEntryLine( pChild );
1157 0 : aPos2.Y() += nEntryHeightDIV2;
1158 0 : pView->DrawLine( aPos1, aPos2 );
1159 : }
1160 0 : pView->SetLineColor( aOldLineColor );
1161 : }
1162 :
1163 0 : void SvImpLBox::PositionScrollBars( Size& rSize, sal_uInt16 nMask )
1164 : {
1165 0 : long nOverlap = 0;
1166 :
1167 0 : Size aVerSize( nVerSBarWidth, rSize.Height() );
1168 0 : Size aHorSize( rSize.Width(), nHorSBarHeight );
1169 :
1170 0 : if( nMask & 0x0001 )
1171 0 : aHorSize.Width() -= nVerSBarWidth;
1172 0 : if( nMask & 0x0002 )
1173 0 : aVerSize.Height() -= nHorSBarHeight;
1174 :
1175 0 : aVerSize.Height() += 2 * nOverlap;
1176 0 : Point aVerPos( rSize.Width() - aVerSize.Width() + nOverlap, -nOverlap );
1177 0 : aVerSBar.SetPosSizePixel( aVerPos, aVerSize );
1178 :
1179 0 : aHorSize.Width() += 2 * nOverlap;
1180 0 : Point aHorPos( -nOverlap, rSize.Height() - aHorSize.Height() + nOverlap );
1181 :
1182 0 : aHorSBar.SetPosSizePixel( aHorPos, aHorSize );
1183 :
1184 0 : if( nMask & 0x0001 )
1185 0 : rSize.Width() = aVerPos.X();
1186 0 : if( nMask & 0x0002 )
1187 0 : rSize.Height() = aHorPos.Y();
1188 :
1189 0 : if( (nMask & (0x0001|0x0002)) == (0x0001|0x0002) )
1190 0 : aScrBarBox.Show();
1191 : else
1192 0 : aScrBarBox.Hide();
1193 0 : }
1194 :
1195 : // nResult: Bit0 == VerSBar Bit1 == HorSBar
1196 0 : sal_uInt16 SvImpLBox::AdjustScrollBars( Size& rSize )
1197 : {
1198 0 : long nEntryHeight = pView->GetEntryHeight();
1199 0 : if( !nEntryHeight )
1200 0 : return 0;
1201 :
1202 0 : sal_uInt16 nResult = 0;
1203 :
1204 0 : Size aOSize( pView->Control::GetOutputSizePixel() );
1205 :
1206 0 : const WinBits nWindowStyle = pView->GetStyle();
1207 0 : bool bVerSBar = ( nWindowStyle & WB_VSCROLL ) != 0;
1208 0 : bool bHorBar = false;
1209 0 : long nMaxRight = aOSize.Width(); //GetOutputSize().Width();
1210 0 : Point aOrigin( pView->GetMapMode().GetOrigin() );
1211 0 : aOrigin.X() *= -1;
1212 0 : nMaxRight += aOrigin.X() - 1;
1213 0 : long nVis = nMostRight - aOrigin.X();
1214 0 : if( (nWindowStyle & WB_HSCROLL) &&
1215 0 : (nVis < nMostRight || nMaxRight < nMostRight) )
1216 : {
1217 0 : bHorBar = true;
1218 : }
1219 :
1220 : // number of entries that are not collapsed
1221 0 : sal_uLong nTotalCount = pView->GetVisibleCount();
1222 :
1223 : // number of entries visible within the view
1224 0 : nVisibleCount = aOSize.Height() / nEntryHeight;
1225 :
1226 : // do we need a vertical scrollbar?
1227 0 : if( bVerSBar || nTotalCount > nVisibleCount )
1228 : {
1229 0 : nResult = 1;
1230 0 : nFlags |= F_HOR_SBARSIZE_WITH_VBAR;
1231 0 : nMaxRight -= nVerSBarWidth;
1232 0 : if( !bHorBar )
1233 : {
1234 0 : if( (nWindowStyle & WB_HSCROLL) &&
1235 0 : (nVis < nMostRight || nMaxRight < nMostRight) )
1236 0 : bHorBar = true;
1237 : }
1238 : }
1239 :
1240 : // do we need a horizontal scrollbar?
1241 0 : if( bHorBar )
1242 : {
1243 0 : nResult |= 0x0002;
1244 : // the number of entries visible within the view has to be recalculated
1245 : // because the horizontal scrollbar is now visible.
1246 0 : nVisibleCount = (aOSize.Height() - nHorSBarHeight) / nEntryHeight;
1247 : // we might actually need a vertical scrollbar now
1248 0 : if( !(nResult & 0x0001) &&
1249 0 : ((nTotalCount > nVisibleCount) || bVerSBar) )
1250 : {
1251 0 : nResult = 3;
1252 0 : nFlags |= F_VER_SBARSIZE_WITH_HBAR;
1253 : }
1254 : }
1255 :
1256 0 : PositionScrollBars( aOSize, nResult );
1257 :
1258 : // adapt Range, VisibleRange etc.
1259 :
1260 : // refresh output size, in case we have to scroll
1261 0 : Rectangle aRect;
1262 0 : aRect.SetSize( aOSize );
1263 0 : aSelEng.SetVisibleArea( aRect );
1264 :
1265 : // vertical scrollbar
1266 0 : long nTemp = (long)nVisibleCount;
1267 0 : nTemp--;
1268 0 : if( nTemp != aVerSBar.GetVisibleSize() )
1269 : {
1270 0 : if( !bInVScrollHdl )
1271 : {
1272 0 : aVerSBar.SetPageSize( nTemp - 1 );
1273 0 : aVerSBar.SetVisibleSize( nTemp );
1274 : }
1275 : else
1276 : {
1277 0 : nFlags |= F_ENDSCROLL_SET_VIS_SIZE;
1278 0 : nNextVerVisSize = nTemp;
1279 : }
1280 : }
1281 :
1282 : // horizontal scrollbar
1283 0 : nTemp = aHorSBar.GetThumbPos();
1284 0 : aHorSBar.SetVisibleSize( aOSize.Width() );
1285 0 : long nNewThumbPos = aHorSBar.GetThumbPos();
1286 0 : Range aRange( aHorSBar.GetRange() );
1287 0 : if( aRange.Max() < nMostRight+25 )
1288 : {
1289 0 : aRange.Max() = nMostRight+25;
1290 0 : aHorSBar.SetRange( aRange );
1291 : }
1292 :
1293 0 : if( nTemp != nNewThumbPos )
1294 : {
1295 0 : nTemp = nNewThumbPos - nTemp;
1296 0 : if( pView->IsEditingActive() )
1297 : {
1298 0 : pView->EndEditing( true ); // Cancel
1299 0 : pView->Update();
1300 : }
1301 0 : pView->nFocusWidth = -1;
1302 0 : KeyLeftRight( nTemp );
1303 : }
1304 :
1305 0 : if( nResult & 0x0001 )
1306 0 : aVerSBar.Show();
1307 : else
1308 0 : aVerSBar.Hide();
1309 :
1310 0 : if( nResult & 0x0002 )
1311 0 : aHorSBar.Show();
1312 : else
1313 : {
1314 0 : aHorSBar.Hide();
1315 : }
1316 0 : rSize = aOSize;
1317 0 : return nResult;
1318 : }
1319 :
1320 0 : void SvImpLBox::InitScrollBarBox()
1321 : {
1322 0 : aScrBarBox.SetSizePixel( Size(nVerSBarWidth, nHorSBarHeight) );
1323 0 : Size aSize( pView->Control::GetOutputSizePixel() );
1324 0 : aScrBarBox.SetPosPixel( Point(aSize.Width()-nVerSBarWidth, aSize.Height()-nHorSBarHeight));
1325 0 : }
1326 :
1327 0 : void SvImpLBox::Resize()
1328 : {
1329 0 : aOutputSize = pView->Control::GetOutputSizePixel();
1330 0 : if( aOutputSize.Width() <= 0 || aOutputSize.Height() <= 0 )
1331 0 : return;
1332 0 : nFlags |= F_IN_RESIZE;
1333 0 : InitScrollBarBox();
1334 :
1335 0 : if( pView->GetEntryHeight())
1336 : {
1337 0 : AdjustScrollBars( aOutputSize );
1338 0 : UpdateAll(false);
1339 : }
1340 : // HACK, as in floating and docked windows the scrollbars might not be drawn
1341 : // correctly/not be drawn at all after resizing!
1342 0 : if( aHorSBar.IsVisible())
1343 0 : aHorSBar.Invalidate();
1344 0 : if( aVerSBar.IsVisible())
1345 0 : aVerSBar.Invalidate();
1346 0 : nFlags &= (~(F_IN_RESIZE | F_PAINTED));
1347 : }
1348 :
1349 0 : void SvImpLBox::FillView()
1350 : {
1351 0 : if( !pStartEntry )
1352 : {
1353 0 : sal_uInt16 nVisibleViewCount = (sal_uInt16)(pView->GetVisibleCount());
1354 0 : sal_uInt16 nTempThumb = (sal_uInt16)aVerSBar.GetThumbPos();
1355 0 : if( nTempThumb >= nVisibleViewCount )
1356 0 : nTempThumb = nVisibleViewCount - 1;
1357 0 : pStartEntry = pView->GetEntryAtVisPos(nTempThumb);
1358 : }
1359 0 : if( pStartEntry )
1360 : {
1361 0 : sal_uInt16 nLast = (sal_uInt16)(pView->GetVisiblePos(pView->LastVisible()));
1362 0 : sal_uInt16 nThumb = (sal_uInt16)(pView->GetVisiblePos( pStartEntry ));
1363 0 : sal_uInt16 nCurDispEntries = nLast-nThumb+1;
1364 0 : if( nCurDispEntries < nVisibleCount )
1365 : {
1366 0 : ShowCursor( false );
1367 : // fill window by moving the thumb up incrementally
1368 0 : bool bFound = false;
1369 0 : SvTreeListEntry* pTemp = pStartEntry;
1370 0 : while( nCurDispEntries < nVisibleCount && pTemp )
1371 : {
1372 0 : pTemp = pView->PrevVisible(pStartEntry);
1373 0 : if( pTemp )
1374 : {
1375 0 : nThumb--;
1376 0 : pStartEntry = pTemp;
1377 0 : nCurDispEntries++;
1378 0 : bFound = true;
1379 : }
1380 : }
1381 0 : if( bFound )
1382 : {
1383 0 : aVerSBar.SetThumbPos( nThumb );
1384 0 : ShowCursor( true ); // recalculate focus rectangle
1385 0 : pView->Invalidate();
1386 : }
1387 : }
1388 : }
1389 0 : }
1390 :
1391 :
1392 :
1393 :
1394 0 : void SvImpLBox::ShowVerSBar()
1395 : {
1396 0 : bool bVerBar = ( pView->GetStyle() & WB_VSCROLL ) != 0;
1397 0 : sal_uLong nVis = 0;
1398 0 : if( !bVerBar )
1399 0 : nVis = pView->GetVisibleCount();
1400 0 : if( bVerBar || (nVisibleCount && nVis > (sal_uLong)(nVisibleCount-1)) )
1401 : {
1402 0 : if( !aVerSBar.IsVisible() )
1403 : {
1404 0 : pView->nFocusWidth = -1;
1405 0 : AdjustScrollBars( aOutputSize );
1406 0 : if( GetUpdateMode() )
1407 0 : aVerSBar.Update();
1408 : }
1409 : }
1410 : else
1411 : {
1412 0 : if( aVerSBar.IsVisible() )
1413 : {
1414 0 : pView->nFocusWidth = -1;
1415 0 : AdjustScrollBars( aOutputSize );
1416 : }
1417 : }
1418 :
1419 0 : long nMaxRight = GetOutputSize().Width();
1420 0 : Point aPos( pView->GetMapMode().GetOrigin() );
1421 0 : aPos.X() *= -1; // convert document coordinates
1422 0 : nMaxRight = nMaxRight + aPos.X() - 1;
1423 0 : if( nMaxRight < nMostRight )
1424 : {
1425 0 : if( !aHorSBar.IsVisible() )
1426 : {
1427 0 : pView->nFocusWidth = -1;
1428 0 : AdjustScrollBars( aOutputSize );
1429 0 : if( GetUpdateMode() )
1430 0 : aHorSBar.Update();
1431 : }
1432 : else
1433 : {
1434 0 : Range aRange( aHorSBar.GetRange() );
1435 0 : if( aRange.Max() < nMostRight+25 )
1436 : {
1437 0 : aRange.Max() = nMostRight+25;
1438 0 : aHorSBar.SetRange( aRange );
1439 : }
1440 : else
1441 : {
1442 0 : pView->nFocusWidth = -1;
1443 0 : AdjustScrollBars( aOutputSize );
1444 : }
1445 : }
1446 : }
1447 : else
1448 : {
1449 0 : if( aHorSBar.IsVisible() )
1450 : {
1451 0 : pView->nFocusWidth = -1;
1452 0 : AdjustScrollBars( aOutputSize );
1453 : }
1454 : }
1455 0 : }
1456 :
1457 :
1458 0 : void SvImpLBox::SyncVerThumb()
1459 : {
1460 0 : if( pStartEntry )
1461 : {
1462 0 : long nEntryPos = pView->GetVisiblePos( pStartEntry );
1463 0 : aVerSBar.SetThumbPos( nEntryPos );
1464 : }
1465 : else
1466 0 : aVerSBar.SetThumbPos( 0 );
1467 0 : }
1468 :
1469 0 : bool SvImpLBox::IsEntryInView( SvTreeListEntry* pEntry ) const
1470 : {
1471 : // parent collapsed
1472 0 : if( !pView->IsEntryVisible(pEntry) )
1473 0 : return false;
1474 0 : long nY = GetEntryLine( pEntry );
1475 0 : if( nY < 0 )
1476 0 : return false;
1477 0 : long nMax = nVisibleCount * pView->GetEntryHeight();
1478 0 : if( nY >= nMax )
1479 0 : return false;
1480 0 : return true;
1481 : }
1482 :
1483 :
1484 0 : long SvImpLBox::GetEntryLine( SvTreeListEntry* pEntry ) const
1485 : {
1486 0 : if(!pStartEntry )
1487 0 : return -1; // invisible position
1488 :
1489 0 : long nFirstVisPos = pView->GetVisiblePos( pStartEntry );
1490 0 : long nEntryVisPos = pView->GetVisiblePos( pEntry );
1491 0 : nFirstVisPos = nEntryVisPos - nFirstVisPos;
1492 0 : nFirstVisPos *= pView->GetEntryHeight();
1493 0 : return nFirstVisPos;
1494 : }
1495 :
1496 0 : void SvImpLBox::SetEntryHeight( short /* nHeight */ )
1497 : {
1498 0 : SetNodeBmpYOffset( GetExpandedNodeBmp() );
1499 0 : SetNodeBmpYOffset( GetCollapsedNodeBmp() );
1500 0 : if(!pView->HasViewData()) // are we within the Clear?
1501 : {
1502 0 : Size aSize = pView->Control::GetOutputSizePixel();
1503 0 : AdjustScrollBars( aSize );
1504 : }
1505 : else
1506 : {
1507 0 : Resize();
1508 0 : if( GetUpdateMode() )
1509 0 : pView->Invalidate();
1510 : }
1511 0 : }
1512 :
1513 :
1514 :
1515 : // ***********************************************************************
1516 : // Callback Functions
1517 : // ***********************************************************************
1518 :
1519 0 : void SvImpLBox::EntryExpanded( SvTreeListEntry* pEntry )
1520 : {
1521 : // SelAllDestrAnch( false, true ); //DeselectAll();
1522 0 : if( GetUpdateMode() )
1523 : {
1524 0 : ShowCursor( false );
1525 0 : long nY = GetEntryLine( pEntry );
1526 0 : if( IsLineVisible(nY) )
1527 : {
1528 0 : InvalidateEntriesFrom( nY );
1529 0 : FindMostRight( pEntry, 0 );
1530 : }
1531 0 : aVerSBar.SetRange( Range(0, pView->GetVisibleCount()-1 ) );
1532 : // if we expanded before the thumb, the thumb's position has to be
1533 : // corrected
1534 0 : SyncVerThumb();
1535 0 : ShowVerSBar();
1536 0 : ShowCursor( true );
1537 : }
1538 0 : }
1539 :
1540 0 : void SvImpLBox::EntryCollapsed( SvTreeListEntry* pEntry )
1541 : {
1542 0 : if( !pView->IsEntryVisible( pEntry ) )
1543 0 : return;
1544 :
1545 0 : ShowCursor( false );
1546 :
1547 0 : if( !pMostRightEntry || pTree->IsChild( pEntry,pMostRightEntry ) )
1548 : {
1549 0 : FindMostRight(0);
1550 : }
1551 :
1552 0 : if( pStartEntry )
1553 : {
1554 0 : long nOldThumbPos = aVerSBar.GetThumbPos();
1555 0 : sal_uLong nVisList = pView->GetVisibleCount();
1556 0 : aVerSBar.SetRange( Range(0, nVisList-1) );
1557 0 : long nNewThumbPos = aVerSBar.GetThumbPos();
1558 0 : if( nNewThumbPos != nOldThumbPos )
1559 : {
1560 0 : pStartEntry = pView->First();
1561 0 : sal_uInt16 nDistance = (sal_uInt16)nNewThumbPos;
1562 0 : if( nDistance )
1563 0 : pStartEntry = pView->NextVisible(pStartEntry, nDistance);
1564 0 : if( GetUpdateMode() )
1565 0 : pView->Invalidate();
1566 : }
1567 : else
1568 0 : SyncVerThumb();
1569 0 : ShowVerSBar();
1570 : }
1571 : // has the cursor been collapsed?
1572 0 : if( pTree->IsChild( pEntry, pCursor ) )
1573 0 : SetCursor( pEntry );
1574 0 : if( GetUpdateMode() )
1575 0 : ShowVerSBar();
1576 0 : ShowCursor( true );
1577 0 : if( GetUpdateMode() && pCursor )
1578 0 : pView->Select( pCursor, true );
1579 : }
1580 :
1581 0 : void SvImpLBox::CollapsingEntry( SvTreeListEntry* pEntry )
1582 : {
1583 0 : if( !pView->IsEntryVisible( pEntry ) || !pStartEntry )
1584 0 : return;
1585 :
1586 0 : SelAllDestrAnch( false, true ); // deselect all
1587 :
1588 : // is the collapsed cursor visible?
1589 0 : long nY = GetEntryLine( pEntry );
1590 0 : if( IsLineVisible(nY) )
1591 : {
1592 0 : if( GetUpdateMode() )
1593 0 : InvalidateEntriesFrom( nY );
1594 : }
1595 : else
1596 : {
1597 0 : if( pTree->IsChild(pEntry, pStartEntry) )
1598 : {
1599 0 : pStartEntry = pEntry;
1600 0 : if( GetUpdateMode() )
1601 0 : pView->Invalidate();
1602 : }
1603 : }
1604 : }
1605 :
1606 :
1607 0 : void SvImpLBox::SetNodeBmpYOffset( const Image& rBmp )
1608 : {
1609 0 : Size aSize;
1610 0 : nYoffsNodeBmp = pView->GetHeightOffset( rBmp, aSize );
1611 0 : nNodeBmpWidth = aSize.Width();
1612 0 : }
1613 :
1614 0 : void SvImpLBox::SetNodeBmpTabDistance()
1615 : {
1616 0 : nNodeBmpTabDistance = -pView->GetIndent();
1617 0 : if( pView->nContextBmpWidthMax )
1618 : {
1619 : // only if the first dynamic tab is centered (we currently assume that)
1620 0 : Size aSize = GetExpandedNodeBmp().GetSizePixel();
1621 0 : nNodeBmpTabDistance -= aSize.Width() / 2;
1622 : }
1623 0 : }
1624 :
1625 :
1626 : // corrects the cursor when using SingleSelection
1627 :
1628 0 : void SvImpLBox::EntrySelected( SvTreeListEntry* pEntry, bool bSelect )
1629 : {
1630 0 : if( nFlags & F_IGNORE_SELECT )
1631 0 : return;
1632 :
1633 0 : nFlags &= (~F_DESEL_ALL);
1634 0 : if( bSelect &&
1635 0 : aSelEng.GetSelectionMode() == SINGLE_SELECTION &&
1636 0 : pEntry != pCursor )
1637 : {
1638 0 : SetCursor( pEntry );
1639 : DBG_ASSERT(pView->GetSelectionCount()==1,"selection count?");
1640 : }
1641 :
1642 0 : if( GetUpdateMode() && pView->IsEntryVisible(pEntry) )
1643 : {
1644 0 : long nY = GetEntryLine( pEntry );
1645 0 : if( IsLineVisible( nY ) )
1646 : {
1647 0 : ShowCursor( false );
1648 0 : pView->PaintEntry1( pEntry, nY, 0xffff ); // because of ItemsetBrowser SV_LBOXTAB_SHOW_SELECTION );
1649 0 : ShowCursor( true );
1650 : }
1651 : }
1652 : }
1653 :
1654 :
1655 0 : void SvImpLBox::RemovingEntry( SvTreeListEntry* pEntry )
1656 : {
1657 0 : CallEventListeners( VCLEVENT_LISTBOX_ITEMREMOVED , pEntry );
1658 :
1659 0 : DestroyAnchor();
1660 :
1661 0 : if( !pView->IsEntryVisible( pEntry ) )
1662 : {
1663 : // if parent is collapsed => bye!
1664 0 : nFlags |= F_REMOVED_ENTRY_INVISIBLE;
1665 0 : return;
1666 : }
1667 :
1668 0 : if( pEntry == pMostRightEntry || (
1669 0 : pEntry->HasChildren() && pView->IsExpanded(pEntry) &&
1670 0 : pTree->IsChild(pEntry, pMostRightEntry)))
1671 : {
1672 0 : nFlags |= F_REMOVED_RECALC_MOST_RIGHT;
1673 : }
1674 :
1675 0 : SvTreeListEntry* pOldStartEntry = pStartEntry;
1676 :
1677 0 : SvTreeListEntry* pParent = pView->GetModel()->GetParent(pEntry);
1678 :
1679 0 : if (pParent && pView->GetModel()->GetChildList(pParent).size() == 1)
1680 : {
1681 : DBG_ASSERT( pView->IsExpanded( pParent ), "Parent not expanded");
1682 0 : pParent->SetFlags( pParent->GetFlags() | SV_ENTRYFLAG_NO_NODEBMP);
1683 0 : InvalidateEntry( pParent );
1684 : }
1685 :
1686 0 : if( pCursor && pTree->IsChild( pEntry, pCursor) )
1687 0 : pCursor = pEntry;
1688 0 : if( pStartEntry && pTree->IsChild(pEntry,pStartEntry) )
1689 0 : pStartEntry = pEntry;
1690 :
1691 : SvTreeListEntry* pTemp;
1692 0 : if( pCursor && pCursor == pEntry )
1693 : {
1694 0 : if( bSimpleTravel )
1695 0 : pView->Select( pCursor, false );
1696 0 : ShowCursor( false ); // focus rectangle gone
1697 : // NextSibling, because we also delete the children of the cursor
1698 0 : pTemp = pView->NextSibling( pCursor );
1699 0 : if( !pTemp )
1700 0 : pTemp = pView->PrevVisible(pCursor);
1701 :
1702 0 : SetCursor( pTemp, true );
1703 : }
1704 0 : if( pStartEntry && pStartEntry == pEntry )
1705 : {
1706 0 : pTemp = pView->NextSibling( pStartEntry );
1707 0 : if( !pTemp )
1708 0 : pTemp = pView->PrevVisible(pStartEntry);
1709 0 : pStartEntry = pTemp;
1710 : }
1711 0 : if( GetUpdateMode())
1712 : {
1713 : // if it is the last one, we have to invalidate it, so the lines are
1714 : // drawn correctly (in this case they're deleted)
1715 0 : if( pStartEntry && (pStartEntry != pOldStartEntry || pEntry == (SvTreeListEntry*)pView->GetModel()->Last()) )
1716 : {
1717 0 : aVerSBar.SetThumbPos( pView->GetVisiblePos( pStartEntry ));
1718 0 : pView->Invalidate( GetVisibleArea() );
1719 : }
1720 : else
1721 0 : InvalidateEntriesFrom( GetEntryLine( pEntry ) );
1722 : }
1723 : }
1724 :
1725 0 : void SvImpLBox::EntryRemoved()
1726 : {
1727 0 : if( nFlags & F_REMOVED_ENTRY_INVISIBLE )
1728 : {
1729 0 : nFlags &= (~F_REMOVED_ENTRY_INVISIBLE);
1730 0 : return;
1731 : }
1732 0 : if( !pStartEntry )
1733 0 : pStartEntry = pTree->First();
1734 0 : if( !pCursor )
1735 0 : SetCursor( pStartEntry, true );
1736 :
1737 0 : if( pCursor && (bSimpleTravel || !pView->GetSelectionCount() ))
1738 0 : pView->Select( pCursor, true );
1739 :
1740 0 : if( GetUpdateMode())
1741 : {
1742 0 : if( nFlags & F_REMOVED_RECALC_MOST_RIGHT )
1743 0 : FindMostRight(0);
1744 0 : aVerSBar.SetRange( Range(0, pView->GetVisibleCount()-1 ) );
1745 0 : FillView();
1746 0 : if( pStartEntry )
1747 : // if something above the thumb was deleted
1748 0 : aVerSBar.SetThumbPos( pView->GetVisiblePos( pStartEntry) );
1749 :
1750 0 : ShowVerSBar();
1751 0 : if( pCursor && pView->HasFocus() && !pView->IsSelected(pCursor) )
1752 : {
1753 0 : if( pView->GetSelectionCount() )
1754 : {
1755 : // is a neighboring entry selected?
1756 0 : SvTreeListEntry* pNextCursor = (SvTreeListEntry*)pView->PrevVisible( pCursor );
1757 0 : if( !pNextCursor || !pView->IsSelected( pNextCursor ))
1758 0 : pNextCursor = (SvTreeListEntry*)pView->NextVisible( pCursor );
1759 0 : if( !pNextCursor || !pView->IsSelected( pNextCursor ))
1760 : // no neighbor selected: use first selected
1761 0 : pNextCursor = pView->FirstSelected();
1762 0 : SetCursor( pNextCursor );
1763 0 : MakeVisible( pCursor );
1764 : }
1765 : else
1766 0 : pView->Select( pCursor, true );
1767 : }
1768 0 : ShowCursor( true );
1769 : }
1770 0 : nFlags &= (~F_REMOVED_RECALC_MOST_RIGHT);
1771 : }
1772 :
1773 :
1774 0 : void SvImpLBox::MovingEntry( SvTreeListEntry* pEntry )
1775 : {
1776 0 : int bDeselAll = nFlags & F_DESEL_ALL;
1777 0 : SelAllDestrAnch( false, true ); // DeselectAll();
1778 0 : if( !bDeselAll )
1779 0 : nFlags &= (~F_DESEL_ALL);
1780 :
1781 0 : if( pEntry == pCursor )
1782 0 : ShowCursor( false );
1783 0 : if( IsEntryInView( pEntry ) )
1784 0 : pView->Invalidate();
1785 0 : if( pEntry == pStartEntry )
1786 : {
1787 0 : SvTreeListEntry* pNew = 0;
1788 0 : if( !pEntry->HasChildren() )
1789 : {
1790 0 : pNew = pView->NextVisible(pStartEntry);
1791 0 : if( !pNew )
1792 0 : pNew = pView->PrevVisible(pStartEntry);
1793 : }
1794 : else
1795 : {
1796 0 : pNew = pTree->NextSibling( pEntry );
1797 0 : if( !pNew )
1798 0 : pNew = pTree->PrevSibling( pEntry );
1799 : }
1800 0 : pStartEntry = pNew;
1801 : }
1802 0 : }
1803 :
1804 0 : void SvImpLBox::EntryMoved( SvTreeListEntry* pEntry )
1805 : {
1806 0 : UpdateContextBmpWidthVectorFromMovedEntry( pEntry );
1807 :
1808 0 : if ( !pStartEntry )
1809 : // this might happen if the only entry in the view is moved to its very same position
1810 : // #i97346#
1811 0 : pStartEntry = pView->First();
1812 :
1813 0 : aVerSBar.SetRange( Range(0, pView->GetVisibleCount()-1));
1814 0 : sal_uInt16 nFirstPos = (sal_uInt16)pTree->GetAbsPos( pStartEntry );
1815 0 : sal_uInt16 nNewPos = (sal_uInt16)pTree->GetAbsPos( pEntry );
1816 0 : FindMostRight(0);
1817 0 : if( nNewPos < nFirstPos ) // HACK!
1818 0 : pStartEntry = pEntry;
1819 0 : SyncVerThumb();
1820 0 : if( pEntry == pCursor )
1821 : {
1822 0 : if( pView->IsEntryVisible( pCursor ) )
1823 0 : ShowCursor( true );
1824 : else
1825 : {
1826 0 : SvTreeListEntry* pParent = pEntry;
1827 0 : do {
1828 0 : pParent = pTree->GetParent( pParent );
1829 : }
1830 0 : while( !pView->IsEntryVisible( pParent ) );
1831 0 : SetCursor( pParent );
1832 : }
1833 : }
1834 0 : if( IsEntryInView( pEntry ) )
1835 0 : pView->Invalidate();
1836 0 : }
1837 :
1838 :
1839 :
1840 0 : void SvImpLBox::EntryInserted( SvTreeListEntry* pEntry )
1841 : {
1842 0 : if( GetUpdateMode() )
1843 : {
1844 0 : SvTreeListEntry* pParent = (SvTreeListEntry*)pTree->GetParent(pEntry);
1845 0 : if (pParent && pTree->GetChildList(pParent).size() == 1)
1846 : // draw plus sign
1847 0 : pTree->InvalidateEntry( pParent );
1848 :
1849 0 : if( !pView->IsEntryVisible( pEntry ) )
1850 0 : return;
1851 0 : int bDeselAll = nFlags & F_DESEL_ALL;
1852 0 : if( bDeselAll )
1853 0 : SelAllDestrAnch( false, true );
1854 : else
1855 0 : DestroyAnchor();
1856 : // nFlags &= (~F_DESEL_ALL);
1857 : // ShowCursor( false ); // if cursor is moved lower
1858 0 : long nY = GetEntryLine( pEntry );
1859 0 : bool bEntryVisible = IsLineVisible( nY );
1860 0 : if( bEntryVisible )
1861 : {
1862 0 : ShowCursor( false ); // if cursor is moved lower
1863 0 : nY -= pView->GetEntryHeight(); // because of lines
1864 0 : InvalidateEntriesFrom( nY );
1865 : }
1866 0 : else if( pStartEntry && nY < GetEntryLine(pStartEntry) )
1867 : {
1868 : // Check if the view is filled completely. If not, then adjust
1869 : // pStartEntry and the Cursor (automatic scrolling).
1870 0 : sal_uInt16 nLast = (sal_uInt16)(pView->GetVisiblePos(pView->LastVisible()));
1871 0 : sal_uInt16 nThumb = (sal_uInt16)(pView->GetVisiblePos( pStartEntry ));
1872 0 : sal_uInt16 nCurDispEntries = nLast-nThumb+1;
1873 0 : if( nCurDispEntries < nVisibleCount )
1874 : {
1875 : // set at the next paint event
1876 0 : pStartEntry = 0;
1877 0 : SetCursor( 0 );
1878 0 : pView->Invalidate();
1879 : }
1880 : }
1881 0 : else if( !pStartEntry )
1882 0 : pView->Invalidate();
1883 :
1884 0 : SetMostRight( pEntry );
1885 0 : aVerSBar.SetRange( Range(0, pView->GetVisibleCount()-1));
1886 0 : SyncVerThumb(); // if something was inserted before the thumb
1887 0 : ShowVerSBar();
1888 0 : ShowCursor( true );
1889 0 : if( pStartEntry != pView->First() && (nFlags & F_FILLING) )
1890 0 : pView->Update();
1891 : }
1892 : }
1893 :
1894 :
1895 :
1896 : // ********************************************************************
1897 : // Event handler
1898 : // ********************************************************************
1899 :
1900 :
1901 : // ****** Control the control animation
1902 :
1903 0 : bool SvImpLBox::ButtonDownCheckCtrl(
1904 : const MouseEvent& rMEvt, SvTreeListEntry* pEntry, long nY)
1905 : {
1906 0 : SvLBoxItem* pItem = pView->GetItem(pEntry,rMEvt.GetPosPixel().X(),&pActiveTab);
1907 0 : if (pItem && pItem->GetType() == SV_ITEM_ID_LBOXBUTTON)
1908 : {
1909 0 : pActiveButton = (SvLBoxButton*)pItem;
1910 0 : pActiveEntry = pEntry;
1911 0 : if( pCursor == pActiveEntry )
1912 0 : pView->HideFocus();
1913 0 : pView->CaptureMouse();
1914 0 : pActiveButton->SetStateHilighted( true );
1915 : pView->PaintEntry1( pActiveEntry, nY,
1916 : SV_LBOXTAB_PUSHABLE | SV_LBOXTAB_ADJUST_CENTER |
1917 0 : SV_LBOXTAB_ADJUST_RIGHT );
1918 0 : return true;
1919 : }
1920 : else
1921 0 : pActiveButton = 0;
1922 0 : return false;
1923 : }
1924 :
1925 0 : bool SvImpLBox::MouseMoveCheckCtrl(const MouseEvent& rMEvt, SvTreeListEntry* pEntry)
1926 : {
1927 0 : if( pActiveButton )
1928 : {
1929 : long nY;
1930 0 : long nMouseX = rMEvt.GetPosPixel().X();
1931 0 : if( pEntry == pActiveEntry &&
1932 0 : pView->GetItem(pActiveEntry, nMouseX) == pActiveButton )
1933 : {
1934 0 : if( !pActiveButton->IsStateHilighted() )
1935 : {
1936 0 : pActiveButton->SetStateHilighted(true );
1937 0 : nY = GetEntryLine( pActiveEntry );
1938 : pView->PaintEntry1( pActiveEntry, nY,
1939 : SV_LBOXTAB_PUSHABLE | SV_LBOXTAB_ADJUST_CENTER |
1940 0 : SV_LBOXTAB_ADJUST_RIGHT );
1941 : }
1942 : }
1943 : else
1944 : {
1945 0 : if( pActiveButton->IsStateHilighted() )
1946 : {
1947 0 : pActiveButton->SetStateHilighted(false );
1948 0 : nY = GetEntryLine( pActiveEntry );
1949 0 : pView->PaintEntry1( pActiveEntry, nY, SV_LBOXTAB_PUSHABLE );
1950 : }
1951 : }
1952 0 : return true;
1953 : }
1954 0 : return false;
1955 : }
1956 :
1957 0 : bool SvImpLBox::ButtonUpCheckCtrl( const MouseEvent& rMEvt )
1958 : {
1959 0 : if( pActiveButton )
1960 : {
1961 0 : pView->ReleaseMouse();
1962 0 : SvTreeListEntry* pEntry = GetClickedEntry( rMEvt.GetPosPixel() );
1963 0 : long nY = GetEntryLine( pActiveEntry );
1964 0 : pActiveButton->SetStateHilighted( false );
1965 0 : long nMouseX = rMEvt.GetPosPixel().X();
1966 0 : if( pEntry == pActiveEntry &&
1967 0 : pView->GetItem( pActiveEntry, nMouseX ) == pActiveButton )
1968 0 : pActiveButton->ClickHdl( pView, pActiveEntry );
1969 : pView->PaintEntry1( pActiveEntry, nY,
1970 : SV_LBOXTAB_PUSHABLE | SV_LBOXTAB_ADJUST_CENTER |
1971 0 : SV_LBOXTAB_ADJUST_RIGHT );
1972 0 : if( pCursor == pActiveEntry )
1973 0 : ShowCursor( true );
1974 0 : pActiveButton = 0;
1975 0 : pActiveEntry = 0;
1976 0 : pActiveTab = 0;
1977 0 : return true;
1978 : }
1979 0 : return false;
1980 : }
1981 :
1982 : // ******* Control plus/minus button for expanding/collapsing
1983 :
1984 : // false == no expand/collapse button hit
1985 0 : bool SvImpLBox::IsNodeButton( const Point& rPosPixel, SvTreeListEntry* pEntry ) const
1986 : {
1987 0 : if( !pEntry->HasChildren() && !pEntry->HasChildrenOnDemand() )
1988 0 : return false;
1989 :
1990 0 : SvLBoxTab* pFirstDynamicTab = pView->GetFirstDynamicTab();
1991 0 : if( !pFirstDynamicTab )
1992 0 : return false;
1993 :
1994 0 : long nMouseX = rPosPixel.X();
1995 : // convert to document coordinates
1996 0 : Point aOrigin( pView->GetMapMode().GetOrigin() );
1997 0 : nMouseX -= aOrigin.X();
1998 :
1999 0 : long nX = pView->GetTabPos( pEntry, pFirstDynamicTab);
2000 0 : nX += nNodeBmpTabDistance;
2001 0 : if( nMouseX < nX )
2002 0 : return false;
2003 0 : nX += nNodeBmpWidth;
2004 0 : if( nMouseX > nX )
2005 0 : return false;
2006 0 : return true;
2007 : }
2008 :
2009 : // false == hit no node button
2010 0 : bool SvImpLBox::ButtonDownCheckExpand( const MouseEvent& rMEvt, SvTreeListEntry* pEntry, long /* nY */ )
2011 : {
2012 0 : bool bRet = false;
2013 :
2014 0 : if ( pView->IsEditingActive() && pEntry == pView->pEdEntry )
2015 : // inplace editing -> nothing to do
2016 0 : bRet = true;
2017 0 : else if ( IsNodeButton( rMEvt.GetPosPixel(), pEntry ) )
2018 : {
2019 0 : if ( pView->IsExpanded( pEntry ) )
2020 : {
2021 0 : pView->EndEditing( true );
2022 0 : pView->Collapse( pEntry );
2023 : }
2024 : else
2025 : {
2026 : // you can expand an entry, which is in editing
2027 0 : pView->Expand( pEntry );
2028 : }
2029 0 : bRet = true;
2030 : }
2031 :
2032 0 : return bRet;
2033 : }
2034 :
2035 0 : void SvImpLBox::MouseButtonDown( const MouseEvent& rMEvt )
2036 : {
2037 0 : if ( !rMEvt.IsLeft() && !rMEvt.IsRight())
2038 0 : return;
2039 :
2040 0 : aEditTimer.Stop();
2041 0 : Point aPos( rMEvt.GetPosPixel());
2042 :
2043 0 : if( aPos.X() > aOutputSize.Width() || aPos.Y() > aOutputSize.Height() )
2044 0 : return;
2045 :
2046 0 : SvTreeListEntry* pEntry = GetEntry( aPos );
2047 0 : if ( pEntry != pCursor )
2048 : // new entry selected -> reset current tab position to first tab
2049 0 : nCurTabPos = FIRST_ENTRY_TAB;
2050 0 : nFlags &= (~F_FILLING);
2051 0 : pView->GrabFocus();
2052 : // the entry can still be invalid!
2053 0 : if( !pEntry || !pView->GetViewData( pEntry ))
2054 0 : return;
2055 :
2056 0 : long nY = GetEntryLine( pEntry );
2057 : // Node-Button?
2058 0 : if( ButtonDownCheckExpand( rMEvt, pEntry, nY ) )
2059 0 : return;
2060 :
2061 0 : if( !EntryReallyHit(pEntry,aPos,nY))
2062 0 : return;
2063 :
2064 0 : SvLBoxItem* pXItem = pView->GetItem( pEntry, aPos.X() );
2065 0 : if( pXItem )
2066 : {
2067 0 : SvLBoxTab* pXTab = pView->GetTab( pEntry, pXItem );
2068 0 : if ( !rMEvt.IsMod1() && !rMEvt.IsMod2() && rMEvt.IsLeft() && pXTab->IsEditable()
2069 0 : && pEntry == pView->FirstSelected() && NULL == pView->NextSelected( pEntry ) )
2070 : // #i8234# FirstSelected() and NextSelected() ensures, that inplace editing is only triggered, when only one entry is selected
2071 0 : nFlags |= F_START_EDITTIMER;
2072 0 : if ( !pView->IsSelected( pEntry ) )
2073 0 : nFlags &= ~F_START_EDITTIMER;
2074 : }
2075 :
2076 :
2077 0 : if( (rMEvt.GetClicks() % 2) == 0 )
2078 : {
2079 0 : nFlags &= (~F_START_EDITTIMER);
2080 0 : pView->pHdlEntry = pEntry;
2081 0 : if( pView->DoubleClickHdl() )
2082 : {
2083 : // if the entry was deleted within the handler
2084 0 : pEntry = GetClickedEntry( aPos );
2085 0 : if( !pEntry )
2086 0 : return;
2087 0 : if( pEntry != pView->pHdlEntry )
2088 : {
2089 : // select anew & bye
2090 0 : if( !bSimpleTravel && !aSelEng.IsAlwaysAdding())
2091 0 : SelAllDestrAnch( false, true ); // DeselectAll();
2092 0 : SetCursor( pEntry );
2093 :
2094 0 : return;
2095 : }
2096 0 : if( pEntry->HasChildren() || pEntry->HasChildrenOnDemand() )
2097 : {
2098 0 : if( pView->IsExpanded(pEntry) )
2099 0 : pView->Collapse( pEntry );
2100 : else
2101 0 : pView->Expand( pEntry );
2102 0 : if( pEntry == pCursor ) // only if Entryitem was clicked
2103 : // (Nodebutton is not an Entryitem!)
2104 0 : pView->Select( pCursor, true );
2105 0 : return;
2106 : }
2107 : }
2108 : }
2109 : else
2110 : {
2111 : // CheckButton? (TreeListBox: Check + Info)
2112 0 : if( ButtonDownCheckCtrl(rMEvt, pEntry, nY) == true)
2113 0 : return;
2114 : // Inplace-Editing?
2115 : }
2116 0 : if ( aSelEng.GetSelectionMode() != NO_SELECTION )
2117 0 : aSelEng.SelMouseButtonDown( rMEvt );
2118 : }
2119 :
2120 0 : void SvImpLBox::MouseButtonUp( const MouseEvent& rMEvt)
2121 : {
2122 0 : if ( !ButtonUpCheckCtrl( rMEvt ) && ( aSelEng.GetSelectionMode() != NO_SELECTION ) )
2123 0 : aSelEng.SelMouseButtonUp( rMEvt );
2124 0 : EndScroll();
2125 0 : if( nFlags & F_START_EDITTIMER )
2126 : {
2127 0 : nFlags &= (~F_START_EDITTIMER);
2128 0 : aEditClickPos = rMEvt.GetPosPixel();
2129 0 : aEditTimer.Start();
2130 : }
2131 :
2132 0 : return;
2133 : }
2134 :
2135 0 : void SvImpLBox::MouseMove( const MouseEvent& rMEvt)
2136 : {
2137 0 : SvTreeListEntry* pEntry = GetClickedEntry( rMEvt.GetPosPixel() );
2138 0 : if ( !MouseMoveCheckCtrl( rMEvt, pEntry ) && ( aSelEng.GetSelectionMode() != NO_SELECTION ) )
2139 0 : aSelEng.SelMouseMove( rMEvt );
2140 0 : return;
2141 : }
2142 :
2143 0 : bool SvImpLBox::KeyInput( const KeyEvent& rKEvt)
2144 : {
2145 0 : aEditTimer.Stop();
2146 0 : const KeyCode& rKeyCode = rKEvt.GetKeyCode();
2147 :
2148 0 : if( rKeyCode.IsMod2() )
2149 0 : return false; // don't evaluate Alt key
2150 :
2151 0 : nFlags &= (~F_FILLING);
2152 :
2153 0 : if( !pCursor )
2154 0 : pCursor = pStartEntry;
2155 0 : if( !pCursor )
2156 0 : return false;
2157 :
2158 0 : bool bKeyUsed = true;
2159 :
2160 0 : sal_uInt16 nDelta = (sal_uInt16)aVerSBar.GetPageSize();
2161 0 : sal_uInt16 aCode = rKeyCode.GetCode();
2162 :
2163 0 : bool bShift = rKeyCode.IsShift();
2164 0 : bool bMod1 = rKeyCode.IsMod1();
2165 :
2166 : SvTreeListEntry* pNewCursor;
2167 :
2168 0 : const WinBits nWindowStyle = pView->GetStyle();
2169 0 : switch( aCode )
2170 : {
2171 : case KEY_UP:
2172 0 : if( !IsEntryInView( pCursor ) )
2173 0 : MakeVisible( pCursor );
2174 :
2175 0 : pNewCursor = pCursor;
2176 0 : do
2177 : {
2178 0 : pNewCursor = pView->PrevVisible(pNewCursor);
2179 0 : } while( pNewCursor && !IsSelectable(pNewCursor) );
2180 :
2181 0 : if ( pNewCursor )
2182 : // new entry selected -> reset current tab position to first tab
2183 0 : nCurTabPos = FIRST_ENTRY_TAB;
2184 : // if there is no next entry, take the current one
2185 : // this ensures that in case of _one_ entry in the list, this entry is selected when pressing
2186 : // the cursor key
2187 0 : if ( !pNewCursor && pCursor )
2188 0 : pNewCursor = pCursor;
2189 :
2190 0 : if( pNewCursor )
2191 : {
2192 0 : aSelEng.CursorPosChanging( bShift, bMod1 );
2193 0 : SetCursor( pNewCursor, bMod1 ); // no selection, when Ctrl is on
2194 0 : if( !IsEntryInView( pNewCursor ) )
2195 0 : KeyUp( false );
2196 : }
2197 0 : break;
2198 :
2199 : case KEY_DOWN:
2200 0 : if( !IsEntryInView( pCursor ) )
2201 0 : MakeVisible( pCursor );
2202 :
2203 0 : pNewCursor = pCursor;
2204 0 : do
2205 : {
2206 0 : pNewCursor = pView->NextVisible(pNewCursor);
2207 0 : } while( pNewCursor && !IsSelectable(pNewCursor) );
2208 :
2209 0 : if ( pNewCursor )
2210 : // new entry selected -> reset current tab position to first tab
2211 0 : nCurTabPos = FIRST_ENTRY_TAB;
2212 :
2213 : // if there is no next entry, take the current one
2214 : // this ensures that in case of _one_ entry in the list, this entry is selected when pressing
2215 : // the cursor key
2216 : // 06.09.20001 - 83416 - frank.schoenheit@sun.com
2217 0 : if ( !pNewCursor && pCursor )
2218 0 : pNewCursor = pCursor;
2219 :
2220 0 : if( pNewCursor )
2221 : {
2222 0 : aSelEng.CursorPosChanging( bShift, bMod1 );
2223 0 : if( IsEntryInView( pNewCursor ) )
2224 0 : SetCursor( pNewCursor, bMod1 ); // no selection, when Ctrl is on
2225 : else
2226 : {
2227 0 : if( pCursor )
2228 0 : pView->Select( pCursor, false );
2229 0 : KeyDown( false );
2230 0 : SetCursor( pNewCursor, bMod1 ); // no selection, when Ctrl is on
2231 : }
2232 : }
2233 : else
2234 0 : KeyDown( false ); // because scrollbar range might still
2235 : // allow scrolling
2236 0 : break;
2237 :
2238 : case KEY_RIGHT:
2239 : {
2240 0 : if( bSubLstOpLR && IsNowExpandable() )
2241 0 : pView->Expand( pCursor );
2242 0 : else if ( bIsCellFocusEnabled && pCursor )
2243 : {
2244 0 : if ( nCurTabPos < ( pView->TabCount() - 1 /*!2*/ ) )
2245 : {
2246 0 : ++nCurTabPos;
2247 0 : ShowCursor( true );
2248 0 : CallEventListeners( VCLEVENT_LISTBOX_SELECT, pCursor );
2249 : }
2250 : }
2251 0 : else if( nWindowStyle & WB_HSCROLL )
2252 : {
2253 0 : long nThumb = aHorSBar.GetThumbPos();
2254 0 : nThumb += aHorSBar.GetLineSize();
2255 0 : long nOldThumb = aHorSBar.GetThumbPos();
2256 0 : aHorSBar.SetThumbPos( nThumb );
2257 0 : nThumb = nOldThumb;
2258 0 : nThumb -= aHorSBar.GetThumbPos();
2259 0 : nThumb *= -1;
2260 0 : if( nThumb )
2261 : {
2262 0 : KeyLeftRight( nThumb );
2263 0 : EndScroll();
2264 : }
2265 : }
2266 : else
2267 0 : bKeyUsed = false;
2268 0 : break;
2269 : }
2270 :
2271 : case KEY_LEFT:
2272 : {
2273 0 : if ( bIsCellFocusEnabled && pCursor )
2274 : {
2275 0 : if ( nCurTabPos > FIRST_ENTRY_TAB )
2276 : {
2277 0 : --nCurTabPos;
2278 0 : ShowCursor( true );
2279 0 : CallEventListeners( VCLEVENT_LISTBOX_SELECT, pCursor );
2280 : }
2281 : }
2282 0 : else if ( nWindowStyle & WB_HSCROLL )
2283 : {
2284 0 : long nThumb = aHorSBar.GetThumbPos();
2285 0 : nThumb -= aHorSBar.GetLineSize();
2286 0 : long nOldThumb = aHorSBar.GetThumbPos();
2287 0 : aHorSBar.SetThumbPos( nThumb );
2288 0 : nThumb = nOldThumb;
2289 0 : nThumb -= aHorSBar.GetThumbPos();
2290 0 : if( nThumb )
2291 : {
2292 0 : KeyLeftRight( -nThumb );
2293 0 : EndScroll();
2294 : }
2295 0 : else if( bSubLstOpLR )
2296 : {
2297 0 : if( IsExpandable() && pView->IsExpanded( pCursor ) )
2298 0 : pView->Collapse( pCursor );
2299 : else
2300 : {
2301 0 : pNewCursor = pView->GetParent( pCursor );
2302 0 : if( pNewCursor )
2303 0 : SetCursor( pNewCursor );
2304 : }
2305 : }
2306 : }
2307 0 : else if( bSubLstOpLR && IsExpandable() )
2308 0 : pView->Collapse( pCursor );
2309 : else
2310 0 : bKeyUsed = false;
2311 0 : break;
2312 : }
2313 :
2314 : case KEY_PAGEUP:
2315 0 : if( !bMod1 )
2316 : {
2317 0 : pNewCursor = pView->PrevVisible(pCursor, nDelta);
2318 :
2319 0 : while( nDelta && pNewCursor && !IsSelectable(pNewCursor) )
2320 : {
2321 0 : pNewCursor = pView->NextVisible(pNewCursor);
2322 0 : nDelta--;
2323 : }
2324 :
2325 0 : if( nDelta )
2326 : {
2327 : DBG_ASSERT(pNewCursor&&(sal_uLong)pNewCursor!=(sal_uLong)pCursor,"Cursor?");
2328 0 : aSelEng.CursorPosChanging( bShift, bMod1 );
2329 0 : if( IsEntryInView( pNewCursor ) )
2330 0 : SetCursor( pNewCursor );
2331 : else
2332 : {
2333 0 : SetCursor( pNewCursor );
2334 0 : KeyUp( true );
2335 : }
2336 : }
2337 : }
2338 : else
2339 0 : bKeyUsed = false;
2340 0 : break;
2341 :
2342 : case KEY_PAGEDOWN:
2343 0 : if( !bMod1 )
2344 : {
2345 0 : pNewCursor= pView->NextVisible(pCursor, nDelta);
2346 :
2347 0 : while( nDelta && pNewCursor && !IsSelectable(pNewCursor) )
2348 : {
2349 0 : pNewCursor = pView->PrevVisible(pNewCursor);
2350 0 : nDelta--;
2351 : }
2352 :
2353 0 : if( nDelta && pNewCursor )
2354 : {
2355 : DBG_ASSERT(pNewCursor&&(sal_uLong)pNewCursor!=(sal_uLong)pCursor,"Cursor?");
2356 0 : aSelEng.CursorPosChanging( bShift, bMod1 );
2357 0 : if( IsEntryInView( pNewCursor ) )
2358 0 : SetCursor( pNewCursor );
2359 : else
2360 : {
2361 0 : SetCursor( pNewCursor );
2362 0 : KeyDown( true );
2363 : }
2364 : }
2365 : else
2366 0 : KeyDown( false ); // see also: KEY_DOWN
2367 : }
2368 : else
2369 0 : bKeyUsed = false;
2370 0 : break;
2371 :
2372 : case KEY_SPACE:
2373 0 : if ( pView->GetSelectionMode() != NO_SELECTION )
2374 : {
2375 0 : if ( bMod1 )
2376 : {
2377 0 : if ( pView->GetSelectionMode() == MULTIPLE_SELECTION && !bShift )
2378 : // toggle selection
2379 0 : pView->Select( pCursor, !pView->IsSelected( pCursor ) );
2380 : }
2381 0 : else if ( !bShift /*&& !bMod1*/ )
2382 : {
2383 0 : if ( aSelEng.IsAddMode() )
2384 : {
2385 : // toggle selection
2386 0 : pView->Select( pCursor, !pView->IsSelected( pCursor ) );
2387 : }
2388 0 : else if ( !pView->IsSelected( pCursor ) )
2389 : {
2390 0 : SelAllDestrAnch( false );
2391 0 : pView->Select( pCursor, true );
2392 : }
2393 : else
2394 0 : bKeyUsed = false;
2395 : }
2396 : else
2397 0 : bKeyUsed = false;
2398 : }
2399 : else
2400 0 : bKeyUsed = false;
2401 0 : break;
2402 :
2403 : case KEY_RETURN:
2404 0 : if( bSubLstOpRet && IsExpandable() )
2405 : {
2406 0 : if( pView->IsExpanded( pCursor ) )
2407 0 : pView->Collapse( pCursor );
2408 : else
2409 0 : pView->Expand( pCursor );
2410 : }
2411 : else
2412 0 : bKeyUsed = false;
2413 0 : break;
2414 :
2415 : case KEY_F2:
2416 0 : if( !bShift && !bMod1 )
2417 : {
2418 0 : aEditClickPos = Point( -1, -1 );
2419 0 : EditTimerCall( 0 );
2420 : }
2421 : else
2422 0 : bKeyUsed = false;
2423 0 : break;
2424 :
2425 : case KEY_F8:
2426 0 : if( bShift && pView->GetSelectionMode()==MULTIPLE_SELECTION &&
2427 0 : !(m_nStyle & WB_SIMPLEMODE))
2428 : {
2429 0 : if( aSelEng.IsAlwaysAdding() )
2430 0 : aSelEng.AddAlways( false );
2431 : else
2432 0 : aSelEng.AddAlways( true );
2433 : }
2434 : else
2435 0 : bKeyUsed = false;
2436 0 : break;
2437 :
2438 : case KEY_ADD:
2439 0 : if( pCursor )
2440 : {
2441 0 : if( !pView->IsExpanded(pCursor))
2442 0 : pView->Expand( pCursor );
2443 0 : if( bMod1 )
2444 : {
2445 0 : sal_uInt16 nRefDepth = pTree->GetDepth( pCursor );
2446 0 : SvTreeListEntry* pCur = pTree->Next( pCursor );
2447 0 : while( pCur && pTree->GetDepth(pCur) > nRefDepth )
2448 : {
2449 0 : if( pCur->HasChildren() && !pView->IsExpanded(pCur))
2450 0 : pView->Expand( pCur );
2451 0 : pCur = pTree->Next( pCur );
2452 : }
2453 : }
2454 : }
2455 : else
2456 0 : bKeyUsed = false;
2457 0 : break;
2458 :
2459 : case KEY_A:
2460 0 : if( bMod1 )
2461 0 : SelAllDestrAnch( true );
2462 : else
2463 0 : bKeyUsed = false;
2464 0 : break;
2465 :
2466 : case KEY_SUBTRACT:
2467 0 : if( pCursor )
2468 : {
2469 0 : if( pView->IsExpanded(pCursor))
2470 0 : pView->Collapse( pCursor );
2471 0 : if( bMod1 )
2472 : {
2473 : // collapse all parents until we get to the root
2474 0 : SvTreeListEntry* pParentToCollapse = (SvTreeListEntry*)pTree->GetRootLevelParent(pCursor);
2475 0 : if( pParentToCollapse )
2476 : {
2477 : sal_uInt16 nRefDepth;
2478 : // special case explorer: if the root only has a single
2479 : // entry, don't collapse the root entry
2480 0 : if (pTree->GetChildList(0).size() < 2)
2481 : {
2482 0 : nRefDepth = 1;
2483 0 : pParentToCollapse = pCursor;
2484 0 : while( pTree->GetParent(pParentToCollapse) &&
2485 0 : pTree->GetDepth( pTree->GetParent(pParentToCollapse)) > 0)
2486 : {
2487 0 : pParentToCollapse = pTree->GetParent(pParentToCollapse);
2488 : }
2489 : }
2490 : else
2491 0 : nRefDepth = 0;
2492 :
2493 0 : if( pView->IsExpanded(pParentToCollapse) )
2494 0 : pView->Collapse( pParentToCollapse );
2495 0 : SvTreeListEntry* pCur = pTree->Next( pParentToCollapse );
2496 0 : while( pCur && pTree->GetDepth(pCur) > nRefDepth )
2497 : {
2498 0 : if( pCur->HasChildren() && pView->IsExpanded(pCur) )
2499 0 : pView->Collapse( pCur );
2500 0 : pCur = pTree->Next( pCur );
2501 : }
2502 : }
2503 : }
2504 : }
2505 : else
2506 0 : bKeyUsed = false;
2507 0 : break;
2508 :
2509 : case KEY_DIVIDE :
2510 0 : if( bMod1 )
2511 0 : SelAllDestrAnch( true );
2512 : else
2513 0 : bKeyUsed = false;
2514 0 : break;
2515 :
2516 : case KEY_COMMA :
2517 0 : if( bMod1 )
2518 0 : SelAllDestrAnch( false );
2519 : else
2520 0 : bKeyUsed = false;
2521 0 : break;
2522 :
2523 : case KEY_HOME :
2524 0 : pNewCursor = pView->GetModel()->First();
2525 :
2526 0 : while( pNewCursor && !IsSelectable(pNewCursor) )
2527 : {
2528 0 : pNewCursor = pView->NextVisible(pNewCursor);
2529 : }
2530 :
2531 0 : if( pNewCursor && pNewCursor != pCursor )
2532 : {
2533 : // SelAllDestrAnch( false );
2534 0 : aSelEng.CursorPosChanging( bShift, bMod1 );
2535 0 : SetCursor( pNewCursor );
2536 0 : if( !IsEntryInView( pNewCursor ) )
2537 0 : MakeVisible( pNewCursor );
2538 : }
2539 : else
2540 0 : bKeyUsed = false;
2541 0 : break;
2542 :
2543 : case KEY_END :
2544 0 : pNewCursor = pView->GetModel()->Last();
2545 :
2546 0 : while( pNewCursor && !IsSelectable(pNewCursor) )
2547 : {
2548 0 : pNewCursor = pView->PrevVisible(pNewCursor);
2549 : }
2550 :
2551 0 : if( pNewCursor && pNewCursor != pCursor)
2552 : {
2553 : // SelAllDestrAnch( false );
2554 0 : aSelEng.CursorPosChanging( bShift, bMod1 );
2555 0 : SetCursor( pNewCursor );
2556 0 : if( !IsEntryInView( pNewCursor ) )
2557 0 : MakeVisible( pNewCursor );
2558 : }
2559 : else
2560 0 : bKeyUsed = false;
2561 0 : break;
2562 :
2563 : case KEY_ESCAPE:
2564 : case KEY_TAB:
2565 : case KEY_DELETE:
2566 : case KEY_BACKSPACE:
2567 : // must not be handled because this quits dialogs and does other magic things...
2568 : // if there are other single keys which should not be handled, they can be added here
2569 0 : bKeyUsed = false;
2570 0 : break;
2571 :
2572 : default:
2573 : // is there any reason why we should eat the events here? The only place where this is called
2574 : // is from SvTreeListBox::KeyInput. If we set bKeyUsed to true here, then the key input
2575 : // is just silenced. However, we want SvLBox::KeyInput to get a chance, to do the QuickSelection
2576 : // handling.
2577 : // (The old code here which intentionally set bKeyUsed to sal_True said this was because of "quick search"
2578 : // handling, but actually there was no quick search handling anymore. We just re-implemented it.)
2579 : // #i31275# / 2009-06-16 / frank.schoenheit@sun.com
2580 0 : bKeyUsed = false;
2581 0 : break;
2582 : }
2583 0 : return bKeyUsed;
2584 : }
2585 :
2586 0 : void SvImpLBox::GetFocus()
2587 : {
2588 0 : if( pCursor )
2589 : {
2590 0 : pView->SetEntryFocus( pCursor, true );
2591 0 : ShowCursor( true );
2592 : // auskommentiert wg. deselectall
2593 : // if( bSimpleTravel && !pView->IsSelected(pCursor) )
2594 : // pView->Select( pCursor, true );
2595 : }
2596 0 : if( m_nStyle & WB_HIDESELECTION )
2597 : {
2598 0 : SvTreeListEntry* pEntry = pView->FirstSelected();
2599 0 : while( pEntry )
2600 : {
2601 0 : InvalidateEntry( pEntry );
2602 0 : pEntry = pView->NextSelected( pEntry );
2603 : }
2604 : }
2605 0 : }
2606 :
2607 0 : void SvImpLBox::LoseFocus()
2608 : {
2609 0 : aEditTimer.Stop();
2610 0 : if( pCursor )
2611 0 : pView->SetEntryFocus( pCursor,false );
2612 0 : ShowCursor( false );
2613 :
2614 0 : if( m_nStyle & WB_HIDESELECTION )
2615 : {
2616 0 : SvTreeListEntry* pEntry = pView->FirstSelected();
2617 0 : while( pEntry )
2618 : {
2619 0 : InvalidateEntry( pEntry );
2620 0 : pEntry = pView->NextSelected( pEntry );
2621 : }
2622 : }
2623 0 : }
2624 :
2625 :
2626 : // ********************************************************************
2627 : // SelectionEngine
2628 : // ********************************************************************
2629 :
2630 0 : void SvImpLBox::SelectEntry( SvTreeListEntry* pEntry, bool bSelect )
2631 : {
2632 0 : pView->Select( pEntry, bSelect );
2633 0 : }
2634 :
2635 0 : ImpLBSelEng::ImpLBSelEng( SvImpLBox* pImpl, SelectionEngine* pSEng,
2636 0 : SvTreeListBox* pV )
2637 : {
2638 0 : pImp = pImpl;
2639 0 : pSelEng = pSEng;
2640 0 : pView = pV;
2641 0 : }
2642 :
2643 0 : ImpLBSelEng::~ImpLBSelEng()
2644 : {
2645 0 : }
2646 :
2647 0 : void ImpLBSelEng::BeginDrag()
2648 : {
2649 0 : pImp->BeginDrag();
2650 0 : }
2651 :
2652 0 : void ImpLBSelEng::CreateAnchor()
2653 : {
2654 0 : pImp->pAnchor = pImp->pCursor;
2655 0 : }
2656 :
2657 0 : void ImpLBSelEng::DestroyAnchor()
2658 : {
2659 0 : pImp->pAnchor = 0;
2660 0 : }
2661 :
2662 0 : bool ImpLBSelEng::SetCursorAtPoint(const Point& rPoint, bool bDontSelectAtCursor)
2663 : {
2664 0 : SvTreeListEntry* pNewCursor = pImp->MakePointVisible( rPoint );
2665 0 : if( pNewCursor != pImp->pCursor )
2666 0 : pImp->BeginScroll();
2667 :
2668 0 : if( pNewCursor )
2669 : {
2670 : // at SimpleTravel, the SetCursor is selected and the select handler is
2671 : // called
2672 : //if( !bDontSelectAtCursor && !pImp->bSimpleTravel )
2673 : // pImp->SelectEntry( pNewCursor, true );
2674 0 : pImp->SetCursor( pNewCursor, bDontSelectAtCursor );
2675 0 : return true;
2676 : }
2677 0 : return false;
2678 : }
2679 :
2680 0 : bool ImpLBSelEng::IsSelectionAtPoint( const Point& rPoint )
2681 : {
2682 0 : SvTreeListEntry* pEntry = pImp->MakePointVisible( rPoint );
2683 0 : if( pEntry )
2684 0 : return pView->IsSelected(pEntry);
2685 0 : return false;
2686 : }
2687 :
2688 0 : void ImpLBSelEng::DeselectAtPoint( const Point& rPoint )
2689 : {
2690 0 : SvTreeListEntry* pEntry = pImp->MakePointVisible( rPoint );
2691 0 : if( !pEntry )
2692 0 : return;
2693 0 : pImp->SelectEntry( pEntry, false );
2694 : }
2695 :
2696 0 : void ImpLBSelEng::DeselectAll()
2697 : {
2698 0 : pImp->SelAllDestrAnch( false, false ); // don't reset SelectionEngine!
2699 0 : pImp->nFlags &= (~F_DESEL_ALL);
2700 0 : }
2701 :
2702 : // ***********************************************************************
2703 : // Selection
2704 : // ***********************************************************************
2705 :
2706 0 : void SvImpLBox::SetAnchorSelection(SvTreeListEntry* pOldCursor,SvTreeListEntry* pNewCursor)
2707 : {
2708 : SvTreeListEntry* pEntry;
2709 0 : sal_uLong nAnchorVisPos = pView->GetVisiblePos( pAnchor );
2710 0 : sal_uLong nOldVisPos = pView->GetVisiblePos( pOldCursor );
2711 0 : sal_uLong nNewVisPos = pView->GetVisiblePos( pNewCursor );
2712 :
2713 0 : if( nOldVisPos > nAnchorVisPos ||
2714 0 : ( nAnchorVisPos==nOldVisPos && nNewVisPos > nAnchorVisPos) )
2715 : {
2716 0 : if( nNewVisPos > nOldVisPos )
2717 : {
2718 0 : pEntry = pOldCursor;
2719 0 : while( pEntry && pEntry != pNewCursor )
2720 : {
2721 0 : pView->Select( pEntry, true );
2722 0 : pEntry = pView->NextVisible(pEntry);
2723 : }
2724 0 : if( pEntry )
2725 0 : pView->Select( pEntry, true );
2726 0 : return;
2727 : }
2728 :
2729 0 : if( nNewVisPos < nAnchorVisPos )
2730 : {
2731 0 : pEntry = pAnchor;
2732 0 : while( pEntry && pEntry != pOldCursor )
2733 : {
2734 0 : pView->Select( pEntry, false );
2735 0 : pEntry = pView->NextVisible(pEntry);
2736 : }
2737 0 : if( pEntry )
2738 0 : pView->Select( pEntry, false );
2739 :
2740 0 : pEntry = pNewCursor;
2741 0 : while( pEntry && pEntry != pAnchor )
2742 : {
2743 0 : pView->Select( pEntry, true );
2744 0 : pEntry = pView->NextVisible(pEntry);
2745 : }
2746 0 : if( pEntry )
2747 0 : pView->Select( pEntry, true );
2748 0 : return;
2749 : }
2750 :
2751 0 : if( nNewVisPos < nOldVisPos )
2752 : {
2753 0 : pEntry = pNewCursor;
2754 0 : pEntry = pView->NextVisible(pEntry);
2755 0 : while( pEntry && pEntry != pOldCursor )
2756 : {
2757 0 : pView->Select( pEntry, false );
2758 0 : pEntry = pView->NextVisible(pEntry);
2759 : }
2760 0 : if( pEntry )
2761 0 : pView->Select( pEntry, false );
2762 0 : return;
2763 : }
2764 : }
2765 : else
2766 : {
2767 0 : if( nNewVisPos < nOldVisPos ) // enlarge selection
2768 : {
2769 0 : pEntry = pNewCursor;
2770 0 : while( pEntry && pEntry != pOldCursor )
2771 : {
2772 0 : pView->Select( pEntry, true );
2773 0 : pEntry = pView->NextVisible(pEntry);
2774 : }
2775 0 : if( pEntry )
2776 0 : pView->Select( pEntry, true );
2777 0 : return;
2778 : }
2779 :
2780 0 : if( nNewVisPos > nAnchorVisPos )
2781 : {
2782 0 : pEntry = pOldCursor;
2783 0 : while( pEntry && pEntry != pAnchor )
2784 : {
2785 0 : pView->Select( pEntry, false );
2786 0 : pEntry = pView->NextVisible(pEntry);
2787 : }
2788 0 : if( pEntry )
2789 0 : pView->Select( pEntry, false );
2790 0 : pEntry = pAnchor;
2791 0 : while( pEntry && pEntry != pNewCursor )
2792 : {
2793 0 : pView->Select( pEntry, true );
2794 0 : pEntry = pView->NextVisible(pEntry);
2795 : }
2796 0 : if( pEntry )
2797 0 : pView->Select( pEntry, true );
2798 0 : return;
2799 : }
2800 :
2801 0 : if( nNewVisPos > nOldVisPos )
2802 : {
2803 0 : pEntry = pOldCursor;
2804 0 : while( pEntry && pEntry != pNewCursor )
2805 : {
2806 0 : pView->Select( pEntry, false );
2807 0 : pEntry = pView->NextVisible(pEntry);
2808 : }
2809 0 : return;
2810 : }
2811 : }
2812 : }
2813 :
2814 0 : void SvImpLBox::SelAllDestrAnch(
2815 : bool bSelect, bool bDestroyAnchor, bool bSingleSelToo )
2816 : {
2817 : SvTreeListEntry* pEntry;
2818 0 : nFlags &= (~F_DESEL_ALL);
2819 0 : if( bSelect && bSimpleTravel )
2820 : {
2821 0 : if( pCursor && !pView->IsSelected( pCursor ))
2822 : {
2823 0 : pView->Select( pCursor, true );
2824 : }
2825 0 : return;
2826 : }
2827 0 : if( !bSelect && pView->GetSelectionCount() == 0 )
2828 : {
2829 0 : if( bSimpleTravel && ( !GetUpdateMode() || !pCursor) )
2830 0 : nFlags |= F_DESEL_ALL;
2831 0 : return;
2832 : }
2833 0 : if( bSelect && pView->GetSelectionCount() == pView->GetEntryCount())
2834 0 : return;
2835 0 : if( !bSingleSelToo && bSimpleTravel )
2836 0 : return;
2837 :
2838 0 : if( !bSelect && pView->GetSelectionCount()==1 && pCursor &&
2839 0 : pView->IsSelected( pCursor ))
2840 : {
2841 0 : pView->Select( pCursor, false );
2842 0 : if( bDestroyAnchor )
2843 0 : DestroyAnchor(); // delete anchor & reset SelectionEngine
2844 : else
2845 0 : pAnchor = 0; // always delete internal anchor
2846 0 : return;
2847 : }
2848 :
2849 0 : if( bSimpleTravel && !pCursor && !GetUpdateMode() )
2850 0 : nFlags |= F_DESEL_ALL;
2851 :
2852 0 : ShowCursor( false );
2853 0 : bool bUpdate = GetUpdateMode();
2854 :
2855 0 : nFlags |= F_IGNORE_SELECT; // EntryInserted should not do anything
2856 0 : pEntry = pTree->First();
2857 0 : while( pEntry )
2858 : {
2859 0 : if( pView->Select( pEntry, bSelect ) )
2860 : {
2861 0 : if( bUpdate && pView->IsEntryVisible(pEntry) )
2862 : {
2863 0 : long nY = GetEntryLine( pEntry );
2864 0 : if( IsLineVisible( nY ) )
2865 0 : pView->PaintEntry1( pEntry, nY, 0xffff ); // because of ItemsetBrowser SV_LBOXTAB_SHOW_SELECTION );
2866 : }
2867 : }
2868 0 : pEntry = pTree->Next( pEntry );
2869 : }
2870 0 : nFlags &= ~F_IGNORE_SELECT;
2871 :
2872 0 : if( bDestroyAnchor )
2873 0 : DestroyAnchor(); // delete anchor & reset SelectionEngine
2874 : else
2875 0 : pAnchor = 0; // always delete internal anchor
2876 0 : ShowCursor( true );
2877 : }
2878 :
2879 0 : void SvImpLBox::SetSelectionMode( SelectionMode eSelMode )
2880 : {
2881 0 : aSelEng.SetSelectionMode( eSelMode);
2882 0 : if( eSelMode == SINGLE_SELECTION )
2883 0 : bSimpleTravel = true;
2884 : else
2885 0 : bSimpleTravel = false;
2886 0 : if( (m_nStyle & WB_SIMPLEMODE) && (eSelMode == MULTIPLE_SELECTION) )
2887 0 : aSelEng.AddAlways( true );
2888 0 : }
2889 :
2890 : // ***********************************************************************
2891 : // Drag & Drop
2892 : // ***********************************************************************
2893 :
2894 0 : void SvImpLBox::SetDragDropMode( DragDropMode eDDMode )
2895 : {
2896 0 : if( eDDMode && eDDMode != SV_DRAGDROP_APP_DROP )
2897 : {
2898 0 : aSelEng.ExpandSelectionOnMouseMove( false );
2899 0 : aSelEng.EnableDrag( true );
2900 : }
2901 : else
2902 : {
2903 0 : aSelEng.ExpandSelectionOnMouseMove( true );
2904 0 : aSelEng.EnableDrag( false );
2905 : }
2906 0 : }
2907 :
2908 0 : void SvImpLBox::BeginDrag()
2909 : {
2910 0 : nFlags &= (~F_FILLING);
2911 0 : if( !bAsyncBeginDrag )
2912 : {
2913 0 : BeginScroll();
2914 0 : pView->StartDrag( 0, aSelEng.GetMousePosPixel() );
2915 0 : EndScroll();
2916 : }
2917 : else
2918 : {
2919 0 : aAsyncBeginDragPos = aSelEng.GetMousePosPixel();
2920 0 : aAsyncBeginDragTimer.Start();
2921 : }
2922 0 : }
2923 :
2924 0 : IMPL_LINK_NOARG(SvImpLBox, BeginDragHdl)
2925 : {
2926 0 : pView->StartDrag( 0, aAsyncBeginDragPos );
2927 0 : return 0;
2928 : }
2929 :
2930 0 : void SvImpLBox::PaintDDCursor( SvTreeListEntry* pInsertionPos )
2931 : {
2932 : long nY;
2933 0 : if( pInsertionPos )
2934 : {
2935 0 : nY = GetEntryLine( pInsertionPos );
2936 0 : nY += pView->GetEntryHeight();
2937 : }
2938 : else
2939 0 : nY = 1;
2940 0 : RasterOp eOldOp = pView->GetRasterOp();
2941 0 : pView->SetRasterOp( ROP_INVERT );
2942 0 : Color aOldLineColor = pView->GetLineColor();
2943 0 : pView->SetLineColor( Color( COL_BLACK ) );
2944 0 : pView->DrawLine( Point( 0, nY ), Point( aOutputSize.Width(), nY ) );
2945 0 : pView->SetLineColor( aOldLineColor );
2946 0 : pView->SetRasterOp( eOldOp );
2947 0 : }
2948 :
2949 : // Delete all submenus of a PopupMenu, recursively
2950 0 : static void lcl_DeleteSubPopups(PopupMenu* pPopup)
2951 : {
2952 0 : for(sal_uInt16 i = 0; i < pPopup->GetItemCount(); i++)
2953 : {
2954 0 : PopupMenu* pSubPopup = pPopup->GetPopupMenu( pPopup->GetItemId( i ));
2955 0 : if(pSubPopup)
2956 : {
2957 0 : lcl_DeleteSubPopups(pSubPopup);
2958 0 : delete pSubPopup;
2959 : }
2960 : }
2961 0 : }
2962 :
2963 0 : void SvImpLBox::Command( const CommandEvent& rCEvt )
2964 : {
2965 0 : sal_uInt16 nCommand = rCEvt.GetCommand();
2966 :
2967 0 : if( nCommand == COMMAND_CONTEXTMENU )
2968 0 : aEditTimer.Stop();
2969 :
2970 : // scroll mouse event?
2971 0 : if( ( ( nCommand == COMMAND_WHEEL ) || ( nCommand == COMMAND_STARTAUTOSCROLL ) || ( nCommand == COMMAND_AUTOSCROLL ) )
2972 0 : && pView->HandleScrollCommand( rCEvt, &aHorSBar, &aVerSBar ) )
2973 0 : return;
2974 :
2975 0 : if( bContextMenuHandling && nCommand == COMMAND_CONTEXTMENU )
2976 : {
2977 0 : Point aPopupPos;
2978 0 : bool bClickedIsFreePlace = false;
2979 0 : std::stack<SvTreeListEntry*> aSelRestore;
2980 :
2981 0 : if( rCEvt.IsMouseEvent() )
2982 : { // change selection, if mouse position doesn't fit to selection
2983 :
2984 0 : aPopupPos = rCEvt.GetMousePosPixel();
2985 :
2986 0 : SvTreeListEntry* pClickedEntry = GetEntry( aPopupPos );
2987 0 : if( pClickedEntry )
2988 : { // mouse in non empty area
2989 0 : bool bClickedIsSelected = false;
2990 :
2991 : // collect the currently selected entries
2992 0 : SvTreeListEntry* pSelected = pView->FirstSelected();
2993 0 : while( pSelected )
2994 : {
2995 0 : bClickedIsSelected |= ( pClickedEntry == pSelected );
2996 0 : pSelected = pView->NextSelected( pSelected );
2997 : }
2998 :
2999 : // if the entry which the user clicked at is not selected
3000 0 : if( !bClickedIsSelected )
3001 : { // deselect all other and select the clicked one
3002 0 : pView->SelectAll( false );
3003 0 : pView->SetCursor( pClickedEntry );
3004 : }
3005 : }
3006 0 : else if( aSelEng.GetSelectionMode() == SINGLE_SELECTION )
3007 : {
3008 0 : bClickedIsFreePlace = true;
3009 0 : sal_Int32 nSelectedEntries = pView->GetSelectionCount();
3010 0 : SvTreeListEntry* pSelected = pView->FirstSelected();
3011 0 : for(sal_uInt16 nSel = 0; nSel < nSelectedEntries; nSel++ )
3012 : {
3013 0 : aSelRestore.push(pSelected);
3014 0 : pSelected = pView->NextSelected( pSelected );
3015 : }
3016 0 : pView->SelectAll( false );
3017 : }
3018 : else
3019 : { // deselect all
3020 0 : pView->SelectAll( false );
3021 : }
3022 :
3023 :
3024 : }
3025 : else
3026 : { // key event (or at least no mouse event)
3027 0 : sal_Int32 nSelectionCount = pView->GetSelectionCount();
3028 :
3029 0 : if( nSelectionCount )
3030 : { // now always take first visible as base for positioning the menu
3031 0 : SvTreeListEntry* pSelected = pView->FirstSelected();
3032 0 : while( pSelected )
3033 : {
3034 0 : if( IsEntryInView( pSelected ) )
3035 0 : break;
3036 :
3037 0 : pSelected = pView->NextSelected( pSelected );
3038 : }
3039 :
3040 0 : if( !pSelected )
3041 : {
3042 : // no one was visible
3043 0 : pSelected = pView->FirstSelected();
3044 0 : pView->MakeVisible( pSelected );
3045 : }
3046 :
3047 0 : aPopupPos = pView->GetFocusRect( pSelected, pView->GetEntryPosition( pSelected ).Y() ).Center();
3048 : }
3049 : else
3050 0 : aPopupPos = Point( 0, 0 );
3051 : }
3052 :
3053 0 : PopupMenu* pPopup = pView->CreateContextMenu();
3054 :
3055 0 : if( pPopup )
3056 : {
3057 : // do action for selected entry in popup menu
3058 0 : sal_uInt16 nMenuAction = pPopup->Execute( pView, aPopupPos );
3059 0 : if ( nMenuAction )
3060 0 : pView->ExcecuteContextMenuAction( nMenuAction );
3061 0 : lcl_DeleteSubPopups(pPopup);
3062 0 : delete pPopup;
3063 : }
3064 :
3065 0 : if( bClickedIsFreePlace )
3066 : {
3067 0 : while(!aSelRestore.empty())
3068 : {
3069 0 : SvTreeListEntry* pEntry = aSelRestore.top();
3070 : //#i19717# the entry is maybe already deleted
3071 0 : bool bFound = false;
3072 0 : for(sal_uLong nEntry = 0; nEntry < pView->GetEntryCount(); nEntry++)
3073 0 : if(pEntry == pView->GetEntry(nEntry))
3074 : {
3075 0 : bFound = true;
3076 0 : break;
3077 : }
3078 0 : if(bFound)
3079 0 : SetCurEntry( pEntry );
3080 0 : aSelRestore.pop();
3081 : }
3082 0 : }
3083 : }
3084 : #ifndef NOCOMMAND
3085 : else
3086 : {
3087 0 : const Point& rPos = rCEvt.GetMousePosPixel();
3088 0 : if( rPos.X() < aOutputSize.Width() && rPos.Y() < aOutputSize.Height() )
3089 0 : aSelEng.Command( rCEvt );
3090 : }
3091 : #endif
3092 : }
3093 :
3094 0 : void SvImpLBox::BeginScroll()
3095 : {
3096 0 : if( !(nFlags & F_IN_SCROLLING))
3097 : {
3098 0 : pView->NotifyBeginScroll();
3099 0 : nFlags |= F_IN_SCROLLING;
3100 : }
3101 0 : }
3102 :
3103 0 : void SvImpLBox::EndScroll()
3104 : {
3105 0 : if( nFlags & F_IN_SCROLLING)
3106 : {
3107 0 : pView->NotifyEndScroll();
3108 0 : nFlags &= (~F_IN_SCROLLING);
3109 : }
3110 0 : }
3111 :
3112 :
3113 0 : Rectangle SvImpLBox::GetVisibleArea() const
3114 : {
3115 0 : Point aPos( pView->GetMapMode().GetOrigin() );
3116 0 : aPos.X() *= -1;
3117 0 : Rectangle aRect( aPos, aOutputSize );
3118 0 : return aRect;
3119 : }
3120 :
3121 0 : void SvImpLBox::Invalidate()
3122 : {
3123 0 : pView->SetClipRegion();
3124 0 : }
3125 :
3126 0 : void SvImpLBox::SetCurEntry( SvTreeListEntry* pEntry )
3127 : {
3128 0 : if ( ( aSelEng.GetSelectionMode() != SINGLE_SELECTION )
3129 0 : && ( aSelEng.GetSelectionMode() != NO_SELECTION )
3130 : )
3131 0 : SelAllDestrAnch( false, true, false );
3132 0 : if ( pEntry )
3133 0 : MakeVisible( pEntry );
3134 0 : SetCursor( pEntry );
3135 0 : if ( pEntry && ( aSelEng.GetSelectionMode() != NO_SELECTION ) )
3136 0 : pView->Select( pEntry, true );
3137 0 : }
3138 :
3139 0 : IMPL_LINK_NOARG(SvImpLBox, EditTimerCall)
3140 : {
3141 0 : if( pView->IsInplaceEditingEnabled() )
3142 : {
3143 0 : bool bIsMouseTriggered = aEditClickPos.X() >= 0;
3144 0 : if ( bIsMouseTriggered )
3145 : {
3146 0 : Point aCurrentMousePos = pView->GetPointerPosPixel();
3147 0 : if ( ( std::abs( aCurrentMousePos.X() - aEditClickPos.X() ) > 5 )
3148 0 : || ( std::abs( aCurrentMousePos.Y() - aEditClickPos.Y() ) > 5 )
3149 : )
3150 : {
3151 0 : return 0L;
3152 : }
3153 : }
3154 :
3155 0 : SvTreeListEntry* pEntry = GetCurEntry();
3156 0 : if( pEntry )
3157 : {
3158 0 : ShowCursor( false );
3159 0 : pView->ImplEditEntry( pEntry );
3160 0 : ShowCursor( true );
3161 : }
3162 : }
3163 0 : return 0;
3164 : }
3165 :
3166 0 : bool SvImpLBox::RequestHelp( const HelpEvent& rHEvt )
3167 : {
3168 0 : if( rHEvt.GetMode() & HELPMODE_QUICK )
3169 : {
3170 0 : Point aPos( pView->ScreenToOutputPixel( rHEvt.GetMousePosPixel() ));
3171 0 : if( !GetVisibleArea().IsInside( aPos ))
3172 0 : return false;
3173 :
3174 0 : SvTreeListEntry* pEntry = GetEntry( aPos );
3175 0 : if( pEntry )
3176 : {
3177 : // recalculate text rectangle
3178 : SvLBoxTab* pTab;
3179 0 : SvLBoxString* pItem = (SvLBoxString*)(pView->GetItem( pEntry, aPos.X(), &pTab ));
3180 0 : if (!pItem || pItem->GetType() != SV_ITEM_ID_LBOXSTRING)
3181 0 : return false;
3182 :
3183 0 : aPos = GetEntryPosition( pEntry );
3184 0 : aPos.X() = pView->GetTabPos( pEntry, pTab ); //pTab->GetPos();
3185 0 : Size aSize( pItem->GetSize( pView, pEntry ) );
3186 0 : SvLBoxTab* pNextTab = NextTab( pTab );
3187 0 : bool bItemClipped = false;
3188 : // is the item cut off by its right neighbor?
3189 0 : if( pNextTab && pView->GetTabPos(pEntry,pNextTab) < aPos.X()+aSize.Width() )
3190 : {
3191 0 : aSize.Width() = pNextTab->GetPos() - pTab->GetPos();
3192 0 : bItemClipped = true;
3193 : }
3194 0 : Rectangle aItemRect( aPos, aSize );
3195 :
3196 0 : Rectangle aViewRect( GetVisibleArea() );
3197 :
3198 0 : if( bItemClipped || !aViewRect.IsInside( aItemRect ) )
3199 : {
3200 : // clip the right edge of the item at the edge of the view
3201 : //if( aItemRect.Right() > aViewRect.Right() )
3202 : // aItemRect.Right() = aViewRect.Right();
3203 :
3204 0 : Point aPt = pView->OutputToScreenPixel( aItemRect.TopLeft() );
3205 0 : aItemRect.Left() = aPt.X();
3206 0 : aItemRect.Top() = aPt.Y();
3207 0 : aPt = pView->OutputToScreenPixel( aItemRect.BottomRight() );
3208 0 : aItemRect.Right() = aPt.X();
3209 0 : aItemRect.Bottom() = aPt.Y();
3210 :
3211 : Help::ShowQuickHelp( pView, aItemRect,
3212 0 : pItem->GetText(), QUICKHELP_LEFT | QUICKHELP_VCENTER );
3213 0 : return true;
3214 : }
3215 : }
3216 : }
3217 0 : return false;
3218 : }
3219 :
3220 0 : SvLBoxTab* SvImpLBox::NextTab( SvLBoxTab* pTab )
3221 : {
3222 0 : sal_uInt16 nTabCount = pView->TabCount();
3223 0 : if( nTabCount <= 1 )
3224 0 : return 0;
3225 0 : for( sal_uInt16 nTab=0; nTab < (nTabCount-1); nTab++)
3226 : {
3227 0 : if( pView->aTabs[nTab]==pTab )
3228 0 : return (SvLBoxTab*)(pView->aTabs[nTab+1]);
3229 : }
3230 0 : return 0;
3231 : }
3232 :
3233 0 : void SvImpLBox::EndSelection()
3234 : {
3235 0 : DestroyAnchor();
3236 0 : nFlags &= ~F_START_EDITTIMER;
3237 0 : }
3238 :
3239 0 : void SvImpLBox::RepaintScrollBars()
3240 : {
3241 0 : }
3242 :
3243 0 : void SvImpLBox::SetUpdateMode( bool bMode )
3244 : {
3245 0 : if( bUpdateMode != bMode )
3246 : {
3247 0 : bUpdateMode = bMode;
3248 0 : if( bUpdateMode )
3249 0 : UpdateAll( false );
3250 : }
3251 0 : }
3252 :
3253 0 : bool SvImpLBox::SetMostRight( SvTreeListEntry* pEntry )
3254 : {
3255 0 : if( pView->nTreeFlags & TREEFLAG_RECALCTABS )
3256 : {
3257 0 : nFlags |= F_IGNORE_CHANGED_TABS;
3258 0 : pView->SetTabs();
3259 0 : nFlags &= ~F_IGNORE_CHANGED_TABS;
3260 : }
3261 :
3262 0 : sal_uInt16 nLastTab = pView->aTabs.size() - 1;
3263 0 : sal_uInt16 nLastItem = pEntry->ItemCount() - 1;
3264 0 : if( !pView->aTabs.empty() && nLastItem != USHRT_MAX )
3265 : {
3266 0 : if( nLastItem < nLastTab )
3267 0 : nLastTab = nLastItem;
3268 :
3269 0 : SvLBoxTab* pTab = pView->aTabs[ nLastTab ];
3270 0 : SvLBoxItem* pItem = pEntry->GetItem( nLastTab );
3271 :
3272 0 : long nTabPos = pView->GetTabPos( pEntry, pTab );
3273 :
3274 0 : long nMaxRight = GetOutputSize().Width();
3275 0 : Point aPos( pView->GetMapMode().GetOrigin() );
3276 0 : aPos.X() *= -1; // conversion document coordinates
3277 0 : nMaxRight = nMaxRight + aPos.X() - 1;
3278 :
3279 0 : long nNextTab = nTabPos < nMaxRight ? nMaxRight : nMaxRight + 50;
3280 0 : long nTabWidth = nNextTab - nTabPos + 1;
3281 0 : long nItemSize = pItem->GetSize(pView,pEntry).Width();
3282 0 : long nOffset = pTab->CalcOffset( nItemSize, nTabWidth );
3283 :
3284 0 : long nRight = nTabPos + nOffset + nItemSize;
3285 0 : if( nRight > nMostRight )
3286 : {
3287 0 : nMostRight = nRight;
3288 0 : pMostRightEntry = pEntry;
3289 0 : return true;
3290 : }
3291 : }
3292 0 : return false;
3293 : }
3294 :
3295 0 : void SvImpLBox::FindMostRight( SvTreeListEntry* pEntryToIgnore )
3296 : {
3297 0 : nMostRight = -1;
3298 0 : pMostRightEntry = 0;
3299 0 : if( !pView->GetModel() )
3300 0 : return;
3301 :
3302 0 : SvTreeListEntry* pEntry = (SvTreeListEntry*)pView->FirstVisible();
3303 0 : while( pEntry )
3304 : {
3305 0 : if( pEntry != pEntryToIgnore )
3306 0 : SetMostRight( pEntry );
3307 0 : pEntry = (SvTreeListEntry*)pView->NextVisible( pEntry );
3308 : }
3309 : }
3310 :
3311 0 : void SvImpLBox::FindMostRight( SvTreeListEntry* pParent, SvTreeListEntry* pEntryToIgnore )
3312 : {
3313 0 : if( !pParent )
3314 0 : FindMostRight( pEntryToIgnore );
3315 : else
3316 0 : FindMostRight_Impl( pParent, pEntryToIgnore );
3317 0 : }
3318 :
3319 0 : void SvImpLBox::FindMostRight_Impl( SvTreeListEntry* pParent, SvTreeListEntry* pEntryToIgnore )
3320 : {
3321 0 : SvTreeListEntries& rList = pTree->GetChildList( pParent );
3322 :
3323 0 : size_t nCount = rList.size();
3324 0 : for( size_t nCur = 0; nCur < nCount; nCur++ )
3325 : {
3326 0 : SvTreeListEntry* pChild = &rList[nCur];
3327 0 : if( pChild != pEntryToIgnore )
3328 : {
3329 0 : SetMostRight( pChild );
3330 0 : if( pChild->HasChildren() && pView->IsExpanded( pChild ))
3331 0 : FindMostRight_Impl( pChild, pEntryToIgnore );
3332 : }
3333 : }
3334 0 : }
3335 :
3336 0 : void SvImpLBox::NotifyTabsChanged()
3337 : {
3338 0 : if( GetUpdateMode() && !(nFlags & F_IGNORE_CHANGED_TABS ) &&
3339 0 : nCurUserEvent == 0xffffffff )
3340 : {
3341 0 : nCurUserEvent = Application::PostUserEvent(LINK(this,SvImpLBox,MyUserEvent),(void*)0);
3342 : }
3343 0 : }
3344 :
3345 0 : bool SvImpLBox::IsExpandable() const
3346 : {
3347 0 : return pCursor->HasChildren() || pCursor->HasChildrenOnDemand();
3348 : }
3349 :
3350 0 : bool SvImpLBox::IsNowExpandable() const
3351 : {
3352 0 : return IsExpandable() && !pView->IsExpanded( pCursor );
3353 : }
3354 :
3355 0 : IMPL_LINK(SvImpLBox,MyUserEvent,void*, pArg )
3356 : {
3357 0 : nCurUserEvent = 0xffffffff;
3358 0 : if( !pArg )
3359 : {
3360 0 : pView->Invalidate();
3361 0 : pView->Update();
3362 : }
3363 : else
3364 : {
3365 0 : FindMostRight( 0 );
3366 0 : ShowVerSBar();
3367 0 : pView->Invalidate( GetVisibleArea() );
3368 : }
3369 0 : return 0;
3370 : }
3371 :
3372 :
3373 0 : void SvImpLBox::StopUserEvent()
3374 : {
3375 0 : if( nCurUserEvent != 0xffffffff )
3376 : {
3377 0 : Application::RemoveUserEvent( nCurUserEvent );
3378 0 : nCurUserEvent = 0xffffffff;
3379 : }
3380 0 : }
3381 :
3382 0 : void SvImpLBox::ShowFocusRect( const SvTreeListEntry* pEntry )
3383 : {
3384 0 : if( pEntry )
3385 : {
3386 0 : long nY = GetEntryLine( (SvTreeListEntry*)pEntry );
3387 0 : Rectangle aRect = pView->GetFocusRect( (SvTreeListEntry*)pEntry, nY );
3388 0 : Region aOldClip( pView->GetClipRegion());
3389 0 : Region aClipRegion( GetClipRegionRect() );
3390 0 : pView->SetClipRegion( aClipRegion );
3391 0 : pView->ShowFocus( aRect );
3392 0 : pView->SetClipRegion( aOldClip );
3393 :
3394 : }
3395 : else
3396 : {
3397 0 : pView->HideFocus();
3398 : }
3399 0 : }
3400 :
3401 :
3402 0 : void SvImpLBox::implInitDefaultNodeImages()
3403 : {
3404 0 : if ( s_pDefCollapsed )
3405 : // assume that all or nothing is initialized
3406 0 : return;
3407 :
3408 0 : s_pDefCollapsed = new Image( SvtResId( RID_IMG_TREENODE_COLLAPSED ) );
3409 0 : s_pDefExpanded = new Image( SvtResId( RID_IMG_TREENODE_EXPANDED ) );
3410 : }
3411 :
3412 :
3413 0 : const Image& SvImpLBox::GetDefaultExpandedNodeImage( )
3414 : {
3415 0 : implInitDefaultNodeImages();
3416 0 : return *s_pDefExpanded;
3417 : }
3418 :
3419 :
3420 0 : const Image& SvImpLBox::GetDefaultCollapsedNodeImage( )
3421 : {
3422 0 : implInitDefaultNodeImages();
3423 0 : return *s_pDefCollapsed;
3424 : }
3425 :
3426 :
3427 0 : void SvImpLBox::CallEventListeners( sal_uLong nEvent, void* pData )
3428 : {
3429 0 : if ( pView )
3430 0 : pView->CallImplEventListeners( nEvent, pData);
3431 0 : }
3432 :
3433 :
3434 :
3435 0 : bool SvImpLBox::SetCurrentTabPos( sal_uInt16 _nNewPos )
3436 : {
3437 0 : bool bRet = false;
3438 :
3439 0 : if ( pView && _nNewPos < ( pView->TabCount() - 2 ) )
3440 : {
3441 0 : nCurTabPos = _nNewPos;
3442 0 : ShowCursor( true );
3443 0 : bRet = true;
3444 : }
3445 :
3446 0 : return bRet;
3447 : }
3448 :
3449 :
3450 :
3451 0 : bool SvImpLBox::IsSelectable( const SvTreeListEntry* pEntry )
3452 : {
3453 0 : if( pEntry )
3454 : {
3455 0 : SvViewDataEntry* pViewDataNewCur = pView->GetViewDataEntry(const_cast<SvTreeListEntry*>(pEntry));
3456 0 : return (pViewDataNewCur == 0) || pViewDataNewCur->IsSelectable();
3457 : }
3458 : else
3459 : {
3460 0 : return false;
3461 : }
3462 : }
3463 :
3464 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
