]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/treectrl.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
1. Pause()/Resume() implemented for wxMSW
[wxWidgets.git] / src / msw / treectrl.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: treectrl.cpp
3// Purpose: wxTreeCtrl
4// Author: Julian Smart
5// Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98
6// Created: 1997
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19#ifdef __GNUG__
20 #pragma implementation "treectrl.h"
21#endif
22
23// For compilers that support precompilation, includes "wx.h".
24#include "wx/wxprec.h"
25
26#ifdef __BORLANDC__
27 #pragma hdrstop
28#endif
29
30#ifndef WX_PRECOMP
31 #include "wx.h"
32#endif
33
34#if defined(__WIN95__)
35
36#include "wx/log.h"
37#include "wx/imaglist.h"
38
39#include "wx/msw/private.h"
40
41#ifndef __GNUWIN32__
42 #include <commctrl.h>
43#endif
44
45#ifdef GetFirstChild
46#undef GetFirstChild
47#endif
48
49#ifdef GetNextChild
50#undef GetNextChild
51#endif
52
53#ifdef GetNextSibling
54#undef GetNextSibling
55#endif
56
57#include "wx/msw/treectrl.h"
58
59// Bug in headers, sometimes
60#ifndef TVIS_FOCUSED
61 #define TVIS_FOCUSED 0x0001
62#endif
63
64// ----------------------------------------------------------------------------
65// private classes
66// ----------------------------------------------------------------------------
67
68// a convenient wrapper around TV_ITEM struct which adds a ctor
69struct wxTreeViewItem : public TV_ITEM
70{
71 wxTreeViewItem(const wxTreeItemId& item,
72 UINT mask_, UINT stateMask_ = 0)
73 {
74 mask = mask_;
75 stateMask = stateMask_;
76 hItem = (HTREEITEM) (WXHTREEITEM) item;
77 }
78};
79
80// ----------------------------------------------------------------------------
81// macros
82// ----------------------------------------------------------------------------
83
84#if !USE_SHARED_LIBRARY
85 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
86#endif
87
88// hide the ugly cast (of course, the macro is _quite_ ugly too...)
89#define wxhWnd ((HWND)m_hWnd)
90
91// ----------------------------------------------------------------------------
92// variables
93// ----------------------------------------------------------------------------
94
95// handy table for sending events
96static const wxEventType g_events[2][2] =
97{
98 { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
99 { wxEVT_COMMAND_TREE_ITEM_EXPANDED, wxEVT_COMMAND_TREE_ITEM_EXPANDING }
100};
101
102// ============================================================================
103// implementation
104// ============================================================================
105
106// ----------------------------------------------------------------------------
107// construction and destruction
108// ----------------------------------------------------------------------------
109
110void wxTreeCtrl::Init()
111{
112 m_imageListNormal = NULL;
113 m_imageListState = NULL;
114 m_textCtrl = NULL;
115}
116
117bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
118 const wxPoint& pos, const wxSize& size,
119 long style, const wxValidator& validator,
120 const wxString& name)
121{
122 Init();
123
124 wxSystemSettings settings;
125
126 SetName(name);
127 SetValidator(validator);
128
129 m_windowStyle = style;
130
131 SetParent(parent);
132
133 m_windowId = (id == -1) ? NewControlId() : id;
134
135 DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP | TVS_HASLINES;
136
137 bool want3D;
138 WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
139
140 // Even with extended styles, need to combine with WS_BORDER
141 // for them to look right.
142 if ( want3D || wxStyleHasBorder(m_windowStyle) )
143 {
144 wstyle |= WS_BORDER;
145 }
146
147 if ( m_windowStyle & wxTR_HAS_BUTTONS )
148 wstyle |= TVS_HASBUTTONS;
149
150 if ( m_windowStyle & wxTR_EDIT_LABELS )
151 wstyle |= TVS_EDITLABELS;
152
153 if ( m_windowStyle & wxTR_LINES_AT_ROOT )
154 wstyle |= TVS_LINESATROOT;
155
156 // Create the tree control.
157 m_hWnd = (WXHWND)::CreateWindowEx
158 (
159 exStyle,
160 WC_TREEVIEW,
161 "",
162 wstyle,
163 pos.x, pos.y, size.x, size.y,
164 (HWND)parent->GetHWND(),
165 (HMENU)m_windowId,
166 wxGetInstance(),
167 NULL
168 );
169
170 wxCHECK_MSG( m_hWnd, FALSE, "Failed to create tree ctrl" );
171
172 if ( parent )
173 parent->AddChild(this);
174
175 SubclassWin(m_hWnd);
176
177 return TRUE;
178}
179
180wxTreeCtrl::~wxTreeCtrl()
181{
182 DeleteTextCtrl();
183
184 // delete user data to prevent memory leaks
185 DeleteAllItems();
186}
187
188// ----------------------------------------------------------------------------
189// accessors
190// ----------------------------------------------------------------------------
191
192// simple wrappers which add error checking in debug mode
193
194bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
195{
196 if ( !TreeView_GetItem(wxhWnd, tvItem) )
197 {
198 wxLogLastError("TreeView_GetItem");
199
200 return FALSE;
201 }
202
203 return TRUE;
204}
205
206void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
207{
208 if ( TreeView_SetItem(wxhWnd, tvItem) == -1 )
209 {
210 wxLogLastError("TreeView_SetItem");
211 }
212}
213
214size_t wxTreeCtrl::GetCount() const
215{
216 return (size_t)TreeView_GetCount(wxhWnd);
217}
218
219unsigned int wxTreeCtrl::GetIndent() const
220{
221 return TreeView_GetIndent(wxhWnd);
222}
223
224void wxTreeCtrl::SetIndent(unsigned int indent)
225{
226 TreeView_SetIndent(wxhWnd, indent);
227}
228
229wxImageList *wxTreeCtrl::GetImageList() const
230{
231 return m_imageListNormal;
232}
233
234wxImageList *wxTreeCtrl::GetStateImageList() const
235{
236 return m_imageListNormal;
237}
238
239void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
240{
241 // no error return
242 TreeView_SetImageList(wxhWnd,
243 imageList ? imageList->GetHIMAGELIST() : 0,
244 which);
245}
246
247void wxTreeCtrl::SetImageList(wxImageList *imageList)
248{
249 SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
250}
251
252void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
253{
254 SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
255}
256
257size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
258{
259 long cookie;
260
261 size_t result = 0;
262
263 wxArrayLong children;
264 wxTreeItemId child = GetFirstChild(item, cookie);
265 while ( child.IsOk() )
266 {
267 if ( recursively )
268 {
269 // recursive call
270 result += GetChildrenCount(child, TRUE);
271 }
272
273 // add the child to the result in any case
274 result++;
275
276 child = GetNextChild(item, cookie);
277 }
278
279 return result;
280}
281
282// ----------------------------------------------------------------------------
283// Item access
284// ----------------------------------------------------------------------------
285
286wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
287{
288 char buf[512]; // the size is arbitrary...
289
290 wxTreeViewItem tvItem(item, TVIF_TEXT);
291 tvItem.pszText = buf;
292 tvItem.cchTextMax = WXSIZEOF(buf);
293 if ( !DoGetItem(&tvItem) )
294 {
295 // don't return some garbage which was on stack, but an empty string
296 buf[0] = '\0';
297 }
298
299 return wxString(buf);
300}
301
302void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
303{
304 wxTreeViewItem tvItem(item, TVIF_TEXT);
305 tvItem.pszText = (char *)text.c_str(); // conversion is ok
306 DoSetItem(&tvItem);
307}
308
309int wxTreeCtrl::GetItemImage(const wxTreeItemId& item) const
310{
311 wxTreeViewItem tvItem(item, TVIF_IMAGE);
312 DoGetItem(&tvItem);
313
314 return tvItem.iImage;
315}
316
317void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image)
318{
319 wxTreeViewItem tvItem(item, TVIF_IMAGE);
320 tvItem.iImage = image;
321 DoSetItem(&tvItem);
322}
323
324int wxTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
325{
326 wxTreeViewItem tvItem(item, TVIF_SELECTEDIMAGE);
327 DoGetItem(&tvItem);
328
329 return tvItem.iSelectedImage;
330}
331
332void wxTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
333{
334 wxTreeViewItem tvItem(item, TVIF_SELECTEDIMAGE);
335 tvItem.iSelectedImage = image;
336 DoSetItem(&tvItem);
337}
338
339wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
340{
341 wxTreeViewItem tvItem(item, TVIF_PARAM);
342 if ( !DoGetItem(&tvItem) )
343 {
344 return NULL;
345 }
346
347 return (wxTreeItemData *)tvItem.lParam;
348}
349
350void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
351{
352 wxTreeViewItem tvItem(item, TVIF_PARAM);
353 tvItem.lParam = (LPARAM)data;
354 DoSetItem(&tvItem);
355}
356
357void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
358{
359 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
360 tvItem.cChildren = (int)has;
361 DoSetItem(&tvItem);
362}
363
364void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
365{
366 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
367 tvItem.state = bold ? TVIS_BOLD : 0;
368 DoSetItem(&tvItem);
369}
370
371// ----------------------------------------------------------------------------
372// Item status
373// ----------------------------------------------------------------------------
374
375bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
376{
377 // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
378 RECT rect;
379 return SendMessage(wxhWnd, TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
380
381}
382
383bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
384{
385 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
386 DoGetItem(&tvItem);
387
388 return tvItem.cChildren != 0;
389}
390
391bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
392{
393 // probably not a good idea to put it here
394 //wxASSERT( ItemHasChildren(item) );
395
396 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
397 DoGetItem(&tvItem);
398
399 return (tvItem.state & TVIS_EXPANDED) != 0;
400}
401
402bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
403{
404 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
405 DoGetItem(&tvItem);
406
407 return (tvItem.state & TVIS_SELECTED) != 0;
408}
409
410bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
411{
412 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
413 DoGetItem(&tvItem);
414
415 return (tvItem.state & TVIS_BOLD) != 0;
416}
417
418// ----------------------------------------------------------------------------
419// navigation
420// ----------------------------------------------------------------------------
421
422wxTreeItemId wxTreeCtrl::GetRootItem() const
423{
424 return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(wxhWnd));
425}
426
427wxTreeItemId wxTreeCtrl::GetSelection() const
428{
429 return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(wxhWnd));
430}
431
432wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
433{
434 return wxTreeItemId((WXHTREEITEM) TreeView_GetParent(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
435}
436
437wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
438 long& _cookie) const
439{
440 // remember the last child returned in 'cookie'
441 _cookie = (long)TreeView_GetChild(wxhWnd, (HTREEITEM) (WXHTREEITEM)item);
442
443 return wxTreeItemId((WXHTREEITEM)_cookie);
444}
445
446wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
447 long& _cookie) const
448{
449 wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(wxhWnd,
450 (HTREEITEM)(WXHTREEITEM)_cookie));
451 _cookie = (long)l;
452
453 return l;
454}
455
456wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
457{
458 return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
459}
460
461wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
462{
463 return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
464}
465
466wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
467{
468 return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(wxhWnd));
469}
470
471wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
472{
473 wxASSERT_MSG( IsVisible(item), "The item you call GetNextVisible() "
474 "for must be visible itself!");
475
476 return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
477}
478
479wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
480{
481 wxASSERT_MSG( IsVisible(item), "The item you call GetPrevVisible() "
482 "for must be visible itself!");
483
484 return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
485}
486
487// ----------------------------------------------------------------------------
488// Usual operations
489// ----------------------------------------------------------------------------
490
491wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
492 wxTreeItemId hInsertAfter,
493 const wxString& text,
494 int image, int selectedImage,
495 wxTreeItemData *data)
496{
497 TV_INSERTSTRUCT tvIns;
498 tvIns.hParent = (HTREEITEM) (WXHTREEITEM)parent;
499 tvIns.hInsertAfter = (HTREEITEM) (WXHTREEITEM) hInsertAfter;
500 UINT mask = 0;
501 if ( !text.IsEmpty() )
502 {
503 mask |= TVIF_TEXT;
504 tvIns.item.pszText = (char *)text.c_str(); // cast is ok
505 }
506
507 if ( image != -1 )
508 {
509 mask |= TVIF_IMAGE;
510 tvIns.item.iImage = image;
511
512 if ( selectedImage == -1 )
513 {
514 // take the same image for selected icon if not specified
515 selectedImage = image;
516 }
517 }
518
519 if ( selectedImage != -1 )
520 {
521 mask |= TVIF_SELECTEDIMAGE;
522 tvIns.item.iSelectedImage = selectedImage;
523 }
524
525 if ( data != NULL )
526 {
527 mask |= TVIF_PARAM;
528 tvIns.item.lParam = (LPARAM)data;
529 }
530
531 tvIns.item.mask = mask;
532
533 HTREEITEM id = (HTREEITEM) TreeView_InsertItem(wxhWnd, &tvIns);
534 if ( id == 0 )
535 {
536 wxLogLastError("TreeView_InsertItem");
537 }
538
539 if ( data != NULL )
540 {
541 // associate the application tree item with Win32 tree item handle
542 data->SetId((WXHTREEITEM)id);
543 }
544
545 return wxTreeItemId((WXHTREEITEM)id);
546}
547
548// for compatibility only
549wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
550 const wxString& text,
551 int image, int selImage,
552 long insertAfter)
553{
554 return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
555 image, selImage, NULL);
556}
557
558wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
559 int image, int selectedImage,
560 wxTreeItemData *data)
561{
562 return DoInsertItem(wxTreeItemId((WXHTREEITEM) 0), (WXHTREEITEM) 0,
563 text, image, selectedImage, data);
564}
565
566wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
567 const wxString& text,
568 int image, int selectedImage,
569 wxTreeItemData *data)
570{
571 return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,
572 text, image, selectedImage, data);
573}
574
575wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
576 const wxTreeItemId& idPrevious,
577 const wxString& text,
578 int image, int selectedImage,
579 wxTreeItemData *data)
580{
581 return DoInsertItem(parent, idPrevious, text, image, selectedImage, data);
582}
583
584wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
585 const wxString& text,
586 int image, int selectedImage,
587 wxTreeItemData *data)
588{
589 return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,
590 text, image, selectedImage, data);
591}
592
593void wxTreeCtrl::Delete(const wxTreeItemId& item)
594{
595 if ( !TreeView_DeleteItem(wxhWnd, (HTREEITEM)(WXHTREEITEM)item) )
596 {
597 wxLogLastError("TreeView_DeleteItem");
598 }
599}
600
601// delete all children (but don't delete the item itself)
602void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
603{
604 long cookie;
605
606 wxArrayLong children;
607 wxTreeItemId child = GetFirstChild(item, cookie);
608 while ( child.IsOk() )
609 {
610 children.Add((long)(WXHTREEITEM)child);
611
612 child = GetNextChild(item, cookie);
613 }
614
615 size_t nCount = children.Count();
616 for ( size_t n = 0; n < nCount; n++ )
617 {
618 if ( !TreeView_DeleteItem(wxhWnd, (HTREEITEM)children[n]) )
619 {
620 wxLogLastError("TreeView_DeleteItem");
621 }
622 }
623}
624
625void wxTreeCtrl::DeleteAllItems()
626{
627 if ( !TreeView_DeleteAllItems(wxhWnd) )
628 {
629 wxLogLastError("TreeView_DeleteAllItems");
630 }
631}
632
633void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
634{
635 wxASSERT_MSG( flag == TVE_COLLAPSE || flag == TVE_COLLAPSERESET ||
636 flag == TVE_EXPAND || flag == TVE_TOGGLE,
637 "Unknown flag in wxTreeCtrl::DoExpand" );
638
639 // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
640 // emulate them
641 if ( TreeView_Expand(wxhWnd, (HTREEITEM) (WXHTREEITEM) item, flag) != 0 )
642 {
643 wxTreeEvent event(wxEVT_NULL, m_windowId);
644 event.m_item = item;
645
646 bool isExpanded = IsExpanded(item);
647
648 event.SetEventObject(this);
649
650 // @@@ return values of {EXPAND|COLLAPS}ING event handler is discarded
651 event.SetEventType(g_events[isExpanded][TRUE]);
652 GetEventHandler()->ProcessEvent(event);
653
654 event.SetEventType(g_events[isExpanded][FALSE]);
655 GetEventHandler()->ProcessEvent(event);
656 }
657 else
658 {
659 // I wonder if it really ever happens...
660 wxLogDebug("TreeView_Expand: change didn't took place.");
661 }
662}
663
664void wxTreeCtrl::Expand(const wxTreeItemId& item)
665{
666 DoExpand(item, TVE_EXPAND);
667}
668
669void wxTreeCtrl::Collapse(const wxTreeItemId& item)
670{
671 DoExpand(item, TVE_COLLAPSE);
672}
673
674void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
675{
676 DoExpand(item, TVE_COLLAPSERESET);
677}
678
679void wxTreeCtrl::Toggle(const wxTreeItemId& item)
680{
681 DoExpand(item, TVE_TOGGLE);
682}
683
684void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
685{
686 DoExpand(item, action);
687}
688
689void wxTreeCtrl::Unselect()
690{
691 SelectItem(wxTreeItemId((WXHTREEITEM) 0));
692}
693
694void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
695{
696 if ( !TreeView_SelectItem(wxhWnd, (HTREEITEM) (WXHTREEITEM) item) )
697 {
698 wxLogLastError("TreeView_SelectItem");
699 }
700}
701
702void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
703{
704 // no error return
705 TreeView_EnsureVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item);
706}
707
708void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
709{
710 if ( !TreeView_SelectSetFirstVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item) )
711 {
712 wxLogLastError("TreeView_SelectSetFirstVisible");
713 }
714}
715
716wxTextCtrl* wxTreeCtrl::GetEditControl() const
717{
718 return m_textCtrl;
719}
720
721void wxTreeCtrl::DeleteTextCtrl()
722{
723 if ( m_textCtrl )
724 {
725 m_textCtrl->UnsubclassWin();
726 m_textCtrl->SetHWND(0);
727 delete m_textCtrl;
728 m_textCtrl = NULL;
729 }
730}
731
732wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
733 wxClassInfo* textControlClass)
734{
735 wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
736
737 HWND hWnd = (HWND) TreeView_EditLabel(wxhWnd, (HTREEITEM) (WXHTREEITEM) item);
738
739 wxCHECK_MSG( hWnd, NULL, "Can't edit tree ctrl label" );
740
741 DeleteTextCtrl();
742
743 m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
744 m_textCtrl->SetHWND((WXHWND)hWnd);
745 m_textCtrl->SubclassWin((WXHWND)hWnd);
746
747 return m_textCtrl;
748}
749
750// End label editing, optionally cancelling the edit
751void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
752{
753 TreeView_EndEditLabelNow(wxhWnd, discardChanges);
754
755 DeleteTextCtrl();
756}
757
758wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
759{
760 TV_HITTESTINFO hitTestInfo;
761 hitTestInfo.pt.x = (int)point.x;
762 hitTestInfo.pt.y = (int)point.y;
763
764 TreeView_HitTest(wxhWnd, &hitTestInfo);
765
766 flags = 0;
767
768 // avoid repetition
769 #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
770 flags |= wxTREE_HITTEST_##flag
771
772 TRANSLATE_FLAG(ABOVE);
773 TRANSLATE_FLAG(BELOW);
774 TRANSLATE_FLAG(NOWHERE);
775 TRANSLATE_FLAG(ONITEMBUTTON);
776 TRANSLATE_FLAG(ONITEMICON);
777 TRANSLATE_FLAG(ONITEMINDENT);
778 TRANSLATE_FLAG(ONITEMLABEL);
779 TRANSLATE_FLAG(ONITEMRIGHT);
780 TRANSLATE_FLAG(ONITEMSTATEICON);
781 TRANSLATE_FLAG(TOLEFT);
782 TRANSLATE_FLAG(TORIGHT);
783
784 #undef TRANSLATE_FLAG
785
786 return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
787}
788
789// ----------------------------------------------------------------------------
790// sorting stuff
791// ----------------------------------------------------------------------------
792static int CALLBACK TreeView_CompareCallback(wxTreeItemData *pItem1,
793 wxTreeItemData *pItem2,
794 wxTreeCtrl *tree)
795{
796 return tree->OnCompareItems(pItem1->GetId(), pItem2->GetId());
797}
798
799int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
800 const wxTreeItemId& item2)
801{
802 return strcmp(GetItemText(item1), GetItemText(item2));
803}
804
805void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
806{
807 // rely on the fact that TreeView_SortChildren does the same thing as our
808 // default behaviour, i.e. sorts items alphabetically and so call it
809 // directly if we're not in derived class (much more efficient!)
810 if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
811 {
812 TreeView_SortChildren(wxhWnd, (HTREEITEM)(WXHTREEITEM)item, 0);
813 }
814 else
815 {
816 TVSORTCB tvSort;
817 tvSort.hParent = (HTREEITEM)(WXHTREEITEM)item;
818 tvSort.lpfnCompare = (PFNTVCOMPARE)TreeView_CompareCallback;
819 tvSort.lParam = (LPARAM)this;
820 TreeView_SortChildrenCB(wxhWnd, &tvSort, 0 /* reserved */);
821 }
822}
823
824// ----------------------------------------------------------------------------
825// implementation
826// ----------------------------------------------------------------------------
827
828bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
829{
830 if ( cmd == EN_UPDATE )
831 {
832 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
833 event.SetEventObject( this );
834 ProcessCommand(event);
835 }
836 else if ( cmd == EN_KILLFOCUS )
837 {
838 wxCommandEvent event(wxEVT_KILL_FOCUS, id);
839 event.SetEventObject( this );
840 ProcessCommand(event);
841 }
842 else
843 {
844 // nothing done
845 return FALSE;
846 }
847
848 // command processed
849 return TRUE;
850}
851
852// process WM_NOTIFY Windows message
853bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam, WXLPARAM *result)
854{
855 wxTreeEvent event(wxEVT_NULL, m_windowId);
856 wxEventType eventType = wxEVT_NULL;
857 NMHDR *hdr = (NMHDR *)lParam;
858
859 switch ( hdr->code )
860 {
861 case TVN_BEGINDRAG:
862 eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
863 // fall through
864
865 case TVN_BEGINRDRAG:
866 {
867 if ( eventType == wxEVT_NULL )
868 eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
869 //else: left drag, already set above
870
871 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
872
873 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
874 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
875 break;
876 }
877
878 case TVN_BEGINLABELEDIT:
879 {
880 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
881 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
882
883 event.m_item = (WXHTREEITEM) info->item.hItem;
884 break;
885 }
886
887 case TVN_DELETEITEM:
888 {
889 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
890 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
891
892 event.m_item = (WXHTREEITEM) tv->itemOld.hItem;
893 break;
894 }
895
896 case TVN_ENDLABELEDIT:
897 {
898 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
899 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
900
901 event.m_item = (WXHTREEITEM) info->item.hItem;
902 break;
903 }
904
905 case TVN_GETDISPINFO:
906 eventType = wxEVT_COMMAND_TREE_GET_INFO;
907 // fall through
908
909 case TVN_SETDISPINFO:
910 {
911 if ( eventType == wxEVT_NULL )
912 eventType = wxEVT_COMMAND_TREE_SET_INFO;
913 //else: get, already set above
914
915 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
916
917 event.m_item = (WXHTREEITEM) info->item.hItem;
918 break;
919 }
920
921 case TVN_ITEMEXPANDING:
922 event.m_code = FALSE;
923 // fall through
924
925 case TVN_ITEMEXPANDED:
926 {
927 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
928
929 bool expand = FALSE;
930 switch ( tv->action )
931 {
932 case TVE_EXPAND:
933 expand = TRUE;
934 break;
935
936 case TVE_COLLAPSE:
937 expand = FALSE;
938 break;
939
940 default:
941 wxLogDebug("unexpected code %d in TVN_ITEMEXPAND "
942 "message", tv->action);
943 }
944
945 bool ing = (hdr->code == TVN_ITEMEXPANDING);
946 eventType = g_events[expand][ing];
947
948 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
949 break;
950 }
951
952 case TVN_KEYDOWN:
953 {
954 eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
955 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
956
957 event.m_code = wxCharCodeMSWToWX(info->wVKey);
958
959 // a separate event for this case
960 if ( info->wVKey == VK_SPACE || info->wVKey == VK_RETURN )
961 {
962 wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
963 m_windowId);
964 event2.SetEventObject(this);
965
966 GetEventHandler()->ProcessEvent(event2);
967 }
968 break;
969 }
970
971 case TVN_SELCHANGED:
972 eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
973 // fall through
974
975 case TVN_SELCHANGING:
976 {
977 if ( eventType == wxEVT_NULL )
978 eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
979 //else: already set above
980
981 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
982
983 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
984 event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
985 break;
986 }
987
988 default:
989 return wxControl::MSWNotify(wParam, lParam, result);
990 }
991
992 event.SetEventObject(this);
993 event.SetEventType(eventType);
994
995 bool processed = GetEventHandler()->ProcessEvent(event);
996
997 // post processing
998 if ( hdr->code == TVN_DELETEITEM )
999 {
1000 // NB: we might process this message using wxWindows event tables, but
1001 // due to overhead of wxWin event system we prefer to do it here
1002 // (otherwise deleting a tree with many items is just too slow)
1003 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
1004 wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
1005 delete data; // may be NULL, ok
1006 }
1007
1008 *result = !event.IsAllowed();
1009
1010 return processed;
1011}
1012
1013// ----------------------------------------------------------------------------
1014// Tree event
1015// ----------------------------------------------------------------------------
1016
1017IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
1018
1019wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)
1020 : wxNotifyEvent(commandType, id)
1021{
1022 m_code = 0;
1023 m_itemOld = 0;
1024}
1025
1026#endif // __WIN95__
1027
wxWidgets (Impactor)