]> git.saurik.com Git - wxWidgets.git/blame - src/generic/treectlg.cpp
move frame decorations drawing to the base class
[wxWidgets.git] / src / generic / treectlg.cpp
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
ed4b0fdc 2// Name: src/generic/treectlg.cpp
f135ff73 3// Purpose: generic tree control implementation
c801d85f
KB
4// Author: Robert Roebling
5// Created: 01/02/97
f135ff73 6// Modified: 22/10/98 - almost total rewrite, simpler interface (VZ)
389cdc7a 7// Id: $Id$
6aa89a22 8// Copyright: (c) 1998 Robert Roebling and Julian Smart
65571936 9// Licence: wxWindows licence
c801d85f
KB
10/////////////////////////////////////////////////////////////////////////////
11
f135ff73
VZ
12// =============================================================================
13// declarations
14// =============================================================================
15
16// -----------------------------------------------------------------------------
17// headers
18// -----------------------------------------------------------------------------
19
1e6d9499
JS
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
1e6feb95 24 #pragma hdrstop
1e6d9499
JS
25#endif
26
1e6feb95
VZ
27#if wxUSE_TREECTRL
28
8cee4a30 29#include "wx/treectrl.h"
ed4b0fdc
WS
30
31#ifndef WX_PRECOMP
32 #include "wx/dcclient.h"
c0badb70 33 #include "wx/timer.h"
9eddec69 34 #include "wx/settings.h"
2a673eb1 35 #include "wx/listbox.h"
fec9cc08 36 #include "wx/textctrl.h"
ed4b0fdc
WS
37#endif
38
941830cb
JS
39#include "wx/generic/treectlg.h"
40#include "wx/imaglist.h"
c801d85f 41
9c7f49f5 42#include "wx/renderer.h"
44c44c82 43
f89d65ea
SC
44#ifdef __WXMAC__
45 #include "wx/mac/private.h"
46#endif
ca65c044 47
f135ff73
VZ
48// -----------------------------------------------------------------------------
49// array types
50// -----------------------------------------------------------------------------
c801d85f 51
1e6d9499
JS
52class WXDLLEXPORT wxGenericTreeItem;
53
d5d29b8a 54WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
c801d85f 55
8dc99046
VZ
56// ----------------------------------------------------------------------------
57// constants
58// ----------------------------------------------------------------------------
59
60static const int NO_IMAGE = -1;
61
cb59313c 62static const int PIXELS_PER_UNIT = 10;
3dbeaa52 63
3e4f8ee2
VZ
64// the margin between the item image and the item text
65static const int MARGIN_BETWEEN_IMAGE_AND_TEXT = 4;
66
f135ff73
VZ
67// -----------------------------------------------------------------------------
68// private classes
69// -----------------------------------------------------------------------------
70
3dbeaa52
VZ
71// timer used for enabling in-place edit
72class WXDLLEXPORT wxTreeRenameTimer: public wxTimer
73{
74public:
cb59313c
VZ
75 // start editing the current item after half a second (if the mouse hasn't
76 // been clicked/moved)
7a944d2f 77 enum { DELAY = 500 };
cb59313c 78
941830cb 79 wxTreeRenameTimer( wxGenericTreeCtrl *owner );
3dbeaa52 80
cb59313c 81 virtual void Notify();
3dbeaa52
VZ
82
83private:
cb59313c 84 wxGenericTreeCtrl *m_owner;
22f3361e
VZ
85
86 DECLARE_NO_COPY_CLASS(wxTreeRenameTimer)
3dbeaa52
VZ
87};
88
89// control used for in-place edit
90class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
91{
92public:
edb8f298 93 wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item);
3dbeaa52 94
8cee4a30
VZ
95 void EndEdit(bool discardChanges = false)
96 {
97 if ( discardChanges )
98 {
99 StopEditing();
100 }
101 else
102 {
103 m_aboutToFinish = true;
104
105 // Notify the owner about the changes
106 AcceptChanges();
107
108 // Even if vetoed, close the control (consistent with MSW)
109 Finish();
110 }
111 }
112
0cf3b542 113 void StopEditing()
eb7f24c1 114 {
0cf3b542
RR
115 Finish();
116 m_owner->OnRenameCancelled(m_itemEdited);
eb7f24c1 117 }
0cf3b542 118 const wxGenericTreeItem* item() const { return m_itemEdited; }
eb7f24c1 119
edb8f298 120protected:
3dbeaa52 121 void OnChar( wxKeyEvent &event );
c13cace1 122 void OnKeyUp( wxKeyEvent &event );
3dbeaa52
VZ
123 void OnKillFocus( wxFocusEvent &event );
124
edb8f298
VZ
125 bool AcceptChanges();
126 void Finish();
127
3dbeaa52 128private:
618a5e38 129 wxGenericTreeCtrl *m_owner;
edb8f298 130 wxGenericTreeItem *m_itemEdited;
3dbeaa52 131 wxString m_startValue;
dd5a32cc 132 bool m_finished;
33fe475a 133 bool m_aboutToFinish;
3dbeaa52
VZ
134
135 DECLARE_EVENT_TABLE()
22f3361e 136 DECLARE_NO_COPY_CLASS(wxTreeTextCtrl)
3dbeaa52
VZ
137};
138
cb59313c
VZ
139// timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed
140// for a sufficiently long time
141class WXDLLEXPORT wxTreeFindTimer : public wxTimer
142{
143public:
144 // reset the current prefix after half a second of inactivity
7a944d2f 145 enum { DELAY = 500 };
cb59313c
VZ
146
147 wxTreeFindTimer( wxGenericTreeCtrl *owner ) { m_owner = owner; }
148
149 virtual void Notify() { m_owner->m_findPrefix.clear(); }
150
151private:
152 wxGenericTreeCtrl *m_owner;
22f3361e
VZ
153
154 DECLARE_NO_COPY_CLASS(wxTreeFindTimer)
cb59313c
VZ
155};
156
f135ff73
VZ
157// a tree item
158class WXDLLEXPORT wxGenericTreeItem
c801d85f 159{
f135ff73 160public:
9ec64fa7
VZ
161 // ctors & dtor
162 wxGenericTreeItem() { m_data = NULL; }
163 wxGenericTreeItem( wxGenericTreeItem *parent,
618a5e38 164 const wxString& text,
618a5e38
RR
165 int image,
166 int selImage,
167 wxTreeItemData *data );
f135ff73 168
9ec64fa7 169 ~wxGenericTreeItem();
f135ff73 170
9ec64fa7
VZ
171 // trivial accessors
172 wxArrayGenericTreeItems& GetChildren() { return m_children; }
f135ff73 173
9ec64fa7
VZ
174 const wxString& GetText() const { return m_text; }
175 int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
3dbeaa52 176 { return m_images[which]; }
9ec64fa7 177 wxTreeItemData *GetData() const { return m_data; }
f135ff73 178
9ec64fa7
VZ
179 // returns the current image for the item (depending on its
180 // selected/expanded/whatever state)
181 int GetCurrentImage() const;
8dc99046 182
9ec64fa7
VZ
183 void SetText( const wxString &text );
184 void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
185 void SetData(wxTreeItemData *data) { m_data = data; }
f135ff73 186
ca65c044 187 void SetHasPlus(bool has = true) { m_hasPlus = has; }
f135ff73 188
9ec64fa7 189 void SetBold(bool bold) { m_isBold = bold; }
ef44a621 190
9ec64fa7
VZ
191 int GetX() const { return m_x; }
192 int GetY() const { return m_y; }
f135ff73 193
9ec64fa7
VZ
194 void SetX(int x) { m_x = x; }
195 void SetY(int y) { m_y = y; }
f135ff73 196
9ec64fa7
VZ
197 int GetHeight() const { return m_height; }
198 int GetWidth() const { return m_width; }
91b8de8d 199
9ec64fa7
VZ
200 void SetHeight(int h) { m_height = h; }
201 void SetWidth(int w) { m_width = w; }
91b8de8d 202
9ec64fa7 203 wxGenericTreeItem *GetParent() const { return m_parent; }
c801d85f 204
9ec64fa7 205 // operations
66619ee5
VZ
206
207 // deletes all children notifying the treectrl about it
208 void DeleteChildren(wxGenericTreeCtrl *tree);
f135ff73 209
9ec64fa7 210 // get count of all children (and grand children if 'recursively')
ca65c044 211 size_t GetChildrenCount(bool recursively = true) const;
f135ff73 212
9ec64fa7 213 void Insert(wxGenericTreeItem *child, size_t index)
f135ff73
VZ
214 { m_children.Insert(child, index); }
215
941830cb 216 void GetSize( int &x, int &y, const wxGenericTreeCtrl* );
f135ff73 217
9ec64fa7 218 // return the item at given position (or NULL if no item), onButton is
ca65c044 219 // true if the point belongs to the item's button, otherwise it lies
f8b043e7 220 // on the item's label
618a5e38
RR
221 wxGenericTreeItem *HitTest( const wxPoint& point,
222 const wxGenericTreeCtrl *,
223 int &flags,
224 int level );
f135ff73 225
ca65c044
WS
226 void Expand() { m_isCollapsed = false; }
227 void Collapse() { m_isCollapsed = true; }
f135ff73 228
ca65c044 229 void SetHilight( bool set = true ) { m_hasHilight = set; }
f135ff73 230
9ec64fa7
VZ
231 // status inquiries
232 bool HasChildren() const { return !m_children.IsEmpty(); }
ef8698d6 233 bool IsSelected() const { return m_hasHilight != 0; }
9ec64fa7
VZ
234 bool IsExpanded() const { return !m_isCollapsed; }
235 bool HasPlus() const { return m_hasPlus || HasChildren(); }
ef8698d6 236 bool IsBold() const { return m_isBold != 0; }
9ec64fa7
VZ
237
238 // attributes
239 // get them - may be NULL
240 wxTreeItemAttr *GetAttributes() const { return m_attr; }
241 // get them ensuring that the pointer is not NULL
242 wxTreeItemAttr& Attr()
243 {
244 if ( !m_attr )
618a5e38 245 {
9ec64fa7 246 m_attr = new wxTreeItemAttr;
ca65c044 247 m_ownsAttr = true;
618a5e38 248 }
9ec64fa7
VZ
249 return *m_attr;
250 }
618a5e38
RR
251 // set them
252 void SetAttributes(wxTreeItemAttr *attr)
253 {
254 if ( m_ownsAttr ) delete m_attr;
255 m_attr = attr;
ca65c044 256 m_ownsAttr = false;
618a5e38
RR
257 }
258 // set them and delete when done
259 void AssignAttributes(wxTreeItemAttr *attr)
260 {
261 SetAttributes(attr);
ca65c044 262 m_ownsAttr = true;
618a5e38 263 }
f135ff73
VZ
264
265private:
618a5e38
RR
266 // since there can be very many of these, we save size by chosing
267 // the smallest representation for the elements and by ordering
268 // the members to avoid padding.
269 wxString m_text; // label to be rendered for item
270
271 wxTreeItemData *m_data; // user-provided data
272
273 wxArrayGenericTreeItems m_children; // list of children
274 wxGenericTreeItem *m_parent; // parent of this item
275
276 wxTreeItemAttr *m_attr; // attributes???
9ec64fa7
VZ
277
278 // tree ctrl images for the normal, selected, expanded and
279 // expanded+selected states
8253f2e0 280 int m_images[wxTreeItemIcon_Max];
9ec64fa7 281
618a5e38 282 wxCoord m_x; // (virtual) offset from top
e549bec4 283 wxCoord m_y; // (virtual) offset from left
8253f2e0
WS
284 int m_width; // width of this item
285 int m_height; // height of this item
9ec64fa7
VZ
286
287 // use bitfields to save size
9bb50fd0
VZ
288 unsigned int m_isCollapsed :1;
289 unsigned int m_hasHilight :1; // same as focused
290 unsigned int m_hasPlus :1; // used for item which doesn't have
9ec64fa7 291 // children but has a [+] button
9bb50fd0
VZ
292 unsigned int m_isBold :1; // render the label in bold font
293 unsigned int m_ownsAttr :1; // delete attribute when done
22f3361e
VZ
294
295 DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
f135ff73
VZ
296};
297
298// =============================================================================
299// implementation
300// =============================================================================
301
06b466c7
VZ
302// ----------------------------------------------------------------------------
303// private functions
304// ----------------------------------------------------------------------------
305
306// translate the key or mouse event flags to the type of selection we're
307// dealing with
308static void EventFlagsToSelType(long style,
309 bool shiftDown,
310 bool ctrlDown,
dfc6cd93
SB
311 bool &is_multiple,
312 bool &extended_select,
313 bool &unselect_others)
06b466c7 314{
dfc6cd93
SB
315 is_multiple = (style & wxTR_MULTIPLE) != 0;
316 extended_select = shiftDown && is_multiple;
317 unselect_others = !(extended_select || (ctrlDown && is_multiple));
06b466c7 318}
e179bd65 319
7475e8a3 320// check if the given item is under another one
0cf3b542 321static bool IsDescendantOf(const wxGenericTreeItem *parent, const wxGenericTreeItem *item)
7475e8a3
VZ
322{
323 while ( item )
324 {
325 if ( item == parent )
326 {
327 // item is a descendant of parent
ca65c044 328 return true;
7475e8a3
VZ
329 }
330
331 item = item->GetParent();
332 }
333
ca65c044 334 return false;
7475e8a3
VZ
335}
336
e179bd65
RR
337// -----------------------------------------------------------------------------
338// wxTreeRenameTimer (internal)
339// -----------------------------------------------------------------------------
340
941830cb 341wxTreeRenameTimer::wxTreeRenameTimer( wxGenericTreeCtrl *owner )
e179bd65
RR
342{
343 m_owner = owner;
344}
345
346void wxTreeRenameTimer::Notify()
347{
348 m_owner->OnRenameTimer();
349}
350
351//-----------------------------------------------------------------------------
352// wxTreeTextCtrl (internal)
353//-----------------------------------------------------------------------------
354
e179bd65
RR
355BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
356 EVT_CHAR (wxTreeTextCtrl::OnChar)
c13cace1 357 EVT_KEY_UP (wxTreeTextCtrl::OnKeyUp)
e179bd65
RR
358 EVT_KILL_FOCUS (wxTreeTextCtrl::OnKillFocus)
359END_EVENT_TABLE()
360
edb8f298
VZ
361wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
362 wxGenericTreeItem *item)
363 : m_itemEdited(item), m_startValue(item->GetText())
364{
e179bd65 365 m_owner = owner;
ca65c044 366 m_finished = false;
33fe475a 367 m_aboutToFinish = false;
e179bd65 368
edb8f298
VZ
369 int w = m_itemEdited->GetWidth(),
370 h = m_itemEdited->GetHeight();
371
372 int x, y;
373 m_owner->CalcScrolledPosition(item->GetX(), item->GetY(), &x, &y);
374
375 int image_h = 0,
376 image_w = 0;
377
378 int image = item->GetCurrentImage();
379 if ( image != NO_IMAGE )
e179bd65 380 {
edb8f298
VZ
381 if ( m_owner->m_imageListNormal )
382 {
383 m_owner->m_imageListNormal->GetSize( image, image_w, image_h );
3e4f8ee2 384 image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
edb8f298
VZ
385 }
386 else
387 {
388 wxFAIL_MSG(_T("you must create an image list to use images!"));
389 }
390 }
33ac7e6f 391
edb8f298
VZ
392 // FIXME: what are all these hardcoded 4, 8 and 11s really?
393 x += image_w;
394 w -= image_w + 4;
3b656728 395#ifdef __WXMAC__
6574f2b1 396 wxSize bs = DoGetBestSize() ;
3b656728 397 // edit control height
6574f2b1 398 if ( h > bs.y - 8 )
3b656728 399 {
6574f2b1 400 int diff = h - ( bs.y - 8 ) ;
3b656728
SC
401 h -= diff ;
402 y += diff / 2 ;
403 }
404#endif
33ac7e6f 405
edb8f298
VZ
406 (void)Create(m_owner, wxID_ANY, m_startValue,
407 wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));
408}
574c939e 409
edb8f298
VZ
410bool wxTreeTextCtrl::AcceptChanges()
411{
412 const wxString value = GetValue();
618a5e38 413
edb8f298
VZ
414 if ( value == m_startValue )
415 {
416 // nothing changed, always accept
c145a47c
RD
417 // when an item remains unchanged, the owner
418 // needs to be notified that the user decided
419 // not to change the tree item label, and that
420 // the edit has been cancelled
421
422 m_owner->OnRenameCancelled(m_itemEdited);
ca65c044 423 return true;
e179bd65 424 }
edb8f298
VZ
425
426 if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
e179bd65 427 {
edb8f298 428 // vetoed by the user
ca65c044 429 return false;
edb8f298
VZ
430 }
431
432 // accepted, do rename the item
433 m_owner->SetItemText(m_itemEdited, value);
33ac7e6f 434
ca65c044 435 return true;
edb8f298
VZ
436}
437
438void wxTreeTextCtrl::Finish()
439{
ce175018 440 if ( !m_finished )
edb8f298 441 {
fbb12260
JS
442 m_owner->ResetTextControl();
443
edb8f298 444 wxPendingDelete.Append(this);
33ac7e6f 445
ca65c044 446 m_finished = true;
9548f380 447
8cee4a30 448 m_owner->SetFocus();
edb8f298
VZ
449 }
450}
dd5a32cc 451
edb8f298
VZ
452void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
453{
454 switch ( event.m_keyCode )
455 {
456 case WXK_RETURN:
8cee4a30 457 EndEdit();
2b4f324a 458 break;
edb8f298
VZ
459
460 case WXK_ESCAPE:
0cf3b542 461 StopEditing();
edb8f298
VZ
462 break;
463
464 default:
465 event.Skip();
e179bd65 466 }
c13cace1
VS
467}
468
469void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
470{
edb8f298 471 if ( !m_finished )
dd5a32cc 472 {
edb8f298
VZ
473 // auto-grow the textctrl:
474 wxSize parentSize = m_owner->GetSize();
475 wxPoint myPos = GetPosition();
476 wxSize mySize = GetSize();
477 int sx, sy;
478 GetTextExtent(GetValue() + _T("M"), &sx, &sy);
479 if (myPos.x + sx > parentSize.x)
480 sx = parentSize.x - myPos.x;
481 if (mySize.x > sx)
482 sx = mySize.x;
422d0ff0 483 SetSize(sx, wxDefaultCoord);
dd5a32cc
RR
484 }
485
c13cace1 486 event.Skip();
e179bd65
RR
487}
488
dd5a32cc 489void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
e179bd65 490{
ce175018 491 if ( !m_finished && !m_aboutToFinish )
edb8f298 492 {
9146872c
VS
493 // We must finish regardless of success, otherwise we'll get
494 // focus problems:
edb8f298 495 Finish();
902725ee 496
33fe475a
RR
497 if ( !AcceptChanges() )
498 m_owner->OnRenameCancelled( m_itemEdited );
edb8f298 499 }
9146872c
VS
500
501 // We must let the native text control handle focus, too, otherwise
33fe475a 502 // it could have problems with the cursor (e.g., in wxGTK).
9146872c 503 event.Skip();
e179bd65
RR
504}
505
f135ff73 506// -----------------------------------------------------------------------------
c801d85f 507// wxGenericTreeItem
f135ff73 508// -----------------------------------------------------------------------------
c801d85f 509
f135ff73
VZ
510wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
511 const wxString& text,
f135ff73
VZ
512 int image, int selImage,
513 wxTreeItemData *data)
514 : m_text(text)
c801d85f 515{
00e12320
RR
516 m_images[wxTreeItemIcon_Normal] = image;
517 m_images[wxTreeItemIcon_Selected] = selImage;
518 m_images[wxTreeItemIcon_Expanded] = NO_IMAGE;
519 m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
8dc99046 520
00e12320
RR
521 m_data = data;
522 m_x = m_y = 0;
f135ff73 523
ca65c044
WS
524 m_isCollapsed = true;
525 m_hasHilight = false;
526 m_hasPlus = false;
527 m_isBold = false;
c801d85f 528
00e12320 529 m_parent = parent;
f135ff73 530
00e12320 531 m_attr = (wxTreeItemAttr *)NULL;
ca65c044 532 m_ownsAttr = false;
06b466c7 533
00e12320
RR
534 // We don't know the height here yet.
535 m_width = 0;
536 m_height = 0;
edaa81ae 537}
c801d85f 538
f135ff73 539wxGenericTreeItem::~wxGenericTreeItem()
c801d85f 540{
00e12320 541 delete m_data;
4832f7c0 542
618a5e38 543 if (m_ownsAttr) delete m_attr;
9ec64fa7 544
00e12320
RR
545 wxASSERT_MSG( m_children.IsEmpty(),
546 wxT("please call DeleteChildren() before deleting the item") );
372edb9d
VZ
547}
548
941830cb 549void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
372edb9d 550{
00e12320
RR
551 size_t count = m_children.Count();
552 for ( size_t n = 0; n < count; n++ )
a43a4f9d 553 {
00e12320 554 wxGenericTreeItem *child = m_children[n];
66619ee5 555 tree->SendDeleteEvent(child);
a43a4f9d 556
00e12320 557 child->DeleteChildren(tree);
66619ee5 558 if ( child == tree->m_select_me )
5117f9bf 559 tree->m_select_me = NULL;
00e12320
RR
560 delete child;
561 }
372edb9d 562
00e12320 563 m_children.Empty();
edaa81ae 564}
c801d85f 565
91b8de8d 566void wxGenericTreeItem::SetText( const wxString &text )
c801d85f 567{
00e12320 568 m_text = text;
edaa81ae 569}
c801d85f 570
4832f7c0 571size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
c801d85f 572{
00e12320
RR
573 size_t count = m_children.Count();
574 if ( !recursively )
575 return count;
4832f7c0 576
00e12320 577 size_t total = count;
f2593d0d 578 for (size_t n = 0; n < count; ++n)
00e12320
RR
579 {
580 total += m_children[n]->GetChildrenCount();
581 }
c801d85f 582
00e12320 583 return total;
edaa81ae 584}
c801d85f 585
618a5e38
RR
586void wxGenericTreeItem::GetSize( int &x, int &y,
587 const wxGenericTreeCtrl *theButton )
c801d85f 588{
618a5e38 589 int bottomY=m_y+theButton->GetLineHeight(this);
00e12320
RR
590 if ( y < bottomY ) y = bottomY;
591 int width = m_x + m_width;
592 if ( x < width ) x = width;
f135ff73 593
00e12320 594 if (IsExpanded())
4832f7c0 595 {
00e12320
RR
596 size_t count = m_children.Count();
597 for ( size_t n = 0; n < count; ++n )
598 {
618a5e38 599 m_children[n]->GetSize( x, y, theButton );
00e12320 600 }
df875e59 601 }
edaa81ae 602}
c801d85f 603
618a5e38
RR
604wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
605 const wxGenericTreeCtrl *theCtrl,
606 int &flags,
607 int level)
c801d85f 608{
618a5e38
RR
609 // for a hidden root node, don't evaluate it, but do evaluate children
610 if ( !(level == 0 && theCtrl->HasFlag(wxTR_HIDE_ROOT)) )
c801d85f 611 {
618a5e38
RR
612 // evaluate the item
613 int h = theCtrl->GetLineHeight(this);
614 if ((point.y > m_y) && (point.y < m_y + h))
f2593d0d 615 {
618a5e38
RR
616 int y_mid = m_y + h/2;
617 if (point.y < y_mid )
618 flags |= wxTREE_HITTEST_ONITEMUPPERPART;
619 else
620 flags |= wxTREE_HITTEST_ONITEMLOWERPART;
d3a9f4af 621
618a5e38 622 int xCross = m_x - theCtrl->GetSpacing();
a6b0ca75
SC
623#ifdef __WXMAC__
624 // according to the drawing code the triangels are drawn
625 // at -4 , -4 from the position up to +10/+10 max
626 if ((point.x > xCross-4) && (point.x < xCross+10) &&
627 (point.y > y_mid-4) && (point.y < y_mid+10) &&
628 HasPlus() && theCtrl->HasButtons() )
629#else
630 // 5 is the size of the plus sign
f8b043e7
RR
631 if ((point.x > xCross-6) && (point.x < xCross+6) &&
632 (point.y > y_mid-6) && (point.y < y_mid+6) &&
618a5e38 633 HasPlus() && theCtrl->HasButtons() )
a6b0ca75 634#endif
618a5e38
RR
635 {
636 flags |= wxTREE_HITTEST_ONITEMBUTTON;
637 return this;
638 }
0ae7f2a2 639
618a5e38
RR
640 if ((point.x >= m_x) && (point.x <= m_x+m_width))
641 {
642 int image_w = -1;
643 int image_h;
91b8de8d 644
618a5e38
RR
645 // assuming every image (normal and selected) has the same size!
646 if ( (GetImage() != NO_IMAGE) && theCtrl->m_imageListNormal )
647 theCtrl->m_imageListNormal->GetSize(GetImage(),
648 image_w, image_h);
649
650 if ((image_w != -1) && (point.x <= m_x + image_w + 1))
651 flags |= wxTREE_HITTEST_ONITEMICON;
652 else
653 flags |= wxTREE_HITTEST_ONITEMLABEL;
654
655 return this;
656 }
657
658 if (point.x < m_x)
659 flags |= wxTREE_HITTEST_ONITEMINDENT;
660 if (point.x > m_x+m_width)
661 flags |= wxTREE_HITTEST_ONITEMRIGHT;
91b8de8d 662
f2593d0d
RR
663 return this;
664 }
91b8de8d 665
618a5e38
RR
666 // if children are expanded, fall through to evaluate them
667 if (m_isCollapsed) return (wxGenericTreeItem*) NULL;
f2593d0d 668 }
618a5e38
RR
669
670 // evaluate children
671 size_t count = m_children.Count();
672 for ( size_t n = 0; n < count; n++ )
c801d85f 673 {
618a5e38
RR
674 wxGenericTreeItem *res = m_children[n]->HitTest( point,
675 theCtrl,
676 flags,
677 level + 1 );
678 if ( res != NULL )
679 return res;
edaa81ae 680 }
f135ff73 681
f2593d0d 682 return (wxGenericTreeItem*) NULL;
edaa81ae 683}
c801d85f 684
8dc99046
VZ
685int wxGenericTreeItem::GetCurrentImage() const
686{
687 int image = NO_IMAGE;
688 if ( IsExpanded() )
689 {
690 if ( IsSelected() )
691 {
692 image = GetImage(wxTreeItemIcon_SelectedExpanded);
693 }
694
695 if ( image == NO_IMAGE )
696 {
697 // we usually fall back to the normal item, but try just the
698 // expanded one (and not selected) first in this case
699 image = GetImage(wxTreeItemIcon_Expanded);
700 }
701 }
702 else // not expanded
703 {
704 if ( IsSelected() )
705 image = GetImage(wxTreeItemIcon_Selected);
706 }
707
618a5e38
RR
708 // maybe it doesn't have the specific image we want,
709 // try the default one instead
710 if ( image == NO_IMAGE ) image = GetImage();
8dc99046
VZ
711
712 return image;
713}
714
f135ff73 715// -----------------------------------------------------------------------------
941830cb 716// wxGenericTreeCtrl implementation
f135ff73
VZ
717// -----------------------------------------------------------------------------
718
8cee4a30 719IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxControl)
f135ff73 720
8cee4a30 721BEGIN_EVENT_TABLE(wxGenericTreeCtrl, wxTreeCtrlBase)
941830cb
JS
722 EVT_PAINT (wxGenericTreeCtrl::OnPaint)
723 EVT_MOUSE_EVENTS (wxGenericTreeCtrl::OnMouse)
724 EVT_CHAR (wxGenericTreeCtrl::OnChar)
725 EVT_SET_FOCUS (wxGenericTreeCtrl::OnSetFocus)
726 EVT_KILL_FOCUS (wxGenericTreeCtrl::OnKillFocus)
ca65c044 727 EVT_TREE_ITEM_GETTOOLTIP(wxID_ANY, wxGenericTreeCtrl::OnGetToolTip)
f135ff73
VZ
728END_EVENT_TABLE()
729
3a5bcc4d 730#if !defined(__WXMSW__) || defined(__WXUNIVERSAL__)
233058c7
JS
731/*
732 * wxTreeCtrl has to be a real class or we have problems with
733 * the run-time information.
734 */
735
736IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl)
737#endif
738
f135ff73
VZ
739// -----------------------------------------------------------------------------
740// construction/destruction
741// -----------------------------------------------------------------------------
91b8de8d 742
941830cb 743void wxGenericTreeCtrl::Init()
c801d85f 744{
8cee4a30
VZ
745 m_current =
746 m_key_current =
747 m_anchor =
748 m_select_me = (wxGenericTreeItem *) NULL;
ca65c044
WS
749 m_hasFocus = false;
750 m_dirty = false;
f135ff73 751
00e12320
RR
752 m_lineHeight = 10;
753 m_indent = 15;
754 m_spacing = 18;
f135ff73 755
b771aa29
VZ
756 m_hilightBrush = new wxBrush
757 (
a756f210 758 wxSystemSettings::GetColour
b771aa29
VZ
759 (
760 wxSYS_COLOUR_HIGHLIGHT
761 ),
762 wxSOLID
763 );
764
765 m_hilightUnfocusedBrush = new wxBrush
766 (
a756f210 767 wxSystemSettings::GetColour
b771aa29
VZ
768 (
769 wxSYS_COLOUR_BTNSHADOW
770 ),
771 wxSOLID
772 );
f135ff73 773
8cee4a30
VZ
774 m_imageListButtons = NULL;
775 m_ownsImageListButtons = false;
978f38c2 776
00e12320 777 m_dragCount = 0;
ca65c044 778 m_isDragging = false;
f8b043e7
RR
779 m_dropTarget = m_oldSelection = NULL;
780 m_underMouse = NULL;
fbb12260 781 m_textCtrl = NULL;
9dfbf520 782
cb59313c 783 m_renameTimer = NULL;
e1983ab5
VZ
784 m_freezeCount = 0;
785
cb59313c
VZ
786 m_findTimer = NULL;
787
e3d64157
RR
788 m_dropEffectAboveItem = false;
789
ca65c044 790 m_lastOnSame = false;
f38374d0 791
1729813a 792#ifdef __WXMAC_CARBON__
f89d65ea
SC
793 m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
794#else
a756f210 795 m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
f89d65ea 796#endif
2b5f62a0
VZ
797 m_boldFont = wxFont(m_normalFont.GetPointSize(),
798 m_normalFont.GetFamily(),
799 m_normalFont.GetStyle(),
800 wxBOLD,
801 m_normalFont.GetUnderlined(),
802 m_normalFont.GetFaceName(),
803 m_normalFont.GetEncoding());
edaa81ae 804}
c801d85f 805
618a5e38
RR
806bool wxGenericTreeCtrl::Create(wxWindow *parent,
807 wxWindowID id,
808 const wxPoint& pos,
809 const wxSize& size,
810 long style,
8cee4a30 811 const wxValidator& validator,
618a5e38 812 const wxString& name )
c801d85f 813{
2593f033
RR
814#ifdef __WXMAC__
815 int major,minor;
816 wxGetOsVersion( &major, &minor );
574c939e 817
2593f033
RR
818 style &= ~wxTR_LINES_AT_ROOT;
819 style |= wxTR_NO_LINES;
820 if (major < 10)
821 style |= wxTR_ROW_LINES;
9c7f49f5 822#endif // __WXMAC__
17d5bdf9 823
8cee4a30
VZ
824 if ( !wxControl::Create( parent, id, pos, size,
825 style|wxHSCROLL|wxVSCROLL,
826 validator,
827 name ) )
828 return false;
618a5e38 829
6f0dd6b2
VZ
830 // If the tree display has no buttons, but does have
831 // connecting lines, we can use a narrower layout.
832 // It may not be a good idea to force this...
618a5e38
RR
833 if (!HasButtons() && !HasFlag(wxTR_NO_LINES))
834 {
835 m_indent= 10;
836 m_spacing = 10;
837 }
978f38c2 838
ca65c044 839 wxVisualAttributes attr = GetDefaultAttributes();
fa47d7a7
VS
840 SetOwnForegroundColour( attr.colFg );
841 SetOwnBackgroundColour( attr.colBg );
92a4e4de
VZ
842 if (!m_hasFont)
843 SetOwnFont(attr.font);
c22886bd 844
9e0a12c9 845 m_dottedPen = wxPen( wxT("grey"), 0, 0 );
f135ff73 846
35d4c967 847 SetBestSize(size);
ca65c044
WS
848
849 return true;
edaa81ae 850}
c801d85f 851
941830cb 852wxGenericTreeCtrl::~wxGenericTreeCtrl()
c801d85f 853{
b771aa29
VZ
854 delete m_hilightBrush;
855 delete m_hilightUnfocusedBrush;
574c939e 856
00e12320 857 DeleteAllItems();
9dfbf520 858
00e12320 859 delete m_renameTimer;
cb59313c
VZ
860 delete m_findTimer;
861
cb59313c
VZ
862 if (m_ownsImageListButtons)
863 delete m_imageListButtons;
edaa81ae 864}
c801d85f 865
f135ff73
VZ
866// -----------------------------------------------------------------------------
867// accessors
868// -----------------------------------------------------------------------------
869
027d45e8 870unsigned int wxGenericTreeCtrl::GetCount() const
c801d85f 871{
ffda4dac
VZ
872 if ( !m_anchor )
873 {
874 // the tree is empty
875 return 0;
876 }
877
027d45e8 878 unsigned int count = m_anchor->GetChildrenCount();
ffda4dac
VZ
879 if ( !HasFlag(wxTR_HIDE_ROOT) )
880 {
881 // take the root itself into account
882 count++;
883 }
884
885 return count;
edaa81ae 886}
c801d85f 887
941830cb 888void wxGenericTreeCtrl::SetIndent(unsigned int indent)
c801d85f 889{
574c939e 890 m_indent = (unsigned short) indent;
ca65c044 891 m_dirty = true;
cf724bce
RR
892}
893
df74fdea
VZ
894size_t
895wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
896 bool recursively) const
4832f7c0 897{
f2593d0d 898 wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
4832f7c0 899
941830cb 900 return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);
4832f7c0
VZ
901}
902
618a5e38
RR
903void wxGenericTreeCtrl::SetWindowStyle(const long styles)
904{
867f2ca4
KH
905 // Do not try to expand the root node if it hasn't been created yet
906 if (m_anchor && !HasFlag(wxTR_HIDE_ROOT) && (styles & wxTR_HIDE_ROOT))
374a8e5c
VS
907 {
908 // if we will hide the root, make sure children are visible
909 m_anchor->SetHasPlus();
910 m_anchor->Expand();
911 CalculatePositions();
912 }
913
914 // right now, just sets the styles. Eventually, we may
915 // want to update the inherited styles, but right now
916 // none of the parents has updatable styles
618a5e38 917 m_windowStyle = styles;
ca65c044 918 m_dirty = true;
618a5e38
RR
919}
920
f135ff73
VZ
921// -----------------------------------------------------------------------------
922// functions to work with tree items
923// -----------------------------------------------------------------------------
74bedbeb 924
941830cb 925wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
f135ff73 926{
9548f380 927 wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") );
4832f7c0 928
941830cb 929 return ((wxGenericTreeItem*) item.m_pItem)->GetText();
edaa81ae 930}
74bedbeb 931
941830cb 932int wxGenericTreeCtrl::GetItemImage(const wxTreeItemId& item,
8dc99046 933 wxTreeItemIcon which) const
74bedbeb 934{
f2593d0d 935 wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
4832f7c0 936
941830cb 937 return ((wxGenericTreeItem*) item.m_pItem)->GetImage(which);
edaa81ae 938}
c801d85f 939
941830cb 940wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const
c801d85f 941{
f2593d0d 942 wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
4832f7c0 943
941830cb 944 return ((wxGenericTreeItem*) item.m_pItem)->GetData();
edaa81ae 945}
c801d85f 946
2b5f62a0
VZ
947wxColour wxGenericTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
948{
949 wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
950
951 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
952 return pItem->Attr().GetTextColour();
953}
954
955wxColour wxGenericTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
956{
957 wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
958
959 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
960 return pItem->Attr().GetBackgroundColour();
961}
962
963wxFont wxGenericTreeCtrl::GetItemFont(const wxTreeItemId& item) const
964{
965 wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") );
966
967 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
968 return pItem->Attr().GetFont();
969}
970
941830cb 971void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
f135ff73 972{
f2593d0d 973 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
4832f7c0 974
f2593d0d 975 wxClientDC dc(this);
941830cb 976 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
f2593d0d
RR
977 pItem->SetText(text);
978 CalculateSize(pItem, dc);
979 RefreshLine(pItem);
f135ff73 980}
c801d85f 981
941830cb 982void wxGenericTreeCtrl::SetItemImage(const wxTreeItemId& item,
8dc99046
VZ
983 int image,
984 wxTreeItemIcon which)
f135ff73 985{
223d09f6 986 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
4832f7c0 987
941830cb 988 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
8dc99046 989 pItem->SetImage(image, which);
4832f7c0 990
8dc99046
VZ
991 wxClientDC dc(this);
992 CalculateSize(pItem, dc);
993 RefreshLine(pItem);
edaa81ae 994}
c801d85f 995
941830cb 996void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
c801d85f 997{
f2593d0d 998 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
4832f7c0 999
74707d69
RR
1000 if (data)
1001 data->SetId( item );
ca65c044 1002
941830cb 1003 ((wxGenericTreeItem*) item.m_pItem)->SetData(data);
edaa81ae 1004}
c801d85f 1005
941830cb 1006void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
c801d85f 1007{
f2593d0d 1008 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
4832f7c0 1009
941830cb 1010 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
f2593d0d
RR
1011 pItem->SetHasPlus(has);
1012 RefreshLine(pItem);
edaa81ae 1013}
c801d85f 1014
941830cb 1015void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
ef44a621 1016{
9ec64fa7 1017 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
ef44a621 1018
9ec64fa7 1019 // avoid redrawing the tree if no real change
941830cb 1020 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
9ec64fa7
VZ
1021 if ( pItem->IsBold() != bold )
1022 {
1023 pItem->SetBold(bold);
3a1a76a8
VZ
1024
1025 // recalculate the item size as bold and non bold fonts have different
1026 // widths
1027 wxClientDC dc(this);
1028 CalculateSize(pItem, dc);
1029
9ec64fa7
VZ
1030 RefreshLine(pItem);
1031 }
1032}
1033
9fce43b7
RR
1034void wxGenericTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item,
1035 bool highlight)
1036{
1037 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1038
1039 wxColour fg, bg;
1040
1041 if (highlight)
1042 {
1043 bg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
1044 fg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
1045 }
1046
1047 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1048 pItem->Attr().SetTextColour(fg);
1049 pItem->Attr().SetBackgroundColour(bg);
1050 RefreshLine(pItem);
1051}
1052
941830cb 1053void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
9ec64fa7
VZ
1054 const wxColour& col)
1055{
1056 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1057
941830cb 1058 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
9ec64fa7
VZ
1059 pItem->Attr().SetTextColour(col);
1060 RefreshLine(pItem);
1061}
1062
941830cb 1063void wxGenericTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
9ec64fa7
VZ
1064 const wxColour& col)
1065{
1066 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1067
941830cb 1068 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
9ec64fa7
VZ
1069 pItem->Attr().SetBackgroundColour(col);
1070 RefreshLine(pItem);
1071}
1072
941830cb 1073void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
9ec64fa7
VZ
1074{
1075 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1076
941830cb 1077 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
9ec64fa7 1078 pItem->Attr().SetFont(font);
ef44a621 1079 RefreshLine(pItem);
ef44a621
VZ
1080}
1081
3da2715f
JS
1082bool wxGenericTreeCtrl::SetFont( const wxFont &font )
1083{
8cee4a30 1084 wxTreeCtrlBase::SetFont(font);
3da2715f
JS
1085
1086 m_normalFont = font ;
2b5f62a0
VZ
1087 m_boldFont = wxFont(m_normalFont.GetPointSize(),
1088 m_normalFont.GetFamily(),
1089 m_normalFont.GetStyle(),
1090 wxBOLD,
1091 m_normalFont.GetUnderlined(),
1092 m_normalFont.GetFaceName(),
1093 m_normalFont.GetEncoding());
3da2715f 1094
ca65c044 1095 return true;
3da2715f
JS
1096}
1097
1098
f135ff73
VZ
1099// -----------------------------------------------------------------------------
1100// item status inquiries
1101// -----------------------------------------------------------------------------
1102
1ed01484 1103bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
c801d85f 1104{
ca65c044 1105 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1ed01484 1106
c22886bd 1107 // An item is only visible if it's not a descendant of a collapsed item
1ed01484 1108 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
c22886bd
RR
1109 wxGenericTreeItem* parent = pItem->GetParent();
1110 while (parent)
1111 {
1112 if (!parent->IsExpanded())
ca65c044 1113 return false;
c22886bd
RR
1114 parent = parent->GetParent();
1115 }
1ed01484
JS
1116
1117 int startX, startY;
1118 GetViewStart(& startX, & startY);
1119
1120 wxSize clientSize = GetClientSize();
1121
1122 wxRect rect;
1123 if (!GetBoundingRect(item, rect))
ca65c044 1124 return false;
c22886bd 1125 if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
ca65c044 1126 return false;
1ed01484 1127 if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
ca65c044 1128 return false;
1ed01484 1129 if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
ca65c044 1130 return false;
f135ff73 1131
ca65c044 1132 return true;
edaa81ae 1133}
c801d85f 1134
941830cb 1135bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
c801d85f 1136{
ca65c044 1137 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
4832f7c0 1138
59a2e635
VZ
1139 // consider that the item does have children if it has the "+" button: it
1140 // might not have them (if it had never been expanded yet) but then it
1141 // could have them as well and it's better to err on this side rather than
1142 // disabling some operations which are restricted to the items with
1143 // children for an item which does have them
607d9cfc 1144 return ((wxGenericTreeItem*) item.m_pItem)->HasPlus();
edaa81ae 1145}
c801d85f 1146
941830cb 1147bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
c801d85f 1148{
ca65c044 1149 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
4832f7c0 1150
941830cb 1151 return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded();
f135ff73 1152}
29d87bba 1153
941830cb 1154bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const
f135ff73 1155{
ca65c044 1156 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
4832f7c0 1157
941830cb 1158 return ((wxGenericTreeItem*) item.m_pItem)->IsSelected();
f135ff73 1159}
29d87bba 1160
941830cb 1161bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
ef44a621 1162{
ca65c044 1163 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
ef44a621 1164
941830cb 1165 return ((wxGenericTreeItem*) item.m_pItem)->IsBold();
ef44a621
VZ
1166}
1167
f135ff73
VZ
1168// -----------------------------------------------------------------------------
1169// navigation
1170// -----------------------------------------------------------------------------
29d87bba 1171
99006e44 1172wxTreeItemId wxGenericTreeCtrl::GetItemParent(const wxTreeItemId& item) const
f135ff73 1173{
618a5e38 1174 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
389cdc7a 1175
618a5e38 1176 return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
f135ff73 1177}
29d87bba 1178
ee4b2721
VZ
1179wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1180 wxTreeItemIdValue& cookie) const
f135ff73 1181{
618a5e38 1182 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
29d87bba 1183
618a5e38
RR
1184 cookie = 0;
1185 return GetNextChild(item, cookie);
f135ff73 1186}
29d87bba 1187
ee4b2721
VZ
1188wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
1189 wxTreeItemIdValue& cookie) const
1190{
1191 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1192
1193 wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1194
1195 // it's ok to cast cookie to size_t, we never have indices big enough to
1196 // overflow "void *"
1197 size_t *pIndex = (size_t *)&cookie;
1198 if ( *pIndex < children.Count() )
1199 {
836543b8 1200 return children.Item((*pIndex)++);
ee4b2721
VZ
1201 }
1202 else
1203 {
1204 // there are no more of them
1205 return wxTreeItemId();
1206 }
1207}
1208
1209#if WXWIN_COMPATIBILITY_2_4
1210
1211wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1212 long& cookie) const
1213{
1214 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1215
1216 cookie = 0;
1217 return GetNextChild(item, cookie);
1218}
1219
1220wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
1221 long& cookie) const
f135ff73 1222{
618a5e38 1223 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
29d87bba 1224
618a5e38
RR
1225 wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1226 if ( (size_t)cookie < children.Count() )
1227 {
1228 return children.Item((size_t)cookie++);
1229 }
1230 else
1231 {
1232 // there are no more of them
1233 return wxTreeItemId();
1234 }
f135ff73 1235}
29d87bba 1236
ee4b2721
VZ
1237#endif // WXWIN_COMPATIBILITY_2_4
1238
941830cb 1239wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
978f38c2 1240{
618a5e38 1241 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
978f38c2 1242
618a5e38
RR
1243 wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1244 return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
978f38c2
VZ
1245}
1246
941830cb 1247wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
f135ff73 1248{
618a5e38 1249 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
f135ff73 1250
618a5e38
RR
1251 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1252 wxGenericTreeItem *parent = i->GetParent();
1253 if ( parent == NULL )
1254 {
1255 // root item doesn't have any siblings
1256 return wxTreeItemId();
1257 }
4832f7c0 1258
618a5e38
RR
1259 wxArrayGenericTreeItems& siblings = parent->GetChildren();
1260 int index = siblings.Index(i);
1261 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
29d87bba 1262
618a5e38
RR
1263 size_t n = (size_t)(index + 1);
1264 return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
edaa81ae 1265}
c801d85f 1266
941830cb 1267wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
c801d85f 1268{
618a5e38 1269 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
f135ff73 1270
618a5e38
RR
1271 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1272 wxGenericTreeItem *parent = i->GetParent();
1273 if ( parent == NULL )
1274 {
1275 // root item doesn't have any siblings
1276 return wxTreeItemId();
1277 }
4832f7c0 1278
618a5e38
RR
1279 wxArrayGenericTreeItems& siblings = parent->GetChildren();
1280 int index = siblings.Index(i);
1281 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
29d87bba 1282
618a5e38
RR
1283 return index == 0 ? wxTreeItemId()
1284 : wxTreeItemId(siblings[(size_t)(index - 1)]);
f135ff73 1285}
389cdc7a 1286
1ed01484
JS
1287// Only for internal use right now, but should probably be public
1288wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
f135ff73 1289{
618a5e38
RR
1290 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1291
1292 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1293
1294 // First see if there are any children.
1295 wxArrayGenericTreeItems& children = i->GetChildren();
1296 if (children.GetCount() > 0)
1297 {
1298 return children.Item(0);
1299 }
1300 else
1301 {
1302 // Try a sibling of this or ancestor instead
1303 wxTreeItemId p = item;
1304 wxTreeItemId toFind;
1305 do
1306 {
1307 toFind = GetNextSibling(p);
99006e44 1308 p = GetItemParent(p);
618a5e38
RR
1309 } while (p.IsOk() && !toFind.IsOk());
1310 return toFind;
1311 }
1ed01484
JS
1312}
1313
1ed01484
JS
1314wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
1315{
618a5e38
RR
1316 wxTreeItemId id = GetRootItem();
1317 if (!id.IsOk())
1ed01484 1318 return id;
1ed01484 1319
618a5e38
RR
1320 do
1321 {
1322 if (IsVisible(id))
1323 return id;
1324 id = GetNext(id);
1325 } while (id.IsOk());
1326
1327 return wxTreeItemId();
1ed01484
JS
1328}
1329
941830cb 1330wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
f135ff73 1331{
618a5e38 1332 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
29d87bba 1333
618a5e38
RR
1334 wxTreeItemId id = item;
1335 if (id.IsOk())
1336 {
1337 while (id = GetNext(id), id.IsOk())
1338 {
1339 if (IsVisible(id))
1340 return id;
1341 }
1342 }
1343 return wxTreeItemId();
f135ff73 1344}
29d87bba 1345
941830cb 1346wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
f135ff73 1347{
618a5e38 1348 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
29d87bba 1349
618a5e38 1350 wxFAIL_MSG(wxT("not implemented"));
29d87bba 1351
618a5e38 1352 return wxTreeItemId();
edaa81ae 1353}
c801d85f 1354
fbb12260
JS
1355// called by wxTextTreeCtrl when it marks itself for deletion
1356void wxGenericTreeCtrl::ResetTextControl()
1357{
eb7f24c1 1358 m_textCtrl = NULL;
fbb12260
JS
1359}
1360
cb59313c
VZ
1361// find the first item starting with the given prefix after the given item
1362wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent,
1363 const wxString& prefixOrig) const
1364{
1365 // match is case insensitive as this is more convenient to the user: having
1366 // to press Shift-letter to go to the item starting with a capital letter
1367 // would be too bothersome
1368 wxString prefix = prefixOrig.Lower();
1369
526b8142
VZ
1370 // determine the starting point: we shouldn't take the current item (this
1371 // allows to switch between two items starting with the same letter just by
1372 // pressing it) but we shouldn't jump to the next one if the user is
1373 // continuing to type as otherwise he might easily skip the item he wanted
cb59313c 1374 wxTreeItemId id = idParent;
526b8142
VZ
1375 if ( prefix.length() == 1 )
1376 {
1377 id = GetNext(id);
1378 }
cb59313c 1379
526b8142 1380 // look for the item starting with the given prefix after it
cb59313c
VZ
1381 while ( id.IsOk() && !GetItemText(id).Lower().StartsWith(prefix) )
1382 {
1383 id = GetNext(id);
1384 }
1385
526b8142
VZ
1386 // if we haven't found anything...
1387 if ( !id.IsOk() )
1388 {
1389 // ... wrap to the beginning
1390 id = GetRootItem();
1391 if ( HasFlag(wxTR_HIDE_ROOT) )
1392 {
1393 // can't select virtual root
1394 id = GetNext(id);
1395 }
1396
1397 // and try all the items (stop when we get to the one we started from)
1398 while ( id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
1399 {
1400 id = GetNext(id);
1401 }
1402 }
1403
cb59313c
VZ
1404 return id;
1405}
1406
f135ff73
VZ
1407// -----------------------------------------------------------------------------
1408// operations
1409// -----------------------------------------------------------------------------
1410
941830cb 1411wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
8cee4a30
VZ
1412 size_t previous,
1413 const wxString& text,
1414 int image,
1415 int selImage,
1416 wxTreeItemData *data)
c801d85f 1417{
941830cb 1418 wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
f49f2b0c
RR
1419 if ( !parent )
1420 {
1421 // should we give a warning here?
1422 return AddRoot(text, image, selImage, data);
1423 }
4832f7c0 1424
ca65c044 1425 m_dirty = true; // do this first so stuff below doesn't cause flicker
618a5e38 1426
f38374d0 1427 wxGenericTreeItem *item =
2b84e565 1428 new wxGenericTreeItem( parent, text, image, selImage, data );
74bedbeb 1429
f49f2b0c
RR
1430 if ( data != NULL )
1431 {
ee4b2721 1432 data->m_pItem = item;
f49f2b0c 1433 }
74bedbeb 1434
8cee4a30
VZ
1435 parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size()
1436 : previous );
ef44a621 1437
f49f2b0c 1438 return item;
4c681997
RR
1439}
1440
941830cb 1441wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
8cee4a30
VZ
1442 int image,
1443 int selImage,
1444 wxTreeItemData *data)
4c681997 1445{
f49f2b0c 1446 wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
389cdc7a 1447
ca65c044 1448 m_dirty = true; // do this first so stuff below doesn't cause flicker
618a5e38 1449
2b84e565 1450 m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text,
f135ff73 1451 image, selImage, data);
cf31a1d7
VS
1452 if ( data != NULL )
1453 {
ee4b2721 1454 data->m_pItem = m_anchor;
cf31a1d7
VS
1455 }
1456
618a5e38
RR
1457 if (HasFlag(wxTR_HIDE_ROOT))
1458 {
1459 // if root is hidden, make sure we can navigate
1460 // into children
1461 m_anchor->SetHasPlus();
999723f3
VS
1462 m_anchor->Expand();
1463 CalculatePositions();
618a5e38 1464 }
f38374d0 1465
f49f2b0c
RR
1466 if (!HasFlag(wxTR_MULTIPLE))
1467 {
1468 m_current = m_key_current = m_anchor;
ca65c044 1469 m_current->SetHilight( true );
f49f2b0c 1470 }
389cdc7a 1471
f49f2b0c 1472 return m_anchor;
edaa81ae 1473}
c801d85f 1474
8cee4a30
VZ
1475wxTreeItemId wxGenericTreeCtrl::DoInsertAfter(const wxTreeItemId& parentId,
1476 const wxTreeItemId& idPrevious,
1477 const wxString& text,
1478 int image, int selImage,
1479 wxTreeItemData *data)
c801d85f 1480{
941830cb 1481 wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
f2593d0d
RR
1482 if ( !parent )
1483 {
1484 // should we give a warning here?
1485 return AddRoot(text, image, selImage, data);
1486 }
c801d85f 1487
4855a477
JS
1488 int index = -1;
1489 if (idPrevious.IsOk())
1490 {
1491 index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem);
1492 wxASSERT_MSG( index != wxNOT_FOUND,
1493 wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );
1494 }
06b466c7 1495
f2593d0d
RR
1496 return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
1497}
1498
74bedbeb 1499
941830cb 1500void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
a43a4f9d 1501{
09f277d6 1502 wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, this, item);
f2593d0d 1503 ProcessEvent( event );
a43a4f9d
VZ
1504}
1505
0cf3b542
RR
1506// Don't leave edit or selection on a child which is about to disappear
1507void wxGenericTreeCtrl::ChildrenClosing(wxGenericTreeItem* item)
1508{
1509 if (m_textCtrl != NULL && item != m_textCtrl->item() && IsDescendantOf(item, m_textCtrl->item())) {
1510 m_textCtrl->StopEditing();
1511 }
1512 if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
1513 m_key_current = NULL;
1514 }
1515 if (IsDescendantOf(item, m_select_me)) {
1516 m_select_me = item;
1517 }
1518 if (item != m_current && IsDescendantOf(item, m_current)) {
af3961b3 1519 m_current->SetHilight( false );
0cf3b542
RR
1520 m_current = NULL;
1521 m_select_me = item;
1522 }
1523}
1524
941830cb 1525void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
372edb9d 1526{
ca65c044 1527 m_dirty = true; // do this first so stuff below doesn't cause flicker
618a5e38 1528
941830cb 1529 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
0cf3b542 1530 ChildrenClosing(item);
a43a4f9d 1531 item->DeleteChildren(this);
372edb9d
VZ
1532}
1533
941830cb 1534void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
c801d85f 1535{
ca65c044 1536 m_dirty = true; // do this first so stuff below doesn't cause flicker
618a5e38 1537
941830cb 1538 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
ff5bf259 1539
0cf3b542 1540 if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item()))
eb7f24c1
VZ
1541 {
1542 // can't delete the item being edited, cancel editing it first
0cf3b542 1543 m_textCtrl->StopEditing();
eb7f24c1
VZ
1544 }
1545
7475e8a3
VZ
1546 wxGenericTreeItem *parent = item->GetParent();
1547
1548 // don't keep stale pointers around!
1549 if ( IsDescendantOf(item, m_key_current) )
aaa2f297 1550 {
3e3a7b97
JS
1551 // Don't silently change the selection:
1552 // do it properly in idle time, so event
1553 // handlers get called.
ca65c044 1554
3e3a7b97
JS
1555 // m_key_current = parent;
1556 m_key_current = NULL;
1557 }
1558
1559 // m_select_me records whether we need to select
1560 // a different item, in idle time.
1561 if ( m_select_me && IsDescendantOf(item, m_select_me) )
1562 {
1563 m_select_me = parent;
aaa2f297
VZ
1564 }
1565
7475e8a3
VZ
1566 if ( IsDescendantOf(item, m_current) )
1567 {
3e3a7b97
JS
1568 // Don't silently change the selection:
1569 // do it properly in idle time, so event
1570 // handlers get called.
ca65c044 1571
3e3a7b97
JS
1572 // m_current = parent;
1573 m_current = NULL;
1574 m_select_me = parent;
7475e8a3
VZ
1575 }
1576
1577 // remove the item from the tree
97d7bfb8
RR
1578 if ( parent )
1579 {
1580 parent->GetChildren().Remove( item ); // remove by value
1581 }
7475e8a3 1582 else // deleting the root
aaa2f297 1583 {
7475e8a3
VZ
1584 // nothing will be left in the tree
1585 m_anchor = NULL;
aaa2f297
VZ
1586 }
1587
7475e8a3 1588 // and delete all of its children and the item itself now
97d7bfb8
RR
1589 item->DeleteChildren(this);
1590 SendDeleteEvent(item);
5117f9bf
JS
1591
1592 if (item == m_select_me)
1593 m_select_me = NULL;
1729813a 1594
97d7bfb8 1595 delete item;
edaa81ae 1596}
c801d85f 1597
941830cb 1598void wxGenericTreeCtrl::DeleteAllItems()
c801d85f 1599{
97d7bfb8
RR
1600 if ( m_anchor )
1601 {
7475e8a3 1602 Delete(m_anchor);
97d7bfb8 1603 }
edaa81ae
RR
1604}
1605
941830cb 1606void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
edaa81ae 1607{
941830cb 1608 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
f135ff73 1609
941830cb 1610 wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );
7a944d2f 1611 wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
999723f3 1612 _T("can't expand hidden root") );
f6bcfd97 1613
f2593d0d
RR
1614 if ( !item->HasPlus() )
1615 return;
978f38c2 1616
f2593d0d
RR
1617 if ( item->IsExpanded() )
1618 return;
f135ff73 1619
09f277d6 1620 wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDING, this, item);
004fd0c8 1621
f2593d0d
RR
1622 if ( ProcessEvent( event ) && !event.IsAllowed() )
1623 {
1624 // cancelled by program
1625 return;
1626 }
4832f7c0 1627
f2593d0d
RR
1628 item->Expand();
1629 CalculatePositions();
f135ff73 1630
f2593d0d 1631 RefreshSubtree(item);
f135ff73 1632
f2593d0d
RR
1633 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
1634 ProcessEvent( event );
edaa81ae
RR
1635}
1636
941830cb 1637void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
edaa81ae 1638{
7a944d2f 1639 wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
999723f3
VS
1640 _T("can't collapse hidden root") );
1641
941830cb 1642 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
f135ff73 1643
f2593d0d
RR
1644 if ( !item->IsExpanded() )
1645 return;
f135ff73 1646
09f277d6 1647 wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, this, item);
f2593d0d
RR
1648 if ( ProcessEvent( event ) && !event.IsAllowed() )
1649 {
1650 // cancelled by program
1651 return;
1652 }
4832f7c0 1653
0cf3b542 1654 ChildrenClosing(item);
f2593d0d 1655 item->Collapse();
f135ff73 1656
618a5e38 1657#if 0 // TODO why should items be collapsed recursively?
f2593d0d
RR
1658 wxArrayGenericTreeItems& children = item->GetChildren();
1659 size_t count = children.Count();
1660 for ( size_t n = 0; n < count; n++ )
1661 {
1662 Collapse(children[n]);
1663 }
618a5e38 1664#endif
f135ff73 1665
f2593d0d 1666 CalculatePositions();
f135ff73 1667
f2593d0d 1668 RefreshSubtree(item);
f135ff73 1669
f2593d0d
RR
1670 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
1671 ProcessEvent( event );
edaa81ae 1672}
c801d85f 1673
941830cb 1674void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
c801d85f 1675{
00e12320
RR
1676 Collapse(item);
1677 DeleteChildren(item);
edaa81ae 1678}
c801d85f 1679
941830cb 1680void wxGenericTreeCtrl::Toggle(const wxTreeItemId& itemId)
c801d85f 1681{
941830cb 1682 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
389cdc7a 1683
00e12320
RR
1684 if (item->IsExpanded())
1685 Collapse(itemId);
1686 else
1687 Expand(itemId);
f135ff73 1688}
389cdc7a 1689
941830cb 1690void wxGenericTreeCtrl::Unselect()
f135ff73 1691{
00e12320
RR
1692 if (m_current)
1693 {
ca65c044 1694 m_current->SetHilight( false );
00e12320 1695 RefreshLine( m_current );
02fe25c2
VZ
1696
1697 m_current = NULL;
3e3a7b97 1698 m_select_me = NULL;
00e12320 1699 }
edaa81ae 1700}
c801d85f 1701
941830cb 1702void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
389cdc7a 1703{
00e12320
RR
1704 if (item->IsSelected())
1705 {
ca65c044 1706 item->SetHilight(false);
00e12320
RR
1707 RefreshLine(item);
1708 }
d3a9f4af 1709
00e12320 1710 if (item->HasChildren())
88ac883a 1711 {
00e12320
RR
1712 wxArrayGenericTreeItems& children = item->GetChildren();
1713 size_t count = children.Count();
1714 for ( size_t n = 0; n < count; ++n )
1715 {
1716 UnselectAllChildren(children[n]);
1717 }
88ac883a
VZ
1718 }
1719}
f135ff73 1720
941830cb 1721void wxGenericTreeCtrl::UnselectAll()
88ac883a 1722{
0a33446c
VZ
1723 wxTreeItemId rootItem = GetRootItem();
1724
1725 // the tree might not have the root item at all
1726 if ( rootItem )
1727 {
1728 UnselectAllChildren((wxGenericTreeItem*) rootItem.m_pItem);
1729 }
88ac883a
VZ
1730}
1731
1732// Recursive function !
1733// To stop we must have crt_item<last_item
91b8de8d 1734// Algorithm :
88ac883a 1735// Tag all next children, when no more children,
d3a9f4af 1736// Move to parent (not to tag)
91b8de8d 1737// Keep going... if we found last_item, we stop.
941830cb 1738bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
88ac883a
VZ
1739{
1740 wxGenericTreeItem *parent = crt_item->GetParent();
1741
00e12320
RR
1742 if (parent == NULL) // This is root item
1743 return TagAllChildrenUntilLast(crt_item, last_item, select);
88ac883a 1744
91b8de8d 1745 wxArrayGenericTreeItems& children = parent->GetChildren();
88ac883a
VZ
1746 int index = children.Index(crt_item);
1747 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1748
1749 size_t count = children.Count();
1750 for (size_t n=(size_t)(index+1); n<count; ++n)
00e12320 1751 {
ca65c044 1752 if (TagAllChildrenUntilLast(children[n], last_item, select)) return true;
00e12320 1753 }
88ac883a
VZ
1754
1755 return TagNextChildren(parent, last_item, select);
1756}
1757
941830cb 1758bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
88ac883a 1759{
00e12320
RR
1760 crt_item->SetHilight(select);
1761 RefreshLine(crt_item);
d3a9f4af 1762
06b466c7 1763 if (crt_item==last_item)
ca65c044 1764 return true;
88ac883a 1765
00e12320 1766 if (crt_item->HasChildren())
88ac883a 1767 {
00e12320
RR
1768 wxArrayGenericTreeItems& children = crt_item->GetChildren();
1769 size_t count = children.Count();
1770 for ( size_t n = 0; n < count; ++n )
1771 {
06b466c7 1772 if (TagAllChildrenUntilLast(children[n], last_item, select))
ca65c044 1773 return true;
06b466c7 1774 }
88ac883a 1775 }
d3a9f4af 1776
ca65c044 1777 return false;
88ac883a
VZ
1778}
1779
941830cb 1780void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
88ac883a 1781{
3e3a7b97 1782 m_select_me = NULL;
88ac883a 1783
999836aa 1784 // item2 is not necessary after item1
f2593d0d 1785 // choice first' and 'last' between item1 and item2
999836aa
VZ
1786 wxGenericTreeItem *first= (item1->GetY()<item2->GetY()) ? item1 : item2;
1787 wxGenericTreeItem *last = (item1->GetY()<item2->GetY()) ? item2 : item1;
88ac883a 1788
f2593d0d 1789 bool select = m_current->IsSelected();
d3a9f4af 1790
f2593d0d
RR
1791 if ( TagAllChildrenUntilLast(first,last,select) )
1792 return;
88ac883a 1793
f2593d0d 1794 TagNextChildren(first,last,select);
88ac883a
VZ
1795}
1796
78f12104
VZ
1797void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId,
1798 bool unselect_others,
1799 bool extended_select)
d3a9f4af 1800{
223d09f6 1801 wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
8b04a037 1802
3e3a7b97 1803 m_select_me = NULL;
ca65c044 1804
88ac883a 1805 bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
941830cb 1806 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
88ac883a
VZ
1807
1808 //wxCHECK_RET( ( (!unselect_others) && is_single),
223d09f6 1809 // wxT("this is a single selection tree") );
88ac883a
VZ
1810
1811 // to keep going anyhow !!!
d3a9f4af 1812 if (is_single)
8dc99046
VZ
1813 {
1814 if (item->IsSelected())
1815 return; // nothing to do
ca65c044
WS
1816 unselect_others = true;
1817 extended_select = false;
8dc99046
VZ
1818 }
1819 else if ( unselect_others && item->IsSelected() )
1820 {
1821 // selection change if there is more than one item currently selected
1822 wxArrayTreeItemIds selected_items;
1823 if ( GetSelections(selected_items) == 1 )
1824 return;
1825 }
d3a9f4af 1826
09f277d6 1827 wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
ee4b2721 1828 event.m_itemOld = m_current;
91b8de8d 1829 // TODO : Here we don't send any selection mode yet !
d3a9f4af 1830
f98e2558 1831 if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
618a5e38 1832 return;
f135ff73 1833
99006e44 1834 wxTreeItemId parent = GetItemParent( itemId );
2cc78389
RR
1835 while (parent.IsOk())
1836 {
1837 if (!IsExpanded(parent))
1838 Expand( parent );
cdb3cffe 1839
99006e44 1840 parent = GetItemParent( parent );
2cc78389 1841 }
cdb3cffe 1842
88ac883a
VZ
1843 // ctrl press
1844 if (unselect_others)
389cdc7a 1845 {
88ac883a 1846 if (is_single) Unselect(); // to speed up thing
c193b707 1847 else UnselectAll();
edaa81ae 1848 }
f135ff73 1849
88ac883a 1850 // shift press
d3a9f4af 1851 if (extended_select)
88ac883a 1852 {
aaa2f297
VZ
1853 if ( !m_current )
1854 {
618a5e38 1855 m_current = m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem;
aaa2f297
VZ
1856 }
1857
88ac883a
VZ
1858 // don't change the mark (m_current)
1859 SelectItemRange(m_current, item);
1860 }
1861 else
1862 {
ca65c044 1863 bool select = true; // the default
88ac883a 1864
c193b707
VZ
1865 // Check if we need to toggle hilight (ctrl mode)
1866 if (!unselect_others)
618a5e38 1867 select=!item->IsSelected();
88ac883a 1868
91b8de8d 1869 m_current = m_key_current = item;
c193b707
VZ
1870 m_current->SetHilight(select);
1871 RefreshLine( m_current );
88ac883a 1872 }
389cdc7a 1873
7ede7389
JS
1874 // This can cause idle processing to select the root
1875 // if no item is selected, so it must be after the
1876 // selection is set
1877 EnsureVisible( itemId );
1878
f135ff73 1879 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
6daa0637 1880 GetEventHandler()->ProcessEvent( event );
389cdc7a
VZ
1881}
1882
78f12104
VZ
1883void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, bool select)
1884{
1885 if ( select )
1886 {
fced5066 1887 DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));
78f12104
VZ
1888 }
1889 else // deselect
1890 {
1891 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1892 wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
1893
714dfaa6
RR
1894 wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
1895 if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
1896 return;
1897
ca65c044 1898 item->SetHilight(false);
78f12104 1899 RefreshLine(item);
714dfaa6
RR
1900
1901 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1902 GetEventHandler()->ProcessEvent( event );
78f12104
VZ
1903 }
1904}
1905
941830cb 1906void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
cb59313c 1907 wxArrayTreeItemIds &array) const
c801d85f 1908{
8dc99046 1909 if ( item->IsSelected() )
9dfbf520 1910 array.Add(wxTreeItemId(item));
91b8de8d 1911
9dfbf520 1912 if ( item->HasChildren() )
91b8de8d 1913 {
9dfbf520
VZ
1914 wxArrayGenericTreeItems& children = item->GetChildren();
1915 size_t count = children.GetCount();
1916 for ( size_t n = 0; n < count; ++n )
f6bcfd97 1917 FillArray(children[n], array);
91b8de8d
RR
1918 }
1919}
1920
941830cb 1921size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
91b8de8d 1922{
618a5e38
RR
1923 array.Empty();
1924 wxTreeItemId idRoot = GetRootItem();
1925 if ( idRoot.IsOk() )
1926 {
1927 FillArray((wxGenericTreeItem*) idRoot.m_pItem, array);
1928 }
1929 //else: the tree is empty, so no selections
91b8de8d 1930
618a5e38 1931 return array.Count();
91b8de8d
RR
1932}
1933
941830cb 1934void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
d3a9f4af 1935{
05b2a432
RD
1936 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1937
91b8de8d
RR
1938 if (!item.IsOk()) return;
1939
941830cb 1940 wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
ef44a621 1941
f65635b5
VZ
1942 // first expand all parent branches
1943 wxGenericTreeItem *parent = gitem->GetParent();
999723f3
VS
1944
1945 if ( HasFlag(wxTR_HIDE_ROOT) )
f65635b5 1946 {
ff38281a 1947 while ( parent && parent != m_anchor )
999723f3
VS
1948 {
1949 Expand(parent);
1950 parent = parent->GetParent();
1951 }
1952 }
1953 else
1954 {
1955 while ( parent )
1956 {
1957 Expand(parent);
1958 parent = parent->GetParent();
1959 }
f65635b5
VZ
1960 }
1961
5391f772 1962 //if (parent) CalculatePositions();
91b8de8d
RR
1963
1964 ScrollTo(item);
1965}
1966
941830cb 1967void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
91b8de8d
RR
1968{
1969 if (!item.IsOk()) return;
1970
dc6c62a9
RR
1971 // We have to call this here because the label in
1972 // question might just have been added and no screen
1973 // update taken place.
ca65c044 1974 if (m_dirty)
f89d65ea
SC
1975#if defined( __WXMSW__ ) || defined(__WXMAC__)
1976 Update();
1977#else
27f8357f 1978 DoDirtyProcessing();
f89d65ea 1979#endif
941830cb 1980 wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
91b8de8d 1981
f65635b5 1982 // now scroll to the item
0659e7ee 1983 int item_y = gitem->GetY();
8dc99046 1984
0659e7ee
RR
1985 int start_x = 0;
1986 int start_y = 0;
1e6feb95 1987 GetViewStart( &start_x, &start_y );
91b8de8d 1988 start_y *= PIXELS_PER_UNIT;
978f38c2 1989
a93109d5
RR
1990 int client_h = 0;
1991 int client_w = 0;
1992 GetClientSize( &client_w, &client_h );
ef44a621 1993
0659e7ee
RR
1994 if (item_y < start_y+3)
1995 {
91b8de8d 1996 // going down
0659e7ee
RR
1997 int x = 0;
1998 int y = 0;
91b8de8d
RR
1999 m_anchor->GetSize( x, y, this );
2000 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
c7a9fa36 2001 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
0659e7ee 2002 int x_pos = GetScrollPos( wxHORIZONTAL );
c193b707 2003 // Item should appear at top
91b8de8d 2004 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
0659e7ee 2005 }
91b8de8d 2006 else if (item_y+GetLineHeight(gitem) > start_y+client_h)
0659e7ee 2007 {
c7a9fa36
RR
2008 // going up
2009 int x = 0;
2010 int y = 0;
2011 m_anchor->GetSize( x, y, this );
2012 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2013 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2014 item_y += PIXELS_PER_UNIT+2;
2015 int x_pos = GetScrollPos( wxHORIZONTAL );
c193b707 2016 // Item should appear at bottom
c7a9fa36 2017 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, (item_y+GetLineHeight(gitem)-client_h)/PIXELS_PER_UNIT );
0659e7ee 2018 }
edaa81ae 2019}
c801d85f 2020
e1ee62bd 2021// FIXME: tree sorting functions are not reentrant and not MT-safe!
941830cb 2022static wxGenericTreeCtrl *s_treeBeingSorted = NULL;
0659e7ee 2023
004fd0c8 2024static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
e1ee62bd 2025 wxGenericTreeItem **item2)
edaa81ae 2026{
941830cb 2027 wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") );
e1ee62bd
VZ
2028
2029 return s_treeBeingSorted->OnCompareItems(*item1, *item2);
0659e7ee
RR
2030}
2031
941830cb 2032void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
e1ee62bd 2033{
223d09f6 2034 wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
e1ee62bd 2035
941830cb 2036 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
978f38c2 2037
e1ee62bd 2038 wxCHECK_RET( !s_treeBeingSorted,
941830cb 2039 wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
e1ee62bd 2040
91b8de8d 2041 wxArrayGenericTreeItems& children = item->GetChildren();
e1ee62bd
VZ
2042 if ( children.Count() > 1 )
2043 {
ca65c044 2044 m_dirty = true;
618a5e38 2045
e1ee62bd
VZ
2046 s_treeBeingSorted = this;
2047 children.Sort(tree_ctrl_compare_func);
2048 s_treeBeingSorted = NULL;
e1ee62bd
VZ
2049 }
2050 //else: don't make the tree dirty as nothing changed
edaa81ae
RR
2051}
2052
618a5e38 2053void wxGenericTreeCtrl::CalculateLineHeight()
e2414cbe 2054{
f2593d0d
RR
2055 wxClientDC dc(this);
2056 m_lineHeight = (int)(dc.GetCharHeight() + 4);
06b466c7 2057
618a5e38
RR
2058 if ( m_imageListNormal )
2059 {
2060 // Calculate a m_lineHeight value from the normal Image sizes.
2061 // May be toggle off. Then wxGenericTreeCtrl will spread when
2062 // necessary (which might look ugly).
2063 int n = m_imageListNormal->GetImageCount();
2064 for (int i = 0; i < n ; i++)
2065 {
2066 int width = 0, height = 0;
2067 m_imageListNormal->GetSize(i, width, height);
2068 if (height > m_lineHeight) m_lineHeight = height;
2069 }
2070 }
2071
2072 if (m_imageListButtons)
f2593d0d 2073 {
618a5e38
RR
2074 // Calculate a m_lineHeight value from the Button image sizes.
2075 // May be toggle off. Then wxGenericTreeCtrl will spread when
2076 // necessary (which might look ugly).
2077 int n = m_imageListButtons->GetImageCount();
2078 for (int i = 0; i < n ; i++)
2079 {
2080 int width = 0, height = 0;
2081 m_imageListButtons->GetSize(i, width, height);
2082 if (height > m_lineHeight) m_lineHeight = height;
2083 }
f2593d0d 2084 }
91b8de8d 2085
618a5e38 2086 if (m_lineHeight < 30)
f2593d0d 2087 m_lineHeight += 2; // at least 2 pixels
06b466c7 2088 else
f2593d0d 2089 m_lineHeight += m_lineHeight/10; // otherwise 10% extra spacing
edaa81ae 2090}
e2414cbe 2091
618a5e38
RR
2092void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
2093{
2094 if (m_ownsImageListNormal) delete m_imageListNormal;
2095 m_imageListNormal = imageList;
ca65c044
WS
2096 m_ownsImageListNormal = false;
2097 m_dirty = true;
f4bd6759
JS
2098 // Don't do any drawing if we're setting the list to NULL,
2099 // since we may be in the process of deleting the tree control.
2100 if (imageList)
2101 CalculateLineHeight();
618a5e38
RR
2102}
2103
941830cb 2104void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
e2414cbe 2105{
46cd520d 2106 if (m_ownsImageListState) delete m_imageListState;
f135ff73 2107 m_imageListState = imageList;
ca65c044 2108 m_ownsImageListState = false;
46cd520d
VS
2109}
2110
618a5e38
RR
2111void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
2112{
2113 if (m_ownsImageListButtons) delete m_imageListButtons;
2114 m_imageListButtons = imageList;
ca65c044
WS
2115 m_ownsImageListButtons = false;
2116 m_dirty = true;
618a5e38
RR
2117 CalculateLineHeight();
2118}
2119
618a5e38
RR
2120void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
2121{
2122 SetButtonsImageList(imageList);
ca65c044 2123 m_ownsImageListButtons = true;
618a5e38
RR
2124}
2125
f135ff73
VZ
2126// -----------------------------------------------------------------------------
2127// helpers
2128// -----------------------------------------------------------------------------
0659e7ee 2129
941830cb 2130void wxGenericTreeCtrl::AdjustMyScrollbars()
c801d85f 2131{
0659e7ee
RR
2132 if (m_anchor)
2133 {
618a5e38 2134 int x = 0, y = 0;
91b8de8d 2135 m_anchor->GetSize( x, y, this );
c193b707 2136 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
c7a9fa36 2137 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
0659e7ee
RR
2138 int x_pos = GetScrollPos( wxHORIZONTAL );
2139 int y_pos = GetScrollPos( wxVERTICAL );
91b8de8d 2140 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
0659e7ee
RR
2141 }
2142 else
2143 {
2144 SetScrollbars( 0, 0, 0, 0 );
2145 }
edaa81ae 2146}
c801d85f 2147
941830cb 2148int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
91b8de8d 2149{
dc6c62a9
RR
2150 if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
2151 return item->GetHeight();
2152 else
2153 return m_lineHeight;
91b8de8d
RR
2154}
2155
941830cb 2156void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
ef44a621 2157{
618a5e38
RR
2158 // TODO implement "state" icon on items
2159
9ec64fa7
VZ
2160 wxTreeItemAttr *attr = item->GetAttributes();
2161 if ( attr && attr->HasFont() )
2162 dc.SetFont(attr->GetFont());
2163 else if (item->IsBold())
eff869aa 2164 dc.SetFont(m_boldFont);
ef44a621 2165
618a5e38 2166 long text_w = 0, text_h = 0;
bbe0af5b 2167 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
ef44a621 2168
618a5e38 2169 int image_h = 0, image_w = 0;
8dc99046
VZ
2170 int image = item->GetCurrentImage();
2171 if ( image != NO_IMAGE )
bbe0af5b 2172 {
2c8e4738
VZ
2173 if ( m_imageListNormal )
2174 {
2175 m_imageListNormal->GetSize( image, image_w, image_h );
3e4f8ee2 2176 image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
2c8e4738
VZ
2177 }
2178 else
2179 {
2180 image = NO_IMAGE;
2181 }
bbe0af5b 2182 }
ef44a621 2183
91b8de8d 2184 int total_h = GetLineHeight(item);
6c051af4 2185 bool drawItemBackground = false;
91b8de8d 2186
b771aa29 2187 if ( item->IsSelected() )
cdb3cffe 2188 {
44c44c82
SC
2189// under mac selections are only a rectangle in case they don't have the focus
2190#ifdef __WXMAC__
2191 if ( !m_hasFocus )
2192 {
2193 dc.SetBrush( *wxTRANSPARENT_BRUSH ) ;
2194 dc.SetPen( wxPen( wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT ) , 1 , wxSOLID ) ) ;
2195 }
2196 else
2197 {
2198 dc.SetBrush( *m_hilightBrush ) ;
2199 }
2200#else
b771aa29 2201 dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
44c44c82 2202#endif
6c051af4 2203 drawItemBackground = true;
cdb3cffe 2204 }
afa6a1a1 2205 else
c0fba4d1
VS
2206 {
2207 wxColour colBg;
2208 if ( attr && attr->HasBackgroundColour() )
902725ee
WS
2209 {
2210 drawItemBackground = true;
c0fba4d1 2211 colBg = attr->GetBackgroundColour();
902725ee 2212 }
c0fba4d1 2213 else
902725ee 2214 {
8cee4a30 2215 colBg = GetBackgroundColour();
902725ee 2216 }
c0fba4d1
VS
2217 dc.SetBrush(wxBrush(colBg, wxSOLID));
2218 }
afa6a1a1 2219
cdb3cffe 2220 int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
b77d9650 2221
c6f4913a 2222 if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
a69cb1cc 2223 {
c6f4913a
VS
2224 int x, y, w, h;
2225
2226 DoGetPosition(&x, &y);
2227 DoGetSize(&w, &h);
2228 dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
a69cb1cc
JS
2229 }
2230 else
b77d9650 2231 {
c6f4913a
VS
2232 if ( item->IsSelected() && image != NO_IMAGE )
2233 {
2234 // If it's selected, and there's an image, then we should
2235 // take care to leave the area under the image painted in the
2236 // background colour.
2237 dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset,
2238 item->GetWidth() - image_w + 2, total_h-offset );
2239 }
602f0c99
JS
2240 // On GTK+ 2, drawing a 'normal' background is wrong for themes that
2241 // don't allow backgrounds to be customized. Not drawing the background,
2242 // except for custom item backgrounds, works for both kinds of theme.
6c051af4 2243 else if (drawItemBackground)
c6f4913a
VS
2244 {
2245 dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
2246 item->GetWidth()+2, total_h-offset );
2247 }
b77d9650 2248 }
ef44a621 2249
8dc99046 2250 if ( image != NO_IMAGE )
bbe0af5b 2251 {
49e74855 2252 dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
8dc99046 2253 m_imageListNormal->Draw( image, dc,
49cd56ef 2254 item->GetX(),
d701d432 2255 item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
bbe0af5b
RR
2256 wxIMAGELIST_DRAW_TRANSPARENT );
2257 dc.DestroyClippingRegion();
2258 }
ef44a621 2259
afa6a1a1 2260 dc.SetBackgroundMode(wxTRANSPARENT);
f6bcfd97
BP
2261 int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
2262 dc.DrawText( item->GetText(),
2263 (wxCoord)(image_w + item->GetX()),
2264 (wxCoord)(item->GetY() + extraH));
ef44a621 2265
eff869aa
RR
2266 // restore normal font
2267 dc.SetFont( m_normalFont );
ef44a621
VZ
2268}
2269
91b8de8d 2270// Now y stands for the top of the item, whereas it used to stand for middle !
941830cb 2271void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
c801d85f 2272{
618a5e38
RR
2273 int x = level*m_indent;
2274 if (!HasFlag(wxTR_HIDE_ROOT))
2275 {
2276 x += m_indent;
2277 }
2278 else if (level == 0)
2279 {
2b84e565
VS
2280 // always expand hidden root
2281 int origY = y;
618a5e38 2282 wxArrayGenericTreeItems& children = item->GetChildren();
2b84e565
VS
2283 int count = children.Count();
2284 if (count > 0)
2285 {
2286 int n = 0, oldY;
2287 do {
2288 oldY = y;
2289 PaintLevel(children[n], dc, 1, y);
2290 } while (++n < count);
2291
e76520fd 2292 if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0)
2b84e565
VS
2293 {
2294 // draw line down to last child
2295 origY += GetLineHeight(children[0])>>1;
2296 oldY += GetLineHeight(children[n-1])>>1;
2297 dc.DrawLine(3, origY, 3, oldY);
2298 }
2299 }
618a5e38
RR
2300 return;
2301 }
91b8de8d 2302
618a5e38
RR
2303 item->SetX(x+m_spacing);
2304 item->SetY(y);
389cdc7a 2305
618a5e38
RR
2306 int h = GetLineHeight(item);
2307 int y_top = y;
2308 int y_mid = y_top + (h>>1);
2309 y += h;
4832f7c0 2310
618a5e38
RR
2311 int exposed_x = dc.LogicalToDeviceX(0);
2312 int exposed_y = dc.LogicalToDeviceY(y_top);
233058c7 2313
618a5e38 2314 if (IsExposed(exposed_x, exposed_y, 10000, h)) // 10000 = very much
bbe0af5b 2315 {
f516d986 2316 const wxPen *pen =
c6f4913a
VS
2317#ifndef __WXMAC__
2318 // don't draw rect outline if we already have the
2319 // background color under Mac
2320 (item->IsSelected() && m_hasFocus) ? wxBLACK_PEN :
2321#endif // !__WXMAC__
2322 wxTRANSPARENT_PEN;
2323
2324 wxColour colText;
633ecf26
RD
2325 if ( item->IsSelected()
2326#ifdef __WXMAC__
2327 // On wxMac, if the tree doesn't have the focus we draw an empty
2328 // rectangle, so we want to make sure that the text is visible
2329 // against the normal background, not the highlightbackground, so
2330 // don't use the highlight text colour unless we have the focus.
2331 && m_hasFocus
2332#endif
2333 )
c6f4913a 2334 {
a756f210 2335 colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
c6f4913a
VS
2336 }
2337 else
2338 {
2339 wxTreeItemAttr *attr = item->GetAttributes();
2340 if (attr && attr->HasTextColour())
2341 colText = attr->GetTextColour();
2342 else
6f0dd6b2 2343 colText = GetForegroundColour();
c6f4913a
VS
2344 }
2345
2346 // prepare to draw
2347 dc.SetTextForeground(colText);
2348 dc.SetPen(*pen);
2349
2350 // draw
2351 PaintItem(item, dc);
2352
2353 if (HasFlag(wxTR_ROW_LINES))
2354 {
2355 // if the background colour is white, choose a
2356 // contrasting color for the lines
2357 dc.SetPen(*((GetBackgroundColour() == *wxWHITE)
2358 ? wxMEDIUM_GREY_PEN : wxWHITE_PEN));
2359 dc.DrawLine(0, y_top, 10000, y_top);
2360 dc.DrawLine(0, y, 10000, y);
2361 }
2362
2363 // restore DC objects
2364 dc.SetBrush(*wxWHITE_BRUSH);
2365 dc.SetPen(m_dottedPen);
2366 dc.SetTextForeground(*wxBLACK);
2367
9c7f49f5 2368 if ( !HasFlag(wxTR_NO_LINES) )
cdb3cffe 2369 {
9c7f49f5
VZ
2370 // draw the horizontal line here
2371 int x_start = x;
2372 if (x > (signed)m_indent)
2373 x_start -= m_indent;
2374 else if (HasFlag(wxTR_LINES_AT_ROOT))
2375 x_start = 3;
2376 dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
2377 }
618a5e38 2378
9c7f49f5
VZ
2379 // should the item show a button?
2380 if ( item->HasPlus() && HasButtons() )
2381 {
2382 if ( m_imageListButtons )
c22886bd 2383 {
618a5e38 2384 // draw the image button here
9c7f49f5
VZ
2385 int image_h = 0,
2386 image_w = 0;
2387 int image = item->IsExpanded() ? wxTreeItemIcon_Expanded
2388 : wxTreeItemIcon_Normal;
2389 if ( item->IsSelected() )
2b84e565 2390 image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
9c7f49f5 2391
618a5e38 2392 m_imageListButtons->GetSize(image, image_w, image_h);
9c7f49f5
VZ
2393 int xx = x - image_w/2;
2394 int yy = y_mid - image_h/2;
2395
2396 wxDCClipper clip(dc, xx, yy, image_w, image_h);
618a5e38
RR
2397 m_imageListButtons->Draw(image, dc, xx, yy,
2398 wxIMAGELIST_DRAW_TRANSPARENT);
c22886bd 2399 }
9c7f49f5 2400 else // no custom buttons
c22886bd 2401 {
0e7761fa
VZ
2402 static const int wImage = 9;
2403 static const int hImage = 9;
ca65c044 2404
f8b043e7
RR
2405 int flag = 0;
2406 if (item->IsExpanded())
2407 flag |= wxCONTROL_EXPANDED;
2408 if (item == m_underMouse)
2409 flag |= wxCONTROL_CURRENT;
ca65c044 2410
9c7f49f5
VZ
2411 wxRendererNative::Get().DrawTreeItemButton
2412 (
2413 this,
2414 dc,
2415 wxRect(x - wImage/2,
2416 y_mid - hImage/2,
2417 wImage, hImage),
f8b043e7 2418 flag
9c7f49f5 2419 );
c22886bd 2420 }
bbe0af5b 2421 }
f135ff73 2422 }
d3a9f4af 2423
bbe0af5b
RR
2424 if (item->IsExpanded())
2425 {
91b8de8d 2426 wxArrayGenericTreeItems& children = item->GetChildren();
618a5e38 2427 int count = children.Count();
f65635b5 2428 if (count > 0)
9ec64fa7 2429 {
618a5e38
RR
2430 int n = 0, oldY;
2431 ++level;
2432 do {
2433 oldY = y;
2434 PaintLevel(children[n], dc, level, y);
2435 } while (++n < count);
2436
e76520fd 2437 if (!HasFlag(wxTR_NO_LINES) && count > 0)
618a5e38
RR
2438 {
2439 // draw line down to last child
2b84e565 2440 oldY += GetLineHeight(children[n-1])>>1;
618a5e38 2441 if (HasButtons()) y_mid += 5;
dd360466
RD
2442
2443 // Only draw the portion of the line that is visible, in case it is huge
ca65c044 2444 wxCoord xOrigin=0, yOrigin=0, width, height;
dd360466
RD
2445 dc.GetDeviceOrigin(&xOrigin, &yOrigin);
2446 yOrigin = abs(yOrigin);
2447 GetClientSize(&width, &height);
2448
2449 // Move end points to the begining/end of the view?
2450 if (y_mid < yOrigin)
2451 y_mid = yOrigin;
2452 if (oldY > yOrigin + height)
2453 oldY = yOrigin + height;
2454
2455 // after the adjustments if y_mid is larger than oldY then the line
2456 // isn't visible at all so don't draw anything
2457 if (y_mid < oldY)
2458 dc.DrawLine(x, y_mid, x, oldY);
618a5e38 2459 }
9ec64fa7 2460 }
bbe0af5b 2461 }
4c681997 2462}
c801d85f 2463
941830cb 2464void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
3dbeaa52
VZ
2465{
2466 if ( item )
2467 {
2468 if ( item->HasPlus() )
2469 {
2470 // it's a folder, indicate it by a border
2471 DrawBorder(item);
2472 }
2473 else
2474 {
2475 // draw a line under the drop target because the item will be
2476 // dropped there
e3d64157 2477 DrawLine(item, !m_dropEffectAboveItem );
3dbeaa52
VZ
2478 }
2479
2480 SetCursor(wxCURSOR_BULLSEYE);
2481 }
2482 else
2483 {
2484 // can't drop here
2485 SetCursor(wxCURSOR_NO_ENTRY);
2486 }
2487}
2488
941830cb 2489void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
91b8de8d 2490{
941830cb 2491 wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
91b8de8d 2492
941830cb 2493 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
91b8de8d 2494
1044a386 2495 wxClientDC dc(this);
91b8de8d
RR
2496 PrepareDC( dc );
2497 dc.SetLogicalFunction(wxINVERT);
3dbeaa52 2498 dc.SetBrush(*wxTRANSPARENT_BRUSH);
91b8de8d 2499
3dbeaa52
VZ
2500 int w = i->GetWidth() + 2;
2501 int h = GetLineHeight(i) + 2;
91b8de8d 2502
3dbeaa52 2503 dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
91b8de8d
RR
2504}
2505
941830cb 2506void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
91b8de8d 2507{
941830cb 2508 wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
91b8de8d 2509
941830cb 2510 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
91b8de8d 2511
1044a386 2512 wxClientDC dc(this);
91b8de8d
RR
2513 PrepareDC( dc );
2514 dc.SetLogicalFunction(wxINVERT);
d3a9f4af 2515
3dbeaa52
VZ
2516 int x = i->GetX(),
2517 y = i->GetY();
2518 if ( below )
2519 {
2520 y += GetLineHeight(i) - 1;
2521 }
91b8de8d 2522
3dbeaa52 2523 dc.DrawLine( x, y, x + i->GetWidth(), y);
91b8de8d
RR
2524}
2525
f135ff73 2526// -----------------------------------------------------------------------------
77ffb593 2527// wxWidgets callbacks
f135ff73
VZ
2528// -----------------------------------------------------------------------------
2529
941830cb 2530void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
c801d85f 2531{
0659e7ee
RR
2532 wxPaintDC dc(this);
2533 PrepareDC( dc );
29d87bba 2534
941830cb
JS
2535 if ( !m_anchor)
2536 return;
2537
eff869aa 2538 dc.SetFont( m_normalFont );
0659e7ee 2539 dc.SetPen( m_dottedPen );
f38374d0 2540
eff869aa 2541 // this is now done dynamically
91b8de8d
RR
2542 //if(GetImageList() == NULL)
2543 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
29d87bba 2544
91b8de8d 2545 int y = 2;
0659e7ee 2546 PaintLevel( m_anchor, dc, 0, y );
edaa81ae 2547}
c801d85f 2548
b771aa29 2549void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
c801d85f 2550{
ca65c044 2551 m_hasFocus = true;
978f38c2 2552
b771aa29
VZ
2553 RefreshSelected();
2554
2555 event.Skip();
edaa81ae 2556}
c801d85f 2557
b771aa29 2558void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
c801d85f 2559{
ca65c044 2560 m_hasFocus = false;
978f38c2 2561
b771aa29
VZ
2562 RefreshSelected();
2563
2564 event.Skip();
edaa81ae 2565}
c801d85f 2566
941830cb 2567void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
c801d85f 2568{
09f277d6 2569 wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, this);
b09bda68 2570 te.m_evtKey = event;
68eb5f63
VZ
2571 if ( GetEventHandler()->ProcessEvent( te ) )
2572 {
2573 // intercepted by the user code
2574 return;
2575 }
435fe83e 2576
91b8de8d 2577 if ( (m_current == 0) || (m_key_current == 0) )
978f38c2
VZ
2578 {
2579 event.Skip();
2580 return;
2581 }
ef44a621 2582
06b466c7
VZ
2583 // how should the selection work for this event?
2584 bool is_multiple, extended_select, unselect_others;
2585 EventFlagsToSelType(GetWindowStyleFlag(),
2586 event.ShiftDown(),
105fc244 2587 event.CmdDown(),
dfc6cd93
SB
2588 is_multiple, extended_select, unselect_others);
2589
03703fc0
RR
2590 if (GetLayoutDirection() == wxLayout_RightToLeft)
2591 {
2592 if (event.GetKeyCode() == WXK_RIGHT)
2593 event.m_keyCode = WXK_LEFT;
2594 else if (event.GetKeyCode() == WXK_LEFT)
2595 event.m_keyCode = WXK_RIGHT;
2596 }
2597
dfc6cd93
SB
2598 // + : Expand
2599 // - : Collaspe
f6bcfd97 2600 // * : Expand all/Collapse all
dfc6cd93
SB
2601 // ' ' | return : activate
2602 // up : go up (not last children!)
2603 // down : go down
2604 // left : go to parent
2605 // right : open if parent and go next
2606 // home : go to root
2607 // end : go to last item without opening parents
cb59313c 2608 // alnum : start or continue searching for the item with this prefix
12a3f227 2609 int keyCode = event.GetKeyCode();
cb59313c 2610 switch ( keyCode )
978f38c2
VZ
2611 {
2612 case '+':
2613 case WXK_ADD:
2614 if (m_current->HasPlus() && !IsExpanded(m_current))
2615 {
2616 Expand(m_current);
2617 }
2618 break;
ef44a621 2619
f6bcfd97
BP
2620 case '*':
2621 case WXK_MULTIPLY:
2622 if ( !IsExpanded(m_current) )
2623 {
2624 // expand all
1a51c85f 2625 ExpandAllChildren(m_current);
f6bcfd97
BP
2626 break;
2627 }
2628 //else: fall through to Collapse() it
2629
978f38c2
VZ
2630 case '-':
2631 case WXK_SUBTRACT:
2632 if (IsExpanded(m_current))
2633 {
2634 Collapse(m_current);
2635 }
2636 break;
ef44a621 2637
f7c6f947
RR
2638 case WXK_MENU:
2639 {
39faaf39
KH
2640 // Use the item's bounding rectangle to determine position for the event
2641 wxRect ItemRect;
2642 GetBoundingRect(m_current, ItemRect, true);
2643
09f277d6 2644 wxTreeEvent eventMenu(wxEVT_COMMAND_TREE_ITEM_MENU, this, m_current);
39faaf39 2645 // Use the left edge, vertical middle
4e115ed2
VZ
2646 eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(),
2647 ItemRect.GetY() + ItemRect.GetHeight() / 2);
4e115ed2 2648 GetEventHandler()->ProcessEvent( eventMenu );
f7c6f947 2649 }
09f277d6
VZ
2650 break;
2651
978f38c2
VZ
2652 case ' ':
2653 case WXK_RETURN:
6151e144 2654 if ( !event.HasModifiers() )
978f38c2 2655 {
09f277d6 2656 wxTreeEvent eventAct(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, m_current);
4e115ed2 2657 GetEventHandler()->ProcessEvent( eventAct );
978f38c2 2658 }
6151e144
VZ
2659
2660 // in any case, also generate the normal key event for this key,
2661 // even if we generated the ACTIVATED event above: this is what
2662 // wxMSW does and it makes sense because you might not want to
2663 // process ACTIVATED event at all and handle Space and Return
2664 // directly (and differently) which would be impossible otherwise
2665 event.Skip();
978f38c2 2666 break;
ef44a621 2667
618a5e38
RR
2668 // up goes to the previous sibling or to the last
2669 // of its children if it's expanded
978f38c2
VZ
2670 case WXK_UP:
2671 {
91b8de8d 2672 wxTreeItemId prev = GetPrevSibling( m_key_current );
978f38c2
VZ
2673 if (!prev)
2674 {
99006e44 2675 prev = GetItemParent( m_key_current );
618a5e38
RR
2676 if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2677 {
2678 break; // don't go to root if it is hidden
2679 }
c193b707
VZ
2680 if (prev)
2681 {
2d75caaa 2682 wxTreeItemIdValue cookie;
91b8de8d 2683 wxTreeItemId current = m_key_current;
618a5e38
RR
2684 // TODO: Huh? If we get here, we'd better be the first child of our parent. How else could it be?
2685 if (current == GetFirstChild( prev, cookie ))
90e58684
RR
2686 {
2687 // otherwise we return to where we came from
78f12104 2688 DoSelectItem( prev, unselect_others, extended_select );
941830cb 2689 m_key_current= (wxGenericTreeItem*) prev.m_pItem;
90e58684 2690 break;
c193b707 2691 }
978f38c2
VZ
2692 }
2693 }
2694 if (prev)
2695 {
69a282d4 2696 while ( IsExpanded(prev) && HasChildren(prev) )
978f38c2 2697 {
69a282d4
VZ
2698 wxTreeItemId child = GetLastChild(prev);
2699 if ( child )
2700 {
2701 prev = child;
2702 }
978f38c2 2703 }
69a282d4 2704
78f12104 2705 DoSelectItem( prev, unselect_others, extended_select );
941830cb 2706 m_key_current=(wxGenericTreeItem*) prev.m_pItem;
978f38c2
VZ
2707 }
2708 }
2709 break;
ef44a621 2710
978f38c2
VZ
2711 // left arrow goes to the parent
2712 case WXK_LEFT:
2713 {
99006e44 2714 wxTreeItemId prev = GetItemParent( m_current );
618a5e38
RR
2715 if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2716 {
2717 // don't go to root if it is hidden
2718 prev = GetPrevSibling( m_current );
2719 }
978f38c2
VZ
2720 if (prev)
2721 {
78f12104 2722 DoSelectItem( prev, unselect_others, extended_select );
978f38c2
VZ
2723 }
2724 }
2725 break;
ef44a621 2726
978f38c2 2727 case WXK_RIGHT:
618a5e38
RR
2728 // this works the same as the down arrow except that we
2729 // also expand the item if it wasn't expanded yet
978f38c2
VZ
2730 Expand(m_current);
2731 // fall through
2732
2733 case WXK_DOWN:
ef44a621 2734 {
91b8de8d 2735 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
978f38c2 2736 {
2d75caaa 2737 wxTreeItemIdValue cookie;
91b8de8d 2738 wxTreeItemId child = GetFirstChild( m_key_current, cookie );
78f12104 2739 DoSelectItem( child, unselect_others, extended_select );
941830cb 2740 m_key_current=(wxGenericTreeItem*) child.m_pItem;
978f38c2
VZ
2741 }
2742 else
2743 {
91b8de8d 2744 wxTreeItemId next = GetNextSibling( m_key_current );
b62c3631 2745 if (!next)
978f38c2 2746 {
91b8de8d 2747 wxTreeItemId current = m_key_current;
a0fad723 2748 while (current.IsOk() && !next)
978f38c2 2749 {
99006e44 2750 current = GetItemParent( current );
978f38c2
VZ
2751 if (current) next = GetNextSibling( current );
2752 }
2753 }
b62c3631 2754 if (next)
978f38c2 2755 {
78f12104 2756 DoSelectItem( next, unselect_others, extended_select );
941830cb 2757 m_key_current=(wxGenericTreeItem*) next.m_pItem;
978f38c2
VZ
2758 }
2759 }
ef44a621 2760 }
978f38c2 2761 break;
ef44a621 2762
978f38c2
VZ
2763 // <End> selects the last visible tree item
2764 case WXK_END:
2765 {
2766 wxTreeItemId last = GetRootItem();
2767
2768 while ( last.IsOk() && IsExpanded(last) )
2769 {
2770 wxTreeItemId lastChild = GetLastChild(last);
2771
2772 // it may happen if the item was expanded but then all of
2773 // its children have been deleted - so IsExpanded() returned
ca65c044 2774 // true, but GetLastChild() returned invalid item
978f38c2
VZ
2775 if ( !lastChild )
2776 break;
2777
2778 last = lastChild;
2779 }
2780
2781 if ( last.IsOk() )
2782 {
78f12104 2783 DoSelectItem( last, unselect_others, extended_select );
978f38c2
VZ
2784 }
2785 }
2786 break;
2787
2788 // <Home> selects the root item
2789 case WXK_HOME:
2790 {
2791 wxTreeItemId prev = GetRootItem();
cb59313c
VZ
2792 if (!prev)
2793 break;
2794
2795 if ( HasFlag(wxTR_HIDE_ROOT) )
978f38c2 2796 {
2d75caaa
VZ
2797 wxTreeItemIdValue cookie;
2798 prev = GetFirstChild(prev, cookie);
cb59313c
VZ
2799 if (!prev)
2800 break;
978f38c2 2801 }
cb59313c 2802
78f12104 2803 DoSelectItem( prev, unselect_others, extended_select );
978f38c2
VZ
2804 }
2805 break;
2806
2807 default:
cb59313c 2808 // do not use wxIsalnum() here
6151e144 2809 if ( !event.HasModifiers() &&
1ec3a984
RR
2810 ((keyCode >= '0' && keyCode <= '9') ||
2811 (keyCode >= 'a' && keyCode <= 'z') ||
2812 (keyCode >= 'A' && keyCode <= 'Z' )))
cb59313c
VZ
2813 {
2814 // find the next item starting with the given prefix
bef7a62d 2815 wxChar ch = (wxChar)keyCode;
6151e144 2816
bef7a62d 2817 wxTreeItemId id = FindItem(m_current, m_findPrefix + ch);
cb59313c
VZ
2818 if ( !id.IsOk() )
2819 {
2820 // no such item
2821 break;
2822 }
2823
2824 SelectItem(id);
2825
2826 m_findPrefix += ch;
2827
2828 // also start the timer to reset the current prefix if the user
2829 // doesn't press any more alnum keys soon -- we wouldn't want
2830 // to use this prefix for a new item search
2831 if ( !m_findTimer )
2832 {
2833 m_findTimer = new wxTreeFindTimer(this);
2834 }
2835
2836 m_findTimer->Start(wxTreeFindTimer::DELAY, wxTIMER_ONE_SHOT);
2837 }
2838 else
2839 {
2840 event.Skip();
2841 }
978f38c2 2842 }
edaa81ae 2843}
c801d85f 2844
be0e5d69
VZ
2845wxTreeItemId
2846wxGenericTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags) const
4f22cf8d 2847{
91b8de8d
RR
2848 int w, h;
2849 GetSize(&w, &h);
91b8de8d 2850 flags=0;
618a5e38
RR
2851 if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
2852 if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
2853 if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
2854 if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
2855 if (flags) return wxTreeItemId();
d3a9f4af 2856
618a5e38
RR
2857 if (m_anchor == NULL)
2858 {
2859 flags = wxTREE_HITTEST_NOWHERE;
2860 return wxTreeItemId();
2861 }
5716a1ab 2862
d027179b
VS
2863 wxGenericTreeItem *hit = m_anchor->HitTest(CalcUnscrolledPosition(point),
2864 this, flags, 0);
618a5e38
RR
2865 if (hit == NULL)
2866 {
2867 flags = wxTREE_HITTEST_NOWHERE;
2868 return wxTreeItemId();
2869 }
2870 return hit;
4f22cf8d
RR
2871}
2872
8fb3bfe2
JS
2873// get the bounding rectangle of the item (or of its label only)
2874bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
edb8f298 2875 wxRect& rect,
3e4f8ee2 2876 bool textOnly) const
8fb3bfe2 2877{
ca65c044 2878 wxCHECK_MSG( item.IsOk(), false, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
8fb3bfe2
JS
2879
2880 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2881
3e4f8ee2
VZ
2882 if ( textOnly )
2883 {
402dfce7 2884 rect.x = i->GetX();
3e4f8ee2
VZ
2885 rect.width = i->GetWidth();
2886
2887 if ( m_imageListNormal )
2888 {
2889 int image_w, image_h;
2890 m_imageListNormal->GetSize( 0, image_w, image_h );
2891 rect.width += image_w + MARGIN_BETWEEN_IMAGE_AND_TEXT;
2892 }
2893 }
2894 else // the entire line
2895 {
2896 rect.x = 0;
2897 rect.width = GetClientSize().x;
2898 }
2899
402dfce7 2900 rect.y = i->GetY();
c22886bd 2901 rect.height = GetLineHeight(i);
8fb3bfe2 2902
402dfce7 2903 // we have to return the logical coordinates, not physical ones
619297ab 2904 rect.SetTopLeft(CalcScrolledPosition(rect.GetTopLeft()));
402dfce7 2905
ca65c044 2906 return true;
8fb3bfe2
JS
2907}
2908
8cee4a30
VZ
2909wxTextCtrl *wxGenericTreeCtrl::EditLabel(const wxTreeItemId& item,
2910 wxClassInfo * WXUNUSED(textCtrlClass))
e179bd65 2911{
8cee4a30 2912 wxCHECK_MSG( item.IsOk(), NULL, _T("can't edit an invalid item") );
e179bd65 2913
edb8f298 2914 wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem;
9dfbf520 2915
09f277d6 2916 wxTreeEvent te(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, this, itemEdit);
edb8f298
VZ
2917 if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
2918 {
2919 // vetoed by user
8cee4a30 2920 return NULL;
edb8f298 2921 }
8dc99046 2922
dc6c62a9
RR
2923 // We have to call this here because the label in
2924 // question might just have been added and no screen
2925 // update taken place.
edb8f298 2926 if ( m_dirty )
f89d65ea
SC
2927#if defined( __WXMSW__ ) || defined(__WXMAC__)
2928 Update();
2929#else
27f8357f 2930 DoDirtyProcessing();
f89d65ea 2931#endif
9dfbf520 2932
8cee4a30 2933 // TODO: use textCtrlClass here to create the control of correct class
fbb12260 2934 m_textCtrl = new wxTreeTextCtrl(this, itemEdit);
8dc99046 2935
fbb12260 2936 m_textCtrl->SetFocus();
8cee4a30
VZ
2937
2938 return m_textCtrl;
fbb12260
JS
2939}
2940
2941// returns a pointer to the text edit control if the item is being
2942// edited, NULL otherwise (it's assumed that no more than one item may
2943// be edited simultaneously)
2944wxTextCtrl* wxGenericTreeCtrl::GetEditControl() const
2945{
2946 return m_textCtrl;
e179bd65
RR
2947}
2948
8cee4a30
VZ
2949void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item),
2950 bool discardChanges)
2951{
2952 wxCHECK_RET( m_textCtrl, _T("not editing label") );
2953
2954 m_textCtrl->EndEdit(discardChanges);
2955}
2956
edb8f298
VZ
2957bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
2958 const wxString& value)
e179bd65 2959{
09f277d6 2960 wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);
edb8f298 2961 le.m_label = value;
ca65c044 2962 le.m_editCancelled = false;
9dfbf520 2963
edb8f298
VZ
2964 return !GetEventHandler()->ProcessEvent( le ) || le.IsAllowed();
2965}
9dfbf520 2966
dd23c25c
JS
2967void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
2968{
2969 // let owner know that the edit was cancelled
09f277d6 2970 wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);
dd23c25c 2971 le.m_label = wxEmptyString;
ca65c044 2972 le.m_editCancelled = true;
dd23c25c
JS
2973
2974 GetEventHandler()->ProcessEvent( le );
2975}
2976
edb8f298
VZ
2977void wxGenericTreeCtrl::OnRenameTimer()
2978{
642446e3 2979 EditLabel( m_current );
e179bd65 2980}
9dfbf520 2981
941830cb 2982void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
c801d85f 2983{
09f277d6 2984 if ( !m_anchor )return;
978f38c2 2985
f8b043e7 2986 wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
ca65c044 2987
f8b043e7
RR
2988 // Is the mouse over a tree item button?
2989 int flags = 0;
73bb6776
JS
2990 wxGenericTreeItem *thisItem = m_anchor->HitTest(pt, this, flags, 0);
2991 wxGenericTreeItem *underMouse = thisItem;
0efd5732 2992#if wxUSE_TOOLTIPS
73bb6776 2993 bool underMouseChanged = (underMouse != m_underMouse) ;
0efd5732 2994#endif // wxUSE_TOOLTIPS
73bb6776 2995
f8b043e7
RR
2996 if ((underMouse) &&
2997 (flags & wxTREE_HITTEST_ONITEMBUTTON) &&
2998 (!event.LeftIsDown()) &&
ca65c044 2999 (!m_isDragging) &&
f8b043e7
RR
3000 (!m_renameTimer || !m_renameTimer->IsRunning()))
3001 {
3002 }
3003 else
3004 {
3005 underMouse = NULL;
3006 }
ca65c044 3007
f8b043e7
RR
3008 if (underMouse != m_underMouse)
3009 {
3010 if (m_underMouse)
3011 {
3012 // unhighlight old item
3013 wxGenericTreeItem *tmp = m_underMouse;
3014 m_underMouse = NULL;
3015 RefreshLine( tmp );
3016 }
ca65c044 3017
f8b043e7
RR
3018 m_underMouse = underMouse;
3019 if (m_underMouse)
3020 RefreshLine( m_underMouse );
3021 }
3022
5b5ea466 3023#if wxUSE_TOOLTIPS
4a5d781c 3024 // Determines what item we are hovering over and need a tooltip for
73bb6776 3025 wxTreeItemId hoverItem = thisItem;
4a5d781c
JS
3026
3027 // We do not want a tooltip if we are dragging, or if the rename timer is running
73bb6776 3028 if (underMouseChanged && hoverItem.IsOk() && !m_isDragging && (!m_renameTimer || !m_renameTimer->IsRunning()))
4a5d781c
JS
3029 {
3030 // Ask the tree control what tooltip (if any) should be shown
09f277d6 3031 wxTreeEvent hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, this, hoverItem);
4a5d781c
JS
3032
3033 if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
3034 {
3035 SetToolTip(hevent.m_label);
3036 }
3037 }
5b5ea466 3038#endif
ca65c044 3039
da87911d 3040 // we process left mouse up event (enables in-place edit), middle/right down
3dbeaa52
VZ
3041 // (pass to the user code), left dbl click (activate item) and
3042 // dragging/moving events for items drag-and-drop
f6bcfd97
BP
3043 if ( !(event.LeftDown() ||
3044 event.LeftUp() ||
da87911d 3045 event.MiddleDown() ||
3dbeaa52
VZ
3046 event.RightDown() ||
3047 event.LeftDClick() ||
3048 event.Dragging() ||
3049 ((event.Moving() || event.RightUp()) && m_isDragging)) )
3050 {
3051 event.Skip();
3052
3053 return;
3054 }
3055
29d87bba 3056
f8b043e7 3057 flags = 0;
d027179b 3058 wxGenericTreeItem *item = m_anchor->HitTest(pt, this, flags, 0);
3dbeaa52 3059
3dbeaa52 3060 if ( event.Dragging() && !m_isDragging )
bbe0af5b 3061 {
fd9811b1 3062 if (m_dragCount == 0)
d027179b 3063 m_dragStart = pt;
8dc99046 3064
fd9811b1 3065 m_dragCount++;
8dc99046 3066
3dbeaa52
VZ
3067 if (m_dragCount != 3)
3068 {
3069 // wait until user drags a bit further...
3070 return;
3071 }
8dc99046 3072
3dbeaa52
VZ
3073 wxEventType command = event.RightIsDown()
3074 ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
3075 : wxEVT_COMMAND_TREE_BEGIN_DRAG;
8dc99046 3076
09f277d6 3077 wxTreeEvent nevent(command, this, m_current);
99411465 3078 nevent.SetPoint(CalcScrolledPosition(pt));
3dbeaa52
VZ
3079
3080 // by default the dragging is not supported, the user code must
3081 // explicitly allow the event for it to take place
3082 nevent.Veto();
3083
3084 if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
3085 {
3086 // we're going to drag this item
ca65c044 3087 m_isDragging = true;
3dbeaa52 3088
b3a7510d
VZ
3089 // remember the old cursor because we will change it while
3090 // dragging
3091 m_oldCursor = m_cursor;
a6fb8636 3092
b3a7510d
VZ
3093 // in a single selection control, hide the selection temporarily
3094 if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
3095 {
941830cb 3096 m_oldSelection = (wxGenericTreeItem*) GetSelection().m_pItem;
b3a7510d
VZ
3097
3098 if ( m_oldSelection )
3099 {
ca65c044 3100 m_oldSelection->SetHilight(false);
b3a7510d
VZ
3101 RefreshLine(m_oldSelection);
3102 }
3103 }
3104
3dbeaa52
VZ
3105 CaptureMouse();
3106 }
bbe0af5b 3107 }
daa7ae0c 3108 else if ( event.Dragging() )
fd9811b1 3109 {
3dbeaa52
VZ
3110 if ( item != m_dropTarget )
3111 {
3112 // unhighlight the previous drop target
3113 DrawDropEffect(m_dropTarget);
fd9811b1 3114
3dbeaa52 3115 m_dropTarget = item;
978f38c2 3116
3dbeaa52
VZ
3117 // highlight the current drop target if any
3118 DrawDropEffect(m_dropTarget);
fb882e1c 3119
daa7ae0c 3120#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK20__)
f89d65ea
SC
3121 Update();
3122#else
cd66f45b 3123 wxYieldIfNeeded();
f89d65ea 3124#endif
3dbeaa52 3125 }
e179bd65 3126 }
3dbeaa52
VZ
3127 else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
3128 {
f0bc6afb
RR
3129 ReleaseMouse();
3130
3dbeaa52
VZ
3131 // erase the highlighting
3132 DrawDropEffect(m_dropTarget);
9dfbf520 3133
4f5fffcc
RR
3134 if ( m_oldSelection )
3135 {
ca65c044 3136 m_oldSelection->SetHilight(true);
4f5fffcc
RR
3137 RefreshLine(m_oldSelection);
3138 m_oldSelection = (wxGenericTreeItem *)NULL;
3139 }
3140
3dbeaa52 3141 // generate the drag end event
09f277d6 3142 wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, this, item);
88ac883a 3143
99411465 3144 eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);
91b8de8d 3145
4e115ed2 3146 (void)GetEventHandler()->ProcessEvent(eventEndDrag);
29d87bba 3147
ca65c044 3148 m_isDragging = false;
3dbeaa52
VZ
3149 m_dropTarget = (wxGenericTreeItem *)NULL;
3150
b3a7510d 3151 SetCursor(m_oldCursor);
3dbeaa52 3152
f89d65ea
SC
3153#if defined( __WXMSW__ ) || defined(__WXMAC__)
3154 Update();
3155#else
cd66f45b 3156 wxYieldIfNeeded();
f89d65ea 3157#endif
3dbeaa52
VZ
3158 }
3159 else
bbe0af5b 3160 {
e4899fd7
KH
3161 // If we got to this point, we are not dragging or moving the mouse.
3162 // Because the code in carbon/toplevel.cpp will only set focus to the tree
3163 // if we skip for EVT_LEFT_DOWN, we MUST skip this event here for focus to work.
3164 // We skip even if we didn't hit an item because we still should
3165 // restore focus to the tree control even if we didn't exactly hit an item.
3166 if ( event.LeftDown() )
3167 {
3168 event.Skip();
3169 }
3170
3dbeaa52
VZ
3171 // here we process only the messages which happen on tree items
3172
3173 m_dragCount = 0;
3174
3175 if (item == NULL) return; /* we hit the blank area */
3176
3177 if ( event.RightDown() )
3178 {
e8cf9a5f
KH
3179 // If the item is already selected, do not update the selection.
3180 // Multi-selections should not be cleared if a selected item is clicked.
3181 if (!IsSelected(item))
3182 {
3183 DoSelectItem(item, true, false);
3184 }
3185
09f277d6 3186 wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, this, item);
d027179b 3187 nevent.m_pointDrag = CalcScrolledPosition(pt);
ac103441 3188 event.Skip(!GetEventHandler()->ProcessEvent(nevent));
39faaf39
KH
3189
3190 // Consistent with MSW (for now), send the ITEM_MENU *after*
3191 // the RIGHT_CLICK event. TODO: This behavior may change.
09f277d6 3192 wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU, this, item);
39faaf39 3193 nevent2.m_pointDrag = CalcScrolledPosition(pt);
39faaf39 3194 GetEventHandler()->ProcessEvent(nevent2);
3dbeaa52 3195 }
da87911d
VZ
3196 else if ( event.MiddleDown() )
3197 {
3198 wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK, this, item);
3199 nevent.m_pointDrag = CalcScrolledPosition(pt);
3200 event.Skip(!GetEventHandler()->ProcessEvent(nevent));
3201 }
80d2803f 3202 else if ( event.LeftUp() )
f6bcfd97 3203 {
35cf1ec6
VZ
3204 // this facilitates multiple-item drag-and-drop
3205
902725ee 3206 if ( /* item && */ HasFlag(wxTR_MULTIPLE))
35cf1ec6
VZ
3207 {
3208 wxArrayTreeItemIds selections;
3209 size_t count = GetSelections(selections);
3210
3211 if (count > 1 &&
105fc244 3212 !event.CmdDown() &&
35cf1ec6
VZ
3213 !event.ShiftDown())
3214 {
78f12104 3215 DoSelectItem(item, true, false);
35cf1ec6
VZ
3216 }
3217 }
3218
80d2803f 3219 if ( m_lastOnSame )
f6bcfd97 3220 {
80d2803f
VZ
3221 if ( (item == m_current) &&
3222 (flags & wxTREE_HITTEST_ONITEMLABEL) &&
3223 HasFlag(wxTR_EDIT_LABELS) )
3224 {
cb59313c
VZ
3225 if ( m_renameTimer )
3226 {
3227 if ( m_renameTimer->IsRunning() )
3228 m_renameTimer->Stop();
3229 }
3230 else
3231 {
3232 m_renameTimer = new wxTreeRenameTimer( this );
3233 }
bdb310a7 3234
ca65c044 3235 m_renameTimer->Start( wxTreeRenameTimer::DELAY, true );
80d2803f 3236 }
f6bcfd97 3237
ca65c044 3238 m_lastOnSame = false;
80d2803f 3239 }
3dbeaa52 3240 }
da87911d 3241 else // !RightDown() && !MiddleDown() && !LeftUp() ==> LeftDown() || LeftDClick()
3dbeaa52 3242 {
f6bcfd97
BP
3243 if ( event.LeftDown() )
3244 {
3245 m_lastOnSame = item == m_current;
3246 }
3247
0326c494
VZ
3248 if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
3249 {
3250 // only toggle the item for a single click, double click on
3251 // the button doesn't do anything (it toggles the item twice)
3252 if ( event.LeftDown() )
3253 {
3254 Toggle( item );
3255 }
3256
3257 // don't select the item if the button was clicked
3258 return;
3259 }
3260
3dbeaa52 3261
35cf1ec6
VZ
3262 // clear the previously selected items, if the
3263 // user clicked outside of the present selection.
3264 // otherwise, perform the deselection on mouse-up.
3265 // this allows multiple drag and drop to work.
105fc244
JS
3266 // but if Cmd is down, toggle selection of the clicked item
3267 if (!IsSelected(item) || event.CmdDown())
35cf1ec6
VZ
3268 {
3269 // how should the selection work for this event?
3270 bool is_multiple, extended_select, unselect_others;
3271 EventFlagsToSelType(GetWindowStyleFlag(),
3272 event.ShiftDown(),
105fc244 3273 event.CmdDown(),
35cf1ec6
VZ
3274 is_multiple, extended_select, unselect_others);
3275
78f12104 3276 DoSelectItem(item, unselect_others, extended_select);
35cf1ec6
VZ
3277 }
3278
3dbeaa52 3279
618a5e38
RR
3280 // For some reason, Windows isn't recognizing a left double-click,
3281 // so we need to simulate it here. Allow 200 milliseconds for now.
3dbeaa52
VZ
3282 if ( event.LeftDClick() )
3283 {
f6bcfd97 3284 // double clicking should not start editing the item label
cb59313c
VZ
3285 if ( m_renameTimer )
3286 m_renameTimer->Stop();
3287
ca65c044 3288 m_lastOnSame = false;
f6bcfd97 3289
ebb987b7 3290 // send activate event first
09f277d6 3291 wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, item);
d027179b 3292 nevent.m_pointDrag = CalcScrolledPosition(pt);
ebb987b7 3293 if ( !GetEventHandler()->ProcessEvent( nevent ) )
618a5e38 3294 {
ebb987b7
VZ
3295 // if the user code didn't process the activate event,
3296 // handle it ourselves by toggling the item when it is
3297 // double clicked
3298 if ( item->HasPlus() )
3299 {
3300 Toggle(item);
3301 }
618a5e38 3302 }
3dbeaa52
VZ
3303 }
3304 }
bbe0af5b 3305 }
edaa81ae 3306}
c801d85f 3307
5180055b 3308void wxGenericTreeCtrl::OnInternalIdle()
3db7be80 3309{
5180055b 3310 wxWindow::OnInternalIdle();
ca65c044 3311
3e3a7b97
JS
3312 // Check if we need to select the root item
3313 // because nothing else has been selected.
3314 // Delaying it means that we can invoke event handlers
3315 // as required, when a first item is selected.
3316 if (!HasFlag(wxTR_MULTIPLE) && !GetSelection().IsOk())
3317 {
3318 if (m_select_me)
3319 SelectItem(m_select_me);
3320 else if (GetRootItem().IsOk())
3321 SelectItem(GetRootItem());
3322 }
3323
27f8357f
VZ
3324 // after all changes have been done to the tree control,
3325 // actually redraw the tree when everything is over
3326 if (m_dirty)
3327 DoDirtyProcessing();
3db7be80
RR
3328}
3329
941830cb 3330void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
d3a9f4af 3331{
e06b9569
JS
3332 wxCoord text_w = 0;
3333 wxCoord text_h = 0;
9dfbf520 3334
40e7f56c
VZ
3335 wxTreeItemAttr *attr = item->GetAttributes();
3336 if ( attr && attr->HasFont() )
3337 dc.SetFont(attr->GetFont());
3338 else if ( item->IsBold() )
eff869aa 3339 dc.SetFont(m_boldFont);
c8fce1a4
VS
3340 else
3341 dc.SetFont(m_normalFont);
9dfbf520 3342
91b8de8d 3343 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
a62867a5 3344 text_h+=2;
91b8de8d 3345
eff869aa
RR
3346 // restore normal font
3347 dc.SetFont( m_normalFont );
9dfbf520 3348
91b8de8d
RR
3349 int image_h = 0;
3350 int image_w = 0;
8dc99046
VZ
3351 int image = item->GetCurrentImage();
3352 if ( image != NO_IMAGE )
91b8de8d 3353 {
2c8e4738
VZ
3354 if ( m_imageListNormal )
3355 {
3356 m_imageListNormal->GetSize( image, image_w, image_h );
3e4f8ee2 3357 image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
2c8e4738 3358 }
91b8de8d
RR
3359 }
3360
3361 int total_h = (image_h > text_h) ? image_h : text_h;
3362
618a5e38 3363 if (total_h < 30)
f2593d0d 3364 total_h += 2; // at least 2 pixels
06b466c7 3365 else
f2593d0d 3366 total_h += total_h/10; // otherwise 10% extra spacing
91b8de8d
RR
3367
3368 item->SetHeight(total_h);
6cedba09
VZ
3369 if (total_h>m_lineHeight)
3370 m_lineHeight=total_h;
bbe0af5b 3371
91b8de8d
RR
3372 item->SetWidth(image_w+text_w+2);
3373}
3374
3375// -----------------------------------------------------------------------------
3376// for developper : y is now the top of the level
3377// not the middle of it !
941830cb 3378void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
c801d85f 3379{
618a5e38
RR
3380 int x = level*m_indent;
3381 if (!HasFlag(wxTR_HIDE_ROOT))
3382 {
3383 x += m_indent;
3384 }
3385 else if (level == 0)
3386 {
3387 // a hidden root is not evaluated, but its
3388 // children are always calculated
3389 goto Recurse;
3390 }
389cdc7a 3391
91b8de8d 3392 CalculateSize( item, dc );
d3a9f4af 3393
91b8de8d 3394 // set its position
618a5e38 3395 item->SetX( x+m_spacing );
91b8de8d 3396 item->SetY( y );
618a5e38 3397 y += GetLineHeight(item);
4c681997 3398
bbe0af5b
RR
3399 if ( !item->IsExpanded() )
3400 {
618a5e38 3401 // we don't need to calculate collapsed branches
bbe0af5b
RR
3402 return;
3403 }
389cdc7a 3404
618a5e38 3405 Recurse:
91b8de8d
RR
3406 wxArrayGenericTreeItems& children = item->GetChildren();
3407 size_t n, count = children.Count();
618a5e38 3408 ++level;
91b8de8d 3409 for (n = 0; n < count; ++n )
618a5e38 3410 CalculateLevel( children[n], dc, level, y ); // recurse
edaa81ae 3411}
c801d85f 3412
941830cb 3413void wxGenericTreeCtrl::CalculatePositions()
c801d85f 3414{
bbe0af5b 3415 if ( !m_anchor ) return;
29d87bba 3416
bbe0af5b
RR
3417 wxClientDC dc(this);
3418 PrepareDC( dc );
29d87bba 3419
eff869aa 3420 dc.SetFont( m_normalFont );
29d87bba 3421
bbe0af5b 3422 dc.SetPen( m_dottedPen );
91b8de8d
RR
3423 //if(GetImageList() == NULL)
3424 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
29d87bba 3425
8dc99046 3426 int y = 2;
f65635b5 3427 CalculateLevel( m_anchor, dc, 0, y ); // start recursion
edaa81ae 3428}
c801d85f 3429
3e6e5147
VZ
3430void wxGenericTreeCtrl::Refresh(bool eraseBackground, const wxRect *rect)
3431{
3432 if ( !m_freezeCount )
3433 wxTreeCtrlBase::Refresh(eraseBackground, rect);
3434}
3435
941830cb 3436void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
c801d85f 3437{
3e6e5147
VZ
3438 if (m_dirty || m_freezeCount)
3439 return;
e6527f9d 3440
d027179b 3441 wxSize client = GetClientSize();
4832f7c0 3442
bbe0af5b 3443 wxRect rect;
5941c5de 3444 CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
d027179b
VS
3445 rect.width = client.x;
3446 rect.height = client.y;
f135ff73 3447
ca65c044 3448 Refresh(true, &rect);
f135ff73 3449
bbe0af5b 3450 AdjustMyScrollbars();
edaa81ae 3451}
c801d85f 3452
941830cb 3453void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
c801d85f 3454{
3e6e5147
VZ
3455 if (m_dirty || m_freezeCount)
3456 return;
e6527f9d 3457
bbe0af5b 3458 wxRect rect;
5941c5de 3459 CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
d027179b 3460 rect.width = GetClientSize().x;
91b8de8d 3461 rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
978f38c2 3462
ca65c044 3463 Refresh(true, &rect);
edaa81ae 3464}
c801d85f 3465
b771aa29
VZ
3466void wxGenericTreeCtrl::RefreshSelected()
3467{
be085544 3468 if (m_freezeCount)
3e6e5147 3469 return;
ca65c044 3470
b771aa29
VZ
3471 // TODO: this is awfully inefficient, we should keep the list of all
3472 // selected items internally, should be much faster
3473 if ( m_anchor )
3474 RefreshSelectedUnder(m_anchor);
3475}
3476
3477void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
3478{
be085544 3479 if (m_freezeCount)
3e6e5147 3480 return;
ca65c044 3481
b771aa29
VZ
3482 if ( item->IsSelected() )
3483 RefreshLine(item);
3484
3485 const wxArrayGenericTreeItems& children = item->GetChildren();
3486 size_t count = children.GetCount();
3487 for ( size_t n = 0; n < count; n++ )
3488 {
3489 RefreshSelectedUnder(children[n]);
3490 }
3491}
3492
e1983ab5
VZ
3493void wxGenericTreeCtrl::Freeze()
3494{
3495 m_freezeCount++;
3496}
3497
3498void wxGenericTreeCtrl::Thaw()
3499{
3500 wxCHECK_RET( m_freezeCount > 0, _T("thawing unfrozen tree control?") );
ca65c044 3501
8d7eaf91 3502 if ( --m_freezeCount == 0 )
e1983ab5
VZ
3503 {
3504 Refresh();
3505 }
3506}
3507
7009f411
VZ
3508// ----------------------------------------------------------------------------
3509// changing colours: we need to refresh the tree control
3510// ----------------------------------------------------------------------------
3511
3512bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
3513{
3514 if ( !wxWindow::SetBackgroundColour(colour) )
ca65c044
WS
3515 return false;
3516
7009f411
VZ
3517 Refresh();
3518
ca65c044 3519 return true;
7009f411
VZ
3520}
3521
0800a4ba 3522bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
7009f411
VZ
3523{
3524 if ( !wxWindow::SetForegroundColour(colour) )
ca65c044
WS
3525 return false;
3526
7009f411
VZ
3527 Refresh();
3528
ca65c044 3529 return true;
7009f411
VZ
3530}
3531
73bb6776
JS
3532// Process the tooltip event, to speed up event processing.
3533// Doesn't actually get a tooltip.
3534void wxGenericTreeCtrl::OnGetToolTip( wxTreeEvent &event )
3535{
3536 event.Veto();
3537}
3538
35d4c967
RD
3539
3540// NOTE: If using the wxListBox visual attributes works everywhere then this can
3541// be removed, as well as the #else case below.
3542#define _USE_VISATTR 0
3543
35d4c967
RD
3544//static
3545wxVisualAttributes
3f927d50 3546#if _USE_VISATTR
35d4c967 3547wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
3f927d50
DS
3548#else
3549wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
3550#endif
35d4c967
RD
3551{
3552#if _USE_VISATTR
3553 // Use the same color scheme as wxListBox
3554 return wxListBox::GetClassDefaultAttributes(variant);
3555#else
3556 wxVisualAttributes attr;
3557 attr.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
3558 attr.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
3559 attr.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
3560 return attr;
3561#endif
3562}
3563
a6fb8636
WS
3564#if WXWIN_COMPATIBILITY_2_4
3565
3566int wxGenericTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
3567{
3568 return GetItemImage(item, wxTreeItemIcon_Selected);
3569}
3570
3571void wxGenericTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
3572{
3573 SetItemImage(item, image, wxTreeItemIcon_Selected);
3574}
3575
3576#endif // WXWIN_COMPATIBILITY_2_4
3577
27f8357f
VZ
3578void wxGenericTreeCtrl::DoDirtyProcessing()
3579{
3580 if (m_freezeCount)
3581 return;
3582
3583 m_dirty = false;
3584
3585 CalculatePositions();
3586 Refresh();
3587 AdjustMyScrollbars();
3588}
3589
1e6feb95 3590#endif // wxUSE_TREECTRL