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 : /*
21 : TODO:
22 : - delete anchor in SelectionEngine when selecting manually
23 : - SelectAll( sal_False ) => only repaint the delselected entries
24 : */
25 :
26 : #include <svtools/treelistbox.hxx>
27 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
28 : #include <vcl/svapp.hxx>
29 : #include <vcl/accel.hxx>
30 : #include <vcl/i18nhelp.hxx>
31 : #include <vcl/builder.hxx>
32 : #include <sot/formats.hxx>
33 : #include <unotools/accessiblestatesethelper.hxx>
34 : #include <rtl/instance.hxx>
35 : #include <comphelper/string.hxx>
36 :
37 : #include <svtools/svmedit.hxx>
38 : #include <svtools/svlbitm.hxx>
39 : #include "svtools/treelistentry.hxx"
40 : #include "svtools/viewdataentry.hxx"
41 : #include "svimpbox.hxx"
42 :
43 : #include <set>
44 : #include <string.h>
45 : #include <vector>
46 :
47 : using namespace ::com::sun::star::accessibility;
48 :
49 : // Drag&Drop
50 : static SvTreeListBox* pDDSource = NULL;
51 : static SvTreeListBox* pDDTarget = NULL;
52 :
53 : DBG_NAME(SvInplaceEdit2)
54 :
55 : #define SVLBOX_ACC_RETURN 1
56 : #define SVLBOX_ACC_ESCAPE 2
57 :
58 : // ***************************************************************
59 :
60 0 : class MyEdit_Impl : public Edit
61 : {
62 : SvInplaceEdit2* pOwner;
63 : public:
64 : MyEdit_Impl( Window* pParent, SvInplaceEdit2* pOwner );
65 : virtual void KeyInput( const KeyEvent& rKEvt );
66 : virtual void LoseFocus();
67 : };
68 :
69 0 : class MyMultiEdit_Impl : public MultiLineEdit
70 : {
71 : SvInplaceEdit2* pOwner;
72 : public:
73 : MyMultiEdit_Impl( Window* pParent, SvInplaceEdit2* pOwner );
74 : virtual void KeyInput( const KeyEvent& rKEvt );
75 : virtual void LoseFocus();
76 : };
77 :
78 0 : MyEdit_Impl::MyEdit_Impl( Window* pParent, SvInplaceEdit2* _pOwner ) :
79 :
80 : Edit( pParent, WB_LEFT ),
81 :
82 0 : pOwner( _pOwner )
83 :
84 : {
85 0 : }
86 :
87 0 : void MyEdit_Impl::KeyInput( const KeyEvent& rKEvt )
88 : {
89 0 : if( !pOwner->KeyInput( rKEvt ))
90 0 : Edit::KeyInput( rKEvt );
91 0 : }
92 :
93 0 : void MyEdit_Impl::LoseFocus()
94 : {
95 0 : pOwner->LoseFocus();
96 0 : }
97 :
98 0 : MyMultiEdit_Impl::MyMultiEdit_Impl( Window* pParent, SvInplaceEdit2* _pOwner )
99 : : MultiLineEdit( pParent,
100 : WB_CENTER
101 0 : ), pOwner(_pOwner)
102 : {
103 0 : }
104 :
105 0 : void MyMultiEdit_Impl::KeyInput( const KeyEvent& rKEvt )
106 : {
107 0 : if( !pOwner->KeyInput( rKEvt ))
108 0 : MultiLineEdit::KeyInput( rKEvt );
109 0 : }
110 :
111 0 : void MyMultiEdit_Impl::LoseFocus()
112 : {
113 0 : pOwner->LoseFocus();
114 0 : }
115 :
116 :
117 0 : SvInplaceEdit2::SvInplaceEdit2
118 : (
119 : Window* pParent, const Point& rPos,
120 : const Size& rSize,
121 : const String& rData,
122 : const Link& rNotifyEditEnd,
123 : const Selection& rSelection,
124 : sal_Bool bMulti
125 : ) :
126 :
127 : aCallBackHdl ( rNotifyEditEnd ),
128 : bCanceled ( sal_False ),
129 0 : bAlreadyInCallBack ( sal_False )
130 :
131 : {
132 : DBG_CTOR(SvInplaceEdit2,0);
133 :
134 0 : if( bMulti )
135 0 : pEdit = new MyMultiEdit_Impl( pParent, this );
136 : else
137 0 : pEdit = new MyEdit_Impl( pParent, this );
138 :
139 0 : Font aFont( pParent->GetFont() );
140 0 : aFont.SetTransparent( sal_False );
141 0 : Color aColor( pParent->GetBackground().GetColor() );
142 0 : aFont.SetFillColor(aColor );
143 0 : pEdit->SetFont( aFont );
144 0 : pEdit->SetBackground( pParent->GetBackground() );
145 0 : pEdit->SetPosPixel( rPos );
146 0 : pEdit->SetSizePixel( rSize );
147 0 : pEdit->SetText( rData );
148 0 : pEdit->SetSelection( rSelection );
149 0 : pEdit->SaveValue();
150 :
151 0 : aAccReturn.InsertItem( SVLBOX_ACC_RETURN, KeyCode(KEY_RETURN) );
152 0 : aAccEscape.InsertItem( SVLBOX_ACC_ESCAPE, KeyCode(KEY_ESCAPE) );
153 :
154 0 : aAccReturn.SetActivateHdl( LINK( this, SvInplaceEdit2, ReturnHdl_Impl) );
155 0 : aAccEscape.SetActivateHdl( LINK( this, SvInplaceEdit2, EscapeHdl_Impl) );
156 0 : GetpApp()->InsertAccel( &aAccReturn );
157 0 : GetpApp()->InsertAccel( &aAccEscape );
158 :
159 0 : pEdit->Show();
160 0 : pEdit->GrabFocus();
161 0 : }
162 :
163 0 : SvInplaceEdit2::~SvInplaceEdit2()
164 : {
165 : DBG_DTOR(SvInplaceEdit2,0);
166 0 : if( !bAlreadyInCallBack )
167 : {
168 0 : GetpApp()->RemoveAccel( &aAccReturn );
169 0 : GetpApp()->RemoveAccel( &aAccEscape );
170 : }
171 0 : delete pEdit;
172 0 : }
173 :
174 0 : String SvInplaceEdit2::GetSavedValue() const
175 : {
176 0 : return pEdit->GetSavedValue();
177 : }
178 :
179 0 : void SvInplaceEdit2::Hide()
180 : {
181 0 : pEdit->Hide();
182 0 : }
183 :
184 :
185 0 : IMPL_LINK_NOARG_INLINE_START(SvInplaceEdit2, ReturnHdl_Impl)
186 : {
187 : DBG_CHKTHIS(SvInplaceEdit2,0);
188 0 : bCanceled = sal_False;
189 0 : CallCallBackHdl_Impl();
190 0 : return 1;
191 : }
192 0 : IMPL_LINK_NOARG_INLINE_END(SvInplaceEdit2, ReturnHdl_Impl)
193 :
194 0 : IMPL_LINK_NOARG_INLINE_START(SvInplaceEdit2, EscapeHdl_Impl)
195 : {
196 : DBG_CHKTHIS(SvInplaceEdit2,0);
197 0 : bCanceled = sal_True;
198 0 : CallCallBackHdl_Impl();
199 0 : return 1;
200 : }
201 0 : IMPL_LINK_NOARG_INLINE_END(SvInplaceEdit2, EscapeHdl_Impl)
202 :
203 :
204 0 : sal_Bool SvInplaceEdit2::KeyInput( const KeyEvent& rKEvt )
205 : {
206 : DBG_CHKTHIS(SvInplaceEdit2,0);
207 0 : KeyCode aCode = rKEvt.GetKeyCode();
208 0 : sal_uInt16 nCode = aCode.GetCode();
209 :
210 0 : switch ( nCode )
211 : {
212 : case KEY_ESCAPE:
213 0 : bCanceled = sal_True;
214 0 : CallCallBackHdl_Impl();
215 0 : return sal_True;
216 :
217 : case KEY_RETURN:
218 0 : bCanceled = sal_False;
219 0 : CallCallBackHdl_Impl();
220 0 : return sal_True;
221 : }
222 0 : return sal_False;
223 : }
224 :
225 0 : void SvInplaceEdit2::StopEditing( sal_Bool bCancel )
226 : {
227 : DBG_CHKTHIS(SvInplaceEdit2,0);
228 0 : if ( !bAlreadyInCallBack )
229 : {
230 0 : bCanceled = bCancel;
231 0 : CallCallBackHdl_Impl();
232 : }
233 0 : }
234 :
235 0 : void SvInplaceEdit2::LoseFocus()
236 : {
237 : DBG_CHKTHIS(SvInplaceEdit2,0);
238 0 : if ( !bAlreadyInCallBack
239 0 : && ((!Application::GetFocusWindow()) || !pEdit->IsChild( Application::GetFocusWindow()) )
240 : )
241 : {
242 0 : bCanceled = sal_False;
243 0 : aTimer.SetTimeout(10);
244 0 : aTimer.SetTimeoutHdl(LINK(this,SvInplaceEdit2,Timeout_Impl));
245 0 : aTimer.Start();
246 : }
247 0 : }
248 :
249 0 : IMPL_LINK_NOARG_INLINE_START(SvInplaceEdit2, Timeout_Impl)
250 : {
251 : DBG_CHKTHIS(SvInplaceEdit2,0);
252 0 : CallCallBackHdl_Impl();
253 0 : return 0;
254 : }
255 0 : IMPL_LINK_NOARG_INLINE_END(SvInplaceEdit2, Timeout_Impl)
256 :
257 0 : void SvInplaceEdit2::CallCallBackHdl_Impl()
258 : {
259 : DBG_CHKTHIS(SvInplaceEdit2,0);
260 0 : aTimer.Stop();
261 0 : if ( !bAlreadyInCallBack )
262 : {
263 0 : bAlreadyInCallBack = sal_True;
264 0 : GetpApp()->RemoveAccel( &aAccReturn );
265 0 : GetpApp()->RemoveAccel( &aAccEscape );
266 0 : pEdit->Hide();
267 0 : aCallBackHdl.Call( this );
268 : }
269 0 : }
270 :
271 0 : String SvInplaceEdit2::GetText() const
272 : {
273 0 : return pEdit->GetText();
274 : }
275 :
276 : // ***************************************************************
277 : // class SvLBoxTab
278 : // ***************************************************************
279 :
280 : DBG_NAME(SvLBoxTab);
281 :
282 0 : SvLBoxTab::SvLBoxTab()
283 : {
284 : DBG_CTOR(SvLBoxTab,0);
285 0 : nPos = 0;
286 0 : pUserData = 0;
287 0 : nFlags = 0;
288 0 : }
289 :
290 0 : SvLBoxTab::SvLBoxTab( long nPosition, sal_uInt16 nTabFlags )
291 : {
292 : DBG_CTOR(SvLBoxTab,0);
293 0 : nPos = nPosition;
294 0 : pUserData = 0;
295 0 : nFlags = nTabFlags;
296 0 : }
297 :
298 0 : SvLBoxTab::SvLBoxTab( const SvLBoxTab& rTab )
299 : {
300 : DBG_CTOR(SvLBoxTab,0);
301 0 : nPos = rTab.nPos;
302 0 : pUserData = rTab.pUserData;
303 0 : nFlags = rTab.nFlags;
304 0 : }
305 :
306 0 : SvLBoxTab::~SvLBoxTab()
307 : {
308 : DBG_DTOR(SvLBoxTab,0);
309 0 : }
310 :
311 :
312 0 : long SvLBoxTab::CalcOffset( long nItemWidth, long nTabWidth )
313 : {
314 : DBG_CHKTHIS(SvLBoxTab,0);
315 0 : long nOffset = 0;
316 0 : if ( nFlags & SV_LBOXTAB_ADJUST_RIGHT )
317 : {
318 0 : nOffset = nTabWidth - nItemWidth;
319 0 : if( nOffset < 0 )
320 0 : nOffset = 0;
321 : }
322 0 : else if ( nFlags & SV_LBOXTAB_ADJUST_CENTER )
323 : {
324 0 : if( nFlags & SV_LBOXTAB_FORCE )
325 : {
326 : // correct implementation of centering
327 0 : nOffset = ( nTabWidth - nItemWidth ) / 2;
328 0 : if( nOffset < 0 )
329 0 : nOffset = 0;
330 : }
331 : else
332 : {
333 : // historically grown, wrong calculation of tabs which is needed by
334 : // Abo-Tabbox, Tools/Options/Customize etc.
335 0 : nItemWidth++;
336 0 : nOffset = -( nItemWidth / 2 );
337 : }
338 : }
339 0 : return nOffset;
340 : }
341 :
342 : // ***************************************************************
343 : // class SvLBoxItem
344 : // ***************************************************************
345 :
346 : DBG_NAME(SvLBoxItem);
347 :
348 0 : SvLBoxItem::SvLBoxItem( SvTreeListEntry*, sal_uInt16 )
349 : {
350 : DBG_CTOR(SvLBoxItem,0);
351 0 : }
352 :
353 0 : SvLBoxItem::SvLBoxItem()
354 : {
355 : DBG_CTOR(SvLBoxItem,0);
356 0 : }
357 :
358 0 : SvLBoxItem::~SvLBoxItem()
359 : {
360 : DBG_DTOR(SvLBoxItem,0);
361 0 : }
362 :
363 0 : const Size& SvLBoxItem::GetSize(const SvTreeListBox* pView, const SvTreeListEntry* pEntry) const
364 : {
365 : DBG_CHKTHIS(SvLBoxItem,0);
366 0 : const SvViewDataItem* pViewData = pView->GetViewDataItem( pEntry, this );
367 0 : return pViewData->maSize;
368 : }
369 :
370 0 : const Size& SvLBoxItem::GetSize(const SvViewDataEntry* pData, sal_uInt16 nItemPos) const
371 : {
372 0 : const SvViewDataItem* pIData = pData->GetItem(nItemPos);
373 0 : return pIData->maSize;
374 : }
375 :
376 0 : struct SvTreeListBoxImpl
377 : {
378 : bool m_bIsEmptyTextAllowed:1;
379 : bool m_bEntryMnemonicsEnabled:1;
380 : bool m_bDoingQuickSelection:1;
381 :
382 : Link* m_pLink;
383 :
384 : vcl::MnemonicEngine m_aMnemonicEngine;
385 : vcl::QuickSelectionEngine m_aQuickSelectionEngine;
386 :
387 0 : SvTreeListBoxImpl(SvTreeListBox& _rBox) :
388 : m_bIsEmptyTextAllowed(true),
389 : m_bEntryMnemonicsEnabled(false),
390 : m_bDoingQuickSelection(false),
391 : m_pLink(NULL),
392 : m_aMnemonicEngine(_rBox),
393 0 : m_aQuickSelectionEngine(_rBox) {}
394 : };
395 :
396 : DBG_NAME(SvTreeListBox);
397 :
398 0 : SvTreeListBox::SvTreeListBox(Window* pParent, WinBits nWinStyle) :
399 : Control(pParent, nWinStyle | WB_CLIPCHILDREN),
400 : DropTargetHelper(this),
401 : DragSourceHelper(this),
402 0 : mpImpl(new SvTreeListBoxImpl(*this)),
403 : mbContextBmpExpanded(false),
404 0 : eSelMode(NO_SELECTION)
405 : {
406 : DBG_CTOR(SvTreeListBox,0);
407 0 : nDragOptions = DND_ACTION_COPYMOVE | DND_ACTION_LINK;
408 0 : nImpFlags = 0;
409 0 : pTargetEntry = 0;
410 0 : nDragDropMode = 0;
411 0 : SvTreeList* pTempModel = new SvTreeList;
412 0 : pTempModel->SetRefCount( 0 );
413 0 : SetBaseModel(pTempModel);
414 0 : pModel->SetCloneLink( LINK(this, SvTreeListBox, CloneHdl_Impl ));
415 0 : pModel->InsertView( this );
416 0 : pHdlEntry = 0;
417 0 : pEdCtrl = 0;
418 0 : eSelMode = SINGLE_SELECTION;
419 0 : nDragDropMode = SV_DRAGDROP_NONE;
420 0 : SetType(WINDOW_TREELISTBOX);
421 :
422 0 : InitTreeView();
423 :
424 0 : SetSublistOpenWithLeftRight();
425 0 : }
426 :
427 0 : SvTreeListBox::SvTreeListBox(Window* pParent, const ResId& rResId) :
428 : Control(pParent, rResId),
429 : DropTargetHelper(this),
430 : DragSourceHelper(this),
431 0 : mpImpl(new SvTreeListBoxImpl(*this)),
432 : mbContextBmpExpanded(false),
433 0 : eSelMode(NO_SELECTION)
434 : {
435 : DBG_CTOR(SvTreeListBox,0);
436 0 : pTargetEntry = 0;
437 0 : nImpFlags = 0;
438 0 : nDragOptions = DND_ACTION_COPYMOVE | DND_ACTION_LINK;
439 0 : nDragDropMode = 0;
440 0 : SvTreeList* pTempModel = new SvTreeList;
441 0 : pTempModel->SetRefCount( 0 );
442 0 : SetBaseModel(pTempModel);
443 0 : pModel->InsertView( this );
444 0 : pHdlEntry = 0;
445 0 : pEdCtrl = 0;
446 0 : pModel->SetCloneLink( LINK(this, SvTreeListBox, CloneHdl_Impl ));
447 0 : SetType(WINDOW_TREELISTBOX);
448 :
449 0 : InitTreeView();
450 0 : Resize();
451 :
452 0 : SetSublistOpenWithLeftRight();
453 0 : }
454 :
455 0 : extern "C" SAL_DLLPUBLIC_EXPORT Window* SAL_CALL makeSvTreeListBox(Window *pParent, VclBuilder::stringmap &)
456 : {
457 0 : return new SvTreeListBox(pParent, WB_TABSTOP);
458 : }
459 :
460 0 : void SvTreeListBox::Clear()
461 : {
462 : DBG_CHKTHIS(SvTreeListBox,0);
463 0 : pModel->Clear(); // Model calls SvTreeListBox::ModelHasCleared()
464 0 : }
465 :
466 0 : void SvTreeListBox::EnableEntryMnemonics( bool _bEnable )
467 : {
468 0 : if ( _bEnable == IsEntryMnemonicsEnabled() )
469 0 : return;
470 :
471 0 : mpImpl->m_bEntryMnemonicsEnabled = _bEnable;
472 0 : Invalidate();
473 : }
474 :
475 0 : bool SvTreeListBox::IsEntryMnemonicsEnabled() const
476 : {
477 0 : return mpImpl->m_bEntryMnemonicsEnabled;
478 : }
479 :
480 0 : IMPL_LINK_INLINE_START( SvTreeListBox, CloneHdl_Impl, SvTreeListEntry*, pEntry )
481 : {
482 : DBG_CHKTHIS(SvTreeListBox,0);
483 0 : return (long)(CloneEntry((SvTreeListEntry*)pEntry));
484 : }
485 0 : IMPL_LINK_INLINE_END( SvTreeListBox, CloneHdl_Impl, SvTreeListEntry*, pEntry )
486 :
487 0 : sal_uLong SvTreeListBox::Insert( SvTreeListEntry* pEntry, SvTreeListEntry* pParent, sal_uLong nPos )
488 : {
489 : DBG_CHKTHIS(SvTreeListBox,0);
490 0 : sal_uLong nInsPos = pModel->Insert( pEntry, pParent, nPos );
491 0 : return nInsPos;
492 : }
493 :
494 0 : sal_uLong SvTreeListBox::Insert( SvTreeListEntry* pEntry,sal_uLong nRootPos )
495 : {
496 : DBG_CHKTHIS(SvTreeListBox,0);
497 0 : sal_uLong nInsPos = pModel->Insert( pEntry, nRootPos );
498 0 : return nInsPos;
499 : }
500 :
501 0 : long SvTreeListBox::ExpandingHdl()
502 : {
503 : DBG_CHKTHIS(SvTreeListBox,0);
504 0 : return aExpandingHdl.IsSet() ? aExpandingHdl.Call( this ) : 1;
505 : }
506 :
507 0 : void SvTreeListBox::ExpandedHdl()
508 : {
509 : DBG_CHKTHIS(SvTreeListBox,0);
510 0 : aExpandedHdl.Call( this );
511 0 : }
512 :
513 0 : void SvTreeListBox::SelectHdl()
514 : {
515 : DBG_CHKTHIS(SvTreeListBox,0);
516 0 : aSelectHdl.Call( this );
517 0 : }
518 :
519 0 : void SvTreeListBox::DeselectHdl()
520 : {
521 : DBG_CHKTHIS(SvTreeListBox,0);
522 0 : aDeselectHdl.Call( this );
523 0 : }
524 :
525 0 : sal_Bool SvTreeListBox::DoubleClickHdl()
526 : {
527 : DBG_CHKTHIS(SvTreeListBox,0);
528 0 : aDoubleClickHdl.Call( this );
529 0 : return sal_True;
530 : }
531 :
532 :
533 0 : sal_Bool SvTreeListBox::CheckDragAndDropMode( SvTreeListBox* pSource, sal_Int8 nAction )
534 : {
535 : DBG_CHKTHIS(SvTreeListBox,0);
536 0 : if ( pSource == this )
537 : {
538 0 : if ( !(nDragDropMode & (SV_DRAGDROP_CTRL_MOVE | SV_DRAGDROP_CTRL_COPY) ) )
539 0 : return sal_False; // D&D locked within list
540 0 : if( DND_ACTION_MOVE == nAction )
541 : {
542 0 : if ( !(nDragDropMode & SV_DRAGDROP_CTRL_MOVE) )
543 0 : return sal_False; // no local move
544 : }
545 : else
546 : {
547 0 : if ( !(nDragDropMode & SV_DRAGDROP_CTRL_COPY))
548 0 : return sal_False; // no local copy
549 : }
550 : }
551 : else
552 : {
553 0 : if ( !(nDragDropMode & SV_DRAGDROP_APP_DROP ) )
554 0 : return sal_False; // no drop
555 0 : if ( DND_ACTION_MOVE == nAction )
556 : {
557 0 : if ( !(nDragDropMode & SV_DRAGDROP_APP_MOVE) )
558 0 : return sal_False; // no global move
559 : }
560 : else
561 : {
562 0 : if ( !(nDragDropMode & SV_DRAGDROP_APP_COPY))
563 0 : return sal_False; // no global copy
564 : }
565 : }
566 0 : return sal_True;
567 : }
568 :
569 :
570 :
571 :
572 0 : void SvTreeListBox::NotifyRemoving( SvTreeListEntry* )
573 : {
574 : DBG_CHKTHIS(SvTreeListBox,0);
575 0 : }
576 :
577 : /*
578 : NotifyMoving/Copying
579 : ====================
580 :
581 : default behavior:
582 :
583 : 1. target doesn't have children
584 : - entry becomes sibling of target. entry comes after target
585 : (->Window: below the target)
586 : 2. target is an expanded parent
587 : - entry inserted at the beginning of the target childlist
588 : 3. target is a collapsed parent
589 : - entry is inserted at the end of the target childlist
590 : */
591 : #ifdef DBG_UTIL
592 : sal_Bool SvTreeListBox::NotifyMoving(
593 : SvTreeListEntry* pTarget, // D&D dropping position in this->GetModel()
594 : SvTreeListEntry* pEntry, // entry that we want to move, from
595 : // GetSourceListBox()->GetModel()
596 : SvTreeListEntry*& rpNewParent, // new target parent
597 : sal_uLong& rNewChildPos) // position in childlist of target parent
598 : #else
599 0 : sal_Bool SvTreeListBox::NotifyMoving(
600 : SvTreeListEntry* pTarget, // D&D dropping position in this->GetModel()
601 : SvTreeListEntry*, // entry that we want to move, from
602 : // GetSourceListBox()->GetModel()
603 : SvTreeListEntry*& rpNewParent, // new target parent
604 : sal_uLong& rNewChildPos) // position in childlist of target parent
605 : #endif
606 : {
607 : DBG_CHKTHIS(SvTreeListBox,0);
608 : DBG_ASSERT(pEntry,"NotifyMoving:SoureEntry?");
609 0 : if( !pTarget )
610 : {
611 0 : rpNewParent = 0;
612 0 : rNewChildPos = 0;
613 0 : return sal_True;
614 : }
615 0 : if ( !pTarget->HasChildren() && !pTarget->HasChildrenOnDemand() )
616 : {
617 : // case 1
618 0 : rpNewParent = GetParent( pTarget );
619 0 : rNewChildPos = pModel->GetRelPos( pTarget ) + 1;
620 0 : rNewChildPos += nCurEntrySelPos;
621 0 : nCurEntrySelPos++;
622 : }
623 : else
624 : {
625 : // cases 2 & 3
626 0 : rpNewParent = pTarget;
627 0 : if( IsExpanded(pTarget))
628 0 : rNewChildPos = 0;
629 : else
630 0 : rNewChildPos = LIST_APPEND;
631 : }
632 0 : return sal_True;
633 : }
634 :
635 0 : sal_Bool SvTreeListBox::NotifyCopying(
636 : SvTreeListEntry* pTarget, // D&D dropping position in this->GetModel()
637 : SvTreeListEntry* pEntry, // entry that we want to move, from
638 : // GetSourceListBox()->GetModel()
639 : SvTreeListEntry*& rpNewParent, // new target parent
640 : sal_uLong& rNewChildPos) // position in childlist of target parent
641 : {
642 : DBG_CHKTHIS(SvTreeListBox,0);
643 0 : return NotifyMoving(pTarget,pEntry,rpNewParent,rNewChildPos);
644 : }
645 :
646 0 : SvTreeListEntry* SvTreeListBox::FirstChild( SvTreeListEntry* pParent ) const
647 : {
648 0 : return pModel->FirstChild(pParent);
649 : }
650 :
651 0 : SvTreeListEntry* SvTreeListBox::NextSibling( SvTreeListEntry* pEntry ) const
652 : {
653 0 : return pModel->NextSibling(pEntry);
654 : }
655 :
656 0 : SvTreeListEntry* SvTreeListBox::PrevSibling( SvTreeListEntry* pEntry ) const
657 : {
658 0 : return pModel->PrevSibling(pEntry);
659 : }
660 :
661 : // return: all entries copied
662 0 : sal_Bool SvTreeListBox::CopySelection( SvTreeListBox* pSource, SvTreeListEntry* pTarget )
663 : {
664 : DBG_CHKTHIS(SvTreeListBox,0);
665 0 : nCurEntrySelPos = 0; // selection counter for NotifyMoving/Copying
666 0 : sal_Bool bSuccess = sal_True;
667 0 : std::vector<SvTreeListEntry*> aList;
668 0 : sal_Bool bClone = (sal_Bool)( (sal_uLong)(pSource->GetModel()) != (sal_uLong)GetModel() );
669 0 : Link aCloneLink( pModel->GetCloneLink() );
670 0 : pModel->SetCloneLink( LINK(this, SvTreeListBox, CloneHdl_Impl ));
671 :
672 : // cache selection to simplify iterating over the selection when doing a D&D
673 : // exchange within the same listbox
674 0 : SvTreeListEntry* pSourceEntry = pSource->FirstSelected();
675 0 : while ( pSourceEntry )
676 : {
677 : // children are copied automatically
678 0 : pSource->SelectChildren( pSourceEntry, sal_False );
679 0 : aList.push_back( pSourceEntry );
680 0 : pSourceEntry = pSource->NextSelected( pSourceEntry );
681 : }
682 :
683 0 : std::vector<SvTreeListEntry*>::const_iterator it = aList.begin(), itEnd = aList.end();
684 0 : for (; it != itEnd; ++it)
685 : {
686 0 : pSourceEntry = *it;
687 0 : SvTreeListEntry* pNewParent = 0;
688 0 : sal_uLong nInsertionPos = ULONG_MAX;
689 0 : sal_Bool bOk=NotifyCopying(pTarget,pSourceEntry,pNewParent,nInsertionPos);
690 0 : if ( bOk )
691 : {
692 0 : if ( bClone )
693 : {
694 0 : sal_uLong nCloneCount = 0;
695 0 : pSourceEntry = pModel->Clone(pSourceEntry, nCloneCount);
696 0 : pModel->InsertTree(pSourceEntry, pNewParent, nInsertionPos);
697 : }
698 : else
699 : {
700 0 : sal_uLong nListPos = pModel->Copy(pSourceEntry, pNewParent, nInsertionPos);
701 0 : pSourceEntry = GetEntry( pNewParent, nListPos );
702 : }
703 : }
704 : else
705 0 : bSuccess = sal_False;
706 :
707 0 : if( bOk == (sal_Bool)2 ) // HACK: make visible moved entry?
708 0 : MakeVisible( pSourceEntry );
709 : }
710 0 : pModel->SetCloneLink( aCloneLink );
711 0 : return bSuccess;
712 : }
713 :
714 : // return: all entries were moved
715 0 : sal_Bool SvTreeListBox::MoveSelection( SvTreeListBox* pSource, SvTreeListEntry* pTarget )
716 : {
717 0 : return MoveSelectionCopyFallbackPossible( pSource, pTarget, sal_False );
718 : }
719 :
720 0 : sal_Bool SvTreeListBox::MoveSelectionCopyFallbackPossible( SvTreeListBox* pSource, SvTreeListEntry* pTarget, sal_Bool bAllowCopyFallback )
721 : {
722 : DBG_CHKTHIS(SvTreeListBox,0);
723 0 : nCurEntrySelPos = 0; // selection counter for NotifyMoving/Copying
724 0 : sal_Bool bSuccess = sal_True;
725 0 : std::vector<SvTreeListEntry*> aList;
726 0 : sal_Bool bClone = (sal_Bool)( (sal_uLong)(pSource->GetModel()) != (sal_uLong)GetModel() );
727 0 : Link aCloneLink( pModel->GetCloneLink() );
728 0 : if ( bClone )
729 0 : pModel->SetCloneLink( LINK(this, SvTreeListBox, CloneHdl_Impl ));
730 :
731 0 : SvTreeListEntry* pSourceEntry = pSource->FirstSelected();
732 0 : while ( pSourceEntry )
733 : {
734 : // children are automatically moved
735 0 : pSource->SelectChildren( pSourceEntry, sal_False );
736 0 : aList.push_back( pSourceEntry );
737 0 : pSourceEntry = pSource->NextSelected( pSourceEntry );
738 : }
739 :
740 0 : std::vector<SvTreeListEntry*>::const_iterator it = aList.begin(), itEnd = aList.end();
741 0 : for (; it != itEnd; ++it)
742 : {
743 0 : pSourceEntry = *it;
744 :
745 0 : SvTreeListEntry* pNewParent = 0;
746 0 : sal_uLong nInsertionPos = ULONG_MAX;
747 0 : sal_Bool bOk = NotifyMoving(pTarget,pSourceEntry,pNewParent,nInsertionPos);
748 0 : sal_Bool bCopyOk = bOk;
749 0 : if ( !bOk && bAllowCopyFallback )
750 : {
751 0 : nInsertionPos = LIST_APPEND;
752 0 : bCopyOk = NotifyCopying(pTarget,pSourceEntry,pNewParent,nInsertionPos);
753 : }
754 :
755 0 : if ( bOk || bCopyOk )
756 : {
757 0 : if ( bClone )
758 : {
759 0 : sal_uLong nCloneCount = 0;
760 0 : pSourceEntry = pModel->Clone(pSourceEntry, nCloneCount);
761 0 : pModel->InsertTree(pSourceEntry, pNewParent, nInsertionPos);
762 : }
763 : else
764 : {
765 0 : if ( bOk )
766 0 : pModel->Move(pSourceEntry, pNewParent, nInsertionPos);
767 : else
768 0 : pModel->Copy(pSourceEntry, pNewParent, nInsertionPos);
769 0 : }
770 : }
771 : else
772 0 : bSuccess = sal_False;
773 :
774 0 : if( bOk == (sal_Bool)2 ) // HACK: make moved entry visible?
775 0 : MakeVisible( pSourceEntry );
776 : }
777 0 : pModel->SetCloneLink( aCloneLink );
778 0 : return bSuccess;
779 : }
780 :
781 0 : void SvTreeListBox::RemoveSelection()
782 : {
783 : DBG_CHKTHIS(SvTreeListBox,0);
784 0 : std::vector<const SvTreeListEntry*> aList;
785 : // cache selection, as the implementation deselects everything on the first
786 : // remove
787 0 : SvTreeListEntry* pEntry = FirstSelected();
788 0 : while ( pEntry )
789 : {
790 0 : aList.push_back( pEntry );
791 0 : if ( pEntry->HasChildren() )
792 : // remove deletes all children automatically
793 0 : SelectChildren(pEntry, false);
794 0 : pEntry = NextSelected( pEntry );
795 : }
796 :
797 0 : std::vector<const SvTreeListEntry*>::const_iterator it = aList.begin(), itEnd = aList.end();
798 0 : for (; it != itEnd; ++it)
799 0 : pModel->Remove(*it);
800 0 : }
801 :
802 0 : SvTreeListBox* SvTreeListBox::GetSourceView() const
803 : {
804 0 : return pDDSource;
805 : }
806 :
807 0 : void SvTreeListBox::RecalcViewData()
808 : {
809 : DBG_CHKTHIS(SvTreeListBox,0);
810 0 : SvTreeListEntry* pEntry = First();
811 0 : while( pEntry )
812 : {
813 0 : sal_uInt16 nCount = pEntry->ItemCount();
814 0 : sal_uInt16 nCurPos = 0;
815 0 : while ( nCurPos < nCount )
816 : {
817 0 : SvLBoxItem* pItem = pEntry->GetItem( nCurPos );
818 0 : pItem->InitViewData( this, pEntry );
819 0 : nCurPos++;
820 : }
821 0 : ViewDataInitialized( pEntry );
822 0 : pEntry = Next( pEntry );
823 : }
824 0 : }
825 :
826 0 : void SvTreeListBox::ViewDataInitialized( SvTreeListEntry* )
827 : {
828 : DBG_CHKTHIS(SvTreeListBox,0);
829 0 : }
830 :
831 0 : void SvTreeListBox::ImplShowTargetEmphasis( SvTreeListEntry* pEntry, sal_Bool bShow)
832 : {
833 : DBG_CHKTHIS(SvTreeListBox,0);
834 0 : if ( bShow && (nImpFlags & SVLBOX_TARGEMPH_VIS) )
835 0 : return;
836 0 : if ( !bShow && !(nImpFlags & SVLBOX_TARGEMPH_VIS) )
837 0 : return;
838 0 : ShowTargetEmphasis( pEntry, bShow );
839 0 : if( bShow )
840 0 : nImpFlags |= SVLBOX_TARGEMPH_VIS;
841 : else
842 0 : nImpFlags &= ~SVLBOX_TARGEMPH_VIS;
843 : }
844 :
845 0 : void SvTreeListBox::OnCurrentEntryChanged()
846 : {
847 0 : if ( !mpImpl->m_bDoingQuickSelection )
848 0 : mpImpl->m_aQuickSelectionEngine.Reset();
849 0 : }
850 :
851 0 : SvTreeListEntry* SvTreeListBox::GetEntry( SvTreeListEntry* pParent, sal_uLong nPos ) const
852 : {
853 0 : return pModel->GetEntry(pParent, nPos);
854 : }
855 :
856 0 : SvTreeListEntry* SvTreeListBox::GetEntry( sal_uLong nRootPos ) const
857 : {
858 0 : return pModel->GetEntry(nRootPos);
859 : }
860 :
861 0 : SvTreeListEntry* SvTreeListBox::GetEntryFromPath( const ::std::deque< sal_Int32 >& _rPath ) const
862 : {
863 : DBG_CHKTHIS(SvTreeListBox,0);
864 :
865 0 : SvTreeListEntry* pEntry = NULL;
866 0 : SvTreeListEntry* pParent = NULL;
867 0 : for( ::std::deque< sal_Int32 >::const_iterator pItem = _rPath.begin(); pItem != _rPath.end(); ++pItem )
868 : {
869 0 : pEntry = GetEntry( pParent, *pItem );
870 0 : if ( !pEntry )
871 0 : break;
872 0 : pParent = pEntry;
873 : }
874 :
875 0 : return pEntry;
876 : }
877 :
878 0 : void SvTreeListBox::FillEntryPath( SvTreeListEntry* pEntry, ::std::deque< sal_Int32 >& _rPath ) const
879 : {
880 : DBG_CHKTHIS(SvTreeListBox,0);
881 :
882 0 : if ( pEntry )
883 : {
884 0 : SvTreeListEntry* pParentEntry = GetParent( pEntry );
885 0 : while ( sal_True )
886 : {
887 0 : sal_uLong i, nCount = GetLevelChildCount( pParentEntry );
888 0 : for ( i = 0; i < nCount; ++i )
889 : {
890 0 : SvTreeListEntry* pTemp = GetEntry( pParentEntry, i );
891 : DBG_ASSERT( pEntry, "invalid entry" );
892 0 : if ( pEntry == pTemp )
893 : {
894 0 : _rPath.push_front( (sal_Int32)i );
895 0 : break;
896 : }
897 : }
898 :
899 0 : if ( pParentEntry )
900 : {
901 0 : pEntry = pParentEntry;
902 0 : pParentEntry = GetParent( pParentEntry );
903 : }
904 : else
905 0 : break;
906 : }
907 : }
908 0 : }
909 :
910 0 : const SvTreeListEntry* SvTreeListBox::GetParent( const SvTreeListEntry* pEntry ) const
911 : {
912 0 : return pModel->GetParent(pEntry);
913 : }
914 :
915 0 : SvTreeListEntry* SvTreeListBox::GetParent( SvTreeListEntry* pEntry ) const
916 : {
917 0 : return pModel->GetParent(pEntry);
918 : }
919 :
920 0 : SvTreeListEntry* SvTreeListBox::GetRootLevelParent( SvTreeListEntry* pEntry ) const
921 : {
922 0 : return pModel->GetRootLevelParent(pEntry);
923 : }
924 :
925 0 : sal_uLong SvTreeListBox::GetChildCount( SvTreeListEntry* pParent ) const
926 : {
927 0 : return pModel->GetChildCount(pParent);
928 : }
929 :
930 0 : sal_uLong SvTreeListBox::GetLevelChildCount( SvTreeListEntry* _pParent ) const
931 : {
932 : DBG_CHKTHIS(SvTreeListBox,0);
933 :
934 0 : sal_uLong nCount = 0;
935 0 : SvTreeListEntry* pEntry = FirstChild( _pParent );
936 0 : while ( pEntry )
937 : {
938 0 : ++nCount;
939 0 : pEntry = NextSibling( pEntry );
940 : }
941 :
942 0 : return nCount;
943 : }
944 :
945 0 : SvViewDataEntry* SvTreeListBox::GetViewDataEntry( SvTreeListEntry* pEntry ) const
946 : {
947 0 : return (SvViewDataEntry*)SvListView::GetViewData(pEntry);
948 : }
949 :
950 0 : SvViewDataItem* SvTreeListBox::GetViewDataItem(SvTreeListEntry* pEntry, SvLBoxItem* pItem)
951 : {
952 0 : return const_cast<SvViewDataItem*>(static_cast<const SvTreeListBox*>(this)->GetViewDataItem(pEntry, pItem));
953 : }
954 :
955 0 : const SvViewDataItem* SvTreeListBox::GetViewDataItem(const SvTreeListEntry* pEntry, const SvLBoxItem* pItem) const
956 : {
957 0 : const SvViewDataEntry* pEntryData = (const SvViewDataEntry*)SvListView::GetViewData(pEntry);
958 : DBG_ASSERT(pEntryData,"Entry not in View");
959 0 : sal_uInt16 nItemPos = pEntry->GetPos(pItem);
960 0 : return pEntryData->GetItem(nItemPos);
961 : }
962 :
963 0 : SvViewDataEntry* SvTreeListBox::CreateViewData( SvTreeListEntry* )
964 : {
965 : DBG_CHKTHIS(SvTreeListBox,0);
966 0 : SvViewDataEntry* pEntryData = new SvViewDataEntry;
967 0 : return (SvViewDataEntry*)pEntryData;
968 : }
969 :
970 0 : void SvTreeListBox::InitViewData( SvViewDataEntry* pData, SvTreeListEntry* pEntry )
971 : {
972 : DBG_CHKTHIS(SvTreeListBox,0);
973 0 : SvTreeListEntry* pInhEntry = (SvTreeListEntry*)pEntry;
974 0 : SvViewDataEntry* pEntryData = (SvViewDataEntry*)pData;
975 :
976 0 : pEntryData->Init(pInhEntry->ItemCount());
977 0 : sal_uInt16 nCount = pInhEntry->ItemCount();
978 0 : sal_uInt16 nCurPos = 0;
979 0 : while( nCurPos < nCount )
980 : {
981 0 : SvLBoxItem* pItem = pInhEntry->GetItem( nCurPos );
982 0 : SvViewDataItem* pItemData = pEntryData->GetItem(nCurPos);
983 0 : pItem->InitViewData( this, pInhEntry, pItemData );
984 0 : pItemData++;
985 0 : nCurPos++;
986 : }
987 0 : }
988 :
989 :
990 :
991 0 : void SvTreeListBox::EnableSelectionAsDropTarget( sal_Bool bEnable, sal_Bool bWithChildren )
992 : {
993 : DBG_CHKTHIS(SvTreeListBox,0);
994 : sal_uInt16 nRefDepth;
995 : SvTreeListEntry* pTemp;
996 :
997 0 : SvTreeListEntry* pSelEntry = FirstSelected();
998 0 : while( pSelEntry )
999 : {
1000 0 : if ( !bEnable )
1001 : {
1002 0 : pSelEntry->nEntryFlags |= SV_ENTRYFLAG_DISABLE_DROP;
1003 0 : if ( bWithChildren )
1004 : {
1005 0 : nRefDepth = pModel->GetDepth( pSelEntry );
1006 0 : pTemp = Next( pSelEntry );
1007 0 : while( pTemp && pModel->GetDepth( pTemp ) > nRefDepth )
1008 : {
1009 0 : pTemp->nEntryFlags |= SV_ENTRYFLAG_DISABLE_DROP;
1010 0 : pTemp = Next( pTemp );
1011 : }
1012 : }
1013 : }
1014 : else
1015 : {
1016 0 : pSelEntry->nEntryFlags &= (~SV_ENTRYFLAG_DISABLE_DROP);
1017 0 : if ( bWithChildren )
1018 : {
1019 0 : nRefDepth = pModel->GetDepth( pSelEntry );
1020 0 : pTemp = Next( pSelEntry );
1021 0 : while( pTemp && pModel->GetDepth( pTemp ) > nRefDepth )
1022 : {
1023 0 : pTemp->nEntryFlags &= (~SV_ENTRYFLAG_DISABLE_DROP);
1024 0 : pTemp = Next( pTemp );
1025 : }
1026 : }
1027 : }
1028 0 : pSelEntry = NextSelected( pSelEntry );
1029 : }
1030 0 : }
1031 :
1032 : // ******************************************************************
1033 : // InplaceEditing
1034 : // ******************************************************************
1035 :
1036 0 : void SvTreeListBox::EditText( const String& rStr, const Rectangle& rRect,
1037 : const Selection& rSel )
1038 : {
1039 0 : EditText( rStr, rRect, rSel, sal_False );
1040 0 : }
1041 :
1042 0 : void SvTreeListBox::EditText( const String& rStr, const Rectangle& rRect,
1043 : const Selection& rSel, sal_Bool bMulti )
1044 : {
1045 : DBG_CHKTHIS(SvTreeListBox,0);
1046 0 : if( pEdCtrl )
1047 0 : delete pEdCtrl;
1048 0 : nImpFlags |= SVLBOX_IN_EDT;
1049 0 : nImpFlags &= ~SVLBOX_EDTEND_CALLED;
1050 0 : HideFocus();
1051 : pEdCtrl = new SvInplaceEdit2(
1052 : this, rRect.TopLeft(), rRect.GetSize(), rStr,
1053 : LINK( this, SvTreeListBox, TextEditEndedHdl_Impl ),
1054 0 : rSel, bMulti );
1055 0 : }
1056 :
1057 0 : IMPL_LINK_NOARG(SvTreeListBox, TextEditEndedHdl_Impl)
1058 : {
1059 : DBG_CHKTHIS(SvTreeListBox,0);
1060 0 : if ( nImpFlags & SVLBOX_EDTEND_CALLED ) // avoid nesting
1061 0 : return 0;
1062 0 : nImpFlags |= SVLBOX_EDTEND_CALLED;
1063 0 : String aStr;
1064 0 : if ( !pEdCtrl->EditingCanceled() )
1065 0 : aStr = pEdCtrl->GetText();
1066 : else
1067 0 : aStr = pEdCtrl->GetSavedValue();
1068 0 : if ( IsEmptyTextAllowed() || aStr.Len() > 0 )
1069 0 : EditedText( aStr );
1070 : // Hide may only be called after the new text was put into the entry, so
1071 : // that we don't call the selection handler in the GetFocus of the listbox
1072 : // with the old entry text.
1073 0 : pEdCtrl->Hide();
1074 : // delete pEdCtrl;
1075 : // pEdCtrl = 0;
1076 0 : nImpFlags &= (~SVLBOX_IN_EDT);
1077 0 : GrabFocus();
1078 0 : return 0;
1079 : }
1080 :
1081 0 : void SvTreeListBox::CancelTextEditing()
1082 : {
1083 : DBG_CHKTHIS(SvTreeListBox,0);
1084 0 : if ( pEdCtrl )
1085 0 : pEdCtrl->StopEditing( sal_True );
1086 0 : nImpFlags &= (~SVLBOX_IN_EDT);
1087 0 : }
1088 :
1089 0 : void SvTreeListBox::EndEditing( bool bCancel )
1090 : {
1091 : DBG_CHKTHIS(SvTreeListBox,0);
1092 0 : if( pEdCtrl )
1093 0 : pEdCtrl->StopEditing( bCancel );
1094 0 : nImpFlags &= (~SVLBOX_IN_EDT);
1095 0 : }
1096 :
1097 :
1098 0 : bool SvTreeListBox::IsEmptyTextAllowed() const
1099 : {
1100 : DBG_CHKTHIS(SvTreeListBox,0);
1101 0 : return mpImpl->m_bIsEmptyTextAllowed;
1102 : }
1103 :
1104 0 : void SvTreeListBox::ForbidEmptyText()
1105 : {
1106 : DBG_CHKTHIS(SvTreeListBox,0);
1107 0 : mpImpl->m_bIsEmptyTextAllowed = false;
1108 0 : }
1109 :
1110 0 : SvTreeListEntry* SvTreeListBox::CreateEntry() const
1111 : {
1112 : DBG_CHKTHIS(SvTreeListBox,0);
1113 0 : return new SvTreeListEntry;
1114 : }
1115 :
1116 0 : const void* SvTreeListBox::FirstSearchEntry( String& _rEntryText ) const
1117 : {
1118 0 : SvTreeListEntry* pEntry = GetCurEntry();
1119 0 : if ( pEntry )
1120 0 : pEntry = const_cast< SvTreeListEntry* >( static_cast< const SvTreeListEntry* >( NextSearchEntry( pEntry, _rEntryText ) ) );
1121 : else
1122 : {
1123 0 : pEntry = FirstSelected();
1124 0 : if ( !pEntry )
1125 0 : pEntry = First();
1126 : }
1127 :
1128 0 : if ( pEntry )
1129 0 : _rEntryText = GetEntryText( pEntry );
1130 :
1131 0 : return pEntry;
1132 : }
1133 :
1134 0 : const void* SvTreeListBox::NextSearchEntry( const void* _pCurrentSearchEntry, String& _rEntryText ) const
1135 : {
1136 0 : SvTreeListEntry* pEntry = const_cast< SvTreeListEntry* >( static_cast< const SvTreeListEntry* >( _pCurrentSearchEntry ) );
1137 :
1138 0 : if ( ( ( GetChildCount( pEntry ) > 0 )
1139 0 : || ( pEntry->HasChildrenOnDemand() )
1140 : )
1141 0 : && !IsExpanded( pEntry )
1142 : )
1143 : {
1144 0 : pEntry = NextSibling( pEntry );
1145 : }
1146 : else
1147 : {
1148 0 : pEntry = Next( pEntry );
1149 : }
1150 :
1151 0 : if ( !pEntry )
1152 0 : pEntry = First();
1153 :
1154 0 : if ( pEntry )
1155 0 : _rEntryText = GetEntryText( pEntry );
1156 :
1157 0 : return pEntry;
1158 : }
1159 :
1160 0 : void SvTreeListBox::SelectSearchEntry( const void* _pEntry )
1161 : {
1162 0 : SvTreeListEntry* pEntry = const_cast< SvTreeListEntry* >( static_cast< const SvTreeListEntry* >( _pEntry ) );
1163 : DBG_ASSERT( pEntry, "SvTreeListBox::SelectSearchEntry: invalid entry!" );
1164 0 : if ( !pEntry )
1165 0 : return;
1166 :
1167 0 : SelectAll( sal_False );
1168 0 : SetCurEntry( pEntry );
1169 0 : Select( pEntry );
1170 : }
1171 :
1172 0 : void SvTreeListBox::ExecuteSearchEntry( const void* /*_pEntry*/ ) const
1173 : {
1174 : // nothing to do here, we have no "execution"
1175 0 : }
1176 :
1177 0 : ::vcl::StringEntryIdentifier SvTreeListBox::CurrentEntry( String& _out_entryText ) const
1178 : {
1179 : // always accept the current entry if there is one
1180 0 : SvTreeListEntry* pCurrentEntry( GetCurEntry() );
1181 0 : if ( pCurrentEntry )
1182 : {
1183 0 : _out_entryText = GetEntryText( pCurrentEntry );
1184 0 : return pCurrentEntry;
1185 : }
1186 0 : return FirstSearchEntry( _out_entryText );
1187 : }
1188 :
1189 0 : ::vcl::StringEntryIdentifier SvTreeListBox::NextEntry( ::vcl::StringEntryIdentifier _currentEntry, String& _out_entryText ) const
1190 : {
1191 0 : return NextSearchEntry( _currentEntry, _out_entryText );
1192 : }
1193 :
1194 0 : void SvTreeListBox::SelectEntry( ::vcl::StringEntryIdentifier _entry )
1195 : {
1196 0 : SelectSearchEntry( _entry );
1197 0 : }
1198 :
1199 0 : bool SvTreeListBox::HandleKeyInput( const KeyEvent& _rKEvt )
1200 : {
1201 0 : if ( IsEntryMnemonicsEnabled()
1202 0 : && mpImpl->m_aMnemonicEngine.HandleKeyEvent( _rKEvt )
1203 : )
1204 0 : return true;
1205 :
1206 0 : if ( ( GetStyle() & WB_QUICK_SEARCH ) != 0 )
1207 : {
1208 0 : mpImpl->m_bDoingQuickSelection = true;
1209 0 : const bool bHandled = mpImpl->m_aQuickSelectionEngine.HandleKeyEvent( _rKEvt );
1210 0 : mpImpl->m_bDoingQuickSelection = false;
1211 0 : if ( bHandled )
1212 0 : return true;
1213 : }
1214 :
1215 0 : return false;
1216 : }
1217 :
1218 0 : void SvTreeListBox::WriteDragServerInfo( const Point&, SvLBoxDDInfo* )
1219 : {
1220 : DBG_CHKTHIS(SvTreeListBox,0);
1221 0 : }
1222 :
1223 0 : void SvTreeListBox::ReadDragServerInfo(const Point&, SvLBoxDDInfo* )
1224 : {
1225 : DBG_CHKTHIS(SvTreeListBox,0);
1226 0 : }
1227 :
1228 0 : sal_Bool SvTreeListBox::EditingCanceled() const
1229 : {
1230 0 : if( pEdCtrl && pEdCtrl->EditingCanceled() )
1231 0 : return sal_True;
1232 0 : return sal_False;
1233 : }
1234 :
1235 :
1236 : //JP 28.3.2001: new Drag & Drop API
1237 0 : sal_Int8 SvTreeListBox::AcceptDrop( const AcceptDropEvent& rEvt )
1238 : {
1239 : DBG_CHKTHIS(SvTreeListBox,0);
1240 0 : sal_Int8 nRet = DND_ACTION_NONE;
1241 :
1242 0 : if( rEvt.mbLeaving || !CheckDragAndDropMode( pDDSource, rEvt.mnAction ) )
1243 : {
1244 0 : ImplShowTargetEmphasis( pTargetEntry, sal_False );
1245 : }
1246 0 : else if( !nDragDropMode )
1247 : {
1248 : SAL_WARN( "svtools.contnr", "SvTreeListBox::QueryDrop(): no target" );
1249 : }
1250 : else
1251 : {
1252 0 : SvTreeListEntry* pEntry = GetDropTarget( rEvt.maPosPixel );
1253 0 : if( !IsDropFormatSupported( SOT_FORMATSTR_ID_TREELISTBOX ) )
1254 : {
1255 : SAL_WARN( "svtools.contnr", "SvTreeListBox::QueryDrop(): no format" );
1256 : }
1257 : else
1258 : {
1259 : DBG_ASSERT( pDDSource, "SvTreeListBox::QueryDrop(): SourceBox == 0" );
1260 0 : if( !( pEntry && pDDSource->GetModel() == this->GetModel()
1261 : && DND_ACTION_MOVE == rEvt.mnAction
1262 0 : && ( pEntry->nEntryFlags & SV_ENTRYFLAG_DISABLE_DROP ) ))
1263 : {
1264 0 : if( NotifyAcceptDrop( pEntry ))
1265 0 : nRet = rEvt.mnAction;
1266 : }
1267 : }
1268 :
1269 : // **** draw emphasis ****
1270 0 : if( DND_ACTION_NONE == nRet )
1271 0 : ImplShowTargetEmphasis( pTargetEntry, sal_False );
1272 0 : else if( pEntry != pTargetEntry || !(nImpFlags & SVLBOX_TARGEMPH_VIS) )
1273 : {
1274 0 : ImplShowTargetEmphasis( pTargetEntry, sal_False );
1275 0 : pTargetEntry = pEntry;
1276 0 : ImplShowTargetEmphasis( pTargetEntry, sal_True );
1277 : }
1278 : }
1279 0 : return nRet;
1280 : }
1281 :
1282 0 : sal_Int8 SvTreeListBox::ExecuteDrop( const ExecuteDropEvent& rEvt, SvTreeListBox* pSourceView )
1283 : {
1284 : DBG_CHKTHIS(SvTreeListBox,0);
1285 0 : sal_Int8 nRet = DND_ACTION_NONE;
1286 :
1287 : DBG_ASSERT( pSourceView, "SvTreeListBox::ExecuteDrop(): no source view" );
1288 0 : pSourceView->EnableSelectionAsDropTarget( sal_True, sal_True );
1289 :
1290 0 : ImplShowTargetEmphasis( pTargetEntry, sal_False );
1291 0 : pDDTarget = this;
1292 :
1293 : SvLBoxDDInfo aDDInfo;
1294 :
1295 0 : TransferableDataHelper aData( rEvt.maDropEvent.Transferable );
1296 0 : if( aData.HasFormat( SOT_FORMATSTR_ID_TREELISTBOX ))
1297 : {
1298 0 : ::com::sun::star::uno::Sequence< sal_Int8 > aSeq;
1299 0 : if( aData.GetSequence( SOT_FORMATSTR_ID_TREELISTBOX, aSeq ) &&
1300 0 : sizeof(SvLBoxDDInfo) == aSeq.getLength() )
1301 : {
1302 0 : memcpy( &aDDInfo, aSeq.getConstArray(), sizeof(SvLBoxDDInfo) );
1303 0 : nRet = rEvt.mnAction;
1304 0 : }
1305 : }
1306 :
1307 0 : if( DND_ACTION_NONE != nRet )
1308 : {
1309 0 : nRet = DND_ACTION_NONE;
1310 :
1311 0 : ReadDragServerInfo( rEvt.maPosPixel, &aDDInfo );
1312 :
1313 0 : SvTreeListEntry* pTarget = pTargetEntry; // may be 0!
1314 :
1315 0 : if( DND_ACTION_COPY == rEvt.mnAction )
1316 : {
1317 0 : if ( CopySelection( aDDInfo.pSource, pTarget ) )
1318 0 : nRet = rEvt.mnAction;
1319 : }
1320 0 : else if( DND_ACTION_MOVE == rEvt.mnAction )
1321 : {
1322 0 : if ( MoveSelection( aDDInfo.pSource, pTarget ) )
1323 0 : nRet = rEvt.mnAction;
1324 : }
1325 0 : else if( DND_ACTION_COPYMOVE == rEvt.mnAction )
1326 : {
1327 0 : if ( MoveSelectionCopyFallbackPossible( aDDInfo.pSource, pTarget, sal_True ) )
1328 0 : nRet = rEvt.mnAction;
1329 : }
1330 : }
1331 0 : return nRet;
1332 : }
1333 :
1334 0 : sal_Int8 SvTreeListBox::ExecuteDrop( const ExecuteDropEvent& rEvt )
1335 : {
1336 : DBG_CHKTHIS(SvTreeListBox,0);
1337 0 : return ExecuteDrop( rEvt, GetSourceView() );
1338 : }
1339 :
1340 0 : void SvTreeListBox::StartDrag( sal_Int8, const Point& rPosPixel )
1341 : {
1342 : DBG_CHKTHIS(SvTreeListBox,0);
1343 :
1344 0 : Point aEventPos( rPosPixel );
1345 0 : MouseEvent aMouseEvt( aEventPos, 1, MOUSE_SELECT, MOUSE_LEFT );
1346 0 : MouseButtonUp( aMouseEvt );
1347 :
1348 0 : nOldDragMode = GetDragDropMode();
1349 0 : if ( !nOldDragMode )
1350 : return;
1351 :
1352 0 : ReleaseMouse();
1353 :
1354 0 : SvTreeListEntry* pEntry = GetEntry( rPosPixel ); // GetDropTarget( rPos );
1355 0 : if( !pEntry )
1356 : {
1357 0 : DragFinished( DND_ACTION_NONE );
1358 : return;
1359 : }
1360 :
1361 0 : TransferDataContainer* pContainer = new TransferDataContainer;
1362 : ::com::sun::star::uno::Reference<
1363 0 : ::com::sun::star::datatransfer::XTransferable > xRef( pContainer );
1364 :
1365 0 : nDragDropMode = NotifyStartDrag( *pContainer, pEntry );
1366 0 : if( !nDragDropMode || 0 == GetSelectionCount() )
1367 : {
1368 0 : nDragDropMode = nOldDragMode;
1369 0 : DragFinished( DND_ACTION_NONE );
1370 : return;
1371 : }
1372 :
1373 : SvLBoxDDInfo aDDInfo;
1374 0 : memset(&aDDInfo,0,sizeof(SvLBoxDDInfo));
1375 0 : aDDInfo.pApp = GetpApp();
1376 0 : aDDInfo.pSource = this;
1377 0 : aDDInfo.pDDStartEntry = pEntry;
1378 : // let derived views do their thing
1379 0 : WriteDragServerInfo( rPosPixel, &aDDInfo );
1380 :
1381 : pContainer->CopyAnyData( SOT_FORMATSTR_ID_TREELISTBOX,
1382 0 : (sal_Char*)&aDDInfo, sizeof(SvLBoxDDInfo) );
1383 0 : pDDSource = this;
1384 0 : pDDTarget = 0;
1385 :
1386 0 : sal_Bool bOldUpdateMode = Control::IsUpdateMode();
1387 0 : Control::SetUpdateMode( sal_True );
1388 0 : Update();
1389 0 : Control::SetUpdateMode( bOldUpdateMode );
1390 :
1391 : // Disallow using the selection and its children as drop targets.
1392 : // Important: If the selection of the SourceListBox is changed in the
1393 : // DropHandler, the entries have to be allowed as drop targets again:
1394 : // (GetSourceListBox()->EnableSelectionAsDropTarget( sal_True, sal_True );)
1395 0 : EnableSelectionAsDropTarget( sal_False, sal_True /* with children */ );
1396 :
1397 0 : pContainer->StartDrag( this, nDragOptions, GetDragFinishedHdl() );
1398 : }
1399 :
1400 0 : void SvTreeListBox::DragFinished( sal_Int8
1401 : #ifndef UNX
1402 : nAction
1403 : #endif
1404 : )
1405 : {
1406 0 : EnableSelectionAsDropTarget( sal_True, sal_True );
1407 :
1408 : #ifndef UNX
1409 : if( (nAction == DND_ACTION_MOVE) && ( (pDDTarget &&
1410 : ((sal_uLong)(pDDTarget->GetModel())!=(sal_uLong)(this->GetModel()))) ||
1411 : !pDDTarget ))
1412 : {
1413 : RemoveSelection();
1414 : }
1415 : #endif
1416 :
1417 0 : ImplShowTargetEmphasis( pTargetEntry, sal_False );
1418 0 : pDDSource = 0;
1419 0 : pDDTarget = 0;
1420 0 : pTargetEntry = 0;
1421 0 : nDragDropMode = nOldDragMode;
1422 0 : }
1423 :
1424 0 : DragDropMode SvTreeListBox::NotifyStartDrag( TransferDataContainer&, SvTreeListEntry* )
1425 : {
1426 : DBG_CHKTHIS(SvTreeListBox,0);
1427 0 : return (DragDropMode)0xffff;
1428 : }
1429 :
1430 0 : sal_Bool SvTreeListBox::NotifyAcceptDrop( SvTreeListEntry* )
1431 : {
1432 : DBG_CHKTHIS(SvTreeListBox,0);
1433 0 : return sal_True;
1434 : }
1435 :
1436 : // Handler and methods for Drag - finished handler.
1437 : // The with get GetDragFinishedHdl() get link can set on the
1438 : // TransferDataContainer. This link is a callback for the DragFinished
1439 : // call. AddBox method is called from the GetDragFinishedHdl() and the
1440 : // remove is called in link callback and in the destructor. So it can't
1441 : // called to a deleted object.
1442 :
1443 : namespace
1444 : {
1445 : struct SortLBoxes : public rtl::Static<std::set<sal_uLong>, SortLBoxes> {};
1446 : }
1447 :
1448 0 : void SvTreeListBox::AddBoxToDDList_Impl( const SvTreeListBox& rB )
1449 : {
1450 0 : sal_uLong nVal = (sal_uLong)&rB;
1451 0 : SortLBoxes::get().insert( nVal );
1452 0 : }
1453 :
1454 0 : void SvTreeListBox::RemoveBoxFromDDList_Impl( const SvTreeListBox& rB )
1455 : {
1456 0 : sal_uLong nVal = (sal_uLong)&rB;
1457 0 : SortLBoxes::get().erase( nVal );
1458 0 : }
1459 :
1460 0 : IMPL_STATIC_LINK( SvTreeListBox, DragFinishHdl_Impl, sal_Int8*, pAction )
1461 : {
1462 0 : sal_uLong nVal = (sal_uLong)pThis;
1463 0 : std::set<sal_uLong> &rSortLBoxes = SortLBoxes::get();
1464 0 : std::set<sal_uLong>::const_iterator it = rSortLBoxes.find(nVal);
1465 0 : if( it != rSortLBoxes.end() )
1466 : {
1467 0 : pThis->DragFinished( *pAction );
1468 0 : rSortLBoxes.erase( it );
1469 : }
1470 0 : return 0;
1471 : }
1472 :
1473 0 : Link SvTreeListBox::GetDragFinishedHdl() const
1474 : {
1475 0 : AddBoxToDDList_Impl( *this );
1476 0 : return STATIC_LINK( this, SvTreeListBox, DragFinishHdl_Impl );
1477 : }
1478 :
1479 : /*
1480 : Bugs/TODO
1481 :
1482 : - calculate rectangle when editing in-place (bug with some fonts)
1483 : - SetSpaceBetweenEntries: offset is not taken into account in SetEntryHeight
1484 : */
1485 :
1486 : #define TREEFLAG_FIXEDHEIGHT 0x0010
1487 :
1488 : #define SV_LBOX_DEFAULT_INDENT_PIXEL 20
1489 :
1490 0 : void SvTreeListBox::InitTreeView()
1491 : {
1492 : DBG_CHKTHIS(SvTreeListBox,0);
1493 0 : pCheckButtonData = NULL;
1494 0 : pEdEntry = NULL;
1495 0 : pEdItem = NULL;
1496 0 : nEntryHeight = 0;
1497 0 : pEdCtrl = NULL;
1498 0 : nFirstSelTab = 0;
1499 0 : nLastSelTab = 0;
1500 0 : nFocusWidth = -1;
1501 0 : mnCheckboxItemWidth = 0;
1502 :
1503 0 : Link* pLink = new Link( LINK(this,SvTreeListBox, DefaultCompare) );
1504 0 : mpImpl->m_pLink = pLink;
1505 :
1506 0 : nTreeFlags = TREEFLAG_RECALCTABS;
1507 0 : nIndent = SV_LBOX_DEFAULT_INDENT_PIXEL;
1508 0 : nEntryHeightOffs = SV_ENTRYHEIGHTOFFS_PIXEL;
1509 0 : pImp = new SvImpLBox( this, GetModel(), GetStyle() );
1510 :
1511 0 : mbContextBmpExpanded = true;
1512 0 : nContextBmpWidthMax = 0;
1513 0 : SetFont( GetFont() );
1514 0 : SetSpaceBetweenEntries( 0 );
1515 0 : SetLineColor();
1516 0 : InitSettings( sal_True, sal_True, sal_True );
1517 0 : ImplInitStyle();
1518 0 : SetTabs();
1519 0 : }
1520 :
1521 :
1522 0 : SvTreeListBox::~SvTreeListBox()
1523 : {
1524 : DBG_DTOR(SvTreeListBox,0);
1525 :
1526 0 : pImp->CallEventListeners( VCLEVENT_OBJECT_DYING );
1527 0 : delete pImp;
1528 0 : delete mpImpl->m_pLink;
1529 0 : ClearTabList();
1530 :
1531 0 : delete pEdCtrl;
1532 0 : pEdCtrl = 0;
1533 0 : pModel->RemoveView( this );
1534 0 : if ( pModel->GetRefCount() == 0 )
1535 : {
1536 0 : pModel->Clear();
1537 0 : delete pModel;
1538 0 : pModel = NULL;
1539 : }
1540 :
1541 0 : SvTreeListBox::RemoveBoxFromDDList_Impl( *this );
1542 :
1543 0 : if( this == pDDSource )
1544 0 : pDDSource = 0;
1545 0 : if( this == pDDTarget )
1546 0 : pDDTarget = 0;
1547 0 : delete mpImpl;
1548 0 : }
1549 :
1550 0 : void SvTreeListBox::SetExtendedWinBits( ExtendedWinBits _nBits )
1551 : {
1552 0 : pImp->SetExtendedWindowBits( _nBits );
1553 0 : }
1554 :
1555 0 : void SvTreeListBox::SetModel( SvTreeList* pNewModel )
1556 : {
1557 : DBG_CHKTHIS(SvTreeListBox,0);
1558 0 : pImp->SetModel( pNewModel );
1559 0 : SetBaseModel(pNewModel);
1560 0 : }
1561 :
1562 0 : void SvTreeListBox::SetBaseModel( SvTreeList* pNewModel )
1563 : {
1564 : // does the CleanUp
1565 0 : SvListView::SetModel( pNewModel );
1566 0 : pModel->SetCloneLink( LINK(this, SvTreeListBox, CloneHdl_Impl ));
1567 0 : SvTreeListEntry* pEntry = First();
1568 0 : while( pEntry )
1569 : {
1570 0 : ModelHasInserted( pEntry );
1571 0 : pEntry = Next( pEntry );
1572 : }
1573 0 : }
1574 :
1575 0 : void SvTreeListBox::DisconnectFromModel()
1576 : {
1577 : DBG_CHKTHIS(SvTreeListBox,0);
1578 0 : SvTreeList* pNewModel = new SvTreeList;
1579 0 : pNewModel->SetRefCount( 0 ); // else this will never be deleted
1580 0 : SvListView::SetModel( pNewModel );
1581 :
1582 0 : pImp->SetModel( GetModel() );
1583 0 : }
1584 :
1585 0 : void SvTreeListBox::SetSublistOpenWithReturn( sal_Bool b )
1586 : {
1587 0 : pImp->bSubLstOpRet = b;
1588 0 : }
1589 :
1590 0 : void SvTreeListBox::SetSublistOpenWithLeftRight( sal_Bool b )
1591 : {
1592 0 : pImp->bSubLstOpLR = b;
1593 0 : }
1594 :
1595 0 : void SvTreeListBox::Resize()
1596 : {
1597 : DBG_CHKTHIS(SvTreeListBox,0);
1598 0 : if( IsEditingActive() )
1599 0 : EndEditing( sal_True );
1600 :
1601 0 : Control::Resize();
1602 :
1603 0 : pImp->Resize();
1604 0 : nFocusWidth = -1;
1605 0 : pImp->ShowCursor( sal_False );
1606 0 : pImp->ShowCursor( sal_True );
1607 0 : }
1608 :
1609 : /* Cases:
1610 :
1611 : A) entries have bitmaps
1612 : 0. no buttons
1613 : 1. node buttons (can optionally also be on root items)
1614 : 2. node buttons (can optionally also be on root items) + CheckButton
1615 : 3. CheckButton
1616 : B) entries don't have bitmaps (=>via WindowBits because of D&D!)
1617 : 0. no buttons
1618 : 1. node buttons (can optionally also be on root items)
1619 : 2. node buttons (can optionally also be on root items) + CheckButton
1620 : 3. CheckButton
1621 : */
1622 :
1623 : #define NO_BUTTONS 0
1624 : #define NODE_BUTTONS 1
1625 : #define NODE_AND_CHECK_BUTTONS 2
1626 : #define CHECK_BUTTONS 3
1627 :
1628 : #define TABFLAGS_TEXT (SV_LBOXTAB_DYNAMIC | \
1629 : SV_LBOXTAB_ADJUST_LEFT | \
1630 : SV_LBOXTAB_EDITABLE | \
1631 : SV_LBOXTAB_SHOW_SELECTION)
1632 :
1633 : #define TABFLAGS_CONTEXTBMP (SV_LBOXTAB_DYNAMIC | SV_LBOXTAB_ADJUST_CENTER)
1634 :
1635 : #define TABFLAGS_CHECKBTN (SV_LBOXTAB_DYNAMIC | \
1636 : SV_LBOXTAB_ADJUST_CENTER | \
1637 : SV_LBOXTAB_PUSHABLE)
1638 :
1639 : #define TAB_STARTPOS 2
1640 :
1641 : // take care of GetTextOffset when doing changes
1642 0 : void SvTreeListBox::SetTabs()
1643 : {
1644 : DBG_CHKTHIS(SvTreeListBox,0);
1645 0 : if( IsEditingActive() )
1646 0 : EndEditing( sal_True );
1647 0 : nTreeFlags &= (~TREEFLAG_RECALCTABS);
1648 0 : nFocusWidth = -1;
1649 0 : const WinBits nStyle( GetStyle() );
1650 0 : sal_Bool bHasButtons = (nStyle & WB_HASBUTTONS)!=0;
1651 : sal_Bool bHasButtonsAtRoot = (nStyle & (WB_HASLINESATROOT |
1652 0 : WB_HASBUTTONSATROOT))!=0;
1653 0 : long nStartPos = TAB_STARTPOS;
1654 0 : long nNodeWidthPixel = GetExpandedNodeBmp().GetSizePixel().Width();
1655 :
1656 : // pCheckButtonData->Width() knows nothing about the native checkbox width,
1657 : // so we have mnCheckboxItemWidth which becomes valid when something is added.
1658 0 : long nCheckWidth = 0;
1659 0 : if( nTreeFlags & TREEFLAG_CHKBTN )
1660 0 : nCheckWidth = mnCheckboxItemWidth;
1661 0 : long nCheckWidthDIV2 = nCheckWidth / 2;
1662 :
1663 0 : long nContextWidth = nContextBmpWidthMax;
1664 0 : long nContextWidthDIV2 = nContextWidth / 2;
1665 :
1666 0 : ClearTabList();
1667 :
1668 0 : int nCase = NO_BUTTONS;
1669 0 : if( !(nTreeFlags & TREEFLAG_CHKBTN) )
1670 : {
1671 0 : if( bHasButtons )
1672 0 : nCase = NODE_BUTTONS;
1673 : }
1674 : else
1675 : {
1676 0 : if( bHasButtons )
1677 0 : nCase = NODE_AND_CHECK_BUTTONS;
1678 : else
1679 0 : nCase = CHECK_BUTTONS;
1680 : }
1681 :
1682 0 : switch( nCase )
1683 : {
1684 : case NO_BUTTONS :
1685 0 : nStartPos += nContextWidthDIV2; // because of centering
1686 0 : AddTab( nStartPos, TABFLAGS_CONTEXTBMP );
1687 0 : nStartPos += nContextWidthDIV2; // right edge of context bitmap
1688 : // only set a distance if there are bitmaps
1689 0 : if( nContextBmpWidthMax )
1690 0 : nStartPos += 5; // distance context bitmap to text
1691 0 : AddTab( nStartPos, TABFLAGS_TEXT );
1692 0 : break;
1693 :
1694 : case NODE_BUTTONS :
1695 0 : if( bHasButtonsAtRoot )
1696 0 : nStartPos += ( nIndent + (nNodeWidthPixel/2) );
1697 : else
1698 0 : nStartPos += nContextWidthDIV2;
1699 0 : AddTab( nStartPos, TABFLAGS_CONTEXTBMP );
1700 0 : nStartPos += nContextWidthDIV2; // right edge of context bitmap
1701 : // only set a distance if there are bitmaps
1702 0 : if( nContextBmpWidthMax )
1703 0 : nStartPos += 5; // distance context bitmap to text
1704 0 : AddTab( nStartPos, TABFLAGS_TEXT );
1705 0 : break;
1706 :
1707 : case NODE_AND_CHECK_BUTTONS :
1708 0 : if( bHasButtonsAtRoot )
1709 0 : nStartPos += ( nIndent + nNodeWidthPixel );
1710 : else
1711 0 : nStartPos += nCheckWidthDIV2;
1712 0 : AddTab( nStartPos, TABFLAGS_CHECKBTN );
1713 0 : nStartPos += nCheckWidthDIV2; // right edge of CheckButton
1714 0 : nStartPos += 3; // distance CheckButton to context bitmap
1715 0 : nStartPos += nContextWidthDIV2; // center of context bitmap
1716 0 : AddTab( nStartPos, TABFLAGS_CONTEXTBMP );
1717 0 : nStartPos += nContextWidthDIV2; // right edge of context bitmap
1718 : // only set a distance if there are bitmaps
1719 0 : if( nContextBmpWidthMax )
1720 0 : nStartPos += 5; // distance context bitmap to text
1721 0 : AddTab( nStartPos, TABFLAGS_TEXT );
1722 0 : break;
1723 :
1724 : case CHECK_BUTTONS :
1725 0 : nStartPos += nCheckWidthDIV2;
1726 0 : AddTab( nStartPos, TABFLAGS_CHECKBTN );
1727 0 : nStartPos += nCheckWidthDIV2; // right edge of CheckButton
1728 0 : nStartPos += 3; // distance CheckButton to context bitmap
1729 0 : nStartPos += nContextWidthDIV2; // center of context bitmap
1730 0 : AddTab( nStartPos, TABFLAGS_CONTEXTBMP );
1731 0 : nStartPos += nContextWidthDIV2; // right edge of context bitmap
1732 : // only set a distance if there are bitmaps
1733 0 : if( nContextBmpWidthMax )
1734 0 : nStartPos += 5; // distance context bitmap to text
1735 0 : AddTab( nStartPos, TABFLAGS_TEXT );
1736 0 : break;
1737 : }
1738 0 : pImp->NotifyTabsChanged();
1739 0 : }
1740 :
1741 0 : void SvTreeListBox::InitEntry(SvTreeListEntry* pEntry,
1742 : const OUString& aStr, const Image& aCollEntryBmp, const Image& aExpEntryBmp,
1743 : SvLBoxButtonKind eButtonKind)
1744 : {
1745 : DBG_CHKTHIS(SvTreeListBox,0);
1746 : SvLBoxButton* pButton;
1747 : SvLBoxString* pString;
1748 : SvLBoxContextBmp* pContextBmp;
1749 :
1750 0 : if( nTreeFlags & TREEFLAG_CHKBTN )
1751 : {
1752 0 : pButton= new SvLBoxButton( pEntry,eButtonKind,0,pCheckButtonData );
1753 0 : pEntry->AddItem( pButton );
1754 : }
1755 :
1756 : pContextBmp= new SvLBoxContextBmp(
1757 0 : pEntry,0, aCollEntryBmp,aExpEntryBmp, mbContextBmpExpanded);
1758 0 : pEntry->AddItem( pContextBmp );
1759 :
1760 0 : pString = new SvLBoxString( pEntry, 0, aStr );
1761 0 : pEntry->AddItem( pString );
1762 0 : }
1763 :
1764 0 : String SvTreeListBox::GetEntryText(SvTreeListEntry* pEntry) const
1765 : {
1766 : DBG_CHKTHIS(SvTreeListBox,0);
1767 : DBG_ASSERT( pEntry, "SvTreeListBox::GetEntryText(): no entry" );
1768 0 : SvLBoxString* pItem = (SvLBoxString*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXSTRING));
1769 : DBG_ASSERT( pEntry, "SvTreeListBox::GetEntryText(): item not found" );
1770 0 : return pItem->GetText();
1771 : }
1772 :
1773 0 : String SvTreeListBox::SearchEntryText( SvTreeListEntry* pEntry ) const
1774 : {
1775 : DBG_CHKTHIS(SvTreeListBox,0);
1776 : DBG_ASSERT( pEntry, "SvTreeListBox::SearchEntryText(): no entry" );
1777 0 : String sRet;
1778 0 : sal_uInt16 nCount = pEntry->ItemCount();
1779 0 : sal_uInt16 nCur = 0;
1780 : SvLBoxItem* pItem;
1781 0 : while( nCur < nCount )
1782 : {
1783 0 : pItem = pEntry->GetItem( nCur );
1784 0 : if (pItem->GetType() == SV_ITEM_ID_LBOXSTRING && !static_cast<const SvLBoxString*>(pItem)->GetText().isEmpty())
1785 : {
1786 0 : sRet = static_cast<const SvLBoxString*>(pItem)->GetText();
1787 0 : break;
1788 : }
1789 0 : nCur++;
1790 : }
1791 0 : return sRet;
1792 : }
1793 :
1794 0 : const Image& SvTreeListBox::GetExpandedEntryBmp(const SvTreeListEntry* pEntry) const
1795 : {
1796 : DBG_CHKTHIS(SvTreeListBox,0);
1797 : DBG_ASSERT(pEntry,"Entry?");
1798 0 : const SvLBoxContextBmp* pItem = static_cast<const SvLBoxContextBmp*>(pEntry->GetFirstItem(SV_ITEM_ID_LBOXCONTEXTBMP));
1799 : DBG_ASSERT(pItem,"GetContextBmp:Item not found");
1800 0 : return pItem->GetBitmap2( );
1801 : }
1802 :
1803 0 : const Image& SvTreeListBox::GetCollapsedEntryBmp( const SvTreeListEntry* pEntry ) const
1804 : {
1805 : DBG_CHKTHIS(SvTreeListBox,0);
1806 : DBG_ASSERT(pEntry,"Entry?");
1807 0 : const SvLBoxContextBmp* pItem = static_cast<const SvLBoxContextBmp*>(pEntry->GetFirstItem(SV_ITEM_ID_LBOXCONTEXTBMP));
1808 : DBG_ASSERT(pItem,"GetContextBmp:Item not found");
1809 0 : return pItem->GetBitmap1( );
1810 : }
1811 :
1812 0 : IMPL_LINK_INLINE_START( SvTreeListBox, CheckButtonClick, SvLBoxButtonData *, pData )
1813 : {
1814 : DBG_CHKTHIS(SvTreeListBox,0);
1815 0 : pHdlEntry = pData->GetActEntry();
1816 0 : CheckButtonHdl();
1817 0 : return 0;
1818 : }
1819 0 : IMPL_LINK_INLINE_END( SvTreeListBox, CheckButtonClick, SvLBoxButtonData *, pData )
1820 :
1821 0 : SvTreeListEntry* SvTreeListBox::InsertEntry(
1822 : const XubString& aText,
1823 : SvTreeListEntry* pParent,
1824 : sal_Bool bChildrenOnDemand, sal_uLong nPos,
1825 : void* pUser,
1826 : SvLBoxButtonKind eButtonKind
1827 : )
1828 : {
1829 : DBG_CHKTHIS(SvTreeListBox,0);
1830 0 : nTreeFlags |= TREEFLAG_MANINS;
1831 :
1832 0 : const Image& rDefExpBmp = pImp->GetDefaultEntryExpBmp( );
1833 0 : const Image& rDefColBmp = pImp->GetDefaultEntryColBmp( );
1834 :
1835 0 : aCurInsertedExpBmp = rDefExpBmp;
1836 0 : aCurInsertedColBmp = rDefColBmp;
1837 :
1838 0 : SvTreeListEntry* pEntry = CreateEntry();
1839 0 : pEntry->SetUserData( pUser );
1840 0 : InitEntry( pEntry, aText, rDefColBmp, rDefExpBmp, eButtonKind );
1841 0 : pEntry->EnableChildrenOnDemand( bChildrenOnDemand );
1842 :
1843 0 : if( !pParent )
1844 0 : Insert( pEntry, nPos );
1845 : else
1846 0 : Insert( pEntry, pParent, nPos );
1847 :
1848 0 : aPrevInsertedExpBmp = rDefExpBmp;
1849 0 : aPrevInsertedColBmp = rDefColBmp;
1850 :
1851 0 : nTreeFlags &= (~TREEFLAG_MANINS);
1852 :
1853 0 : return pEntry;
1854 : }
1855 :
1856 0 : SvTreeListEntry* SvTreeListBox::InsertEntry( const XubString& aText,
1857 : const Image& aExpEntryBmp, const Image& aCollEntryBmp,
1858 : SvTreeListEntry* pParent, sal_Bool bChildrenOnDemand, sal_uLong nPos, void* pUser,
1859 : SvLBoxButtonKind eButtonKind )
1860 : {
1861 : DBG_CHKTHIS(SvTreeListBox,0);
1862 0 : nTreeFlags |= TREEFLAG_MANINS;
1863 :
1864 0 : aCurInsertedExpBmp = aExpEntryBmp;
1865 0 : aCurInsertedColBmp = aCollEntryBmp;
1866 :
1867 0 : SvTreeListEntry* pEntry = CreateEntry();
1868 0 : pEntry->SetUserData( pUser );
1869 0 : InitEntry( pEntry, aText, aCollEntryBmp, aExpEntryBmp, eButtonKind );
1870 :
1871 0 : pEntry->EnableChildrenOnDemand( bChildrenOnDemand );
1872 :
1873 0 : if( !pParent )
1874 0 : Insert( pEntry, nPos );
1875 : else
1876 0 : Insert( pEntry, pParent, nPos );
1877 :
1878 0 : aPrevInsertedExpBmp = aExpEntryBmp;
1879 0 : aPrevInsertedColBmp = aCollEntryBmp;
1880 :
1881 0 : nTreeFlags &= (~TREEFLAG_MANINS);
1882 :
1883 0 : return pEntry;
1884 : }
1885 :
1886 0 : void SvTreeListBox::SetEntryText( SvTreeListEntry* pEntry, const XubString& aStr)
1887 : {
1888 : DBG_CHKTHIS(SvTreeListBox,0);
1889 0 : SvLBoxString* pItem = (SvLBoxString*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXSTRING));
1890 : DBG_ASSERT(pItem,"SetText:Item not found");
1891 0 : pItem->SetText( aStr );
1892 0 : pItem->InitViewData( this, pEntry, 0 );
1893 0 : GetModel()->InvalidateEntry( pEntry );
1894 0 : }
1895 :
1896 0 : void SvTreeListBox::SetExpandedEntryBmp( SvTreeListEntry* pEntry, const Image& aBmp )
1897 : {
1898 : DBG_CHKTHIS(SvTreeListBox,0);
1899 0 : SvLBoxContextBmp* pItem = (SvLBoxContextBmp*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXCONTEXTBMP));
1900 :
1901 : DBG_ASSERT(pItem,"SetExpBmp:Item not found");
1902 0 : pItem->SetBitmap2( aBmp );
1903 :
1904 0 : GetModel()->InvalidateEntry( pEntry );
1905 0 : SetEntryHeight( pEntry );
1906 0 : Size aSize = aBmp.GetSizePixel();
1907 0 : short nWidth = pImp->UpdateContextBmpWidthVector( pEntry, (short)aSize.Width() );
1908 0 : if( nWidth > nContextBmpWidthMax )
1909 : {
1910 0 : nContextBmpWidthMax = nWidth;
1911 0 : SetTabs();
1912 : }
1913 0 : }
1914 :
1915 0 : void SvTreeListBox::SetCollapsedEntryBmp(SvTreeListEntry* pEntry,const Image& aBmp )
1916 : {
1917 : DBG_CHKTHIS(SvTreeListBox,0);
1918 0 : SvLBoxContextBmp* pItem = (SvLBoxContextBmp*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXCONTEXTBMP));
1919 :
1920 : DBG_ASSERT(pItem,"SetExpBmp:Item not found");
1921 0 : pItem->SetBitmap1( aBmp );
1922 :
1923 0 : GetModel()->InvalidateEntry( pEntry );
1924 0 : SetEntryHeight( pEntry );
1925 0 : Size aSize = aBmp.GetSizePixel();
1926 0 : short nWidth = pImp->UpdateContextBmpWidthVector( pEntry, (short)aSize.Width() );
1927 0 : if( nWidth > nContextBmpWidthMax )
1928 : {
1929 0 : nContextBmpWidthMax = nWidth;
1930 0 : SetTabs();
1931 : }
1932 0 : }
1933 :
1934 0 : void SvTreeListBox::ImpEntryInserted( SvTreeListEntry* pEntry )
1935 : {
1936 : DBG_CHKTHIS(SvTreeListBox,0);
1937 :
1938 0 : SvTreeListEntry* pParent = (SvTreeListEntry*)pModel->GetParent( pEntry );
1939 0 : if( pParent )
1940 : {
1941 0 : sal_uInt16 nFlags = pParent->GetFlags();
1942 0 : nFlags &= ~SV_ENTRYFLAG_NO_NODEBMP;
1943 0 : pParent->SetFlags( nFlags );
1944 : }
1945 :
1946 0 : if(!((nTreeFlags & TREEFLAG_MANINS) &&
1947 0 : (aPrevInsertedExpBmp == aCurInsertedExpBmp) &&
1948 0 : (aPrevInsertedColBmp == aCurInsertedColBmp) ))
1949 : {
1950 0 : Size aSize = GetCollapsedEntryBmp( pEntry ).GetSizePixel();
1951 0 : if( aSize.Width() > nContextBmpWidthMax )
1952 : {
1953 0 : nContextBmpWidthMax = (short)aSize.Width();
1954 0 : nTreeFlags |= TREEFLAG_RECALCTABS;
1955 : }
1956 0 : aSize = GetExpandedEntryBmp( pEntry ).GetSizePixel();
1957 0 : if( aSize.Width() > nContextBmpWidthMax )
1958 : {
1959 0 : nContextBmpWidthMax = (short)aSize.Width();
1960 0 : nTreeFlags |= TREEFLAG_RECALCTABS;
1961 : }
1962 : }
1963 0 : SetEntryHeight( (SvTreeListEntry*)pEntry );
1964 :
1965 0 : if( nTreeFlags & TREEFLAG_CHKBTN )
1966 : {
1967 0 : SvLBoxButton* pItem = (SvLBoxButton*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXBUTTON));
1968 0 : if( pItem )
1969 : {
1970 0 : long nWidth = pItem->GetSize(this, pEntry).Width();
1971 0 : if( mnCheckboxItemWidth < nWidth )
1972 : {
1973 0 : mnCheckboxItemWidth = nWidth;
1974 0 : nTreeFlags |= TREEFLAG_RECALCTABS;
1975 : }
1976 : }
1977 : }
1978 0 : }
1979 :
1980 :
1981 :
1982 0 : void SvTreeListBox::SetCheckButtonState( SvTreeListEntry* pEntry, SvButtonState eState)
1983 : {
1984 : DBG_CHKTHIS(SvTreeListBox,0);
1985 0 : if( nTreeFlags & TREEFLAG_CHKBTN )
1986 : {
1987 0 : SvLBoxButton* pItem = (SvLBoxButton*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXBUTTON));
1988 0 : if(!(pItem && pItem->CheckModification()))
1989 0 : return ;
1990 0 : switch( eState )
1991 : {
1992 : case SV_BUTTON_CHECKED:
1993 0 : pItem->SetStateChecked();
1994 0 : break;
1995 :
1996 : case SV_BUTTON_UNCHECKED:
1997 0 : pItem->SetStateUnchecked();
1998 0 : break;
1999 :
2000 : case SV_BUTTON_TRISTATE:
2001 0 : pItem->SetStateTristate();
2002 0 : break;
2003 : }
2004 0 : InvalidateEntry( pEntry );
2005 : }
2006 : }
2007 :
2008 0 : SvButtonState SvTreeListBox::GetCheckButtonState( SvTreeListEntry* pEntry ) const
2009 : {
2010 : DBG_CHKTHIS(SvTreeListBox,0);
2011 0 : SvButtonState eState = SV_BUTTON_UNCHECKED;
2012 0 : if( nTreeFlags & TREEFLAG_CHKBTN )
2013 : {
2014 0 : SvLBoxButton* pItem = (SvLBoxButton*)(pEntry->GetFirstItem(SV_ITEM_ID_LBOXBUTTON));
2015 0 : if(!pItem)
2016 0 : return SV_BUTTON_TRISTATE;
2017 0 : sal_uInt16 nButtonFlags = pItem->GetButtonFlags();
2018 0 : eState = pCheckButtonData->ConvertToButtonState( nButtonFlags );
2019 : }
2020 0 : return eState;
2021 : }
2022 :
2023 0 : void SvTreeListBox::CheckButtonHdl()
2024 : {
2025 : DBG_CHKTHIS(SvTreeListBox,0);
2026 0 : aCheckButtonHdl.Call( this );
2027 0 : if ( pCheckButtonData )
2028 0 : pImp->CallEventListeners( VCLEVENT_CHECKBOX_TOGGLE, (void*)pCheckButtonData->GetActEntry() );
2029 0 : }
2030 :
2031 : //
2032 : // TODO: Currently all data is cloned so that they conform to the default tree
2033 : // view format. Actually, the model should be used as a reference here. This
2034 : // leads to us _not_ calling SvTreeListEntry::Clone, but only its base class
2035 : // SvTreeListEntry.
2036 : //
2037 :
2038 0 : SvTreeListEntry* SvTreeListBox::CloneEntry( SvTreeListEntry* pSource )
2039 : {
2040 : DBG_CHKTHIS(SvTreeListBox,0);
2041 0 : XubString aStr;
2042 0 : Image aCollEntryBmp;
2043 0 : Image aExpEntryBmp;
2044 0 : SvLBoxButtonKind eButtonKind = SvLBoxButtonKind_enabledCheckbox;
2045 :
2046 0 : SvLBoxString* pStringItem = (SvLBoxString*)(pSource->GetFirstItem(SV_ITEM_ID_LBOXSTRING));
2047 0 : if( pStringItem )
2048 0 : aStr = pStringItem->GetText();
2049 0 : SvLBoxContextBmp* pBmpItem = (SvLBoxContextBmp*)(pSource->GetFirstItem(SV_ITEM_ID_LBOXCONTEXTBMP));
2050 0 : if( pBmpItem )
2051 : {
2052 0 : aCollEntryBmp = pBmpItem->GetBitmap1( );
2053 0 : aExpEntryBmp = pBmpItem->GetBitmap2( );
2054 : }
2055 0 : SvLBoxButton* pButtonItem = (SvLBoxButton*)(pSource->GetFirstItem(SV_ITEM_ID_LBOXBUTTON));
2056 0 : if( pButtonItem )
2057 0 : eButtonKind = pButtonItem->GetKind();
2058 0 : SvTreeListEntry* pClone = CreateEntry();
2059 0 : InitEntry( pClone, aStr, aCollEntryBmp, aExpEntryBmp, eButtonKind );
2060 0 : pClone->SvTreeListEntry::Clone( pSource );
2061 0 : pClone->EnableChildrenOnDemand( pSource->HasChildrenOnDemand() );
2062 0 : pClone->SetUserData( pSource->GetUserData() );
2063 :
2064 0 : return pClone;
2065 : }
2066 :
2067 0 : void SvTreeListBox::SetIndent( short nNewIndent )
2068 : {
2069 : DBG_CHKTHIS(SvTreeListBox,0);
2070 0 : nIndent = nNewIndent;
2071 0 : SetTabs();
2072 0 : if( IsUpdateMode() )
2073 0 : Invalidate();
2074 0 : }
2075 :
2076 0 : const Image& SvTreeListBox::GetDefaultExpandedEntryBmp( ) const
2077 : {
2078 0 : return pImp->GetDefaultEntryExpBmp( );
2079 : }
2080 :
2081 0 : const Image& SvTreeListBox::GetDefaultCollapsedEntryBmp( ) const
2082 : {
2083 0 : return pImp->GetDefaultEntryColBmp( );
2084 : }
2085 :
2086 0 : void SvTreeListBox::SetDefaultExpandedEntryBmp( const Image& aBmp )
2087 : {
2088 : DBG_CHKTHIS(SvTreeListBox,0);
2089 0 : Size aSize = aBmp.GetSizePixel();
2090 0 : if( aSize.Width() > nContextBmpWidthMax )
2091 0 : nContextBmpWidthMax = (short)aSize.Width();
2092 0 : SetTabs();
2093 :
2094 0 : pImp->SetDefaultEntryExpBmp( aBmp );
2095 0 : }
2096 :
2097 0 : void SvTreeListBox::SetDefaultCollapsedEntryBmp( const Image& aBmp )
2098 : {
2099 : DBG_CHKTHIS(SvTreeListBox,0);
2100 0 : Size aSize = aBmp.GetSizePixel();
2101 0 : if( aSize.Width() > nContextBmpWidthMax )
2102 0 : nContextBmpWidthMax = (short)aSize.Width();
2103 0 : SetTabs();
2104 :
2105 0 : pImp->SetDefaultEntryColBmp( aBmp );
2106 0 : }
2107 :
2108 0 : void SvTreeListBox::EnableCheckButton( SvLBoxButtonData* pData )
2109 : {
2110 : DBG_CHKTHIS(SvTreeListBox,0);
2111 : DBG_ASSERT(!GetEntryCount(),"EnableCheckButton: Entry count != 0");
2112 0 : if( !pData )
2113 0 : nTreeFlags &= (~TREEFLAG_CHKBTN);
2114 : else
2115 : {
2116 0 : SetCheckButtonData( pData );
2117 0 : nTreeFlags |= TREEFLAG_CHKBTN;
2118 0 : pData->SetLink( LINK(this, SvTreeListBox, CheckButtonClick));
2119 : }
2120 :
2121 0 : SetTabs();
2122 0 : if( IsUpdateMode() )
2123 0 : Invalidate();
2124 0 : }
2125 :
2126 0 : void SvTreeListBox::SetCheckButtonData( SvLBoxButtonData* pData )
2127 : {
2128 : DBG_CHKTHIS(SvTreeListBox,0);
2129 0 : if ( pData )
2130 0 : pCheckButtonData = pData;
2131 0 : }
2132 :
2133 0 : const Image& SvTreeListBox::GetDefaultExpandedNodeImage( )
2134 : {
2135 0 : return SvImpLBox::GetDefaultExpandedNodeImage( );
2136 : }
2137 :
2138 0 : const Image& SvTreeListBox::GetDefaultCollapsedNodeImage( )
2139 : {
2140 0 : return SvImpLBox::GetDefaultCollapsedNodeImage( );
2141 : }
2142 :
2143 0 : void SvTreeListBox::SetNodeBitmaps( const Image& rCollapsedNodeBmp, const Image& rExpandedNodeBmp )
2144 : {
2145 : DBG_CHKTHIS(SvTreeListBox,0);
2146 0 : SetExpandedNodeBmp( rExpandedNodeBmp );
2147 0 : SetCollapsedNodeBmp( rCollapsedNodeBmp );
2148 0 : SetTabs();
2149 0 : }
2150 :
2151 0 : sal_Bool SvTreeListBox::EditingEntry( SvTreeListEntry*, Selection& )
2152 : {
2153 : DBG_CHKTHIS(SvTreeListBox,0);
2154 0 : return sal_True;
2155 : }
2156 :
2157 0 : sal_Bool SvTreeListBox::EditedEntry( SvTreeListEntry* /*pEntry*/,const rtl::OUString& /*rNewText*/)
2158 : {
2159 : DBG_CHKTHIS(SvTreeListBox,0);
2160 0 : return sal_True;
2161 : }
2162 :
2163 0 : void SvTreeListBox::EnableInplaceEditing( bool bOn )
2164 : {
2165 : DBG_CHKTHIS(SvTreeListBox,0);
2166 0 : if (bOn)
2167 0 : nImpFlags |= SVLBOX_EDT_ENABLED;
2168 : else
2169 0 : nImpFlags &= ~SVLBOX_EDT_ENABLED;
2170 0 : }
2171 :
2172 0 : void SvTreeListBox::KeyInput( const KeyEvent& rKEvt )
2173 : {
2174 : DBG_CHKTHIS(SvTreeListBox,0);
2175 : // under OS/2, we get key up/down even while editing
2176 0 : if( IsEditingActive() )
2177 0 : return;
2178 :
2179 0 : nImpFlags |= SVLBOX_IS_TRAVELSELECT;
2180 :
2181 : #ifdef OVDEBUG
2182 : sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
2183 : switch ( nCode )
2184 : {
2185 : case KEY_F1:
2186 : {
2187 : SvTreeListEntry* pEntry = First();
2188 : pEntry = NextVisible( pEntry );
2189 : SetEntryText( pEntry, "SetEntryText" );
2190 : }
2191 : break;
2192 : }
2193 : #endif
2194 :
2195 0 : if( !pImp->KeyInput( rKEvt ) )
2196 : {
2197 0 : bool bHandled = HandleKeyInput( rKEvt );
2198 0 : if ( !bHandled )
2199 0 : Control::KeyInput( rKEvt );
2200 : }
2201 :
2202 0 : nImpFlags &= ~SVLBOX_IS_TRAVELSELECT;
2203 : }
2204 :
2205 0 : void SvTreeListBox::RequestingChildren( SvTreeListEntry* pParent )
2206 : {
2207 : DBG_CHKTHIS(SvTreeListBox,0);
2208 0 : if( !pParent->HasChildren() )
2209 0 : InsertEntry( rtl::OUString("<dummy>"), pParent, sal_False, LIST_APPEND );
2210 0 : }
2211 :
2212 0 : void SvTreeListBox::GetFocus()
2213 : {
2214 : DBG_CHKTHIS(SvTreeListBox,0);
2215 0 : pImp->GetFocus();
2216 0 : Control::GetFocus();
2217 :
2218 0 : SvTreeListEntry* pEntry = FirstSelected();
2219 0 : if ( pEntry )
2220 0 : pImp->CallEventListeners( VCLEVENT_LISTBOX_SELECT, pEntry );
2221 :
2222 0 : }
2223 :
2224 0 : void SvTreeListBox::LoseFocus()
2225 : {
2226 : DBG_CHKTHIS(SvTreeListBox,0);
2227 0 : pImp->LoseFocus();
2228 0 : Control::LoseFocus();
2229 0 : }
2230 :
2231 0 : void SvTreeListBox::ModelHasCleared()
2232 : {
2233 : DBG_CHKTHIS(SvTreeListBox,0);
2234 0 : pImp->pCursor = 0; // else we crash in GetFocus when editing in-place
2235 0 : delete pEdCtrl;
2236 0 : pEdCtrl = NULL;
2237 0 : pImp->Clear();
2238 0 : nFocusWidth = -1;
2239 :
2240 0 : nContextBmpWidthMax = 0;
2241 0 : SetDefaultExpandedEntryBmp( GetDefaultExpandedEntryBmp() );
2242 0 : SetDefaultCollapsedEntryBmp( GetDefaultCollapsedEntryBmp() );
2243 :
2244 0 : if( !(nTreeFlags & TREEFLAG_FIXEDHEIGHT ))
2245 0 : nEntryHeight = 0;
2246 0 : AdjustEntryHeight( GetFont() );
2247 0 : AdjustEntryHeight( GetDefaultExpandedEntryBmp() );
2248 0 : AdjustEntryHeight( GetDefaultCollapsedEntryBmp() );
2249 :
2250 0 : SvListView::ModelHasCleared();
2251 0 : }
2252 :
2253 0 : void SvTreeListBox::ShowTargetEmphasis( SvTreeListEntry* pEntry, sal_Bool /*bShow*/ )
2254 : {
2255 : DBG_CHKTHIS(SvTreeListBox,0);
2256 0 : pImp->PaintDDCursor( pEntry );
2257 0 : }
2258 :
2259 0 : void SvTreeListBox::ScrollOutputArea( short nDeltaEntries )
2260 : {
2261 : DBG_CHKTHIS(SvTreeListBox,0);
2262 0 : if( !nDeltaEntries || !pImp->aVerSBar.IsVisible() )
2263 0 : return;
2264 :
2265 0 : long nThumb = pImp->aVerSBar.GetThumbPos();
2266 0 : long nMax = pImp->aVerSBar.GetRange().Max();
2267 :
2268 0 : NotifyBeginScroll();
2269 0 : if( nDeltaEntries < 0 )
2270 : {
2271 : // move window up
2272 0 : nDeltaEntries *= -1;
2273 0 : long nVis = pImp->aVerSBar.GetVisibleSize();
2274 0 : long nTemp = nThumb + nVis;
2275 0 : if( nDeltaEntries > (nMax - nTemp) )
2276 0 : nDeltaEntries = (short)(nMax - nTemp);
2277 0 : pImp->PageDown( (sal_uInt16)nDeltaEntries );
2278 : }
2279 : else
2280 : {
2281 0 : if( nDeltaEntries > nThumb )
2282 0 : nDeltaEntries = (short)nThumb;
2283 0 : pImp->PageUp( (sal_uInt16)nDeltaEntries );
2284 : }
2285 0 : pImp->SyncVerThumb();
2286 0 : NotifyEndScroll();
2287 : }
2288 :
2289 0 : void SvTreeListBox::ScrollToAbsPos( long nPos )
2290 : {
2291 0 : pImp->ScrollToAbsPos( nPos );
2292 0 : }
2293 :
2294 0 : void SvTreeListBox::SetSelectionMode( SelectionMode eSelectMode )
2295 : {
2296 : DBG_CHKTHIS(SvTreeListBox,0);
2297 0 : eSelMode = eSelectMode;
2298 0 : pImp->SetSelectionMode( eSelectMode );
2299 0 : }
2300 :
2301 0 : void SvTreeListBox::SetDragDropMode( DragDropMode nDDMode )
2302 : {
2303 : DBG_CHKTHIS(SvTreeListBox,0);
2304 0 : nDragDropMode = nDDMode;
2305 0 : pImp->SetDragDropMode( nDDMode );
2306 0 : }
2307 :
2308 0 : short SvTreeListBox::GetHeightOffset(const Image& rBmp, Size& aSizeLogic )
2309 : {
2310 : DBG_CHKTHIS(SvTreeListBox,0);
2311 0 : short nOffset = 0;
2312 0 : aSizeLogic = rBmp.GetSizePixel();
2313 0 : if( GetEntryHeight() > aSizeLogic.Height() )
2314 0 : nOffset = ( GetEntryHeight() - (short)aSizeLogic.Height()) / 2;
2315 0 : return nOffset;
2316 : }
2317 :
2318 0 : short SvTreeListBox::GetHeightOffset(const Font& /* rFont */, Size& aSizeLogic )
2319 : {
2320 : DBG_CHKTHIS(SvTreeListBox,0);
2321 0 : short nOffset = 0;
2322 0 : aSizeLogic = Size(GetTextWidth(rtl::OUString('X')), GetTextHeight());
2323 0 : if( GetEntryHeight() > aSizeLogic.Height() )
2324 0 : nOffset = ( GetEntryHeight() - (short)aSizeLogic.Height()) / 2;
2325 0 : return nOffset;
2326 : }
2327 :
2328 0 : void SvTreeListBox::SetEntryHeight( SvTreeListEntry* pEntry )
2329 : {
2330 : DBG_CHKTHIS(SvTreeListBox,0);
2331 0 : short nHeight, nHeightMax=0;
2332 0 : sal_uInt16 nCount = pEntry->ItemCount();
2333 0 : sal_uInt16 nCur = 0;
2334 0 : SvViewDataEntry* pViewData = GetViewDataEntry( pEntry );
2335 0 : while( nCur < nCount )
2336 : {
2337 0 : SvLBoxItem* pItem = pEntry->GetItem( nCur );
2338 0 : nHeight = (short)(pItem->GetSize( pViewData, nCur ).Height());
2339 0 : if( nHeight > nHeightMax )
2340 0 : nHeightMax = nHeight;
2341 0 : nCur++;
2342 : }
2343 :
2344 0 : if( nHeightMax > nEntryHeight )
2345 : {
2346 0 : nEntryHeight = nHeightMax;
2347 0 : Control::SetFont( GetFont() );
2348 0 : pImp->SetEntryHeight( nHeightMax );
2349 : }
2350 0 : }
2351 :
2352 0 : void SvTreeListBox::SetEntryHeight( short nHeight, sal_Bool bAlways )
2353 : {
2354 : DBG_CHKTHIS(SvTreeListBox,0);
2355 :
2356 0 : if( bAlways || nHeight > nEntryHeight )
2357 : {
2358 0 : nEntryHeight = nHeight;
2359 0 : if( nEntryHeight )
2360 0 : nTreeFlags |= TREEFLAG_FIXEDHEIGHT;
2361 : else
2362 0 : nTreeFlags &= ~TREEFLAG_FIXEDHEIGHT;
2363 0 : Control::SetFont( GetFont() );
2364 0 : pImp->SetEntryHeight( nHeight );
2365 : }
2366 0 : }
2367 :
2368 :
2369 0 : void SvTreeListBox::AdjustEntryHeight( const Image& rBmp )
2370 : {
2371 : DBG_CHKTHIS(SvTreeListBox,0);
2372 0 : Size aSize;
2373 0 : GetHeightOffset( rBmp, aSize );
2374 0 : if( aSize.Height() > nEntryHeight )
2375 : {
2376 0 : nEntryHeight = (short)aSize.Height() + nEntryHeightOffs;
2377 0 : pImp->SetEntryHeight( nEntryHeight );
2378 : }
2379 0 : }
2380 :
2381 0 : void SvTreeListBox::AdjustEntryHeight( const Font& rFont )
2382 : {
2383 : DBG_CHKTHIS(SvTreeListBox,0);
2384 0 : Size aSize;
2385 0 : GetHeightOffset( rFont, aSize );
2386 0 : if( aSize.Height() > nEntryHeight )
2387 : {
2388 0 : nEntryHeight = (short)aSize.Height() + nEntryHeightOffs;
2389 0 : pImp->SetEntryHeight( nEntryHeight );
2390 : }
2391 0 : }
2392 :
2393 0 : sal_Bool SvTreeListBox::Expand( SvTreeListEntry* pParent )
2394 : {
2395 : DBG_CHKTHIS(SvTreeListBox,0);
2396 0 : pHdlEntry = pParent;
2397 0 : sal_Bool bExpanded = sal_False;
2398 : sal_uInt16 nFlags;
2399 :
2400 0 : if( pParent->HasChildrenOnDemand() )
2401 0 : RequestingChildren( pParent );
2402 0 : if( pParent->HasChildren() )
2403 : {
2404 0 : nImpFlags |= SVLBOX_IS_EXPANDING;
2405 0 : if( ExpandingHdl() )
2406 : {
2407 0 : bExpanded = sal_True;
2408 0 : SvListView::Expand( pParent );
2409 0 : pImp->EntryExpanded( pParent );
2410 0 : pHdlEntry = pParent;
2411 0 : ExpandedHdl();
2412 : }
2413 0 : nFlags = pParent->GetFlags();
2414 0 : nFlags &= ~SV_ENTRYFLAG_NO_NODEBMP;
2415 0 : nFlags |= SV_ENTRYFLAG_HAD_CHILDREN;
2416 0 : pParent->SetFlags( nFlags );
2417 : }
2418 : else
2419 : {
2420 0 : nFlags = pParent->GetFlags();
2421 0 : nFlags |= SV_ENTRYFLAG_NO_NODEBMP;
2422 0 : pParent->SetFlags( nFlags );
2423 0 : GetModel()->InvalidateEntry( pParent ); // repaint
2424 : }
2425 :
2426 : // #i92103#
2427 0 : if ( bExpanded )
2428 : {
2429 0 : pImp->CallEventListeners( VCLEVENT_ITEM_EXPANDED, pParent );
2430 : }
2431 :
2432 0 : return bExpanded;
2433 : }
2434 :
2435 0 : sal_Bool SvTreeListBox::Collapse( SvTreeListEntry* pParent )
2436 : {
2437 : DBG_CHKTHIS(SvTreeListBox,0);
2438 0 : nImpFlags &= ~SVLBOX_IS_EXPANDING;
2439 0 : pHdlEntry = pParent;
2440 0 : sal_Bool bCollapsed = sal_False;
2441 :
2442 0 : if( ExpandingHdl() )
2443 : {
2444 0 : bCollapsed = sal_True;
2445 0 : pImp->CollapsingEntry( pParent );
2446 0 : SvListView::Collapse( pParent );
2447 0 : pImp->EntryCollapsed( pParent );
2448 0 : pHdlEntry = pParent;
2449 0 : ExpandedHdl();
2450 : }
2451 :
2452 : // #i92103#
2453 0 : if ( bCollapsed )
2454 : {
2455 0 : pImp->CallEventListeners( VCLEVENT_ITEM_COLLAPSED, pParent );
2456 : }
2457 :
2458 0 : return bCollapsed;
2459 : }
2460 :
2461 0 : sal_Bool SvTreeListBox::Select( SvTreeListEntry* pEntry, sal_Bool bSelect )
2462 : {
2463 : DBG_CHKTHIS(SvTreeListBox,0);
2464 : DBG_ASSERT(pEntry,"Select: Null-Ptr");
2465 0 : sal_Bool bRetVal = SvListView::Select( pEntry, bSelect );
2466 : DBG_ASSERT(IsSelected(pEntry)==bSelect,"Select failed");
2467 0 : if( bRetVal )
2468 : {
2469 0 : pImp->EntrySelected( pEntry, bSelect );
2470 0 : pHdlEntry = pEntry;
2471 0 : if( bSelect )
2472 : {
2473 0 : SelectHdl();
2474 0 : pImp->CallEventListeners( VCLEVENT_LISTBOX_SELECT, pEntry );
2475 : }
2476 : else
2477 0 : DeselectHdl();
2478 : }
2479 0 : return bRetVal;
2480 : }
2481 :
2482 0 : sal_uLong SvTreeListBox::SelectChildren( SvTreeListEntry* pParent, sal_Bool bSelect )
2483 : {
2484 : DBG_CHKTHIS(SvTreeListBox,0);
2485 0 : pImp->DestroyAnchor();
2486 0 : sal_uLong nRet = 0;
2487 0 : if( !pParent->HasChildren() )
2488 0 : return 0;
2489 0 : sal_uInt16 nRefDepth = pModel->GetDepth( pParent );
2490 0 : SvTreeListEntry* pChild = FirstChild( pParent );
2491 0 : do {
2492 0 : nRet++;
2493 0 : Select( pChild, bSelect );
2494 0 : pChild = Next( pChild );
2495 0 : } while( pChild && pModel->GetDepth( pChild ) > nRefDepth );
2496 0 : return nRet;
2497 : }
2498 :
2499 0 : void SvTreeListBox::SelectAll( sal_Bool bSelect, sal_Bool )
2500 : {
2501 : DBG_CHKTHIS(SvTreeListBox,0);
2502 : pImp->SelAllDestrAnch(
2503 : bSelect,
2504 : sal_True, // delete anchor,
2505 0 : sal_True ); // even when using SINGLE_SELECTION, deselect the cursor
2506 0 : }
2507 :
2508 0 : void SvTreeListBox::ModelHasInsertedTree( SvTreeListEntry* pEntry )
2509 : {
2510 : DBG_CHKTHIS(SvTreeListBox,0);
2511 0 : sal_uInt16 nRefDepth = pModel->GetDepth( (SvTreeListEntry*)pEntry );
2512 0 : SvTreeListEntry* pTmp = (SvTreeListEntry*)pEntry;
2513 0 : do
2514 : {
2515 0 : ImpEntryInserted( pTmp );
2516 0 : pTmp = Next( pTmp );
2517 0 : } while( pTmp && nRefDepth < pModel->GetDepth( pTmp ) );
2518 0 : pImp->TreeInserted( (SvTreeListEntry*)pEntry );
2519 0 : }
2520 :
2521 0 : void SvTreeListBox::ModelHasInserted( SvTreeListEntry* pEntry )
2522 : {
2523 : DBG_CHKTHIS(SvTreeListBox,0);
2524 0 : ImpEntryInserted( (SvTreeListEntry*)pEntry );
2525 0 : pImp->EntryInserted( (SvTreeListEntry*)pEntry );
2526 0 : }
2527 :
2528 0 : void SvTreeListBox::ModelIsMoving(SvTreeListEntry* pSource,
2529 : SvTreeListEntry* /* pTargetParent */,
2530 : sal_uLong /* nChildPos */ )
2531 : {
2532 : DBG_CHKTHIS(SvTreeListBox,0);
2533 0 : pImp->MovingEntry( (SvTreeListEntry*)pSource );
2534 0 : }
2535 :
2536 0 : void SvTreeListBox::ModelHasMoved( SvTreeListEntry* pSource )
2537 : {
2538 : DBG_CHKTHIS(SvTreeListBox,0);
2539 0 : pImp->EntryMoved( (SvTreeListEntry*)pSource );
2540 0 : }
2541 :
2542 0 : void SvTreeListBox::ModelIsRemoving( SvTreeListEntry* pEntry )
2543 : {
2544 : DBG_CHKTHIS(SvTreeListBox,0);
2545 0 : if(pEdEntry == pEntry)
2546 0 : pEdEntry = NULL;
2547 :
2548 0 : pImp->RemovingEntry( (SvTreeListEntry*)pEntry );
2549 0 : NotifyRemoving( (SvTreeListEntry*)pEntry );
2550 0 : }
2551 :
2552 0 : void SvTreeListBox::ModelHasRemoved( SvTreeListEntry* pEntry )
2553 : {
2554 : DBG_CHKTHIS(SvTreeListBox,0);
2555 0 : if ( pEntry == pHdlEntry)
2556 0 : pHdlEntry = NULL;
2557 0 : pImp->EntryRemoved();
2558 0 : }
2559 :
2560 0 : void SvTreeListBox::SetCollapsedNodeBmp( const Image& rBmp)
2561 : {
2562 : DBG_CHKTHIS(SvTreeListBox,0);
2563 0 : AdjustEntryHeight( rBmp );
2564 0 : pImp->SetCollapsedNodeBmp( rBmp );
2565 0 : }
2566 :
2567 0 : void SvTreeListBox::SetExpandedNodeBmp( const Image& rBmp )
2568 : {
2569 : DBG_CHKTHIS(SvTreeListBox,0);
2570 0 : AdjustEntryHeight( rBmp );
2571 0 : pImp->SetExpandedNodeBmp( rBmp );
2572 0 : }
2573 :
2574 :
2575 0 : void SvTreeListBox::SetFont( const Font& rFont )
2576 : {
2577 : DBG_CHKTHIS(SvTreeListBox,0);
2578 0 : Font aTempFont( rFont );
2579 0 : aTempFont.SetTransparent( sal_True );
2580 0 : Control::SetFont( aTempFont );
2581 0 : AdjustEntryHeight( aTempFont );
2582 : // always invalidate, else things go wrong in SetEntryHeight
2583 0 : RecalcViewData();
2584 0 : }
2585 :
2586 :
2587 0 : void SvTreeListBox::Paint( const Rectangle& rRect )
2588 : {
2589 : DBG_CHKTHIS(SvTreeListBox,0);
2590 0 : Control::Paint( rRect );
2591 0 : if( nTreeFlags & TREEFLAG_RECALCTABS )
2592 0 : SetTabs();
2593 0 : pImp->Paint( rRect );
2594 0 : }
2595 :
2596 0 : void SvTreeListBox::MouseButtonDown( const MouseEvent& rMEvt )
2597 : {
2598 : DBG_CHKTHIS(SvTreeListBox,0);
2599 0 : pImp->MouseButtonDown( rMEvt );
2600 0 : }
2601 :
2602 0 : void SvTreeListBox::MouseButtonUp( const MouseEvent& rMEvt )
2603 : {
2604 : DBG_CHKTHIS(SvTreeListBox,0);
2605 0 : pImp->MouseButtonUp( rMEvt );
2606 0 : }
2607 :
2608 0 : void SvTreeListBox::MouseMove( const MouseEvent& rMEvt )
2609 : {
2610 : DBG_CHKTHIS(SvTreeListBox,0);
2611 0 : pImp->MouseMove( rMEvt );
2612 0 : }
2613 :
2614 :
2615 0 : void SvTreeListBox::SetUpdateMode( sal_Bool bUpdate )
2616 : {
2617 : DBG_CHKTHIS(SvTreeListBox,0);
2618 0 : pImp->SetUpdateMode( bUpdate );
2619 0 : }
2620 :
2621 0 : void SvTreeListBox::SetSpaceBetweenEntries( short nOffsLogic )
2622 : {
2623 : DBG_CHKTHIS(SvTreeListBox,0);
2624 0 : if( nOffsLogic != nEntryHeightOffs )
2625 : {
2626 0 : nEntryHeight = nEntryHeight - nEntryHeightOffs;
2627 0 : nEntryHeightOffs = (short)nOffsLogic;
2628 0 : nEntryHeight = nEntryHeight + nOffsLogic;
2629 0 : AdjustEntryHeight( GetFont() );
2630 0 : RecalcViewData();
2631 0 : pImp->SetEntryHeight( nEntryHeight );
2632 : }
2633 0 : }
2634 :
2635 0 : void SvTreeListBox::SetCursor( SvTreeListEntry* pEntry, sal_Bool bForceNoSelect )
2636 : {
2637 : DBG_CHKTHIS(SvTreeListBox,0);
2638 0 : pImp->SetCursor(pEntry, bForceNoSelect);
2639 0 : }
2640 :
2641 0 : void SvTreeListBox::SetCurEntry( SvTreeListEntry* pEntry )
2642 : {
2643 : DBG_CHKTHIS(SvTreeListBox,0);
2644 0 : pImp->SetCurEntry( pEntry );
2645 0 : }
2646 :
2647 0 : Image SvTreeListBox::GetExpandedNodeBmp( ) const
2648 : {
2649 0 : return pImp->GetExpandedNodeBmp( );
2650 : }
2651 :
2652 0 : Point SvTreeListBox::GetEntryPosition( SvTreeListEntry* pEntry ) const
2653 : {
2654 0 : return pImp->GetEntryPosition( pEntry );
2655 : }
2656 :
2657 0 : void SvTreeListBox::ShowEntry( SvTreeListEntry* pEntry )
2658 : {
2659 0 : MakeVisible( pEntry );
2660 0 : }
2661 :
2662 0 : void SvTreeListBox::MakeVisible( SvTreeListEntry* pEntry )
2663 : {
2664 0 : pImp->MakeVisible(pEntry);
2665 0 : }
2666 :
2667 0 : void SvTreeListBox::MakeVisible( SvTreeListEntry* pEntry, sal_Bool bMoveToTop )
2668 : {
2669 0 : pImp->MakeVisible( pEntry, bMoveToTop );
2670 0 : }
2671 :
2672 0 : void SvTreeListBox::ModelHasEntryInvalidated( SvTreeListEntry* pEntry )
2673 : {
2674 : DBG_CHKTHIS(SvTreeListBox,0);
2675 :
2676 : // reinitialize the separate items of the entries
2677 0 : sal_uInt16 nCount = ((SvTreeListEntry*)pEntry)->ItemCount();
2678 0 : for( sal_uInt16 nIdx = 0; nIdx < nCount; nIdx++ )
2679 : {
2680 0 : SvLBoxItem* pItem = ((SvTreeListEntry*)pEntry)->GetItem( nIdx );
2681 0 : pItem->InitViewData( this, (SvTreeListEntry*)pEntry, 0 );
2682 : }
2683 :
2684 : // repaint
2685 0 : pImp->InvalidateEntry( (SvTreeListEntry*)pEntry );
2686 0 : }
2687 :
2688 0 : void SvTreeListBox::EditItemText( SvTreeListEntry* pEntry, SvLBoxString* pItem,
2689 : const Selection& rSelection )
2690 : {
2691 : DBG_CHKTHIS(SvTreeListBox,0);
2692 : DBG_ASSERT(pEntry&&pItem,"EditItemText: Bad params");
2693 0 : if( IsSelected( pEntry ))
2694 : {
2695 0 : pImp->ShowCursor( sal_False );
2696 0 : SvListView::Select( pEntry, sal_False );
2697 0 : PaintEntry( pEntry );
2698 0 : SvListView::Select( pEntry, sal_True );
2699 0 : pImp->ShowCursor( sal_True );
2700 : }
2701 0 : pEdEntry = pEntry;
2702 0 : pEdItem = pItem;
2703 0 : SvLBoxTab* pTab = GetTab( pEntry, pItem );
2704 : DBG_ASSERT(pTab,"EditItemText:Tab not found");
2705 :
2706 0 : Size aItemSize( pItem->GetSize(this, pEntry) );
2707 0 : Point aPos = GetEntryPosition( pEntry );
2708 0 : aPos.Y() += ( nEntryHeight - aItemSize.Height() ) / 2;
2709 0 : aPos.X() = GetTabPos( pEntry, pTab );
2710 0 : long nOutputWidth = pImp->GetOutputSize().Width();
2711 0 : Size aSize( nOutputWidth - aPos.X(), aItemSize.Height() );
2712 0 : sal_uInt16 nPos = std::find( aTabs.begin(), aTabs.end(), pTab ) - aTabs.begin();
2713 0 : if( nPos+1 < (sal_uInt16)aTabs.size() )
2714 : {
2715 0 : SvLBoxTab* pRightTab = aTabs[ nPos + 1 ];
2716 0 : long nRight = GetTabPos( pEntry, pRightTab );
2717 0 : if( nRight <= nOutputWidth )
2718 0 : aSize.Width() = nRight - aPos.X();
2719 : }
2720 0 : Point aOrigin( GetMapMode().GetOrigin() );
2721 0 : aPos += aOrigin; // convert to win coordinates
2722 0 : aSize.Width() -= aOrigin.X();
2723 0 : Rectangle aRect( aPos, aSize );
2724 0 : EditText( pItem->GetText(), aRect, rSelection );
2725 0 : }
2726 :
2727 0 : void SvTreeListBox::EditEntry( SvTreeListEntry* pEntry )
2728 : {
2729 0 : pImp->aEditClickPos = Point( -1, -1 );
2730 0 : ImplEditEntry( pEntry );
2731 0 : }
2732 :
2733 0 : void SvTreeListBox::ImplEditEntry( SvTreeListEntry* pEntry )
2734 : {
2735 : DBG_CHKTHIS(SvTreeListBox,0);
2736 0 : if( IsEditingActive() )
2737 0 : EndEditing();
2738 0 : if( !pEntry )
2739 0 : pEntry = GetCurEntry();
2740 0 : if( pEntry )
2741 : {
2742 0 : long nClickX = pImp->aEditClickPos.X();
2743 0 : bool bIsMouseTriggered = nClickX >= 0;
2744 :
2745 0 : SvLBoxString* pItem = NULL;
2746 0 : sal_uInt16 nCount = pEntry->ItemCount();
2747 0 : long nTabPos, nNextTabPos = 0;
2748 0 : for( sal_uInt16 i = 0 ; i < nCount ; i++ )
2749 : {
2750 0 : SvLBoxItem* pTmpItem = pEntry->GetItem( i );
2751 0 : if (pTmpItem->GetType() != SV_ITEM_ID_LBOXSTRING)
2752 0 : continue;
2753 :
2754 0 : SvLBoxTab* pTab = GetTab( pEntry, pTmpItem );
2755 0 : nNextTabPos = -1;
2756 0 : if( i < nCount - 1 )
2757 : {
2758 0 : SvLBoxItem* pNextItem = pEntry->GetItem( i + 1 );
2759 0 : SvLBoxTab* pNextTab = GetTab( pEntry, pNextItem );
2760 0 : nNextTabPos = pNextTab->GetPos();
2761 : }
2762 :
2763 0 : if( pTab && pTab->IsEditable() )
2764 : {
2765 0 : nTabPos = pTab->GetPos();
2766 0 : if( !bIsMouseTriggered || (nClickX > nTabPos && (nNextTabPos == -1 || nClickX < nNextTabPos ) ) )
2767 : {
2768 0 : pItem = static_cast<SvLBoxString*>( pTmpItem );
2769 0 : break;
2770 : }
2771 : }
2772 : }
2773 :
2774 0 : Selection aSel( SELECTION_MIN, SELECTION_MAX );
2775 0 : if( pItem && EditingEntry( pEntry, aSel ) )
2776 : {
2777 0 : SelectAll( sal_False );
2778 0 : MakeVisible( pEntry );
2779 0 : EditItemText( pEntry, pItem, aSel );
2780 : }
2781 : }
2782 0 : }
2783 :
2784 0 : sal_Bool SvTreeListBox::AreChildrenTransient() const
2785 : {
2786 0 : return pImp->AreChildrenTransient();
2787 : }
2788 :
2789 0 : void SvTreeListBox::SetChildrenNotTransient()
2790 : {
2791 0 : pImp->SetChildrenNotTransient();
2792 0 : }
2793 :
2794 0 : void SvTreeListBox::EditedText( const XubString& rStr )
2795 :
2796 : {
2797 : DBG_CHKTHIS(SvTreeListBox,0);
2798 0 : if(pEdEntry) // we have to check if this entry is null that means that it is removed while editing
2799 : {
2800 0 : if( EditedEntry( pEdEntry, rStr ) )
2801 : {
2802 0 : ((SvLBoxString*)pEdItem)->SetText( rStr );
2803 0 : pModel->InvalidateEntry( pEdEntry );
2804 : }
2805 0 : if( GetSelectionCount() == 0 )
2806 0 : Select( pEdEntry );
2807 0 : if( GetSelectionMode() == MULTIPLE_SELECTION && !GetCurEntry() )
2808 0 : SetCurEntry( pEdEntry );
2809 : }
2810 0 : }
2811 :
2812 0 : SvTreeListEntry* SvTreeListBox::GetDropTarget( const Point& rPos )
2813 : {
2814 : DBG_CHKTHIS(SvTreeListBox,0);
2815 : // scroll
2816 0 : if( rPos.Y() < 12 )
2817 : {
2818 0 : ImplShowTargetEmphasis(pTargetEntry, false);
2819 0 : ScrollOutputArea( +1 );
2820 : }
2821 : else
2822 : {
2823 0 : Size aSize( pImp->GetOutputSize() );
2824 0 : if( rPos.Y() > aSize.Height() - 12 )
2825 : {
2826 0 : ImplShowTargetEmphasis(pTargetEntry, false);
2827 0 : ScrollOutputArea( -1 );
2828 : }
2829 : }
2830 :
2831 0 : SvTreeListEntry* pTarget = pImp->GetEntry( rPos );
2832 : // when dropping in a vacant space, use the last entry
2833 0 : if( !pTarget )
2834 0 : return (SvTreeListEntry*)LastVisible();
2835 0 : else if( (GetDragDropMode() & SV_DRAGDROP_ENABLE_TOP) &&
2836 0 : pTarget == First() && rPos.Y() < 6 )
2837 0 : return 0;
2838 :
2839 0 : return pTarget;
2840 : }
2841 :
2842 :
2843 0 : SvTreeListEntry* SvTreeListBox::GetEntry( const Point& rPos, sal_Bool bHit ) const
2844 : {
2845 : DBG_CHKTHIS(SvTreeListBox,0);
2846 0 : SvTreeListEntry* pEntry = pImp->GetEntry( rPos );
2847 0 : if( pEntry && bHit )
2848 : {
2849 0 : long nLine = pImp->GetEntryLine( pEntry );
2850 0 : if( !(pImp->EntryReallyHit( pEntry, rPos, nLine)) )
2851 0 : return 0;
2852 : }
2853 0 : return pEntry;
2854 : }
2855 :
2856 0 : SvTreeListEntry* SvTreeListBox::GetCurEntry() const
2857 : {
2858 : DBG_CHKTHIS(SvTreeListBox,0);
2859 0 : return pImp->GetCurEntry();
2860 : }
2861 :
2862 0 : void SvTreeListBox::ImplInitStyle()
2863 : {
2864 : DBG_CHKTHIS(SvTreeListBox,0);
2865 :
2866 0 : const WinBits nWindowStyle = GetStyle();
2867 :
2868 0 : nTreeFlags |= TREEFLAG_RECALCTABS;
2869 0 : if( nWindowStyle & WB_SORT )
2870 : {
2871 0 : GetModel()->SetSortMode( SortAscending );
2872 0 : GetModel()->SetCompareHdl( LINK(this,SvTreeListBox,DefaultCompare));
2873 : }
2874 : else
2875 : {
2876 0 : GetModel()->SetSortMode( SortNone );
2877 0 : GetModel()->SetCompareHdl( Link() );
2878 : }
2879 0 : pImp->SetStyle( nWindowStyle );
2880 0 : pImp->Resize();
2881 0 : Invalidate();
2882 0 : }
2883 :
2884 0 : void SvTreeListBox::PaintEntry( SvTreeListEntry* pEntry )
2885 : {
2886 : DBG_CHKTHIS(SvTreeListBox,0);
2887 : DBG_ASSERT(pEntry,"PaintEntry:No Entry");
2888 0 : if( pEntry )
2889 0 : pImp->PaintEntry( pEntry );
2890 0 : }
2891 :
2892 0 : void SvTreeListBox::InvalidateEntry( SvTreeListEntry* pEntry )
2893 : {
2894 : DBG_CHKTHIS(SvTreeListBox,0);
2895 : DBG_ASSERT(pEntry,"InvalidateEntry:No Entry");
2896 0 : if( pEntry )
2897 : {
2898 0 : GetModel()->InvalidateEntry( pEntry );
2899 : }
2900 0 : }
2901 :
2902 0 : long SvTreeListBox::PaintEntry(SvTreeListEntry* pEntry,long nLine,sal_uInt16 nTabFlags)
2903 : {
2904 0 : return PaintEntry1(pEntry,nLine,nTabFlags);
2905 : }
2906 :
2907 0 : long SvTreeListBox::PaintEntry1(SvTreeListEntry* pEntry,long nLine,sal_uInt16 nTabFlags,
2908 : sal_Bool bHasClipRegion )
2909 : {
2910 : DBG_CHKTHIS(SvTreeListBox,0);
2911 :
2912 0 : Rectangle aRect; // multi purpose
2913 :
2914 0 : sal_Bool bHorSBar = pImp->HasHorScrollBar();
2915 0 : PreparePaint( pEntry );
2916 :
2917 0 : pImp->UpdateContextBmpWidthMax( pEntry );
2918 :
2919 0 : if( nTreeFlags & TREEFLAG_RECALCTABS )
2920 0 : SetTabs();
2921 :
2922 0 : short nTempEntryHeight = GetEntryHeight();
2923 0 : long nWidth = pImp->GetOutputSize().Width();
2924 :
2925 : // Did we turn on the scrollbar within PreparePaints? If yes, we have to set
2926 : // the ClipRegion anew.
2927 0 : if( !bHorSBar && pImp->HasHorScrollBar() )
2928 0 : SetClipRegion( Region(pImp->GetClipRegionRect()) );
2929 :
2930 0 : Point aEntryPos( GetMapMode().GetOrigin() );
2931 0 : aEntryPos.X() *= -1; // conversion document coordinates
2932 0 : long nMaxRight = nWidth + aEntryPos.X() - 1;
2933 :
2934 0 : Color aBackupTextColor( GetTextColor() );
2935 0 : Font aBackupFont( GetFont() );
2936 0 : Color aBackupColor = GetFillColor();
2937 :
2938 0 : bool bCurFontIsSel = false;
2939 0 : sal_Bool bInUse = pEntry->HasInUseEmphasis();
2940 : // if a ClipRegion was set from outside, we don't have to reset it
2941 0 : const WinBits nWindowStyle = GetStyle();
2942 0 : const sal_Bool bResetClipRegion = !bHasClipRegion;
2943 0 : const sal_Bool bHideSelection = ((nWindowStyle & WB_HIDESELECTION) && !HasFocus())!=0;
2944 0 : const StyleSettings& rSettings = GetSettings().GetStyleSettings();
2945 :
2946 0 : Font aHighlightFont( GetFont() );
2947 0 : const Color aHighlightTextColor( rSettings.GetHighlightTextColor() );
2948 0 : aHighlightFont.SetColor( aHighlightTextColor );
2949 :
2950 0 : Size aRectSize( 0, nTempEntryHeight );
2951 :
2952 0 : if( !bHasClipRegion && nWindowStyle & WB_HSCROLL )
2953 : {
2954 0 : SetClipRegion( Region(pImp->GetClipRegionRect()) );
2955 0 : bHasClipRegion = sal_True;
2956 : }
2957 :
2958 0 : SvViewDataEntry* pViewDataEntry = GetViewDataEntry( pEntry );
2959 :
2960 0 : sal_uInt16 nTabCount = aTabs.size();
2961 0 : sal_uInt16 nItemCount = pEntry->ItemCount();
2962 0 : sal_uInt16 nCurTab = 0;
2963 0 : sal_uInt16 nCurItem = 0;
2964 :
2965 0 : while( nCurTab < nTabCount && nCurItem < nItemCount )
2966 : {
2967 0 : SvLBoxTab* pTab = aTabs[ nCurTab ];
2968 0 : sal_uInt16 nNextTab = nCurTab + 1;
2969 0 : SvLBoxTab* pNextTab = nNextTab < nTabCount ? aTabs[nNextTab] : 0;
2970 0 : SvLBoxItem* pItem = nCurItem < nItemCount ? pEntry->GetItem(nCurItem) : 0;
2971 :
2972 0 : sal_uInt16 nFlags = pTab->nFlags;
2973 0 : Size aSize( pItem->GetSize( pViewDataEntry, nCurItem ));
2974 0 : long nTabPos = GetTabPos( pEntry, pTab );
2975 :
2976 : long nNextTabPos;
2977 0 : if( pNextTab )
2978 0 : nNextTabPos = GetTabPos( pEntry, pNextTab );
2979 : else
2980 : {
2981 0 : nNextTabPos = nMaxRight;
2982 0 : if( nTabPos > nMaxRight )
2983 0 : nNextTabPos += 50;
2984 : }
2985 :
2986 : long nX;
2987 0 : if( pTab->nFlags & SV_LBOXTAB_ADJUST_RIGHT )
2988 : // avoid cutting the right edge off the tab separation
2989 0 : nX = nTabPos + pTab->CalcOffset(aSize.Width(), (nNextTabPos-SV_TAB_BORDER-1) -nTabPos);
2990 : else
2991 0 : nX = nTabPos + pTab->CalcOffset(aSize.Width(), nNextTabPos-nTabPos);
2992 :
2993 0 : if( nFlags & nTabFlags )
2994 : {
2995 0 : if( !bHasClipRegion && nX + aSize.Width() >= nMaxRight )
2996 : {
2997 0 : SetClipRegion( Region(pImp->GetClipRegionRect()) );
2998 0 : bHasClipRegion = sal_True;
2999 : }
3000 0 : aEntryPos.X() = nX;
3001 0 : aEntryPos.Y() = nLine;
3002 :
3003 : // set background pattern/color
3004 :
3005 0 : Wallpaper aWallpaper = GetBackground();
3006 :
3007 0 : int bSelTab = nFlags & SV_LBOXTAB_SHOW_SELECTION;
3008 0 : sal_uInt16 nItemType = pItem->GetType();
3009 :
3010 0 : if (pViewDataEntry->IsHighlighted() && bSelTab && !pViewDataEntry->IsCursored())
3011 : {
3012 0 : Color aNewWallColor = rSettings.GetHighlightColor();
3013 0 : if ( !bInUse || nItemType != SV_ITEM_ID_LBOXCONTEXTBMP )
3014 : {
3015 : // if the face color is bright then the deactive color is also bright
3016 : // -> so you can't see any deactive selection
3017 0 : if ( bHideSelection && !rSettings.GetFaceColor().IsBright() &&
3018 0 : aWallpaper.GetColor().IsBright() != rSettings.GetDeactiveColor().IsBright() )
3019 0 : aNewWallColor = rSettings.GetDeactiveColor();
3020 : // set font color to highlight
3021 0 : if ( !bCurFontIsSel )
3022 : {
3023 0 : SetTextColor( aHighlightTextColor );
3024 0 : Control::SetFont( aHighlightFont );
3025 0 : bCurFontIsSel = true;
3026 : }
3027 : }
3028 0 : aWallpaper.SetColor( aNewWallColor );
3029 : }
3030 : else // no selection
3031 : {
3032 0 : if( bInUse && nItemType == SV_ITEM_ID_LBOXCONTEXTBMP )
3033 0 : aWallpaper.SetColor( rSettings.GetFieldColor() );
3034 0 : else if( bCurFontIsSel )
3035 : {
3036 0 : bCurFontIsSel = false;
3037 0 : SetTextColor( aBackupTextColor );
3038 0 : Control::SetFont( aBackupFont );
3039 : }
3040 : }
3041 :
3042 : // draw background
3043 0 : if( !(nTreeFlags & TREEFLAG_USESEL))
3044 : {
3045 : // only draw the area that is used by the item
3046 0 : aRectSize.Width() = aSize.Width();
3047 0 : aRect.SetPos( aEntryPos );
3048 0 : aRect.SetSize( aRectSize );
3049 : }
3050 : else
3051 : {
3052 : // draw from the current to the next tab
3053 0 : if( nCurTab != 0 )
3054 0 : aRect.Left() = nTabPos;
3055 : else
3056 : // if we're in the 0th tab, always draw from column 0 --
3057 : // else we get problems with centered tabs
3058 0 : aRect.Left() = 0;
3059 0 : aRect.Top() = nLine;
3060 0 : aRect.Bottom() = nLine + nTempEntryHeight - 1;
3061 0 : if( pNextTab )
3062 : {
3063 : long nRight;
3064 0 : nRight = GetTabPos(pEntry,pNextTab)-1;
3065 0 : if( nRight > nMaxRight )
3066 0 : nRight = nMaxRight;
3067 0 : aRect.Right() = nRight;
3068 : }
3069 : else
3070 0 : aRect.Right() = nMaxRight;
3071 : }
3072 : // A custom selection that starts at a tab position > 0, do not fill
3073 : // the background of the 0th item, else e.g. we might not be able to
3074 : // realize tab listboxes with lines.
3075 0 : if( !(nCurTab==0 && (nTreeFlags & TREEFLAG_USESEL) && nFirstSelTab) )
3076 : {
3077 0 : SetFillColor( aWallpaper.GetColor() );
3078 : // this case may occur for smaller horizontal resizes
3079 0 : if( aRect.Left() < aRect.Right() )
3080 0 : DrawRect( aRect );
3081 : }
3082 : // draw item
3083 : // center vertically
3084 0 : aEntryPos.Y() += ( nTempEntryHeight - aSize.Height() ) / 2;
3085 0 : pItem->Paint(aEntryPos, *this, pViewDataEntry, pEntry);
3086 :
3087 : // division line between tabs
3088 0 : if (pNextTab && pItem->GetType() == SV_ITEM_ID_LBOXSTRING &&
3089 : // not at the right edge of the window!
3090 0 : aRect.Right() < nMaxRight)
3091 : {
3092 0 : aRect.Left() = aRect.Right() - SV_TAB_BORDER;
3093 0 : DrawRect( aRect );
3094 : }
3095 :
3096 0 : SetFillColor( aBackupColor );
3097 : }
3098 0 : nCurItem++;
3099 0 : nCurTab++;
3100 : }
3101 0 : if( pViewDataEntry->IsCursored() && !HasFocus() )
3102 : {
3103 : // cursor emphasis
3104 0 : SetFillColor();
3105 0 : Color aOldLineColor = GetLineColor();
3106 0 : SetLineColor( Color( COL_BLACK ) );
3107 0 : aRect = GetFocusRect( pEntry, nLine );
3108 0 : aRect.Top()++;
3109 0 : aRect.Bottom()--;
3110 0 : DrawRect( aRect );
3111 0 : SetLineColor( aOldLineColor );
3112 0 : SetFillColor( aBackupColor );
3113 : }
3114 :
3115 0 : if( bCurFontIsSel )
3116 : {
3117 0 : SetTextColor( aBackupTextColor );
3118 0 : Control::SetFont( aBackupFont );
3119 : }
3120 :
3121 : sal_uInt16 nFirstDynTabPos;
3122 0 : SvLBoxTab* pFirstDynamicTab = GetFirstDynamicTab( nFirstDynTabPos );
3123 0 : long nDynTabPos = GetTabPos( pEntry, pFirstDynamicTab );
3124 0 : nDynTabPos += pImp->nNodeBmpTabDistance;
3125 0 : nDynTabPos += pImp->nNodeBmpWidth / 2;
3126 0 : nDynTabPos += 4; // 4 pixels of buffer, so the node bitmap is not too close
3127 : // to the next tab
3128 :
3129 0 : if( (!(pEntry->GetFlags() & SV_ENTRYFLAG_NO_NODEBMP)) &&
3130 : (nWindowStyle & WB_HASBUTTONS) && pFirstDynamicTab &&
3131 0 : ( pEntry->HasChildren() || pEntry->HasChildrenOnDemand() ) )
3132 : {
3133 : // find first tab and check if the node bitmap extends into it
3134 0 : sal_uInt16 nNextTab = nFirstDynTabPos;
3135 : SvLBoxTab* pNextTab;
3136 0 : do
3137 : {
3138 0 : nNextTab++;
3139 0 : pNextTab = nNextTab < nTabCount ? aTabs[nNextTab] : 0;
3140 0 : } while( pNextTab && pNextTab->IsDynamic() );
3141 :
3142 0 : if( !pNextTab || (GetTabPos( pEntry, pNextTab ) > nDynTabPos) )
3143 : {
3144 0 : if((nWindowStyle & WB_HASBUTTONSATROOT) || pModel->GetDepth(pEntry) > 0)
3145 : {
3146 0 : Point aPos( GetTabPos(pEntry,pFirstDynamicTab), nLine );
3147 0 : aPos.X() += pImp->nNodeBmpTabDistance;
3148 :
3149 0 : const Image* pImg = 0;
3150 :
3151 0 : if( IsExpanded(pEntry) )
3152 0 : pImg = &pImp->GetExpandedNodeBmp( );
3153 : else
3154 : {
3155 0 : if( (!pEntry->HasChildren()) && pEntry->HasChildrenOnDemand() &&
3156 0 : (!(pEntry->GetFlags() & SV_ENTRYFLAG_HAD_CHILDREN)) &&
3157 0 : pImp->GetDontKnowNodeBmp().GetSizePixel().Width() )
3158 0 : pImg = &pImp->GetDontKnowNodeBmp( );
3159 : else
3160 0 : pImg = &pImp->GetCollapsedNodeBmp( );
3161 : }
3162 0 : aPos.Y() += (nTempEntryHeight - pImg->GetSizePixel().Height()) / 2;
3163 :
3164 0 : sal_uInt16 nStyle = 0;
3165 0 : if ( !IsEnabled() )
3166 0 : nStyle |= IMAGE_DRAW_DISABLE;
3167 :
3168 : //native
3169 0 : sal_Bool bNativeOK = sal_False;
3170 0 : if ( IsNativeControlSupported( CTRL_LISTNODE, PART_ENTIRE_CONTROL) )
3171 : {
3172 0 : ImplControlValue aControlValue;
3173 0 : Rectangle aCtrlRegion( aPos, pImg->GetSizePixel() );
3174 0 : ControlState nState = 0;
3175 :
3176 0 : if ( IsEnabled() ) nState |= CTRL_STATE_ENABLED;
3177 :
3178 0 : if ( IsExpanded(pEntry) )
3179 0 : aControlValue.setTristateVal( BUTTONVALUE_ON );//expanded node
3180 : else
3181 : {
3182 0 : if( (!pEntry->HasChildren() ) &&
3183 0 : pEntry->HasChildrenOnDemand() &&
3184 0 : (!(pEntry->GetFlags() & SV_ENTRYFLAG_HAD_CHILDREN)) &&
3185 0 : pImp->GetDontKnowNodeBmp().GetSizePixel().Width()
3186 : )
3187 0 : aControlValue.setTristateVal( BUTTONVALUE_DONTKNOW ); //dont know
3188 : else
3189 0 : aControlValue.setTristateVal( BUTTONVALUE_OFF ); //collapsed node
3190 : }
3191 :
3192 : bNativeOK = DrawNativeControl( CTRL_LISTNODE, PART_ENTIRE_CONTROL,
3193 0 : aCtrlRegion, nState, aControlValue, rtl::OUString() );
3194 : }
3195 :
3196 0 : if( !bNativeOK) {
3197 0 : DrawImage( aPos, *pImg ,nStyle);
3198 : }
3199 : }
3200 : }
3201 : }
3202 :
3203 :
3204 0 : if( bHasClipRegion && bResetClipRegion )
3205 0 : SetClipRegion();
3206 0 : return 0; // nRowLen;
3207 : }
3208 :
3209 0 : void SvTreeListBox::PreparePaint( SvTreeListEntry* )
3210 : {
3211 0 : }
3212 :
3213 0 : Rectangle SvTreeListBox::GetFocusRect( SvTreeListEntry* pEntry, long nLine )
3214 : {
3215 : DBG_CHKTHIS(SvTreeListBox,0);
3216 0 : Size aSize;
3217 0 : Rectangle aRect;
3218 0 : aRect.Top() = nLine;
3219 0 : aSize.Height() = GetEntryHeight();
3220 :
3221 0 : long nRealWidth = pImp->GetOutputSize().Width();
3222 0 : nRealWidth -= GetMapMode().GetOrigin().X();
3223 :
3224 : sal_uInt16 nCurTab;
3225 0 : SvLBoxTab* pTab = GetFirstTab( SV_LBOXTAB_SHOW_SELECTION, nCurTab );
3226 0 : long nTabPos = 0;
3227 0 : if( pTab )
3228 0 : nTabPos = GetTabPos( pEntry, pTab );
3229 : long nNextTabPos;
3230 0 : if( pTab && nCurTab < aTabs.size() - 1 )
3231 : {
3232 0 : SvLBoxTab* pNextTab = aTabs[ nCurTab + 1 ];
3233 0 : nNextTabPos = GetTabPos( pEntry, pNextTab );
3234 : }
3235 : else
3236 : {
3237 0 : nNextTabPos = nRealWidth;
3238 0 : if( nTabPos > nRealWidth )
3239 0 : nNextTabPos += 50;
3240 : }
3241 :
3242 0 : sal_Bool bUserSelection = (sal_Bool)( nTreeFlags & TREEFLAG_USESEL ) != 0;
3243 0 : if( !bUserSelection )
3244 : {
3245 0 : if( pTab && nCurTab < pEntry->ItemCount() )
3246 : {
3247 0 : SvLBoxItem* pItem = pEntry->GetItem( nCurTab );
3248 0 : aSize.Width() = pItem->GetSize( this, pEntry ).Width();
3249 0 : if( !aSize.Width() )
3250 0 : aSize.Width() = 15;
3251 0 : long nX = nTabPos; //GetTabPos( pEntry, pTab );
3252 : // alignment
3253 0 : nX += pTab->CalcOffset( aSize.Width(), nNextTabPos - nTabPos );
3254 0 : aRect.Left() = nX;
3255 : // make sure that first and last letter aren't cut off slightly
3256 0 : aRect.SetSize( aSize );
3257 0 : if( aRect.Left() > 0 )
3258 0 : aRect.Left()--;
3259 0 : aRect.Right()++;
3260 : }
3261 : }
3262 : else
3263 : {
3264 : // if SelTab != 0, we have to calculate also
3265 0 : if( nFocusWidth == -1 || nFirstSelTab )
3266 : {
3267 : sal_uInt16 nLastTab;
3268 0 : SvLBoxTab* pLastTab = GetLastTab(SV_LBOXTAB_SHOW_SELECTION,nLastTab);
3269 0 : nLastTab++;
3270 0 : if( nLastTab < aTabs.size() ) // is there another one?
3271 0 : pLastTab = aTabs[ nLastTab ];
3272 : else
3273 0 : pLastTab = 0; // select whole width
3274 0 : aSize.Width() = pLastTab ? pLastTab->GetPos() : 0x0fffffff;
3275 0 : nFocusWidth = (short)aSize.Width();
3276 0 : if( pTab )
3277 0 : nFocusWidth = nFocusWidth - (short)nTabPos; //pTab->GetPos();
3278 : }
3279 : else
3280 : {
3281 0 : aSize.Width() = nFocusWidth;
3282 0 : if( pTab )
3283 : {
3284 0 : if( nCurTab )
3285 0 : aSize.Width() += nTabPos;
3286 : else
3287 0 : aSize.Width() += pTab->GetPos(); // Tab0 always from the leftmost position
3288 : }
3289 : }
3290 : // if selection starts with 0th tab, draw from column 0 on
3291 0 : if( nCurTab != 0 )
3292 : {
3293 0 : aRect.Left() = nTabPos;
3294 0 : aSize.Width() -= nTabPos;
3295 : }
3296 0 : aRect.SetSize( aSize );
3297 : }
3298 : // adjust right edge because of clipping
3299 0 : if( aRect.Right() >= nRealWidth )
3300 : {
3301 0 : aRect.Right() = nRealWidth-1;
3302 0 : nFocusWidth = (short)aRect.GetWidth();
3303 : }
3304 0 : return aRect;
3305 : }
3306 :
3307 :
3308 0 : long SvTreeListBox::GetTabPos( SvTreeListEntry* pEntry, SvLBoxTab* pTab)
3309 : {
3310 : DBG_CHKTHIS(SvTreeListBox,0);
3311 : DBG_ASSERT(pTab,"No Tab");
3312 0 : long nPos = pTab->GetPos();
3313 0 : if( pTab->IsDynamic() )
3314 : {
3315 0 : sal_uInt16 nDepth = pModel->GetDepth( pEntry );
3316 0 : nDepth = nDepth * (sal_uInt16)nIndent;
3317 0 : nPos += (long)nDepth;
3318 : }
3319 0 : return nPos;
3320 : }
3321 :
3322 0 : SvLBoxItem* SvTreeListBox::GetItem_Impl( SvTreeListEntry* pEntry, long nX,
3323 : SvLBoxTab** ppTab, sal_uInt16 nEmptyWidth )
3324 : {
3325 : DBG_CHKTHIS(SvTreeListBox,0);
3326 0 : SvLBoxItem* pItemClicked = 0;
3327 0 : sal_uInt16 nTabCount = aTabs.size();
3328 0 : sal_uInt16 nItemCount = pEntry->ItemCount();
3329 0 : SvLBoxTab* pTab = aTabs.front();
3330 0 : SvLBoxItem* pItem = pEntry->GetItem(0);
3331 0 : sal_uInt16 nNextItem = 1;
3332 0 : nX -= GetMapMode().GetOrigin().X();
3333 0 : long nRealWidth = pImp->GetOutputSize().Width();
3334 0 : nRealWidth -= GetMapMode().GetOrigin().X();
3335 :
3336 0 : while( 1 )
3337 : {
3338 0 : SvLBoxTab* pNextTab=nNextItem<nTabCount ? aTabs[nNextItem] : 0;
3339 0 : long nStart = GetTabPos( pEntry, pTab );
3340 :
3341 : long nNextTabPos;
3342 0 : if( pNextTab )
3343 0 : nNextTabPos = GetTabPos( pEntry, pNextTab );
3344 : else
3345 : {
3346 0 : nNextTabPos = nRealWidth;
3347 0 : if( nStart > nRealWidth )
3348 0 : nNextTabPos += 50;
3349 : }
3350 :
3351 0 : Size aItemSize( pItem->GetSize(this, pEntry));
3352 0 : nStart += pTab->CalcOffset( aItemSize.Width(), nNextTabPos - nStart );
3353 0 : long nLen = aItemSize.Width();
3354 0 : if( pNextTab )
3355 : {
3356 0 : long nTabWidth = GetTabPos( pEntry, pNextTab ) - nStart;
3357 0 : if( nTabWidth < nLen )
3358 0 : nLen = nTabWidth;
3359 : }
3360 :
3361 0 : if( !nLen )
3362 0 : nLen = nEmptyWidth;
3363 :
3364 0 : if( nX >= nStart && nX < (nStart+nLen ) )
3365 : {
3366 0 : pItemClicked = pItem;
3367 0 : if( ppTab )
3368 : {
3369 0 : *ppTab = pTab;
3370 : break;
3371 : }
3372 : }
3373 0 : if( nNextItem >= nItemCount || nNextItem >= nTabCount)
3374 : break;
3375 0 : pTab = aTabs[ nNextItem ];
3376 0 : pItem = pEntry->GetItem( nNextItem );
3377 0 : nNextItem++;
3378 : }
3379 0 : return pItemClicked;
3380 : }
3381 :
3382 0 : long SvTreeListBox::getPreferredDimensions(std::vector<long> &rWidths) const
3383 : {
3384 0 : long nHeight = 0;
3385 0 : rWidths.clear();
3386 0 : SvTreeListEntry* pEntry = First();
3387 0 : while (pEntry)
3388 : {
3389 0 : sal_uInt16 nCount = pEntry->ItemCount();
3390 0 : sal_uInt16 nCurPos = 0;
3391 0 : if (nCount > rWidths.size())
3392 0 : rWidths.resize(nCount);
3393 0 : while (nCurPos < nCount)
3394 : {
3395 0 : SvLBoxItem* pItem = pEntry->GetItem( nCurPos );
3396 0 : long nWidth = pItem->GetSize(this, pEntry).Width();
3397 0 : if (nWidth)
3398 : {
3399 0 : nWidth += SV_TAB_BORDER * 2;
3400 0 : if (nWidth > rWidths[nCurPos])
3401 0 : rWidths[nCurPos] = nWidth;
3402 : }
3403 0 : ++nCurPos;
3404 : }
3405 0 : pEntry = Next( pEntry );
3406 0 : nHeight += GetEntryHeight();
3407 : }
3408 0 : return nHeight;
3409 : }
3410 :
3411 0 : Size SvTreeListBox::GetOptimalSize(WindowSizeType eType) const
3412 : {
3413 0 : Size aRet;
3414 0 : switch (eType)
3415 : {
3416 : case WINDOWSIZE_MINIMUM:
3417 : case WINDOWSIZE_PREFERRED:
3418 : {
3419 0 : std::vector<long> aWidths;
3420 0 : aRet.Height() = getPreferredDimensions(aWidths);
3421 0 : for (size_t i = 0; i < aWidths.size(); ++i)
3422 0 : aRet.Width() += aWidths[i];
3423 0 : break;
3424 : }
3425 : default:
3426 0 : aRet = Control::GetOptimalSize(eType);
3427 0 : break;
3428 : }
3429 0 : return aRet;
3430 : }
3431 :
3432 0 : SvLBoxItem* SvTreeListBox::GetItem(SvTreeListEntry* pEntry,long nX,SvLBoxTab** ppTab)
3433 : {
3434 0 : return GetItem_Impl( pEntry, nX, ppTab, 0 );
3435 : }
3436 :
3437 0 : SvLBoxItem* SvTreeListBox::GetItem(SvTreeListEntry* pEntry,long nX )
3438 : {
3439 : DBG_CHKTHIS(SvTreeListBox,0);
3440 : SvLBoxTab* pDummyTab;
3441 0 : return GetItem_Impl( pEntry, nX, &pDummyTab, 0 );
3442 : }
3443 :
3444 0 : void SvTreeListBox::AddTab(long nTabPos,sal_uInt16 nFlags,void* pUserData )
3445 : {
3446 : DBG_CHKTHIS(SvTreeListBox,0);
3447 0 : nFocusWidth = -1;
3448 0 : SvLBoxTab* pTab = new SvLBoxTab( nTabPos, nFlags );
3449 0 : pTab->SetUserData( pUserData );
3450 0 : aTabs.push_back( pTab );
3451 0 : if( nTreeFlags & TREEFLAG_USESEL )
3452 : {
3453 0 : sal_uInt16 nPos = aTabs.size() - 1;
3454 0 : if( nPos >= nFirstSelTab && nPos <= nLastSelTab )
3455 0 : pTab->nFlags |= SV_LBOXTAB_SHOW_SELECTION;
3456 : else
3457 : // string items usually have to be selected -- turn this off
3458 : // explicitly
3459 0 : pTab->nFlags &= ~SV_LBOXTAB_SHOW_SELECTION;
3460 : }
3461 0 : }
3462 :
3463 :
3464 :
3465 0 : SvLBoxTab* SvTreeListBox::GetFirstDynamicTab( sal_uInt16& rPos ) const
3466 : {
3467 : DBG_CHKTHIS(SvTreeListBox,0);
3468 0 : sal_uInt16 nCurTab = 0;
3469 0 : sal_uInt16 nTabCount = aTabs.size();
3470 0 : while( nCurTab < nTabCount )
3471 : {
3472 0 : SvLBoxTab* pTab = aTabs[nCurTab];
3473 0 : if( pTab->nFlags & SV_LBOXTAB_DYNAMIC )
3474 : {
3475 0 : rPos = nCurTab;
3476 0 : return pTab;
3477 : }
3478 0 : nCurTab++;
3479 : }
3480 0 : return 0;
3481 : }
3482 :
3483 0 : SvLBoxTab* SvTreeListBox::GetFirstDynamicTab() const
3484 : {
3485 : sal_uInt16 nDummy;
3486 0 : return GetFirstDynamicTab( nDummy );
3487 : }
3488 :
3489 0 : SvLBoxTab* SvTreeListBox::GetTab( SvTreeListEntry* pEntry, SvLBoxItem* pItem) const
3490 : {
3491 : DBG_CHKTHIS(SvTreeListBox,0);
3492 0 : sal_uInt16 nPos = pEntry->GetPos( pItem );
3493 0 : return aTabs[ nPos ];
3494 : }
3495 :
3496 0 : void SvTreeListBox::ClearTabList()
3497 : {
3498 : DBG_CHKTHIS(SvTreeListBox,0);
3499 0 : sal_uInt16 nTabCount = aTabs.size();
3500 0 : while( nTabCount )
3501 : {
3502 0 : nTabCount--;
3503 0 : SvLBoxTab* pDelTab = aTabs[ nTabCount ];
3504 0 : delete pDelTab;
3505 : }
3506 0 : aTabs.clear();
3507 0 : }
3508 :
3509 :
3510 0 : Size SvTreeListBox::GetOutputSizePixel() const
3511 : {
3512 : DBG_CHKTHIS(SvTreeListBox,0);
3513 0 : Size aSize = pImp->GetOutputSize();
3514 0 : return aSize;
3515 : }
3516 :
3517 0 : void SvTreeListBox::NotifyBeginScroll()
3518 : {
3519 : DBG_CHKTHIS(SvTreeListBox,0);
3520 0 : }
3521 :
3522 0 : void SvTreeListBox::NotifyEndScroll()
3523 : {
3524 : DBG_CHKTHIS(SvTreeListBox,0);
3525 0 : }
3526 :
3527 0 : void SvTreeListBox::NotifyScrolling( long )
3528 : {
3529 : DBG_CHKTHIS(SvTreeListBox,0);
3530 0 : }
3531 :
3532 0 : void SvTreeListBox::NotifyScrolled()
3533 : {
3534 : DBG_CHKTHIS(SvTreeListBox,0);
3535 0 : aScrolledHdl.Call( this );
3536 0 : }
3537 :
3538 0 : void SvTreeListBox::NotifyInvalidating()
3539 : {
3540 : DBG_CHKTHIS(SvTreeListBox,0);
3541 0 : }
3542 :
3543 0 : void SvTreeListBox::Invalidate( sal_uInt16 nInvalidateFlags )
3544 : {
3545 : DBG_CHKTHIS(SvTreeListBox,0);
3546 0 : if( nFocusWidth == -1 )
3547 : // to make sure that the control doesn't show the wrong focus rectangle
3548 : // after painting
3549 0 : pImp->RecalcFocusRect();
3550 0 : NotifyInvalidating();
3551 0 : Control::Invalidate( nInvalidateFlags );
3552 0 : pImp->Invalidate();
3553 0 : }
3554 :
3555 0 : void SvTreeListBox::Invalidate( const Rectangle& rRect, sal_uInt16 nInvalidateFlags )
3556 : {
3557 : DBG_CHKTHIS(SvTreeListBox,0);
3558 0 : if( nFocusWidth == -1 )
3559 : // to make sure that the control doesn't show the wrong focus rectangle
3560 : // after painting
3561 0 : pImp->RecalcFocusRect();
3562 0 : NotifyInvalidating();
3563 0 : Control::Invalidate( rRect, nInvalidateFlags );
3564 0 : }
3565 :
3566 :
3567 0 : void SvTreeListBox::SetHighlightRange( sal_uInt16 nStart, sal_uInt16 nEnd)
3568 : {
3569 : DBG_CHKTHIS(SvTreeListBox,0);
3570 :
3571 : sal_uInt16 nTemp;
3572 0 : nTreeFlags |= TREEFLAG_USESEL;
3573 0 : if( nStart > nEnd )
3574 : {
3575 0 : nTemp = nStart;
3576 0 : nStart = nEnd;
3577 0 : nEnd = nTemp;
3578 : }
3579 : // select all tabs that lie within the area
3580 0 : nTreeFlags |= TREEFLAG_RECALCTABS;
3581 0 : nFirstSelTab = nStart;
3582 0 : nLastSelTab = nEnd;
3583 0 : pImp->RecalcFocusRect();
3584 0 : }
3585 :
3586 0 : sal_uLong SvTreeListBox::GetAscInsertionPos(SvTreeListEntry*,SvTreeListEntry*)
3587 : {
3588 0 : return LIST_APPEND;
3589 : }
3590 :
3591 0 : sal_uLong SvTreeListBox::GetDescInsertionPos(SvTreeListEntry*,SvTreeListEntry*)
3592 : {
3593 : DBG_CHKTHIS(SvTreeListBox,0);
3594 0 : return LIST_APPEND;
3595 : }
3596 :
3597 0 : Region SvTreeListBox::GetDragRegion() const
3598 : {
3599 : DBG_CHKTHIS(SvTreeListBox,0);
3600 0 : Rectangle aRect;
3601 0 : SvTreeListEntry* pEntry = GetCurEntry();
3602 0 : if( pEntry )
3603 : {
3604 0 : Point aPos = GetEntryPosition( pEntry );
3605 0 : aRect = ((SvTreeListBox*)this)->GetFocusRect( pEntry, aPos.Y() );
3606 : }
3607 0 : Region aRegion( aRect );
3608 0 : return aRegion;
3609 : }
3610 :
3611 :
3612 0 : void SvTreeListBox::Command( const CommandEvent& rCEvt )
3613 : {
3614 : DBG_CHKTHIS(SvTreeListBox,0);
3615 : // FIXME gnumake2 resync to DEV300_m84
3616 0 : pImp->Command( rCEvt );
3617 0 : }
3618 :
3619 :
3620 0 : void SvTreeListBox::RemoveParentKeepChildren( SvTreeListEntry* pParent )
3621 : {
3622 : DBG_CHKTHIS(SvTreeListBox,0);
3623 : DBG_ASSERT(pParent,"RemoveParentKeepChildren:No Parent");
3624 0 : SvTreeListEntry* pNewParent = GetParent( pParent );
3625 0 : if( pParent->HasChildren())
3626 : {
3627 0 : SvTreeListEntry* pChild = FirstChild( pParent );
3628 0 : while( pChild )
3629 : {
3630 0 : pModel->Move( pChild, pNewParent, LIST_APPEND );
3631 0 : pChild = FirstChild( pParent );
3632 : }
3633 : }
3634 0 : pModel->Remove( pParent );
3635 0 : }
3636 :
3637 0 : SvLBoxTab* SvTreeListBox::GetFirstTab( sal_uInt16 nFlagMask, sal_uInt16& rPos )
3638 : {
3639 0 : sal_uInt16 nTabCount = aTabs.size();
3640 0 : for( sal_uInt16 nPos = 0; nPos < nTabCount; nPos++ )
3641 : {
3642 0 : SvLBoxTab* pTab = aTabs[ nPos ];
3643 0 : if( (pTab->nFlags & nFlagMask) )
3644 : {
3645 0 : rPos = nPos;
3646 0 : return pTab;
3647 : }
3648 : }
3649 0 : rPos = 0xffff;
3650 0 : return 0;
3651 : }
3652 :
3653 0 : SvLBoxTab* SvTreeListBox::GetLastTab( sal_uInt16 nFlagMask, sal_uInt16& rTabPos )
3654 : {
3655 0 : sal_uInt16 nPos = (sal_uInt16)aTabs.size();
3656 0 : while( nPos )
3657 : {
3658 0 : --nPos;
3659 0 : SvLBoxTab* pTab = aTabs[ nPos ];
3660 0 : if( (pTab->nFlags & nFlagMask) )
3661 : {
3662 0 : rTabPos = nPos;
3663 0 : return pTab;
3664 : }
3665 : }
3666 0 : rTabPos = 0xffff;
3667 0 : return 0;
3668 : }
3669 :
3670 0 : void SvTreeListBox::RequestHelp( const HelpEvent& rHEvt )
3671 : {
3672 0 : if( !pImp->RequestHelp( rHEvt ) )
3673 0 : Control::RequestHelp( rHEvt );
3674 0 : }
3675 :
3676 0 : void SvTreeListBox::CursorMoved( SvTreeListEntry* )
3677 : {
3678 0 : }
3679 :
3680 0 : IMPL_LINK( SvTreeListBox, DefaultCompare, SvSortData*, pData )
3681 : {
3682 0 : const SvTreeListEntry* pLeft = pData->pLeft;
3683 0 : const SvTreeListEntry* pRight = pData->pRight;
3684 0 : String aLeft( ((SvLBoxString*)(pLeft->GetFirstItem(SV_ITEM_ID_LBOXSTRING)))->GetText());
3685 0 : String aRight( ((SvLBoxString*)(pRight->GetFirstItem(SV_ITEM_ID_LBOXSTRING)))->GetText());
3686 0 : pImp->UpdateStringSorter();
3687 0 : return pImp->m_pStringSorter->compare(aLeft, aRight);
3688 : }
3689 :
3690 0 : void SvTreeListBox::ModelNotification( sal_uInt16 nActionId, SvTreeListEntry* pEntry1,
3691 : SvTreeListEntry* pEntry2, sal_uLong nPos )
3692 : {
3693 0 : if( nActionId == LISTACTION_CLEARING )
3694 0 : CancelTextEditing();
3695 :
3696 0 : SvListView::ModelNotification( nActionId, pEntry1, pEntry2, nPos );
3697 0 : switch( nActionId )
3698 : {
3699 : case LISTACTION_INSERTED:
3700 : {
3701 0 : SvTreeListEntry* pEntry( dynamic_cast< SvTreeListEntry* >( pEntry1 ) );
3702 0 : if ( !pEntry )
3703 : {
3704 : SAL_WARN( "svtools.contnr", "SvTreeListBox::ModelNotification: invalid entry!" );
3705 0 : break;
3706 : }
3707 :
3708 0 : SvLBoxContextBmp* pBmpItem = static_cast< SvLBoxContextBmp* >( pEntry->GetFirstItem( SV_ITEM_ID_LBOXCONTEXTBMP ) );
3709 0 : if ( !pBmpItem )
3710 0 : break;
3711 0 : const Image& rBitmap1( pBmpItem->GetBitmap1() );
3712 0 : const Image& rBitmap2( pBmpItem->GetBitmap2() );
3713 0 : short nMaxWidth = short( Max( rBitmap1.GetSizePixel().Width(), rBitmap2.GetSizePixel().Width() ) );
3714 0 : nMaxWidth = pImp->UpdateContextBmpWidthVector( pEntry, nMaxWidth );
3715 0 : if( nMaxWidth > nContextBmpWidthMax )
3716 : {
3717 0 : nContextBmpWidthMax = nMaxWidth;
3718 0 : SetTabs();
3719 : }
3720 0 : queue_resize();
3721 : }
3722 0 : break;
3723 :
3724 : case LISTACTION_RESORTING:
3725 0 : SetUpdateMode( sal_False );
3726 0 : break;
3727 :
3728 : case LISTACTION_RESORTED:
3729 : // after a selection: show first entry and also keep the selection
3730 0 : MakeVisible( (SvTreeListEntry*)pModel->First(), sal_True );
3731 0 : SetUpdateMode( sal_True );
3732 0 : break;
3733 :
3734 : case LISTACTION_CLEARED:
3735 0 : if( IsUpdateMode() )
3736 0 : Update();
3737 0 : break;
3738 : }
3739 0 : }
3740 :
3741 0 : void SvTreeListBox::EndSelection()
3742 : {
3743 0 : pImp->EndSelection();
3744 0 : }
3745 :
3746 0 : void SvTreeListBox::RepaintScrollBars() const
3747 : {
3748 0 : ((SvTreeListBox*)this)->pImp->RepaintScrollBars();
3749 0 : }
3750 :
3751 0 : ScrollBar *SvTreeListBox::GetVScroll()
3752 : {
3753 0 : return &((SvTreeListBox*)this)->pImp->aVerSBar;
3754 : }
3755 :
3756 0 : ScrollBar *SvTreeListBox::GetHScroll()
3757 : {
3758 0 : return &((SvTreeListBox*)this)->pImp->aHorSBar;
3759 : }
3760 :
3761 0 : void SvTreeListBox::EnableAsyncDrag( sal_Bool b )
3762 : {
3763 0 : pImp->EnableAsyncDrag( b );
3764 0 : }
3765 :
3766 0 : SvTreeListEntry* SvTreeListBox::GetFirstEntryInView() const
3767 : {
3768 0 : Point aPos;
3769 0 : return GetEntry( aPos );
3770 : }
3771 :
3772 0 : SvTreeListEntry* SvTreeListBox::GetNextEntryInView(SvTreeListEntry* pEntry ) const
3773 : {
3774 0 : SvTreeListEntry* pNext = (SvTreeListEntry*)NextVisible( pEntry );
3775 0 : if( pNext )
3776 : {
3777 0 : Point aPos( GetEntryPosition(pNext) );
3778 0 : const Size& rSize = pImp->GetOutputSize();
3779 0 : if( aPos.Y() < 0 || aPos.Y() >= rSize.Height() )
3780 0 : return 0;
3781 : }
3782 0 : return pNext;
3783 : }
3784 :
3785 0 : SvTreeListEntry* SvTreeListBox::GetLastEntryInView() const
3786 : {
3787 0 : SvTreeListEntry* pEntry = GetFirstEntryInView();
3788 0 : SvTreeListEntry* pNext = 0;
3789 0 : while( pEntry )
3790 : {
3791 0 : pNext = (SvTreeListEntry*)NextVisible( pEntry );
3792 0 : if( pNext )
3793 : {
3794 0 : Point aPos( GetEntryPosition(pNext) );
3795 0 : const Size& rSize = pImp->GetOutputSize();
3796 0 : if( aPos.Y() < 0 || aPos.Y() + GetEntryHeight() >= rSize.Height() )
3797 : break;
3798 : else
3799 0 : pEntry = pNext;
3800 : }
3801 : else
3802 0 : break;
3803 : }
3804 0 : return pEntry;
3805 : }
3806 :
3807 0 : void SvTreeListBox::ShowFocusRect( const SvTreeListEntry* pEntry )
3808 : {
3809 0 : pImp->ShowFocusRect( pEntry );
3810 0 : }
3811 :
3812 0 : void SvTreeListBox::DataChanged( const DataChangedEvent& rDCEvt )
3813 : {
3814 0 : if( (rDCEvt.GetType()==DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
3815 : {
3816 0 : nEntryHeight = 0; // _together_ with sal_True of 1. par (bFont) of InitSettings() a zero-height
3817 : // forces complete recalc of heights!
3818 0 : InitSettings( sal_True, sal_True, sal_True );
3819 0 : Invalidate();
3820 : }
3821 : else
3822 0 : Control::DataChanged( rDCEvt );
3823 0 : }
3824 :
3825 0 : void SvTreeListBox::StateChanged( StateChangedType eType )
3826 : {
3827 0 : if( eType == STATE_CHANGE_ENABLE )
3828 0 : Invalidate( INVALIDATE_CHILDREN );
3829 :
3830 0 : Control::StateChanged( eType );
3831 :
3832 0 : if ( eType == STATE_CHANGE_STYLE )
3833 0 : ImplInitStyle();
3834 0 : }
3835 :
3836 0 : void SvTreeListBox::InitSettings(sal_Bool bFont,sal_Bool bForeground,sal_Bool bBackground)
3837 : {
3838 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
3839 0 : if( bFont )
3840 : {
3841 0 : Font aFont;
3842 0 : aFont = rStyleSettings.GetFieldFont();
3843 0 : aFont.SetColor( rStyleSettings.GetWindowTextColor() );
3844 0 : SetPointFont( aFont );
3845 0 : AdjustEntryHeight( aFont );
3846 0 : RecalcViewData();
3847 : }
3848 :
3849 0 : if( bForeground || bFont )
3850 : {
3851 0 : SetTextColor( rStyleSettings.GetFieldTextColor() );
3852 0 : SetTextFillColor();
3853 : }
3854 :
3855 0 : if( bBackground )
3856 0 : SetBackground( rStyleSettings.GetFieldColor() );
3857 :
3858 : // always try to re-create default-SvLBoxButtonData
3859 0 : if( pCheckButtonData && pCheckButtonData->HasDefaultImages() )
3860 0 : pCheckButtonData->SetDefaultImages( this );
3861 0 : }
3862 :
3863 0 : sal_Bool SvTreeListBox::IsCellFocusEnabled() const
3864 : {
3865 0 : return pImp->IsCellFocusEnabled();
3866 : }
3867 :
3868 0 : bool SvTreeListBox::SetCurrentTabPos( sal_uInt16 _nNewPos )
3869 : {
3870 0 : return pImp->SetCurrentTabPos( _nNewPos );
3871 : }
3872 :
3873 0 : sal_uInt16 SvTreeListBox::GetCurrentTabPos() const
3874 : {
3875 0 : return pImp->GetCurrentTabPos();
3876 : }
3877 :
3878 0 : void SvTreeListBox::InitStartEntry()
3879 : {
3880 0 : if( !pImp->pStartEntry )
3881 0 : pImp->pStartEntry = GetModel()->First();
3882 0 : }
3883 :
3884 0 : PopupMenu* SvTreeListBox::CreateContextMenu( void )
3885 : {
3886 0 : return NULL;
3887 : }
3888 :
3889 0 : void SvTreeListBox::ExcecuteContextMenuAction( sal_uInt16 )
3890 : {
3891 : DBG_WARNING( "SvTreeListBox::ExcecuteContextMenuAction(): now there's happening nothing!" );
3892 0 : }
3893 :
3894 0 : void SvTreeListBox::EnableContextMenuHandling( void )
3895 : {
3896 : DBG_ASSERT( pImp, "-SvTreeListBox::EnableContextMenuHandling(): No implementation!" );
3897 :
3898 0 : pImp->bContextMenuHandling = sal_True;
3899 0 : }
3900 :
3901 0 : void SvTreeListBox::EnableContextMenuHandling( sal_Bool b )
3902 : {
3903 : DBG_ASSERT( pImp, "-SvTreeListBox::EnableContextMenuHandling(): No implementation!" );
3904 :
3905 0 : pImp->bContextMenuHandling = b;
3906 0 : }
3907 :
3908 0 : sal_Bool SvTreeListBox::IsContextMenuHandlingEnabled( void ) const
3909 : {
3910 : DBG_ASSERT( pImp, "-SvTreeListBox::IsContextMenuHandlingEnabled(): No implementation!" );
3911 :
3912 0 : return pImp->bContextMenuHandling;
3913 : }
3914 :
3915 0 : void SvTreeListBox::EnableList( bool _bEnable )
3916 : {
3917 : // call base class method
3918 0 : Window::Enable( _bEnable != false );
3919 : // then paint immediately
3920 0 : Paint( Rectangle( Point(), GetSizePixel() ) );
3921 0 : }
3922 :
3923 0 : ::com::sun::star::uno::Reference< XAccessible > SvTreeListBox::CreateAccessible()
3924 : {
3925 0 : Window* pParent = GetAccessibleParentWindow();
3926 : DBG_ASSERT( pParent, "SvTreeListBox::CreateAccessible - accessible parent not found" );
3927 :
3928 0 : ::com::sun::star::uno::Reference< XAccessible > xAccessible;
3929 0 : if ( pParent )
3930 : {
3931 0 : ::com::sun::star::uno::Reference< XAccessible > xAccParent = pParent->GetAccessible();
3932 0 : if ( xAccParent.is() )
3933 : {
3934 : // need to be done here to get the vclxwindow later on in the accessbile
3935 0 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xTemp(GetComponentInterface());
3936 0 : xAccessible = pImp->m_aFactoryAccess.getFactory().createAccessibleTreeListBox( *this, xAccParent );
3937 0 : }
3938 : }
3939 0 : return xAccessible;
3940 : }
3941 :
3942 0 : void SvTreeListBox::FillAccessibleEntryStateSet( SvTreeListEntry* pEntry, ::utl::AccessibleStateSetHelper& rStateSet ) const
3943 : {
3944 : DBG_ASSERT( pEntry, "SvTreeListBox::FillAccessibleEntryStateSet: invalid entry" );
3945 :
3946 0 : if ( pEntry->HasChildrenOnDemand() || pEntry->HasChildren() )
3947 : {
3948 0 : rStateSet.AddState( AccessibleStateType::EXPANDABLE );
3949 0 : if ( IsExpanded( pEntry ) )
3950 0 : rStateSet.AddState( (sal_Int16)AccessibleStateType::EXPANDED );
3951 : }
3952 :
3953 0 : if ( GetCheckButtonState( pEntry ) == SV_BUTTON_CHECKED )
3954 0 : rStateSet.AddState( AccessibleStateType::CHECKED );
3955 0 : if ( IsEntryVisible( pEntry ) )
3956 0 : rStateSet.AddState( AccessibleStateType::VISIBLE );
3957 0 : if ( IsSelected( pEntry ) )
3958 0 : rStateSet.AddState( AccessibleStateType::SELECTED );
3959 0 : }
3960 :
3961 0 : Rectangle SvTreeListBox::GetBoundingRect( SvTreeListEntry* pEntry )
3962 : {
3963 0 : Point aPos = GetEntryPosition( pEntry );
3964 0 : Rectangle aRect = GetFocusRect( pEntry, aPos.Y() );
3965 0 : return aRect;
3966 : }
3967 :
3968 0 : void SvTreeListBox::EnableCellFocus()
3969 : {
3970 0 : pImp->EnableCellFocus();
3971 0 : }
3972 :
3973 0 : void SvTreeListBox::CallImplEventListeners(sal_uLong nEvent, void* pData)
3974 : {
3975 0 : CallEventListeners(nEvent, pData);
3976 0 : }
3977 :
3978 0 : void SvTreeListBox::FillAccessibleStateSet( ::utl::AccessibleStateSetHelper& /*rStateSet*/ ) const
3979 : {
3980 0 : }
3981 :
3982 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
