1
/////////////////////////////////////////////////////////////////////////////
2
// Name: treelistctrl.cpp
3
// Purpose: multi column tree control implementation
4
// Author: Robert Roebling
6
// Modified: Alberto Griggio, 2002
7
// 22/10/98 - almost total rewrite, simpler interface (VZ)
8
// Id: $Id: treelistctrl.cpp,v 1.21.2.2 2006/02/24 01:04:21 RD Exp $
9
// Copyright: (c) Robert Roebling, Julian Smart, Alberto Griggio,
10
// Vadim Zeitlin, Otto Wyss
11
// Licence: wxWindows licence
12
/////////////////////////////////////////////////////////////////////////////
14
// ===========================================================================
16
// ===========================================================================
18
// ---------------------------------------------------------------------------
20
// ---------------------------------------------------------------------------
22
// For compilers that support precompilation, includes "wx.h".
23
#include "wx/wxprec.h"
30
#include <wx/treebase.h>
32
#include <wx/textctrl.h>
33
#include <wx/imaglist.h>
34
#include <wx/settings.h>
35
#include <wx/dcclient.h>
36
#include <wx/dcscreen.h>
37
#include <wx/scrolwin.h>
38
#include <wx/renderer.h>
39
#include <wx/dcmemory.h>
41
#include "wx/treelistctrl.h"
45
#include <wx/gtk/win_gtk.h>
49
#include "wx/mac/private.h"
53
// ---------------------------------------------------------------------------
55
// ---------------------------------------------------------------------------
59
#if !wxCHECK_VERSION(2, 5, 0)
60
WX_DEFINE_ARRAY(wxTreeListItem *, wxArrayTreeListItems);
62
WX_DEFINE_ARRAY_PTR(wxTreeListItem *, wxArrayTreeListItems);
65
#include <wx/dynarray.h>
66
WX_DECLARE_OBJARRAY(wxTreeListColumnInfo, wxArrayTreeListColumnInfo);
67
#include <wx/arrimpl.cpp>
68
WX_DEFINE_OBJARRAY(wxArrayTreeListColumnInfo);
70
#if !wxCHECK_VERSION(2, 3, 3)
71
WX_DEFINE_ARRAY(short, wxArrayShort);
75
// --------------------------------------------------------------------------
77
// --------------------------------------------------------------------------
79
static const int NO_IMAGE = -1;
81
const int LINEHEIGHT = 10;
82
const int PIXELS_PER_UNIT = 10;
83
const int LINEATROOT = 5;
85
const int MININDENT = 10;
86
const int BTNWIDTH = 9; //11;
87
const int BTNHEIGHT = 9; //11;
89
// extra margins around the text label
90
static const int EXTRA_WIDTH = 4;
91
static const int EXTRA_HEIGHT = 4;
93
// offset for the header window
94
static const int HEADER_OFFSET_X = 1;
95
static const int HEADER_OFFSET_Y = 1;
99
const wxChar* wxTreeListCtrlNameStr = wxT("treelistctrl");
101
static wxTreeListColumnInfo wxInvalidTreeListColumnInfo;
104
// ---------------------------------------------------------------------------
106
// ---------------------------------------------------------------------------
107
//-----------------------------------------------------------------------------
108
// wxTreeListHeaderWindow (internal)
109
//-----------------------------------------------------------------------------
111
class wxTreeListHeaderWindow : public wxWindow
114
wxTreeListMainWindow *m_owner;
115
wxCursor *m_currentCursor;
116
wxCursor *m_resizeCursor;
119
// column being resized
122
// divider line position in logical (unscrolled) coords
125
// minimal position beyond which the divider line can't be dragged in
129
wxArrayTreeListColumnInfo m_columns;
131
// total width of the columns
132
int m_total_col_width;
136
wxTreeListHeaderWindow();
138
wxTreeListHeaderWindow( wxWindow *win,
140
wxTreeListMainWindow *owner,
141
const wxPoint &pos = wxDefaultPosition,
142
const wxSize &size = wxDefaultSize,
144
const wxString &name = wxT("wxtreelistctrlcolumntitles") );
146
virtual ~wxTreeListHeaderWindow();
148
void DoDrawRect( wxDC *dc, int x, int y, int w, int h );
150
void AdjustDC(wxDC& dc);
152
void OnEraseBackground( wxEraseEvent& event );
153
void OnPaint( wxPaintEvent &event );
154
void OnMouse( wxMouseEvent &event );
155
void OnSetFocus( wxFocusEvent &event );
158
// columns manipulation
160
size_t GetColumnCount() const { return m_columns.GetCount(); }
162
void AddColumn(const wxTreeListColumnInfo& col);
164
void InsertColumn(size_t before, const wxTreeListColumnInfo& col);
166
void RemoveColumn(size_t column);
168
void SetColumn(size_t column, const wxTreeListColumnInfo& info);
169
const wxTreeListColumnInfo& GetColumn(size_t column) const
171
wxCHECK_MSG(column < GetColumnCount(), wxInvalidTreeListColumnInfo, wxT("Invalid column"));
172
return m_columns[column];
174
wxTreeListColumnInfo& GetColumn(size_t column)
176
wxCHECK_MSG(column < GetColumnCount(), wxInvalidTreeListColumnInfo, wxT("Invalid column"));
177
return m_columns[column];
180
void SetColumnWidth(size_t column, size_t width);
182
void SetColumnText(size_t column, const wxString& text)
184
wxCHECK_RET(column < GetColumnCount(), wxT("Invalid column"));
185
m_columns[column].SetText(text);
188
void SetColumnShown(size_t column, bool shown)
190
wxCHECK_RET(column < GetColumnCount(), wxT("Invalid column"));
191
m_columns[column].SetShown(shown);
194
wxString GetColumnText(size_t column) const
196
wxCHECK_MSG(column < GetColumnCount(), wxEmptyString, wxT("Invalid column"));
197
return m_columns[column].GetText();
200
int GetColumnWidth(size_t column) const
202
wxCHECK_MSG(column < GetColumnCount(), -1, wxT("Invalid column"));
203
return m_columns[column].GetWidth();
206
int GetWidth() const { return m_total_col_width; }
208
int GetColumnShown(size_t column) const
210
wxCHECK_MSG(column < GetColumnCount(), -1, wxT("Invalid column"));
211
return m_columns[column].GetShown();
218
// common part of all ctors
221
void SendListEvent(wxEventType type, wxPoint pos);
223
DECLARE_DYNAMIC_CLASS(wxTreeListHeaderWindow)
224
DECLARE_EVENT_TABLE()
228
// this is the "true" control
229
class wxTreeListMainWindow: public wxScrolledWindow
234
wxTreeListMainWindow() { Init(); }
236
wxTreeListMainWindow(wxTreeListCtrl *parent, wxWindowID id = -1,
237
const wxPoint& pos = wxDefaultPosition,
238
const wxSize& size = wxDefaultSize,
239
long style = wxTR_DEFAULT_STYLE,
240
const wxValidator &validator = wxDefaultValidator,
241
const wxString& name = wxT("wxtreelistmainwindow"))
244
Create(parent, id, pos, size, style, validator, name);
247
virtual ~wxTreeListMainWindow();
249
bool Create(wxTreeListCtrl *parent, wxWindowID id = -1,
250
const wxPoint& pos = wxDefaultPosition,
251
const wxSize& size = wxDefaultSize,
252
long style = wxTR_DEFAULT_STYLE,
253
const wxValidator &validator = wxDefaultValidator,
254
const wxString& name = wxT("wxtreelistctrl"));
259
// get the total number of items in the control
260
size_t GetCount() const;
262
// indent is the number of pixels the children are indented relative to
263
// the parents position. SetIndent() also redraws the control
265
unsigned int GetIndent() const { return m_indent; }
266
void SetIndent(unsigned int indent);
268
// see wxTreeListCtrl for the meaning
269
unsigned int GetLineSpacing() const { return m_linespacing; }
270
void SetLineSpacing(unsigned int spacing);
272
// image list: these functions allow to associate an image list with
273
// the control and retrieve it. Note that when assigned with
274
// SetImageList, the control does _not_ delete
275
// the associated image list when it's deleted in order to allow image
276
// lists to be shared between different controls. If you use
277
// AssignImageList, the control _does_ delete the image list.
279
// The normal image list is for the icons which correspond to the
280
// normal tree item state (whether it is selected or not).
281
// Additionally, the application might choose to show a state icon
282
// which corresponds to an app-defined item state (for example,
283
// checked/unchecked) which are taken from the state image list.
284
wxImageList *GetImageList() const;
285
wxImageList *GetStateImageList() const;
286
wxImageList *GetButtonsImageList() const;
288
void SetImageList(wxImageList *imageList);
289
void SetStateImageList(wxImageList *imageList);
290
void SetButtonsImageList(wxImageList *imageList);
291
void AssignImageList(wxImageList *imageList);
292
void AssignStateImageList(wxImageList *imageList);
293
void AssignButtonsImageList(wxImageList *imageList);
295
// Functions to work with tree ctrl items.
300
// retrieve item's label
301
wxString GetItemText(const wxTreeItemId& item) const
302
{ return GetItemText(item, GetMainColumn()); }
303
// get one of the images associated with the item (normal by default)
304
int GetItemImage(const wxTreeItemId& item,
305
wxTreeItemIcon which = wxTreeItemIcon_Normal) const
306
{ return GetItemImage(item, GetMainColumn(), which); }
308
// get the data associated with the item
309
wxTreeItemData *GetItemData(const wxTreeItemId& item) const;
311
bool GetItemBold(const wxTreeItemId& item) const;
312
wxColour GetItemTextColour(const wxTreeItemId& item) const;
313
wxColour GetItemBackgroundColour(const wxTreeItemId& item) const;
314
wxFont GetItemFont(const wxTreeItemId& item) const;
320
void SetItemText(const wxTreeItemId& item, const wxString& text)
321
{ SetItemText(item, GetMainColumn(), text); }
323
// get one of the images associated with the item (normal by default)
324
void SetItemImage(const wxTreeItemId& item, int image,
325
wxTreeItemIcon which = wxTreeItemIcon_Normal)
326
{ SetItemImage(item, GetMainColumn(), image, which); }
328
// associate some data with the item
329
void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
331
// force appearance of [+] button near the item. This is useful to
332
// allow the user to expand the items which don't have any children now
333
// - but instead add them only when needed, thus minimizing memory
334
// usage and loading time.
335
void SetItemHasChildren(const wxTreeItemId& item, bool has = TRUE);
337
// the item will be shown in bold
338
void SetItemBold(const wxTreeItemId& item, bool bold = TRUE);
340
// set the item's text colour
341
void SetItemTextColour(const wxTreeItemId& item, const wxColour& colour);
343
// set the item's background colour
344
void SetItemBackgroundColour(const wxTreeItemId& item, const wxColour& colour);
346
// set the item's font (should be of the same height for all items)
347
void SetItemFont(const wxTreeItemId& item, const wxFont& font);
349
// set the window font
350
virtual bool SetFont( const wxFont &font );
352
// set the styles. No need to specify a GetWindowStyle here since
353
// the base wxWindow member function will do it for us
354
void SetWindowStyle(const long styles);
356
// item status inquiries
357
// ---------------------
359
// is the item visible (it might be outside the view or not expanded)?
360
bool IsVisible(const wxTreeItemId& item) const;
361
// does the item has any children?
362
bool HasChildren(const wxTreeItemId& item) const
363
{ return ItemHasChildren(item); }
364
bool ItemHasChildren(const wxTreeItemId& item) const;
365
// is the item expanded (only makes sense if HasChildren())?
366
bool IsExpanded(const wxTreeItemId& item) const;
367
// is this item currently selected (the same as has focus)?
368
bool IsSelected(const wxTreeItemId& item) const;
369
// is item text in bold font?
370
bool IsBold(const wxTreeItemId& item) const;
371
// does the layout include space for a button?
373
// number of children
374
// ------------------
376
// if 'recursively' is FALSE, only immediate children count, otherwise
377
// the returned number is the number of all items in this branch
378
size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = TRUE);
383
// wxTreeItemId.IsOk() will return FALSE if there is no such item
385
// get the root tree item
386
wxTreeItemId GetRootItem() const { return m_anchor; }
388
// get the item currently selected (may return NULL if no selection)
389
wxTreeItemId GetSelection() const { return m_current; }
391
// get the items currently selected, return the number of such item
392
size_t GetSelections(wxArrayTreeItemIds&) const;
394
// get the parent of this item (may return NULL if root)
395
wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
397
// for this enumeration function you must pass in a "cookie" parameter
398
// which is opaque for the application but is necessary for the library
399
// to make these functions reentrant (i.e. allow more than one
400
// enumeration on one and the same object simultaneously). Of course,
401
// the "cookie" passed to GetFirstChild() and GetNextChild() should be
404
// get the first child of this item
405
#if !wxCHECK_VERSION(2, 5, 0)
406
wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& cookie) const;
408
wxTreeItemId GetFirstChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
410
// get the next child
411
#if !wxCHECK_VERSION(2, 5, 0)
412
wxTreeItemId GetNextChild(const wxTreeItemId& item, long& cookie) const;
414
wxTreeItemId GetNextChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
416
// get the prev child
417
#if !wxCHECK_VERSION(2, 5, 0)
418
wxTreeItemId GetPrevChild(const wxTreeItemId& item, long& cookie) const;
420
wxTreeItemId GetPrevChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
422
// get the last child of this item - this method doesn't use cookies
423
wxTreeItemId GetLastChild(const wxTreeItemId& item) const;
425
// get the next sibling of this item
426
wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
427
// get the previous sibling
428
wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
430
// get first visible item
431
wxTreeItemId GetFirstVisibleItem() const;
432
// get the next visible item: item must be visible itself!
433
// see IsVisible() and wxTreeCtrl::GetFirstVisibleItem()
434
wxTreeItemId GetNextVisible(const wxTreeItemId& item) const;
435
// get the previous visible item: item must be visible itself!
436
wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const;
438
// Only for internal use right now, but should probably be public
439
wxTreeItemId GetNext(const wxTreeItemId& item) const;
444
// add the root node to the tree
445
wxTreeItemId AddRoot(const wxString& text,
446
int image = -1, int selectedImage = -1,
447
wxTreeItemData *data = NULL);
449
// insert a new item in as the first child of the parent
450
wxTreeItemId PrependItem(const wxTreeItemId& parent,
451
const wxString& text,
452
int image = -1, int selectedImage = -1,
453
wxTreeItemData *data = NULL);
455
// insert a new item after a given one
456
wxTreeItemId InsertItem(const wxTreeItemId& parent,
457
const wxTreeItemId& idPrevious,
458
const wxString& text,
459
int image = -1, int selectedImage = -1,
460
wxTreeItemData *data = NULL);
462
// insert a new item before the one with the given index
463
wxTreeItemId InsertItem(const wxTreeItemId& parent,
465
const wxString& text,
466
int image = -1, int selectedImage = -1,
467
wxTreeItemData *data = NULL);
469
// insert a new item in as the last child of the parent
470
wxTreeItemId AppendItem(const wxTreeItemId& parent,
471
const wxString& text,
472
int image = -1, int selectedImage = -1,
473
wxTreeItemData *data = NULL);
475
// delete this item and associated data if any
476
void Delete(const wxTreeItemId& item);
477
// delete all children (but don't delete the item itself)
478
// NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
479
void DeleteChildren(const wxTreeItemId& item);
480
// delete all items from the tree
481
// NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
482
void DeleteAllItems();
485
void Expand(const wxTreeItemId& item);
486
// expand this item and all subitems recursively
487
void ExpandAll(const wxTreeItemId& item);
488
// collapse the item without removing its children
489
void Collapse(const wxTreeItemId& item);
490
// collapse the item and remove all children
491
void CollapseAndReset(const wxTreeItemId& item);
492
// toggles the current state
493
void Toggle(const wxTreeItemId& item);
495
// remove the selection from currently selected item (if any)
499
void SelectItem(const wxTreeItemId& item, bool unselect_others=TRUE,
500
bool extended_select=FALSE);
501
void SelectAll(bool extended_select=FALSE);
502
// make sure this item is visible (expanding the parent item and/or
503
// scrolling to this item if necessary)
504
void EnsureVisible(const wxTreeItemId& item);
505
// scroll to this item (but don't expand its parent)
506
void ScrollTo(const wxTreeItemId& item);
507
void AdjustMyScrollbars();
509
// The first function is more portable (because easier to implement
510
// on other platforms), but the second one returns some extra info.
511
wxTreeItemId HitTest(const wxPoint& point)
512
{ int dummy; return HitTest(point, dummy); }
513
wxTreeItemId HitTest(const wxPoint& point, int& flags)
514
{ int col; return HitTest(point, flags, col); }
516
wxTreeItemId HitTest(const wxPoint& point, int& flags, int& column);
519
// get the bounding rectangle of the item (or of its label only)
520
bool GetBoundingRect(const wxTreeItemId& item,
522
bool textOnly = FALSE) const;
524
// Start editing the item label: this (temporarily) replaces the item
525
// with a one line edit control. The item will be selected if it hadn't
527
void EditLabel( const wxTreeItemId& item ) { Edit( item ); }
528
void Edit( const wxTreeItemId& item );
531
// this function is called to compare 2 items and should return -1, 0
532
// or +1 if the first item is less than, equal to or greater than the
533
// second one. The base class version performs alphabetic comparaison
534
// of item labels (GetText)
535
virtual int OnCompareItems(const wxTreeItemId& item1,
536
const wxTreeItemId& item2);
537
// sort the children of this item using OnCompareItems
539
// NB: this function is not reentrant and not MT-safe (FIXME)!
540
void SortChildren(const wxTreeItemId& item);
543
wxTreeItemId FindItem (const wxTreeItemId& item, const wxString& str, int flags = 0);
545
// deprecated functions: use Set/GetItemImage directly
546
// get the selected item image
547
int GetItemSelectedImage(const wxTreeItemId& item) const
548
{ return GetItemImage(item, wxTreeItemIcon_Selected); }
549
// set the selected item image
550
void SetItemSelectedImage(const wxTreeItemId& item, int image)
551
{ SetItemImage(item, image, wxTreeItemIcon_Selected); }
553
// implementation only from now on
555
// overridden base class virtuals
556
virtual bool SetBackgroundColour(const wxColour& colour);
557
virtual bool SetForegroundColour(const wxColour& colour);
560
void OnPaint( wxPaintEvent &event );
561
void OnSetFocus( wxFocusEvent &event );
562
void OnKillFocus( wxFocusEvent &event );
563
void OnChar( wxKeyEvent &event );
564
void OnMouse( wxMouseEvent &event );
565
void OnIdle( wxIdleEvent &event );
566
void OnScroll(wxScrollWinEvent& event); // ALB
568
// implementation helpers
569
void SendDeleteEvent(wxTreeListItem *itemBeingDeleted);
571
void DrawBorder(const wxTreeItemId& item);
572
void DrawLine(const wxTreeItemId& item, bool below);
574
size_t GetColumnCount() const
575
{ return m_owner->GetHeaderWindow()->GetColumnCount(); }
577
void SetMainColumn(size_t column)
579
if(column < GetColumnCount())
580
m_main_column = column;
582
size_t GetMainColumn() const { return m_main_column; }
584
void SetItemText(const wxTreeItemId& item, size_t column,
585
const wxString& text);
586
wxString GetItemText(const wxTreeItemId& item, size_t column) const;
588
void SetItemImage(const wxTreeItemId& item, size_t column, int image,
589
wxTreeItemIcon which = wxTreeItemIcon_Normal);
590
int GetItemImage(const wxTreeItemId& item, size_t column,
591
wxTreeItemIcon which = wxTreeItemIcon_Normal) const;
596
wxTreeListCtrl* m_owner; // ALB
598
size_t m_main_column; // ALB
600
friend class wxTreeListItem;
601
friend class wxTreeListRenameTimer;
602
friend class wxTreeListTextCtrl;
607
wxTreeListItem *m_anchor;
608
wxTreeListItem *m_current, *m_key_current, *m_currentEdit;
609
int m_btnWidth, m_btnWidth2;
610
int m_btnHeight, m_btnHeight2;
611
int m_imgWidth, m_imgWidth2;
612
int m_imgHeight, m_imgHeight2;
613
unsigned short m_indent;
615
unsigned short m_linespacing;
617
wxBrush *m_hilightBrush,
618
*m_hilightUnfocusedBrush;
623
bool m_ownsImageListNormal,
624
m_ownsImageListState,
625
m_ownsImageListButtons;
626
bool m_isDragging; // true between BEGIN/END drag events
628
bool m_lastOnSame; // last click on the same item as prev
629
wxImageList *m_imageListNormal,
635
wxTreeListItem *m_dropTarget;
636
wxCursor m_oldCursor; // cursor is changed while dragging
637
wxTreeListItem *m_oldSelection;
638
wxTreeListItem *m_underMouse; // for visual effects
640
wxTimer *m_renameTimer;
641
wxString m_renameRes;
644
wxTimer *m_findTimer;
647
// the common part of all ctors
651
wxTreeItemId DoInsertItem(const wxTreeItemId& parent,
653
const wxString& text,
654
int image, int selectedImage,
655
wxTreeItemData *data);
656
bool HasButtons(void) const
657
{ return (m_imageListButtons != NULL) ||
658
HasFlag (wxTR_TWIST_BUTTONS|wxTR_HAS_BUTTONS); }
661
void CalculateLineHeight();
662
int GetLineHeight(wxTreeListItem *item) const;
663
void PaintLevel( wxTreeListItem *item, wxDC& dc, int level, int &y,
665
void PaintItem( wxTreeListItem *item, wxDC& dc);
667
void CalculateLevel( wxTreeListItem *item, wxDC &dc, int level, int &y,
669
void CalculatePositions();
670
void CalculateSize( wxTreeListItem *item, wxDC &dc );
672
void RefreshSubtree( wxTreeListItem *item );
673
void RefreshLine( wxTreeListItem *item );
675
// redraw all selected items
676
void RefreshSelected();
678
// RefreshSelected() recursive helper
679
void RefreshSelectedUnder(wxTreeListItem *item);
681
void OnRenameTimer();
682
void OnRenameAccept();
684
void FillArray(wxTreeListItem*, wxArrayTreeItemIds&) const;
685
void SelectItemRange( wxTreeListItem *item1, wxTreeListItem *item2 );
686
bool TagAllChildrenUntilLast(wxTreeListItem *crt_item,
687
wxTreeListItem *last_item, bool select);
688
bool TagNextChildren(wxTreeListItem *crt_item, wxTreeListItem *last_item,
690
void UnselectAllChildren( wxTreeListItem *item );
692
void DrawDropEffect(wxTreeListItem *item);
695
DECLARE_EVENT_TABLE()
696
DECLARE_DYNAMIC_CLASS(wxTreeListMainWindow)
700
// timer used for enabling in-place edit
701
class wxTreeListRenameTimer: public wxTimer
704
wxTreeListRenameTimer( wxTreeListMainWindow *owner );
709
wxTreeListMainWindow *m_owner;
712
// control used for in-place edit
713
class wxTreeListTextCtrl: public wxTextCtrl
716
wxTreeListTextCtrl( wxWindow *parent,
720
wxTreeListMainWindow *owner,
721
const wxString &value = wxEmptyString,
722
const wxPoint &pos = wxDefaultPosition,
723
const wxSize &size = wxDefaultSize,
724
int style = wxSIMPLE_BORDER,
725
const wxValidator& validator = wxDefaultValidator,
726
const wxString &name = wxTextCtrlNameStr );
728
void OnChar( wxKeyEvent &event );
729
void OnKeyUp( wxKeyEvent &event );
730
void OnKillFocus( wxFocusEvent &event );
735
wxTreeListMainWindow *m_owner;
736
wxString m_startValue;
739
DECLARE_EVENT_TABLE()
747
wxTreeListItem() { m_data = NULL; }
748
wxTreeListItem( wxTreeListMainWindow *owner,
749
wxTreeListItem *parent,
750
const wxArrayString& text,
753
wxTreeItemData *data );
758
wxArrayTreeListItems& GetChildren() { return m_children; }
760
const wxString GetText() const
762
if(m_text.GetCount() > 0) return m_text[0];
763
return wxEmptyString;
765
const wxString GetText(size_t col) const
767
if(m_text.GetCount() > col) return m_text[col];
768
return wxEmptyString;
770
int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
771
{ return m_images[which]; }
772
int GetImage(size_t col, wxTreeItemIcon which=wxTreeItemIcon_Normal) const
774
if(col == m_owner->GetMainColumn()) return m_images[which];
775
if(col < m_col_images.GetCount()) return m_col_images[col];
778
wxTreeItemData *GetData() const { return m_data; }
780
// returns the current image for the item (depending on its
781
// selected/expanded/whatever state)
782
int GetCurrentImage() const;
784
void SetText( const wxString &text );
785
void SetText(size_t col, const wxString& text) // ALB
787
if(col < m_text.GetCount())
789
else if(col < m_owner->GetColumnCount()) {
790
int howmany = m_owner->GetColumnCount();
791
for(int i = m_text.GetCount(); i < howmany; ++i)
792
m_text.Add(wxEmptyString);
796
void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
797
void SetImage(size_t col, int image, wxTreeItemIcon which)
799
if(col == m_owner->GetMainColumn()) m_images[which] = image;
800
else if(col < m_col_images.GetCount())
801
m_col_images[col] = image;
802
else if(col < m_owner->GetColumnCount()) {
803
int howmany = m_owner->GetColumnCount();
804
for(int i = m_col_images.GetCount(); i < howmany; ++i)
805
m_col_images.Add(NO_IMAGE);
806
m_col_images[col] = image;
810
void SetData(wxTreeItemData *data) { m_data = data; }
812
void SetHasPlus(bool has = TRUE) { m_hasPlus = has; }
814
void SetBold(bool bold) { m_isBold = bold; }
816
int GetX() const { return m_x; }
817
int GetY() const { return m_y; }
819
void SetX(int x) { m_x = x; }
820
void SetY(int y) { m_y = y; }
822
int GetHeight() const { return m_height; }
823
int GetWidth() const { return m_width; }
825
void SetHeight(int h) { m_height = h; }
826
void SetWidth(int w) { m_width = w; }
828
wxTreeListItem *GetItemParent() const { return m_parent; }
831
// deletes all children notifying the treectrl about it if !NULL
833
void DeleteChildren(wxTreeListMainWindow *tree = NULL);
835
// get count of all children (and grand children if 'recursively')
836
size_t GetChildrenCount(bool recursively = TRUE) const;
838
void Insert(wxTreeListItem *child, size_t index)
839
{ m_children.Insert(child, index); }
841
void GetSize( int &x, int &y, const wxTreeListMainWindow* );
843
// return the item at given position (or NULL if no item), onButton is
844
// TRUE if the point belongs to the item's button, otherwise it lies
845
// on the button's label
846
wxTreeListItem *HitTest( const wxPoint& point,
847
const wxTreeListMainWindow *,
850
wxTreeListItem *HitTest( const wxPoint& point,
851
const wxTreeListMainWindow *,
852
int &flags, int& column /*ALB*/,
855
void Expand() { m_isCollapsed = FALSE; }
856
void Collapse() { m_isCollapsed = TRUE; }
858
void SetHilight( bool set = TRUE ) { m_hasHilight = set; }
861
bool HasChildren() const { return !m_children.IsEmpty(); }
862
bool IsSelected() const { return m_hasHilight != 0; }
863
bool IsExpanded() const { return !m_isCollapsed; }
864
bool HasPlus() const { return m_hasPlus || HasChildren(); }
865
bool IsBold() const { return m_isBold != 0; }
868
// get them - may be NULL
869
wxTreeItemAttr *GetAttributes() const { return m_attr; }
870
// get them ensuring that the pointer is not NULL
871
wxTreeItemAttr& Attr()
875
m_attr = new wxTreeItemAttr;
881
void SetAttributes(wxTreeItemAttr *attr)
883
if ( m_ownsAttr ) delete m_attr;
887
// set them and delete when done
888
void AssignAttributes(wxTreeItemAttr *attr)
895
wxTreeListMainWindow *m_owner; // control the item belongs to
897
// since there can be very many of these, we save size by chosing
898
// the smallest representation for the elements and by ordering
899
// the members to avoid padding.
900
wxArrayString m_text; // labels to be rendered for item
902
wxTreeItemData *m_data; // user-provided data
904
wxArrayTreeListItems m_children; // list of children
905
wxTreeListItem *m_parent; // parent of this item
907
wxTreeItemAttr *m_attr; // attributes???
909
// tree ctrl images for the normal, selected, expanded and
910
// expanded+selected states
911
short m_images[wxTreeItemIcon_Max];
912
wxArrayShort m_col_images; // images for the various columns (!= main)
914
wxCoord m_x; // (virtual) offset from top
915
wxCoord m_y; // (virtual) offset from left
916
short m_width; // width of this item
917
unsigned char m_height; // height of this item
919
// use bitfields to save size
920
int m_isCollapsed :1;
921
int m_hasHilight :1; // same as focused
922
int m_hasPlus :1; // used for item which doesn't have
923
// children but has a [+] button
924
int m_isBold :1; // render the label in bold font
925
int m_ownsAttr :1; // delete attribute when done
928
// ===========================================================================
930
// ===========================================================================
932
// ----------------------------------------------------------------------------
934
// ----------------------------------------------------------------------------
936
// translate the key or mouse event flags to the type of selection we're
938
static void EventFlagsToSelType(long style,
942
bool &extended_select,
943
bool &unselect_others)
945
is_multiple = (style & wxTR_MULTIPLE) != 0;
946
extended_select = shiftDown && is_multiple;
947
unselect_others = !(extended_select || (ctrlDown && is_multiple));
950
// ---------------------------------------------------------------------------
951
// wxTreeListRenameTimer (internal)
952
// ---------------------------------------------------------------------------
954
wxTreeListRenameTimer::wxTreeListRenameTimer( wxTreeListMainWindow *owner )
959
void wxTreeListRenameTimer::Notify()
961
m_owner->OnRenameTimer();
964
//-----------------------------------------------------------------------------
965
// wxTreeListTextCtrl (internal)
966
//-----------------------------------------------------------------------------
968
BEGIN_EVENT_TABLE(wxTreeListTextCtrl,wxTextCtrl)
969
EVT_CHAR (wxTreeListTextCtrl::OnChar)
970
EVT_KEY_UP (wxTreeListTextCtrl::OnKeyUp)
971
EVT_KILL_FOCUS (wxTreeListTextCtrl::OnKillFocus)
974
wxTreeListTextCtrl::wxTreeListTextCtrl( wxWindow *parent,
978
wxTreeListMainWindow *owner,
979
const wxString &value,
983
const wxValidator& validator,
984
const wxString &name )
985
: wxTextCtrl( parent, id, value, pos, size, style, validator, name )
991
(*m_res) = wxEmptyString;
992
m_startValue = value;
996
void wxTreeListTextCtrl::OnChar( wxKeyEvent &event )
998
if (event.m_keyCode == WXK_RETURN)
1001
(*m_res) = GetValue();
1003
if ((*m_res) != m_startValue)
1004
m_owner->OnRenameAccept();
1006
if (!wxPendingDelete.Member(this))
1007
wxPendingDelete.Append(this);
1010
m_owner->SetFocus(); // This doesn't work. TODO.
1014
if (event.m_keyCode == WXK_ESCAPE)
1016
(*m_accept) = FALSE;
1017
(*m_res) = wxEmptyString;
1019
if (!wxPendingDelete.Member(this))
1020
wxPendingDelete.Append(this);
1023
m_owner->SetFocus(); // This doesn't work. TODO.
1030
void wxTreeListTextCtrl::OnKeyUp( wxKeyEvent &event )
1038
// auto-grow the textctrl:
1039
wxSize parentSize = m_owner->GetSize();
1040
wxPoint myPos = GetPosition();
1041
wxSize mySize = GetSize();
1043
GetTextExtent(GetValue() + _T("M"), &sx, &sy);
1044
if (myPos.x + sx > parentSize.x) sx = parentSize.x - myPos.x;
1045
if (mySize.x > sx) sx = mySize.x;
1051
void wxTreeListTextCtrl::OnKillFocus( wxFocusEvent &event )
1059
if (!wxPendingDelete.Member(this))
1060
wxPendingDelete.Append(this);
1063
(*m_res) = GetValue();
1065
if ((*m_res) != m_startValue)
1066
m_owner->OnRenameAccept();
1069
//-----------------------------------------------------------------------------
1070
// wxTreeListHeaderWindow
1071
//-----------------------------------------------------------------------------
1073
IMPLEMENT_DYNAMIC_CLASS(wxTreeListHeaderWindow,wxWindow)
1075
BEGIN_EVENT_TABLE(wxTreeListHeaderWindow,wxWindow)
1076
EVT_ERASE_BACKGROUND (wxTreeListHeaderWindow::OnEraseBackground)
1077
EVT_PAINT (wxTreeListHeaderWindow::OnPaint)
1078
EVT_MOUSE_EVENTS (wxTreeListHeaderWindow::OnMouse)
1079
EVT_SET_FOCUS (wxTreeListHeaderWindow::OnSetFocus)
1082
void wxTreeListHeaderWindow::Init()
1084
m_currentCursor = (wxCursor *) NULL;
1085
m_isDragging = FALSE;
1087
m_total_col_width = 0;
1090
wxTreeListHeaderWindow::wxTreeListHeaderWindow()
1094
m_owner = (wxTreeListMainWindow *) NULL;
1095
m_resizeCursor = (wxCursor *) NULL;
1098
wxTreeListHeaderWindow::wxTreeListHeaderWindow( wxWindow *win,
1100
wxTreeListMainWindow *owner,
1104
const wxString &name )
1105
: wxWindow( win, id, pos, size, style, name )
1110
m_resizeCursor = new wxCursor(wxCURSOR_SIZEWE);
1112
SetBackgroundColour(wxSystemSettings::GetColour(
1113
wxSYS_COLOUR_BTNFACE));
1116
wxTreeListHeaderWindow::~wxTreeListHeaderWindow()
1118
delete m_resizeCursor;
1121
void wxTreeListHeaderWindow::DoDrawRect( wxDC *dc, int x, int y, int w, int h )
1124
GtkStateType state = m_parent->IsEnabled() ? GTK_STATE_NORMAL
1125
: GTK_STATE_INSENSITIVE;
1127
x = dc->XLOG2DEV( x );
1129
gtk_paint_box (m_wxwindow->style, GTK_PIZZA(m_wxwindow)->bin_window,
1130
state, GTK_SHADOW_OUT,
1131
(GdkRectangle*) NULL, m_wxwindow, "button",
1132
x-1, y-1, w+2, h+2);
1133
#elif defined( __WXMAC__ )
1134
const int m_corner = 1;
1136
dc->SetBrush( *wxTRANSPARENT_BRUSH );
1138
dc->SetPen( wxPen(wxSystemSettings::GetColour(
1139
wxSYS_COLOUR_BTNSHADOW), 1, wxSOLID));
1140
dc->DrawLine( x+w-m_corner+1, y, x+w, y+h ); // right (outer)
1141
dc->DrawRectangle( x, y+h, w+1, 1 ); // bottom (outer)
1143
wxPen pen( wxColour( 0x88 , 0x88 , 0x88 ), 1, wxSOLID );
1146
dc->DrawLine( x+w-m_corner, y, x+w-1, y+h ); // right (inner)
1147
dc->DrawRectangle( x+1, y+h-1, w-2, 1 ); // bottom (inner)
1149
dc->SetPen( *wxWHITE_PEN );
1150
dc->DrawRectangle( x, y, w-m_corner+1, 1 ); // top (outer)
1151
dc->DrawRectangle( x, y, 1, h ); // left (outer)
1152
dc->DrawLine( x, y+h-1, x+1, y+h-1 );
1153
dc->DrawLine( x+w-1, y, x+w-1, y+1 );
1155
const int m_corner = 1;
1157
dc->SetBrush( *wxTRANSPARENT_BRUSH );
1159
dc->SetPen( *wxBLACK_PEN );
1160
dc->DrawLine( x+w-m_corner+1, y, x+w, y+h ); // right (outer)
1161
dc->DrawRectangle( x, y+h, w+1, 1 ); // bottom (outer)
1163
wxPen pen(wxSystemSettings::GetColour(
1164
wxSYS_COLOUR_BTNSHADOW ), 1, wxSOLID);
1167
dc->DrawLine( x+w-m_corner, y, x+w-1, y+h ); // right (inner)
1168
dc->DrawRectangle( x+1, y+h-1, w-2, 1 ); // bottom (inner)
1170
dc->SetPen( *wxWHITE_PEN );
1171
dc->DrawRectangle( x, y, w-m_corner+1, 1 ); // top (outer)
1172
dc->DrawRectangle( x, y, 1, h ); // left (outer)
1173
dc->DrawLine( x, y+h-1, x+1, y+h-1 );
1174
dc->DrawLine( x+w-1, y, x+w-1, y+1 );
1178
// shift the DC origin to match the position of the main window horz
1179
// scrollbar: this allows us to always use logical coords
1180
void wxTreeListHeaderWindow::AdjustDC(wxDC& dc)
1183
m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
1186
m_owner->GetViewStart( &x, NULL );
1188
// account for the horz scrollbar offset
1189
dc.SetDeviceOrigin( -x * xpix, 0 );
1193
void wxTreeListHeaderWindow::OnEraseBackground( wxEraseEvent& event )
1197
void wxTreeListHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1200
wxClientDC real_dc( this );
1202
wxPaintDC real_dc( this );
1205
AdjustDC( real_dc );
1207
// width and height of the entire header window
1209
GetClientSize( &w, &h );
1210
m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1212
// Setup double buffering to eliminate the flicker
1214
wxBitmap buffer(w, h);
1215
dc.SelectObject(buffer);
1216
dc.SetBackground(wxBrush(GetBackgroundColour()));
1220
dc.SetFont( GetFont() );
1221
dc.SetBackgroundMode(wxTRANSPARENT);
1223
// do *not* use the listctrl colour for headers - one day we will have a
1224
// function to set it separately
1225
//dc.SetTextForeground( *wxBLACK );
1226
dc.SetTextForeground(wxSystemSettings::
1227
GetColour( wxSYS_COLOUR_WINDOWTEXT ));
1229
int x = HEADER_OFFSET_X;
1231
int numColumns = GetColumnCount();
1232
for ( int i = 0; i < numColumns && x < w; i++ )
1234
if (!GetColumnShown (i)) continue;
1236
wxTreeListColumnInfo& column = GetColumn(i);
1237
int wCol = column.GetWidth();
1239
// the width of the rect to draw: make it smaller to fit entirely
1240
// inside the column rect
1243
dc.SetPen( *wxWHITE_PEN );
1245
//DoDrawRect( &dc, x, HEADER_OFFSET_Y, cw, h-2 );
1246
wxRendererNative::Get().DrawHeaderButton(
1247
this, dc, wxRect(x, HEADER_OFFSET_Y, cw, h - 2),
1248
m_parent->IsEnabled() ? 0 : wxCONTROL_DISABLED);
1251
// if we have an image, draw it on the right of the label
1252
int image = column.GetImage(); //item.m_image;
1253
int ix = -2, iy = 0;
1254
wxImageList* imageList = m_owner->GetImageList();
1257
imageList->GetSize(image, ix, iy);
1259
//else: ignore the column image
1264
int image_offset = cw - ix - 1;
1266
switch(column.GetAlignment()) {
1267
case wxTL_ALIGN_LEFT:
1268
text_x += EXTRA_WIDTH;
1271
case wxTL_ALIGN_RIGHT:
1272
dc.GetTextExtent(column.GetText(), &text_width, NULL);
1273
text_x += cw - text_width - EXTRA_WIDTH;
1276
case wxTL_ALIGN_CENTER:
1277
dc.GetTextExtent(column.GetText(), &text_width, NULL);
1278
text_x += (cw - text_width)/2 + ix + 2;
1279
image_offset = (cw - text_width - ix - 2)/2;
1284
if(image != -1 && imageList) {
1285
imageList->Draw(image, dc, x + image_offset/*cw - ix - 1*/,
1286
HEADER_OFFSET_Y + (h - 4 - iy)/2,
1287
wxIMAGELIST_DRAW_TRANSPARENT);
1290
// draw the text clipping it so that it doesn't overwrite the column
1292
wxDCClipper clipper(dc, x, HEADER_OFFSET_Y, cw, h - 4 );
1294
dc.DrawText( column.GetText(),
1295
text_x, HEADER_OFFSET_Y + EXTRA_HEIGHT );
1300
int more_w = m_owner->GetSize().x - x -1;
1303
//DoDrawRect( &dc, x, HEADER_OFFSET_Y, more_w, h-2 );
1304
wxRendererNative::Get().DrawHeaderButton(
1305
this, dc, wxRect(x, HEADER_OFFSET_Y, more_w, h-2),
1306
m_parent->IsEnabled() ? 0 : wxCONTROL_DISABLED);
1309
// Finish up by drawing the buffer to the real dc
1311
dc.SelectObject(wxNullBitmap);
1312
real_dc.DrawBitmap(buffer, 0, 0, false);
1315
void wxTreeListHeaderWindow::DrawCurrent()
1317
int x1 = m_currentX;
1319
ClientToScreen( &x1, &y1 );
1321
int x2 = m_currentX-1;
1326
m_owner->GetClientSize( NULL, &y2 );
1327
m_owner->ClientToScreen( &x2, &y2 );
1330
dc.SetLogicalFunction( wxINVERT );
1331
dc.SetPen( wxPen( *wxBLACK, 2, wxSOLID ) );
1332
dc.SetBrush( *wxTRANSPARENT_BRUSH );
1336
dc.DrawLine( x1, y1, x2, y2 );
1338
dc.SetLogicalFunction( wxCOPY );
1340
dc.SetPen( wxNullPen );
1341
dc.SetBrush( wxNullBrush );
1344
void wxTreeListHeaderWindow::OnMouse( wxMouseEvent &event )
1346
// we want to work with logical coords
1348
m_owner->CalcUnscrolledPosition(event.GetX(), 0, &x, NULL);
1349
int y = event.GetY();
1353
SendListEvent(wxEVT_COMMAND_LIST_COL_DRAGGING,
1354
event.GetPosition());
1356
// we don't draw the line beyond our window, but we allow dragging it
1359
GetClientSize( &w, NULL );
1360
m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1363
// erase the line if it was drawn
1364
if ( m_currentX < w )
1367
if (event.ButtonUp())
1370
m_isDragging = FALSE;
1372
SetColumnWidth( m_column, m_currentX - m_minX );
1374
SendListEvent(wxEVT_COMMAND_LIST_COL_END_DRAG,
1375
event.GetPosition());
1382
m_currentX = m_minX + 7;
1384
// draw in the new location
1385
if ( m_currentX < w )
1389
else // not dragging
1392
bool hit_border = FALSE;
1394
// end of the current column
1397
// find the column where this event occurred
1398
int countCol = GetColumnCount();
1399
for (int col = 0; col < countCol; col++)
1401
if (!GetColumnShown (col)) continue;
1402
xpos += GetColumnWidth (col);
1405
if ( (abs(x-xpos) < 3) && (y < 22) )
1407
// near the column border
1414
// inside the column
1421
if (event.LeftDown() || event.RightUp())
1423
if (hit_border && event.LeftDown())
1425
m_isDragging = TRUE;
1429
SendListEvent(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG,
1430
event.GetPosition());
1432
else // click on a column
1434
SendListEvent( event.LeftDown()
1435
? wxEVT_COMMAND_LIST_COL_CLICK
1436
: wxEVT_COMMAND_LIST_COL_RIGHT_CLICK,
1437
event.GetPosition());
1440
else if (event.Moving())
1445
setCursor = m_currentCursor == wxSTANDARD_CURSOR;
1446
m_currentCursor = m_resizeCursor;
1450
setCursor = m_currentCursor != wxSTANDARD_CURSOR;
1451
m_currentCursor = wxSTANDARD_CURSOR;
1455
SetCursor(*m_currentCursor);
1460
void wxTreeListHeaderWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
1462
m_owner->SetFocus();
1465
void wxTreeListHeaderWindow::SendListEvent(wxEventType type, wxPoint pos)
1467
wxWindow *parent = GetParent();
1468
wxListEvent le( type, parent->GetId() );
1469
le.SetEventObject( parent );
1470
le.m_pointDrag = pos;
1472
// the position should be relative to the parent window, not
1473
// this one for compatibility with MSW and common sense: the
1474
// user code doesn't know anything at all about this header
1475
// window, so why should it get positions relative to it?
1476
le.m_pointDrag.y -= GetSize().y;
1478
le.m_col = m_column;
1479
parent->GetEventHandler()->ProcessEvent( le );
1482
void wxTreeListHeaderWindow::AddColumn(const wxTreeListColumnInfo& col)
1485
m_total_col_width += col.GetWidth();
1486
//m_owner->GetHeaderWindow()->Refresh();
1488
m_owner->AdjustMyScrollbars();
1489
m_owner->m_dirty = TRUE;
1493
void wxTreeListHeaderWindow::SetColumnWidth(size_t column, size_t width)
1495
if(column < GetColumnCount()) {
1496
m_total_col_width -= m_columns[column].GetWidth();
1497
m_columns[column].SetWidth(width);
1498
m_total_col_width += width;
1499
m_owner->AdjustMyScrollbars();
1500
m_owner->m_dirty = TRUE;
1507
void wxTreeListHeaderWindow::InsertColumn(size_t before,
1508
const wxTreeListColumnInfo& col)
1510
wxCHECK_RET(before < GetColumnCount(), wxT("Invalid column index"));
1511
m_columns.Insert(col, before);
1512
m_total_col_width += col.GetWidth();
1514
//m_owner->GetHeaderWindow()->Refresh();
1515
m_owner->AdjustMyScrollbars();
1516
m_owner->m_dirty = TRUE;
1520
void wxTreeListHeaderWindow::RemoveColumn(size_t column)
1522
wxCHECK_RET(column < GetColumnCount(), wxT("Invalid column"));
1523
m_total_col_width -= m_columns[column].GetWidth();
1524
m_columns.RemoveAt(column);
1526
m_owner->AdjustMyScrollbars();
1527
m_owner->m_dirty = TRUE;
1531
void wxTreeListHeaderWindow::SetColumn(size_t column,
1532
const wxTreeListColumnInfo& info)
1534
wxCHECK_RET(column < GetColumnCount(), wxT("Invalid column"));
1535
size_t w = m_columns[column].GetWidth();
1536
m_columns[column] = info;
1537
//m_owner->GetHeaderWindow()->Refresh();
1539
if(w != info.GetWidth()) {
1540
m_total_col_width += info.GetWidth() - w;
1541
m_owner->AdjustMyScrollbars();
1542
m_owner->m_dirty = TRUE;
1547
// ---------------------------------------------------------------------------
1549
// ---------------------------------------------------------------------------
1551
wxTreeListItem::wxTreeListItem(wxTreeListMainWindow *owner,
1552
wxTreeListItem *parent,
1553
const wxArrayString& text,
1554
int image, int selImage,
1555
wxTreeItemData *data)
1558
m_images[wxTreeItemIcon_Normal] = image;
1559
m_images[wxTreeItemIcon_Selected] = selImage;
1560
m_images[wxTreeItemIcon_Expanded] = NO_IMAGE;
1561
m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
1566
m_isCollapsed = TRUE;
1567
m_hasHilight = FALSE;
1575
m_attr = (wxTreeItemAttr *)NULL;
1578
// We don't know the height here yet.
1583
wxTreeListItem::~wxTreeListItem()
1587
if (m_ownsAttr) delete m_attr;
1589
wxASSERT_MSG( m_children.IsEmpty(),
1590
wxT("please call DeleteChildren() before deleting the item") );
1593
void wxTreeListItem::DeleteChildren(wxTreeListMainWindow *tree)
1595
size_t count = m_children.Count();
1596
for ( size_t n = 0; n < count; n++ )
1598
wxTreeListItem *child = m_children[n];
1600
tree->SendDeleteEvent(child);
1602
child->DeleteChildren(tree);
1609
void wxTreeListItem::SetText( const wxString &text )
1611
if(m_text.GetCount() > 0) m_text[0] = text;
1617
size_t wxTreeListItem::GetChildrenCount(bool recursively) const
1619
size_t count = m_children.Count();
1623
size_t total = count;
1624
for (size_t n = 0; n < count; ++n)
1626
total += m_children[n]->GetChildrenCount();
1632
void wxTreeListItem::GetSize( int &x, int &y,
1633
const wxTreeListMainWindow *theButton )
1635
int bottomY=m_y+theButton->GetLineHeight(this);
1636
if ( y < bottomY ) y = bottomY;
1637
int width = m_x + m_width;
1638
if ( x < width ) x = width;
1642
size_t count = m_children.Count();
1643
for ( size_t n = 0; n < count; ++n )
1645
m_children[n]->GetSize( x, y, theButton );
1650
wxTreeListItem *wxTreeListItem::HitTest(const wxPoint& point,
1651
const wxTreeListMainWindow *theCtrl,
1655
// for a hidden root node, don't evaluate it, but do evaluate children
1656
if (!(theCtrl->HasFlag(wxTR_HIDE_ROOT) && (level == 0)))
1658
// evaluate the item
1659
int h = theCtrl->GetLineHeight(this);
1660
if ((point.y > m_y) && (point.y <= m_y + h))
1662
// check for above/below middle
1663
int y_mid = m_y + h/2;
1664
if (point.y < y_mid )
1665
flags |= wxTREE_HITTEST_ONITEMUPPERPART;
1667
flags |= wxTREE_HITTEST_ONITEMLOWERPART;
1669
// check for button hit
1670
int xCross = m_x; // - theCtrl->GetLineSpacing();
1672
// according to the drawing code the triangels are drawn
1673
// at -4 , -4 from the position up to +10/+10 max
1674
if ((point.x > xCross-4) && (point.x < xCross+10) &&
1675
(point.y > y_mid-4) && (point.y < y_mid+10) &&
1676
HasPlus() && theCtrl->HasButtons() )
1678
// 5 is the size of the plus sign
1679
if ((point.x > xCross-6) && (point.x < xCross+6) &&
1680
(point.y > y_mid-6) && (point.y < y_mid+6) &&
1681
HasPlus() && theCtrl->HasButtons() )
1684
flags |= wxTREE_HITTEST_ONITEMBUTTON;
1688
// check for image hit
1689
if (theCtrl->m_imgWidth > 0 && GetImage() != NO_IMAGE) {
1690
int imgX = m_x - theCtrl->m_imgWidth2;
1691
if (HasPlus() && theCtrl->HasButtons())
1692
imgX += theCtrl->m_btnWidth + LINEATROOT;
1693
int imgY = y_mid - theCtrl->m_imgHeight2;
1694
if ((point.x >= imgX) && (point.x <= (imgX + theCtrl->m_imgWidth)) &&
1695
(point.y >= imgY) && (point.y <= (imgY + theCtrl->m_imgHeight))) {
1696
flags |= wxTREE_HITTEST_ONITEMICON;
1701
// check for label hit
1702
int lblX = m_x - theCtrl->m_imgWidth2 + theCtrl->m_imgWidth + MARGIN;
1703
if ((point.x >= lblX) && (point.x <= (m_x + m_width)) &&
1704
(point.y >= m_y) && (point.y <= (m_y + h))) {
1705
flags |= wxTREE_HITTEST_ONITEMLABEL;
1709
// else check for indent
1710
if (point.x < m_x) {
1711
flags |= wxTREE_HITTEST_ONITEMINDENT;
1715
// else check for item right???
1716
if (point.x > m_x + m_width) {
1717
flags |= wxTREE_HITTEST_ONITEMRIGHT;
1723
// if children are expanded, fall through to evaluate them
1724
if (m_isCollapsed) return (wxTreeListItem*) NULL;
1727
// evaluate children
1728
size_t count = m_children.Count();
1729
for ( size_t n = 0; n < count; n++ )
1731
wxTreeListItem *res = m_children[n]->HitTest(point, theCtrl,
1737
return (wxTreeListItem*) NULL;
1741
wxTreeListItem *wxTreeListItem::HitTest(const wxPoint& point,
1742
const wxTreeListMainWindow *theCtrl,
1743
int &flags, int& column, int level)
1745
column = theCtrl->GetMainColumn(); //-1;
1747
wxTreeListItem* res = HitTest(point, theCtrl, flags, level);
1753
wxTreeListHeaderWindow* header_win = theCtrl->m_owner->GetHeaderWindow();
1754
if (point.x >= header_win->GetWidth())
1756
else if(flags & wxTREE_HITTEST_ONITEMINDENT) {
1758
for(size_t i = 0; i < theCtrl->GetMainColumn(); ++i) {
1759
if (!header_win->GetColumnShown(i)) continue;
1760
int w = header_win->GetColumnWidth(i);
1761
if(point.x >= x && point.x < x+w) {
1762
flags ^= wxTREE_HITTEST_ONITEMINDENT;
1763
flags |= wxTREE_HITTEST_ONITEMCOLUMN;
1769
else if(flags & wxTREE_HITTEST_ONITEMRIGHT) {
1772
for(i = 0; i < theCtrl->GetMainColumn()+1; ++i) {
1773
if (!header_win->GetColumnShown(i)) continue;
1774
x += header_win->GetColumnWidth(i);
1776
for(i = theCtrl->GetMainColumn()+1; i < theCtrl->GetColumnCount(); ++i) {
1777
if (!header_win->GetColumnShown(i)) continue;
1778
int w = header_win->GetColumnWidth(i);
1779
if(point.x >= x && point.x < x+w) {
1780
flags ^= wxTREE_HITTEST_ONITEMRIGHT;
1781
flags |= wxTREE_HITTEST_ONITEMCOLUMN;
1793
int wxTreeListItem::GetCurrentImage() const
1795
int image = NO_IMAGE;
1800
image = GetImage(wxTreeItemIcon_SelectedExpanded);
1803
if ( image == NO_IMAGE )
1805
// we usually fall back to the normal item, but try just the
1806
// expanded one (and not selected) first in this case
1807
image = GetImage(wxTreeItemIcon_Expanded);
1810
else // not expanded
1813
image = GetImage(wxTreeItemIcon_Selected);
1816
// maybe it doesn't have the specific image we want,
1817
// try the default one instead
1818
if ( image == NO_IMAGE ) image = GetImage();
1823
// ---------------------------------------------------------------------------
1824
// wxTreeListMainWindow implementation
1825
// ---------------------------------------------------------------------------
1827
IMPLEMENT_DYNAMIC_CLASS(wxTreeListMainWindow, wxScrolledWindow)
1829
BEGIN_EVENT_TABLE(wxTreeListMainWindow, wxScrolledWindow)
1830
EVT_PAINT (wxTreeListMainWindow::OnPaint)
1831
EVT_MOUSE_EVENTS (wxTreeListMainWindow::OnMouse)
1832
EVT_CHAR (wxTreeListMainWindow::OnChar)
1833
EVT_SET_FOCUS (wxTreeListMainWindow::OnSetFocus)
1834
EVT_KILL_FOCUS (wxTreeListMainWindow::OnKillFocus)
1835
EVT_IDLE (wxTreeListMainWindow::OnIdle)
1836
EVT_SCROLLWIN (wxTreeListMainWindow::OnScroll)
1840
// ---------------------------------------------------------------------------
1841
// construction/destruction
1842
// ---------------------------------------------------------------------------
1844
void wxTreeListMainWindow::Init()
1846
m_current = m_key_current = m_anchor = (wxTreeListItem *) NULL;
1850
m_lineHeight = LINEHEIGHT;
1851
m_indent = MININDENT; // min. indent
1853
m_imgWidth = 0, m_imgWidth2 = 0;
1854
m_imgHeight = 0, m_imgHeight2 = 0;
1856
m_hilightBrush = new wxBrush
1858
wxSystemSettings::GetColour
1860
wxSYS_COLOUR_HIGHLIGHT
1865
m_hilightUnfocusedBrush = new wxBrush
1867
wxSystemSettings::GetColour
1869
wxSYS_COLOUR_BTNSHADOW
1874
m_imageListNormal = m_imageListButtons =
1875
m_imageListState = (wxImageList *) NULL;
1876
m_ownsImageListNormal = m_ownsImageListButtons =
1877
m_ownsImageListState = FALSE;
1880
m_isDragging = FALSE;
1881
m_dropTarget = m_oldSelection = (wxTreeListItem *)NULL;
1883
m_renameTimer = new wxTreeListRenameTimer( this );
1884
m_lastOnSame = FALSE;
1886
m_findTimer = new wxTimer (this, -1);
1888
m_underMouse = NULL;
1890
#ifdef __WXMAC_CARBON__
1891
m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
1893
m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
1895
m_boldFont = wxFont( m_normalFont.GetPointSize(),
1896
m_normalFont.GetFamily(),
1897
m_normalFont.GetStyle(),
1899
m_normalFont.GetUnderlined(),
1900
m_normalFont.GetFaceName(),
1901
m_normalFont.GetEncoding());
1905
bool wxTreeListMainWindow::Create(wxTreeListCtrl *parent,
1910
const wxValidator &validator,
1911
const wxString& name )
1914
if ( !(style & wxTR_DONT_ADJUST_MAC))
1917
wxGetOsVersion( &major, &minor );
1919
if (style & wxTR_HAS_BUTTONS) style |= wxTR_TWIST_BUTTONS;
1920
if (style & wxTR_HAS_BUTTONS) style &= ~wxTR_HAS_BUTTONS;
1921
style &= ~wxTR_LINES_AT_ROOT;
1922
style |= wxTR_NO_LINES;
1924
style |= wxTR_ROW_LINES;
1928
wxScrolledWindow::Create( parent, id, pos, size,
1929
style|wxHSCROLL|wxVSCROLL, name );
1931
#if wxUSE_VALIDATORS
1932
SetValidator( validator );
1935
SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_LISTBOX ) );
1942
bdc.SelectObject(bmp);
1943
bdc.SetPen(*wxGREY_PEN);
1944
bdc.DrawRectangle(-1, -1, 10, 10);
1945
for (i = 0; i < 8; i++) {
1946
for (j = 0; j < 8; j++) {
1947
if (!((i + j) & 1)) {
1948
bdc.DrawPoint(i, j);
1953
m_dottedPen = wxPen(bmp, 1);
1956
//m_dottedPen = wxPen( *wxGREY_PEN, 1, wxDOT ); // too slow under XFree86
1957
m_dottedPen = wxPen( wxT("grey"), 0, 0 ); // Bitmap based pen is not supported by GTK!
1967
wxTreeListMainWindow::~wxTreeListMainWindow()
1969
delete m_hilightBrush;
1970
delete m_hilightUnfocusedBrush;
1974
delete m_renameTimer;
1976
if (m_ownsImageListNormal) delete m_imageListNormal;
1977
if (m_ownsImageListState) delete m_imageListState;
1978
if (m_ownsImageListButtons) delete m_imageListButtons;
1983
//-----------------------------------------------------------------------------
1985
//-----------------------------------------------------------------------------
1987
size_t wxTreeListMainWindow::GetCount() const
1989
return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount();
1992
void wxTreeListMainWindow::SetIndent(unsigned int indent)
1998
void wxTreeListMainWindow::SetLineSpacing(unsigned int spacing)
2000
m_linespacing = spacing;
2002
CalculateLineHeight();
2005
size_t wxTreeListMainWindow::GetChildrenCount(const wxTreeItemId& item,
2008
wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
2010
return ((wxTreeListItem*) item.m_pItem)->GetChildrenCount(recursively);
2013
void wxTreeListMainWindow::SetWindowStyle(const long styles)
2015
// right now, just sets the styles. Eventually, we may
2016
// want to update the inherited styles, but right now
2017
// none of the parents has updatable styles
2018
m_windowStyle = styles;
2022
//-----------------------------------------------------------------------------
2023
// functions to work with tree items
2024
//-----------------------------------------------------------------------------
2026
int wxTreeListMainWindow::GetItemImage(const wxTreeItemId& item, size_t column,
2027
wxTreeItemIcon which) const
2029
wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
2031
return ((wxTreeListItem*) item.m_pItem)->GetImage(column, which);
2034
wxTreeItemData *wxTreeListMainWindow::GetItemData(const wxTreeItemId& item)
2037
wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
2039
return ((wxTreeListItem*) item.m_pItem)->GetData();
2042
bool wxTreeListMainWindow::GetItemBold(const wxTreeItemId& item) const
2044
wxCHECK_MSG(item.IsOk(), FALSE, wxT("invalid tree item"));
2045
return ((wxTreeListItem *)item.m_pItem)->IsBold();
2048
wxColour wxTreeListMainWindow::GetItemTextColour(const wxTreeItemId& item)
2051
wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
2053
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2054
return pItem->Attr().GetTextColour();
2057
wxColour wxTreeListMainWindow::GetItemBackgroundColour(
2058
const wxTreeItemId& item) const
2060
wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
2062
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2063
return pItem->Attr().GetBackgroundColour();
2066
wxFont wxTreeListMainWindow::GetItemFont(const wxTreeItemId& item) const
2068
wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") );
2070
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2071
return pItem->Attr().GetFont();
2076
void wxTreeListMainWindow::SetItemImage(const wxTreeItemId& item,
2078
int image, wxTreeItemIcon which)
2080
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2082
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2083
pItem->SetImage(column, image, which);
2085
wxClientDC dc(this);
2086
CalculateSize(pItem, dc);
2090
void wxTreeListMainWindow::SetItemData(const wxTreeItemId& item,
2091
wxTreeItemData *data)
2093
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2095
((wxTreeListItem*) item.m_pItem)->SetData(data);
2098
void wxTreeListMainWindow::SetItemHasChildren(const wxTreeItemId& item,
2101
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2103
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2104
pItem->SetHasPlus(has);
2108
void wxTreeListMainWindow::SetItemBold(const wxTreeItemId& item, bool bold)
2110
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2112
// avoid redrawing the tree if no real change
2113
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2114
if ( pItem->IsBold() != bold )
2116
pItem->SetBold(bold);
2121
void wxTreeListMainWindow::SetItemTextColour(const wxTreeItemId& item,
2122
const wxColour& col)
2124
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2126
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2127
pItem->Attr().SetTextColour(col);
2131
void wxTreeListMainWindow::SetItemBackgroundColour(const wxTreeItemId& item,
2132
const wxColour& col)
2134
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2136
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2137
pItem->Attr().SetBackgroundColour(col);
2141
void wxTreeListMainWindow::SetItemFont(const wxTreeItemId& item,
2144
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2146
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2147
pItem->Attr().SetFont(font);
2151
bool wxTreeListMainWindow::SetFont( const wxFont &font )
2153
wxScrolledWindow::SetFont(font);
2155
m_normalFont = font ;
2156
m_boldFont = wxFont( m_normalFont.GetPointSize(),
2157
m_normalFont.GetFamily(),
2158
m_normalFont.GetStyle(),
2160
m_normalFont.GetUnderlined());
2166
// ----------------------------------------------------------------------------
2167
// item status inquiries
2168
// ----------------------------------------------------------------------------
2170
bool wxTreeListMainWindow::IsVisible(const wxTreeItemId& item) const
2172
wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
2174
// An item is only visible if it's not a descendant of a collapsed item
2175
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2176
wxTreeListItem* parent = pItem->GetItemParent();
2179
if (!parent->IsExpanded())
2181
parent = parent->GetItemParent();
2185
GetViewStart(& startX, & startY);
2187
wxSize clientSize = GetClientSize();
2190
if (!GetBoundingRect(item, rect))
2192
if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
2194
if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
2196
if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
2202
bool wxTreeListMainWindow::ItemHasChildren(const wxTreeItemId& item) const
2204
wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
2206
// consider that the item does have children if it has the "+" button: it
2207
// might not have them (if it had never been expanded yet) but then it
2208
// could have them as well and it's better to err on this side rather than
2209
// disabling some operations which are restricted to the items with
2210
// children for an item which does have them
2211
return ((wxTreeListItem*) item.m_pItem)->HasPlus();
2214
bool wxTreeListMainWindow::IsExpanded(const wxTreeItemId& item) const
2216
wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
2218
return ((wxTreeListItem*) item.m_pItem)->IsExpanded();
2221
bool wxTreeListMainWindow::IsSelected(const wxTreeItemId& item) const
2223
wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
2225
return ((wxTreeListItem*) item.m_pItem)->IsSelected();
2228
bool wxTreeListMainWindow::IsBold(const wxTreeItemId& item) const
2230
wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
2232
return ((wxTreeListItem*) item.m_pItem)->IsBold();
2235
// ----------------------------------------------------------------------------
2237
// ----------------------------------------------------------------------------
2239
wxTreeItemId wxTreeListMainWindow::GetItemParent(const wxTreeItemId& item) const
2241
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2243
return ((wxTreeListItem*) item.m_pItem)->GetItemParent();
2246
#if !wxCHECK_VERSION(2, 5, 0)
2247
wxTreeItemId wxTreeListMainWindow::GetFirstChild(const wxTreeItemId& item,
2250
wxTreeItemId wxTreeListMainWindow::GetFirstChild(const wxTreeItemId& item,
2251
wxTreeItemIdValue& cookie) const
2254
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2257
return GetNextChild(item, cookie);
2260
#if !wxCHECK_VERSION(2, 5, 0)
2261
wxTreeItemId wxTreeListMainWindow::GetNextChild(const wxTreeItemId& item,
2264
wxTreeItemId wxTreeListMainWindow::GetNextChild(const wxTreeItemId& item,
2265
wxTreeItemIdValue& cookie) const
2268
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2270
wxArrayTreeListItems& children = ((wxTreeListItem*) item.m_pItem)->GetChildren();
2272
// it's ok to cast cookie to size_t, we never have indices big enough to
2273
// overflow "void *"
2274
size_t *pIndex = (size_t *)&cookie;
2275
if ( *pIndex < children.Count() )
2277
return children.Item((*pIndex)++);
2281
// there are no more of them
2282
return wxTreeItemId();
2286
#if !wxCHECK_VERSION(2, 5, 0)
2287
wxTreeItemId wxTreeListMainWindow::GetPrevChild(const wxTreeItemId& item,
2290
wxTreeItemId wxTreeListMainWindow::GetPrevChild(const wxTreeItemId& item,
2291
wxTreeItemIdValue& cookie) const
2294
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2296
wxArrayTreeListItems& children = ((wxTreeListItem*) item.m_pItem)->GetChildren();
2298
// it's ok to cast cookie to size_t, we never have indices big enough to
2299
// overflow "void *"
2300
size_t *pIndex = (size_t *)&cookie;
2303
return children.Item(--(*pIndex));
2307
// there are no more of them
2308
return wxTreeItemId();
2312
wxTreeItemId wxTreeListMainWindow::GetLastChild(const wxTreeItemId& item) const
2314
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2316
wxArrayTreeListItems& children = ((wxTreeListItem*) item.m_pItem)->GetChildren();
2317
return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
2320
wxTreeItemId wxTreeListMainWindow::GetNextSibling(const wxTreeItemId& item) const
2322
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2324
wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
2325
wxTreeListItem *parent = i->GetItemParent();
2326
if ( parent == NULL )
2328
// root item doesn't have any siblings
2329
return wxTreeItemId();
2332
wxArrayTreeListItems& siblings = parent->GetChildren();
2333
int index = siblings.Index(i);
2334
wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
2336
size_t n = (size_t)(index + 1);
2337
return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
2340
wxTreeItemId wxTreeListMainWindow::GetPrevSibling(const wxTreeItemId& item)
2343
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2345
wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
2346
wxTreeListItem *parent = i->GetItemParent();
2347
if ( parent == NULL )
2349
// root item doesn't have any siblings
2350
return wxTreeItemId();
2353
wxArrayTreeListItems& siblings = parent->GetChildren();
2354
int index = siblings.Index(i);
2355
wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
2357
return index == 0 ? wxTreeItemId()
2358
: wxTreeItemId(siblings[(size_t)(index - 1)]);
2361
// Only for internal use right now, but should probably be public
2362
wxTreeItemId wxTreeListMainWindow::GetNext(const wxTreeItemId& item) const
2364
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2366
wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
2368
// First see if there are any children.
2369
wxArrayTreeListItems& children = i->GetChildren();
2370
if (children.GetCount() > 0)
2372
return children.Item(0);
2376
// Try a sibling of this or ancestor instead
2377
wxTreeItemId p = item;
2378
wxTreeItemId toFind;
2381
toFind = GetNextSibling(p);
2382
p = GetItemParent(p);
2383
} while (p.IsOk() && !toFind.IsOk());
2388
wxTreeItemId wxTreeListMainWindow::GetFirstVisibleItem() const
2390
wxTreeItemId id = GetRootItem();
2399
} while (id.IsOk());
2401
return wxTreeItemId();
2404
wxTreeItemId wxTreeListMainWindow::GetNextVisible(const wxTreeItemId& item)
2407
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2409
wxTreeItemId id = item;
2412
while (id = GetNext(id), id.IsOk())
2418
return wxTreeItemId();
2421
wxTreeItemId wxTreeListMainWindow::GetPrevVisible(const wxTreeItemId& item)
2424
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
2426
wxFAIL_MSG(wxT("not implemented"));
2428
return wxTreeItemId();
2431
// ----------------------------------------------------------------------------
2433
// ----------------------------------------------------------------------------
2435
wxTreeItemId wxTreeListMainWindow::DoInsertItem(const wxTreeItemId& parentId,
2437
const wxString& text,
2438
int image, int selImage,
2439
wxTreeItemData *data)
2441
wxTreeListItem *parent = (wxTreeListItem*) parentId.m_pItem;
2444
// should we give a warning here?
2445
return AddRoot(text, image, selImage, data);
2448
m_dirty = TRUE; // do this first so stuff below doesn't cause flicker
2452
arr.Alloc(GetColumnCount());
2453
for(size_t i = 0; i < GetColumnCount(); ++i) {
2454
arr.Add(wxEmptyString);
2456
arr[m_main_column] = text;
2457
wxTreeListItem *item =
2458
new wxTreeListItem( this, parent, arr, image, selImage, data );
2462
data->SetId((void*)item);
2465
parent->Insert( item, previous );
2470
wxTreeItemId wxTreeListMainWindow::AddRoot(const wxString& text,
2471
int image, int selImage,
2472
wxTreeItemData *data)
2474
wxCHECK_MSG(!m_anchor, wxTreeItemId(), wxT("tree can have only one root"));
2475
wxCHECK_MSG(GetColumnCount(), wxTreeItemId(), wxT("Add column(s) before adding the root item"));
2477
m_dirty = TRUE; // do this first so stuff below doesn't cause flicker
2481
arr.Alloc(GetColumnCount());
2482
for(size_t i = 0; i < GetColumnCount(); ++i) {
2483
arr.Add(wxEmptyString);
2485
arr[m_main_column] = text;
2486
m_anchor = new wxTreeListItem( this, (wxTreeListItem *)NULL, arr,
2487
image, selImage, data);
2489
if (HasFlag(wxTR_HIDE_ROOT))
2491
// if root is hidden, make sure we can navigate
2493
m_anchor->SetHasPlus();
2499
data->SetId((void*)m_anchor);
2502
if (!HasFlag(wxTR_MULTIPLE))
2504
m_current = m_key_current = m_anchor;
2505
m_current->SetHilight( TRUE );
2511
wxTreeItemId wxTreeListMainWindow::PrependItem(const wxTreeItemId& parent,
2512
const wxString& text,
2513
int image, int selImage,
2514
wxTreeItemData *data)
2516
return DoInsertItem(parent, 0u, text, image, selImage, data);
2519
wxTreeItemId wxTreeListMainWindow::InsertItem(const wxTreeItemId& parentId,
2520
const wxTreeItemId& idPrevious,
2521
const wxString& text,
2522
int image, int selImage,
2523
wxTreeItemData *data)
2525
wxTreeListItem *parent = (wxTreeListItem*) parentId.m_pItem;
2528
// should we give a warning here?
2529
return AddRoot(text, image, selImage, data);
2532
int index = parent->GetChildren().Index((wxTreeListItem*) idPrevious.m_pItem);
2533
wxASSERT_MSG( index != wxNOT_FOUND,
2534
wxT("previous item in wxTreeListMainWindow::InsertItem() is not a sibling") );
2536
return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
2539
wxTreeItemId wxTreeListMainWindow::InsertItem(const wxTreeItemId& parentId,
2541
const wxString& text,
2542
int image, int selImage,
2543
wxTreeItemData *data)
2545
wxTreeListItem *parent = (wxTreeListItem*) parentId.m_pItem;
2548
// should we give a warning here?
2549
return AddRoot(text, image, selImage, data);
2552
return DoInsertItem(parentId, before, text, image, selImage, data);
2555
wxTreeItemId wxTreeListMainWindow::AppendItem(const wxTreeItemId& parentId,
2556
const wxString& text,
2557
int image, int selImage,
2558
wxTreeItemData *data)
2560
wxTreeListItem *parent = (wxTreeListItem*) parentId.m_pItem;
2563
// should we give a warning here?
2564
return AddRoot(text, image, selImage, data);
2567
return DoInsertItem( parent, parent->GetChildren().Count(), text,
2568
image, selImage, data);
2571
void wxTreeListMainWindow::SendDeleteEvent(wxTreeListItem *item)
2573
wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, m_owner->GetId() );
2574
event.SetItem((void*)item);
2575
event.SetEventObject( /*this*/m_owner );
2576
m_owner->ProcessEvent( event );
2579
void wxTreeListMainWindow::DeleteChildren(const wxTreeItemId& itemId)
2581
m_dirty = TRUE; // do this first so stuff below doesn't cause flicker
2583
wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2584
item->DeleteChildren(this);
2587
void wxTreeListMainWindow::Delete(const wxTreeItemId& itemId)
2589
m_dirty = TRUE; // do this first so stuff below doesn't cause flicker
2591
wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2593
// don't stay with invalid m_key_current or we will crash in
2594
// the next call to OnChar()
2595
bool changeKeyCurrent = FALSE;
2596
wxTreeListItem *itemKey = m_key_current;
2599
if ( itemKey == item )
2601
// m_key_current is a descendant of the item being deleted
2602
changeKeyCurrent = TRUE;
2605
itemKey = itemKey->GetItemParent();
2608
wxTreeListItem *parent = item->GetItemParent();
2611
parent->GetChildren().Remove( item ); // remove by value
2614
if ( changeKeyCurrent )
2616
// may be NULL or not
2617
m_key_current = parent;
2620
item->DeleteChildren(this);
2621
SendDeleteEvent(item);
2625
void wxTreeListMainWindow::DeleteAllItems()
2631
m_anchor->DeleteChildren(this);
2638
void wxTreeListMainWindow::Expand(const wxTreeItemId& itemId)
2640
wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2642
wxCHECK_RET( item, _T("invalid item in wxTreeListMainWindow::Expand") );
2644
if ( !item->HasPlus() )
2647
if ( item->IsExpanded() )
2650
wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, m_owner->GetId() );
2651
event.SetItem( (void*)item );
2652
event.SetEventObject( /*this*/m_owner );
2654
if ( m_owner->ProcessEvent( event ) && !event.IsAllowed() )
2656
// cancelled by program
2661
CalculatePositions();
2663
RefreshSubtree(item);
2665
event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
2666
ProcessEvent( event );
2669
void wxTreeListMainWindow::ExpandAll(const wxTreeItemId& item)
2672
if ( IsExpanded(item) )
2674
#if !wxCHECK_VERSION(2, 5, 0)
2677
wxTreeItemIdValue cookie;
2679
wxTreeItemId child = GetFirstChild(item, cookie);
2680
while ( child.IsOk() )
2684
child = GetNextChild(item, cookie);
2689
void wxTreeListMainWindow::Collapse(const wxTreeItemId& itemId)
2691
wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2693
if ( !item->IsExpanded() )
2696
wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, m_owner->GetId() );
2697
event.SetItem( (void*)item );
2698
event.SetEventObject( /*this*/m_owner );
2699
if ( m_owner->ProcessEvent( event ) && !event.IsAllowed() )
2701
// cancelled by program
2707
#if 0 // TODO why should items be collapsed recursively?
2708
wxArrayTreeListItems& children = item->GetChildren();
2709
size_t count = children.Count();
2710
for ( size_t n = 0; n < count; n++ )
2712
Collapse(children[n]);
2716
CalculatePositions();
2718
RefreshSubtree(item);
2720
event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
2721
ProcessEvent( event );
2724
void wxTreeListMainWindow::CollapseAndReset(const wxTreeItemId& item)
2727
DeleteChildren(item);
2730
void wxTreeListMainWindow::Toggle(const wxTreeItemId& itemId)
2732
wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2734
if (item->IsExpanded())
2740
void wxTreeListMainWindow::Unselect()
2744
m_current->SetHilight( FALSE );
2745
RefreshLine( m_current );
2749
void wxTreeListMainWindow::UnselectAllChildren(wxTreeListItem *item)
2751
if (item->IsSelected())
2753
item->SetHilight(FALSE);
2757
if (item->HasChildren())
2759
wxArrayTreeListItems& children = item->GetChildren();
2760
size_t count = children.Count();
2761
for ( size_t n = 0; n < count; ++n )
2763
UnselectAllChildren(children[n]);
2768
void wxTreeListMainWindow::UnselectAll()
2770
UnselectAllChildren((wxTreeListItem*)GetRootItem().m_pItem);
2773
// Recursive function !
2774
// To stop we must have crt_item<last_item
2776
// Tag all next children, when no more children,
2777
// Move to parent (not to tag)
2778
// Keep going... if we found last_item, we stop.
2779
bool wxTreeListMainWindow::TagNextChildren(wxTreeListItem *crt_item, wxTreeListItem *last_item, bool select)
2781
wxTreeListItem *parent = crt_item->GetItemParent();
2783
if (parent == NULL) // This is root item
2784
return TagAllChildrenUntilLast(crt_item, last_item, select);
2786
wxArrayTreeListItems& children = parent->GetChildren();
2787
int index = children.Index(crt_item);
2788
wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
2790
size_t count = children.Count();
2791
for (size_t n=(size_t)(index+1); n<count; ++n)
2793
if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
2796
return TagNextChildren(parent, last_item, select);
2799
bool wxTreeListMainWindow::TagAllChildrenUntilLast(wxTreeListItem *crt_item, wxTreeListItem *last_item, bool select)
2801
crt_item->SetHilight(select);
2802
RefreshLine(crt_item);
2804
if (crt_item==last_item)
2807
if (crt_item->HasChildren())
2809
wxArrayTreeListItems& children = crt_item->GetChildren();
2810
size_t count = children.Count();
2811
for ( size_t n = 0; n < count; ++n )
2813
if (TagAllChildrenUntilLast(children[n], last_item, select))
2821
void wxTreeListMainWindow::SelectItemRange(wxTreeListItem *item1, wxTreeListItem *item2)
2823
// item2 is not necessary after item1
2824
wxTreeListItem *first=NULL, *last=NULL;
2826
// choice first' and 'last' between item1 and item2
2827
if (item1->GetY()<item2->GetY())
2838
bool select = m_current->IsSelected();
2840
if ( TagAllChildrenUntilLast(first,last,select) )
2843
TagNextChildren(first,last,select);
2846
void wxTreeListMainWindow::SelectItem(const wxTreeItemId& itemId,
2847
bool unselect_others,
2848
bool extended_select)
2850
wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
2852
bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
2853
wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2855
//wxCHECK_RET( ( (!unselect_others) && is_single),
2856
// wxT("this is a single selection tree") );
2858
// to keep going anyhow !!!
2861
if (item->IsSelected())
2862
return; // nothing to do
2863
unselect_others = TRUE;
2864
extended_select = FALSE;
2866
else if ( unselect_others && item->IsSelected() )
2868
// selection change if there is more than one item currently selected
2869
wxArrayTreeItemIds selected_items;
2870
if ( GetSelections(selected_items) == 1 )
2874
wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, m_owner->GetId() );
2875
event.SetItem( (void*)item );
2876
event.SetOldItem( (void*)m_current );
2877
event.SetEventObject( /*this*/m_owner );
2878
// TODO : Here we don't send any selection mode yet !
2880
if(m_owner->GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed())
2883
wxTreeItemId parent = GetItemParent( itemId );
2884
while (parent.IsOk())
2886
if (!IsExpanded(parent))
2889
parent = GetItemParent( parent );
2892
EnsureVisible( itemId );
2895
if (unselect_others)
2897
if (is_single) Unselect(); // to speed up thing
2902
if (extended_select)
2906
m_current = m_key_current = (wxTreeListItem*)GetRootItem().m_pItem;
2909
// don't change the mark (m_current)
2910
SelectItemRange(m_current, item);
2914
bool select=TRUE; // the default
2916
// Check if we need to toggle hilight (ctrl mode)
2917
if (!unselect_others)
2918
select=!item->IsSelected();
2920
m_current = m_key_current = item;
2921
m_current->SetHilight(select);
2922
RefreshLine( m_current );
2925
event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
2926
GetEventHandler()->ProcessEvent( event );
2929
void wxTreeListMainWindow::SelectAll(bool extended_select)
2931
wxCHECK_RET( GetWindowStyleFlag() & wxTR_MULTIPLE, wxT("invalid tree style") );
2933
wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, m_owner->GetId() );
2934
event.SetItem( GetRootItem() );
2935
event.SetOldItem( (void*) m_current );
2936
event.SetEventObject( /*this*/m_owner );
2937
// TODO : Here we don't send any selection mode yet !
2939
if(m_owner->GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed())
2943
if (!extended_select)
2951
#if !wxCHECK_VERSION(2, 5, 0)
2954
wxTreeItemIdValue cookie = 0;
2956
wxTreeItemId root = GetRootItem();
2957
wxTreeListItem *first = (wxTreeListItem *)GetFirstChild (root, cookie).m_pItem;
2958
wxTreeListItem *last = (wxTreeListItem *)GetLastChild (GetRootItem()).m_pItem;
2959
if (TagAllChildrenUntilLast (first, last, true)) return;
2960
TagNextChildren (first, last, true);
2962
event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
2963
GetEventHandler()->ProcessEvent( event );
2966
void wxTreeListMainWindow::FillArray(wxTreeListItem *item,
2967
wxArrayTreeItemIds &array) const
2969
if ( item->IsSelected() )
2970
array.Add(wxTreeItemId(item));
2972
if ( item->HasChildren() )
2974
wxArrayTreeListItems& children = item->GetChildren();
2975
size_t count = children.GetCount();
2976
for ( size_t n = 0; n < count; ++n )
2977
FillArray(children[n], array);
2981
size_t wxTreeListMainWindow::GetSelections(wxArrayTreeItemIds &array) const
2984
wxTreeItemId idRoot = GetRootItem();
2985
if ( idRoot.IsOk() )
2987
FillArray((wxTreeListItem*) idRoot.m_pItem, array);
2989
//else: the tree is empty, so no selections
2991
return array.Count();
2994
void wxTreeListMainWindow::EnsureVisible(const wxTreeItemId& item)
2996
if (!item.IsOk()) return;
2998
wxTreeListItem *gitem = (wxTreeListItem*) item.m_pItem;
3000
// first expand all parent branches
3001
wxTreeListItem *parent = gitem->GetItemParent();
3005
parent = parent->GetItemParent();
3008
//if (parent) CalculatePositions();
3013
void wxTreeListMainWindow::ScrollTo(const wxTreeItemId &item)
3015
if (!item.IsOk()) return;
3017
// We have to call this here because the label in
3018
// question might just have been added and no screen
3019
// update taken place.
3020
if (m_dirty) wxYieldIfNeeded();
3022
wxTreeListItem *gitem = (wxTreeListItem*) item.m_pItem;
3024
// now scroll to the item
3025
int item_y = gitem->GetY();
3029
GetViewStart( &start_x, &start_y );
3030
start_y *= PIXELS_PER_UNIT;
3034
GetClientSize( &client_w, &client_h );
3036
if (item_y < start_y+3)
3041
m_anchor->GetSize( x, y, this );
3042
x = m_owner->GetHeaderWindow()->GetWidth(); //m_total_col_width; // ALB
3043
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
3044
//x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
3045
int x_pos = GetScrollPos( wxHORIZONTAL );
3046
// Item should appear at top
3047
SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
3049
else if (item_y+GetLineHeight(gitem) > start_y+client_h)
3054
m_anchor->GetSize( x, y, this );
3055
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
3056
//x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
3057
x = m_owner->GetHeaderWindow()->GetWidth(); //m_total_col_width; // ALB
3058
item_y += PIXELS_PER_UNIT+2;
3059
int x_pos = GetScrollPos( wxHORIZONTAL );
3060
// Item should appear at bottom
3061
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 );
3065
// FIXME: tree sorting functions are not reentrant and not MT-safe!
3066
static wxTreeListMainWindow *s_treeBeingSorted = NULL;
3068
static int LINKAGEMODE tree_ctrl_compare_func(wxTreeListItem **item1,
3069
wxTreeListItem **item2)
3071
wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxTreeListMainWindow::SortChildren()") );
3073
return s_treeBeingSorted->OnCompareItems(*item1, *item2);
3076
int wxTreeListMainWindow::OnCompareItems(const wxTreeItemId& item1,
3077
const wxTreeItemId& item2)
3079
// ALB: delegate to m_owner, to let the user overrride the comparison
3080
//return wxStrcmp(GetItemText(item1), GetItemText(item2));
3081
return m_owner->OnCompareItems(item1, item2);
3084
void wxTreeListMainWindow::SortChildren(const wxTreeItemId& itemId)
3086
wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
3088
wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
3090
wxCHECK_RET( !s_treeBeingSorted,
3091
wxT("wxTreeListMainWindow::SortChildren is not reentrant") );
3093
wxArrayTreeListItems& children = item->GetChildren();
3094
if ( children.Count() > 1 )
3098
s_treeBeingSorted = this;
3099
children.Sort(tree_ctrl_compare_func);
3100
s_treeBeingSorted = NULL;
3102
//else: don't make the tree dirty as nothing changed
3105
wxTreeItemId wxTreeListMainWindow::FindItem (const wxTreeItemId& item, const wxString& str, int flags) {
3106
#if !wxCHECK_VERSION(2, 5, 0)
3109
wxTreeItemIdValue cookie = 0;
3111
wxTreeItemId next = item;
3112
if (!next.IsOk()) next = GetSelection();
3114
if (HasFlag(wxTR_HIDE_ROOT)) {
3115
next = (wxTreeListItem*)GetFirstChild (GetRootItem().m_pItem, cookie).m_pItem;
3117
next = (wxTreeListItem*)GetRootItem().m_pItem;
3120
if (!next.IsOk()) return item;
3122
// start checking the next items
3124
while (next.IsOk()) {
3125
itemText = GetItemText (next);
3126
if (flags & wxTL_SEARCH_LEVEL) {
3127
next = GetNextSibling (next);
3128
}else if (flags & wxTL_SEARCH_FULL) {
3129
wxTreeItemId n = GetFirstChild (next, cookie);
3131
n = GetNextSibling (next);
3133
n = GetNextSibling (GetItemParent (next));
3135
}else{ // wxTL_SEARCH_VISIBLE
3136
next = GetNextVisible (next);
3138
if (!next.IsOk()) break; // done
3139
if (flags & wxTL_SEARCH_PARTIAL) {
3140
itemText = GetItemText (next).Mid (0, str.Length());
3142
itemText = GetItemText (next);
3144
if (flags & wxTL_SEARCH_NOCASE) {
3145
if (itemText.CmpNoCase (str) == 0) return next;
3147
if (itemText.Cmp (str) == 0) return next;
3153
wxImageList *wxTreeListMainWindow::GetImageList() const
3155
return m_imageListNormal;
3158
wxImageList *wxTreeListMainWindow::GetButtonsImageList() const
3160
return m_imageListButtons;
3163
wxImageList *wxTreeListMainWindow::GetStateImageList() const
3165
return m_imageListState;
3168
void wxTreeListMainWindow::CalculateLineHeight()
3170
wxClientDC dc(this);
3171
dc.SetFont( m_normalFont );
3172
m_lineHeight = (int)(dc.GetCharHeight() + m_linespacing);
3174
if ( m_imageListNormal )
3176
// Calculate a m_lineHeight value from the normal Image sizes.
3177
// May be toggle off. Then wxTreeListMainWindow will spread when
3178
// necessary (which might look ugly).
3179
int n = m_imageListNormal->GetImageCount();
3180
for (int i = 0; i < n ; i++)
3182
int width = 0, height = 0;
3183
m_imageListNormal->GetSize(i, width, height);
3184
if (height > m_lineHeight) m_lineHeight = height + m_linespacing;
3188
if (m_imageListButtons)
3190
// Calculate a m_lineHeight value from the Button image sizes.
3191
// May be toggle off. Then wxTreeListMainWindow will spread when
3192
// necessary (which might look ugly).
3193
int n = m_imageListButtons->GetImageCount();
3194
for (int i = 0; i < n ; i++)
3196
int width = 0, height = 0;
3197
m_imageListButtons->GetSize(i, width, height);
3198
if (height > m_lineHeight) m_lineHeight = height + m_linespacing;
3202
/*? FIXME: Don't get what this code is for... Adding a line space is already done!!!
3203
if (m_lineHeight < 30)
3204
m_lineHeight += 2; // at least 2 pixels
3206
m_lineHeight += m_lineHeight/10; // otherwise 10% extra spacing
3210
void wxTreeListMainWindow::SetImageList(wxImageList *imageList)
3212
if (m_ownsImageListNormal) delete m_imageListNormal;
3213
m_imageListNormal = imageList;
3214
m_ownsImageListNormal = FALSE;
3216
CalculateLineHeight();
3219
void wxTreeListMainWindow::SetStateImageList(wxImageList *imageList)
3221
if (m_ownsImageListState) delete m_imageListState;
3222
m_imageListState = imageList;
3223
m_ownsImageListState = FALSE;
3226
void wxTreeListMainWindow::SetButtonsImageList(wxImageList *imageList)
3228
if (m_ownsImageListButtons) delete m_imageListButtons;
3229
m_imageListButtons = imageList;
3230
m_ownsImageListButtons = FALSE;
3232
CalculateLineHeight();
3235
void wxTreeListMainWindow::AssignImageList(wxImageList *imageList)
3237
SetImageList(imageList);
3238
m_ownsImageListNormal = TRUE;
3241
void wxTreeListMainWindow::AssignStateImageList(wxImageList *imageList)
3243
SetStateImageList(imageList);
3244
m_ownsImageListState = TRUE;
3247
void wxTreeListMainWindow::AssignButtonsImageList(wxImageList *imageList)
3249
SetButtonsImageList(imageList);
3250
m_ownsImageListButtons = TRUE;
3253
// ----------------------------------------------------------------------------
3255
// ----------------------------------------------------------------------------
3257
void wxTreeListMainWindow::AdjustMyScrollbars()
3262
m_anchor->GetSize( x, y, this );
3263
y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
3264
//x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
3265
int x_pos = GetScrollPos( wxHORIZONTAL );
3266
int y_pos = GetScrollPos( wxVERTICAL );
3267
x = m_owner->GetHeaderWindow()->GetWidth() + 2;
3268
if(x < GetClientSize().GetWidth()) x_pos = 0;
3269
//m_total_col_width + 2; // ALB
3270
SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT,
3271
y/PIXELS_PER_UNIT, x_pos, y_pos );
3275
SetScrollbars( 0, 0, 0, 0 );
3279
int wxTreeListMainWindow::GetLineHeight(wxTreeListItem *item) const
3281
if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
3282
return item->GetHeight();
3284
return m_lineHeight;
3287
void wxTreeListMainWindow::PaintItem(wxTreeListItem *item, wxDC& dc)
3289
wxTreeItemAttr *attr = item->GetAttributes();
3290
if (attr && attr->HasFont()) {
3291
dc.SetFont(attr->GetFont());
3292
}else if (item->IsBold()) {
3293
dc.SetFont(m_boldFont);
3296
if (attr && attr->HasTextColour()) {
3297
colText = attr->GetTextColour();
3299
colText = GetForegroundColour();
3302
dc.SetPen(*wxTRANSPARENT_PEN);
3304
long text_w = 0, text_h = 0;
3306
dc.GetTextExtent( item->GetText(GetMainColumn()), &text_w, &text_h );
3308
int total_h = GetLineHeight(item);
3310
if (item->IsSelected() && HasFlag(wxTR_FULL_ROW_HIGHLIGHT)) {
3311
dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
3312
dc.SetPen(*wxBLACK_PEN);
3313
colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
3316
if (attr && attr->HasBackgroundColour()) {
3317
colBg = attr->GetBackgroundColour();
3319
colBg = GetBackgroundColour();
3321
dc.SetBrush(wxBrush(colBg, wxSOLID));
3324
int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
3325
dc.DrawRectangle(0, item->GetY() + offset,
3326
m_owner->GetHeaderWindow()->GetWidth(), total_h-offset);
3328
dc.SetBackgroundMode(wxTRANSPARENT);
3329
int text_extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
3330
int img_extraH = (total_h > m_imgHeight)? (total_h-m_imgHeight)/2: 0;
3332
for ( size_t i = 0; i < GetColumnCount(); ++i ) {
3333
if (!m_owner->GetHeaderWindow()->GetColumnShown(i)) continue;
3334
int colwidth = m_owner->GetHeaderWindow()->GetColumnWidth(i);
3338
if (i == GetMainColumn()) {
3339
image = item->GetCurrentImage();
3340
if (item->HasPlus()) {
3341
image_x = item->GetX() + (m_btnWidth-m_btnWidth2) + LINEATROOT;
3343
image_x = item->GetX() - m_imgWidth2;
3348
image = item->GetImage(i);
3349
image_x = x_colstart + MARGIN;
3351
if (image != NO_IMAGE) image_w = m_imgWidth + MARGIN;
3353
// honor text alignment
3354
wxString text = item->GetText(i);
3355
switch ( m_owner->GetHeaderWindow()->GetColumn(i).GetAlignment() ) {
3356
case wxTL_ALIGN_LEFT:
3357
// already left aligned
3359
case wxTL_ALIGN_RIGHT:
3360
dc.GetTextExtent(text, &text_w, NULL);
3361
image_x = x_colstart + colwidth - (image_w + text_w + MARGIN);
3363
case wxTL_ALIGN_CENTER:
3364
dc.GetTextExtent(text, &text_w, NULL);
3365
int w = colwidth - image_w - text_w;
3366
image_x = x_colstart + (w > 0)? w: 0;
3369
int text_x = image_x + image_w;
3371
if (item->IsSelected() && (i==GetMainColumn()) && !HasFlag(wxTR_FULL_ROW_HIGHLIGHT))
3373
dc.SetPen(*wxBLACK_PEN);
3374
dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
3375
int offset = HasFlag (wxTR_ROW_LINES) ? 1 : 0;
3376
int width = wxMin(text_w+2, colwidth - text_x - x_colstart);
3377
dc.DrawRectangle(text_x-1, item->GetY() + offset, width, total_h-offset);
3378
dc.SetBackgroundMode(wxTRANSPARENT);
3379
dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
3381
dc.SetTextForeground(colText);
3384
wxDCClipper clipper (dc, x_colstart, item->GetY(), colwidth, total_h);
3385
if (image != NO_IMAGE)
3387
int image_y = item->GetY() + img_extraH;
3388
m_imageListNormal->Draw ( image, dc, image_x, image_y,
3389
wxIMAGELIST_DRAW_TRANSPARENT );
3391
int text_y = item->GetY() + text_extraH;
3392
dc.DrawText ( text, (wxCoord)text_x, (wxCoord)text_y );
3394
x_colstart += colwidth;
3397
// restore normal font
3398
dc.SetFont( m_normalFont );
3401
// Now y stands for the top of the item, whereas it used to stand for middle !
3402
void wxTreeListMainWindow::PaintLevel (wxTreeListItem *item, wxDC &dc,
3403
int level, int &y, int x_colstart )
3405
// Handle hide root (only level 0)
3406
if (HasFlag(wxTR_HIDE_ROOT) && (level == 0)) {
3407
// always expand hidden root
3408
wxArrayTreeListItems& children = item->GetChildren();
3410
for (n = 0; n < (int)children.Count(); n++) {
3411
PaintLevel (children[n], dc, 1, y, x_colstart);
3413
// end after expanding root
3417
// calculate position of vertical lines
3418
int x = x_colstart + MARGIN; // start of column
3419
if (HasFlag (wxTR_LINES_AT_ROOT)) x += LINEATROOT; // space for lines at root
3421
x += m_btnWidth2; // middle of button
3423
if (m_imgWidth > 0) x += m_imgWidth2; // middle of image
3425
if (!HasFlag (wxTR_HIDE_ROOT)) {
3426
x += m_indent * level; // indent according to level
3428
if (level > 0) x += m_indent * (level-1); // but not level 1
3431
// handle column text
3435
int h = GetLineHeight(item);
3437
int y_mid = y_top + (h/2);
3440
int exposed_x = dc.LogicalToDeviceX(0);
3441
int exposed_y = dc.LogicalToDeviceY(y_top);
3443
if (IsExposed(exposed_x, exposed_y, 10000, h)) // 10000 = very much
3446
PaintItem(item, dc);
3448
if (HasFlag(wxTR_ROW_LINES))
3450
//dc.DestroyClippingRegion();
3451
int total_width = m_owner->GetHeaderWindow()->GetWidth();
3452
// if the background colour is white, choose a
3453
// contrasting color for the lines
3454
dc.SetPen(((GetBackgroundColour() == *wxWHITE) ?
3455
wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT) : *wxWHITE_PEN));
3456
dc.DrawLine(0, y_top, total_width, y_top);
3457
dc.DrawLine(0, y, total_width, y);
3460
// restore DC objects
3461
dc.SetBrush(*wxWHITE_BRUSH);
3462
dc.SetPen(m_dottedPen);
3464
if (((level == 0) || ((level == 1) && HasFlag(wxTR_HIDE_ROOT))) &&
3465
HasFlag(wxTR_LINES_AT_ROOT) && !HasFlag(wxTR_NO_LINES)) {
3466
int rootPos = x_colstart + MARGIN;
3467
dc.DrawLine (rootPos, y_mid, rootPos+LINEATROOT, y_mid);
3470
size_t clip_width = m_owner->GetHeaderWindow()->
3471
GetColumn(m_main_column).GetWidth();
3473
if (item->HasPlus() && HasButtons()) // should the item show a button?
3475
// clip to the column width
3476
wxDCClipper clipper(dc, x_colstart, y_top, clip_width, 10000);
3478
if ( !HasFlag(wxTR_NO_LINES) )
3480
// draw the horizontal line here
3482
if (x > (signed)m_indent)
3483
x_start -= m_indent;
3484
else if (HasFlag(wxTR_LINES_AT_ROOT))
3486
dc.DrawLine(x_start, y_mid, x /*+ m_spacing*/, y_mid);
3489
if (m_imageListButtons != NULL)
3491
// draw the image button here
3492
int image = wxTreeItemIcon_Normal;
3493
if (item->IsExpanded()) image = wxTreeItemIcon_Expanded;
3494
if (item->IsSelected())
3495
image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
3496
int xx = x + m_btnWidth2;
3497
int yy = y_mid - m_btnHeight2;
3498
dc.SetClippingRegion(xx, yy, m_btnWidth, m_btnHeight);
3499
m_imageListButtons->Draw(image, dc, xx, yy,
3500
wxIMAGELIST_DRAW_TRANSPARENT);
3501
dc.DestroyClippingRegion();
3503
else // no custom buttons
3505
static const int wImage = 9;
3506
static const int hImage = 9;
3509
if (item->IsExpanded())
3510
flag |= wxCONTROL_EXPANDED;
3511
if (item == m_underMouse)
3512
flag |= wxCONTROL_CURRENT;
3514
wxRendererNative::Get().DrawTreeItemButton(
3516
wxRect(x - wImage/2, y_mid - hImage/2, wImage, hImage),
3520
if (!HasFlag(wxTR_NO_LINES)) {
3521
if (/*!(level == 0) &&*/ !((level == 1) && HasFlag(wxTR_HIDE_ROOT))) {
3522
if (m_imgWidth > 0) {
3523
dc.DrawLine(x+m_btnWidth2, y_mid, x+m_indent-m_imgWidth2, y_mid);
3525
dc.DrawLine(x+m_btnWidth2, y_mid, x+m_btnWidth2+LINEATROOT-MARGIN, y_mid);
3530
else if (!HasFlag(wxTR_NO_LINES)) // no button; maybe a line?
3532
// clip to the column width
3533
wxDCClipper clipper(dc, x_colstart, y_top, clip_width, 10000);
3535
// draw the horizontal line here
3536
if (/*!(level == 0) &&*/ !((level == 1) && HasFlag(wxTR_HIDE_ROOT))) {
3537
int x2 = x - m_indent;
3538
if (m_imgWidth > 0) {
3539
dc.DrawLine(x2, y_mid, x2+m_indent-m_imgWidth2, y_mid);
3541
dc.DrawLine(x2, y_mid, x2+m_btnWidth2+LINEATROOT+MARGIN, y_mid);
3547
// restore DC objects
3548
dc.SetBrush(*wxWHITE_BRUSH);
3549
dc.SetPen(m_dottedPen);
3550
dc.SetTextForeground(*wxBLACK);
3552
if (item->IsExpanded())
3554
wxArrayTreeListItems& children = item->GetChildren();
3555
int count = children.Count();
3558
// paint sublevel items first
3559
for (n=0; n<count; ++n) {
3561
PaintLevel(children[n], dc, level+1, y, x_colstart);
3564
// then draw the connecting lines
3565
if (!HasFlag(wxTR_NO_LINES) && count > 0)
3567
// clip to the column width
3568
size_t clip_width = m_owner->GetHeaderWindow()->GetColumn(m_main_column).GetWidth();
3569
wxDCClipper clipper(dc, x_colstart, y_top, clip_width, 10000);
3571
// draw line down to last child
3572
oldY += GetLineHeight(children[n-1]) >> 1;
3573
if (HasButtons()) y_mid += 5;
3574
dc.DrawLine(x, y_mid, x, oldY);
3579
void wxTreeListMainWindow::DrawDropEffect(wxTreeListItem *item)
3583
if ( item->HasPlus() )
3585
// it's a folder, indicate it by a border
3590
// draw a line under the drop target because the item will be
3592
DrawLine(item, TRUE /* below */);
3595
SetCursor(wxCURSOR_BULLSEYE);
3600
SetCursor(wxCURSOR_NO_ENTRY);
3604
void wxTreeListMainWindow::DrawBorder(const wxTreeItemId &item)
3606
wxCHECK_RET( item.IsOk(), _T("invalid item in wxTreeListMainWindow::DrawLine") );
3608
wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
3610
wxClientDC dc(this);
3612
dc.SetLogicalFunction(wxINVERT);
3613
dc.SetBrush(*wxTRANSPARENT_BRUSH);
3615
int w = i->GetWidth() + 2;
3616
int h = GetLineHeight(i) + 2;
3618
dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
3621
void wxTreeListMainWindow::DrawLine(const wxTreeItemId &item, bool below)
3623
wxCHECK_RET( item.IsOk(), _T("invalid item in wxTreeListMainWindow::DrawLine") );
3625
wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
3627
wxClientDC dc(this);
3629
dc.SetLogicalFunction(wxINVERT);
3635
y += GetLineHeight(i) - 1;
3638
dc.DrawLine( x, y, x + i->GetWidth(), y);
3641
// ----------------------------------------------------------------------------
3642
// wxWindows callbacks
3643
// ----------------------------------------------------------------------------
3645
void wxTreeListMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
3651
if(!GetColumnCount()) return; // ALB
3656
// calculate button size
3657
m_btnWidth = 0, m_btnWidth2 = 0;
3658
m_btnHeight = 0, m_btnHeight2 = 0;
3659
if (m_imageListButtons) {
3660
m_imageListButtons->GetSize (0, m_btnWidth, m_btnHeight);
3661
}else if (HasButtons()) {
3662
m_btnWidth = BTNWIDTH;
3663
m_btnHeight = BTNHEIGHT;
3665
m_btnWidth2 = m_btnWidth/2;
3666
m_btnHeight2 = m_btnHeight/2;
3668
// calculate image size
3669
m_imgWidth = 0, m_imgWidth2 = 0;
3670
m_imgHeight = 0, m_imgHeight2 = 0;
3671
if (m_imageListNormal) {
3672
m_imageListNormal->GetSize (0, m_imgWidth, m_imgHeight);
3673
m_imgWidth += 4; //? ToDo: Why + 4?
3675
m_imgWidth2 = m_imgWidth/2;
3676
m_imgHeight2 = m_imgHeight/2;
3678
// calculate indent size
3679
int btnIndent = HasButtons()? m_btnWidth + LINEATROOT: 0;
3680
m_indent = wxMax (MININDENT, wxMax (m_imgWidth, btnIndent)) + MARGIN;
3682
// set default values
3683
dc.SetFont( m_normalFont );
3684
dc.SetPen( m_dottedPen );
3686
// this is now done dynamically
3687
//if(GetImageList() == NULL)
3688
// m_lineHeight = (int)(dc.GetCharHeight() + 4);
3690
// calculate column start and paint
3693
for (i = 0; i < (int)GetMainColumn(); ++i) {
3694
if (!m_owner->GetHeaderWindow()->GetColumnShown(i)) continue;
3695
x_colstart += m_owner->GetHeaderWindow()->GetColumnWidth (i);
3698
PaintLevel ( m_anchor, dc, 0, y, x_colstart );
3701
void wxTreeListMainWindow::OnSetFocus( wxFocusEvent &event )
3710
void wxTreeListMainWindow::OnKillFocus( wxFocusEvent &event )
3719
void wxTreeListMainWindow::OnChar( wxKeyEvent &event )
3721
wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, m_owner->GetId() );
3722
te.SetKeyEvent( event );
3723
te.SetEventObject( /*this*/m_owner );
3724
if ( m_owner->GetEventHandler()->ProcessEvent( te ) )
3726
// intercepted by the user code
3732
if (HasFlag(wxTR_HIDE_ROOT)) {
3733
#if !wxCHECK_VERSION(2, 5, 0)
3736
wxTreeItemIdValue cookie = 0;
3738
m_current = m_key_current = (wxTreeListItem*)GetFirstChild (GetRootItem().m_pItem, cookie).m_pItem;
3742
m_current = m_key_current = (wxTreeListItem*)GetRootItem().m_pItem;
3746
// how should the selection work for this event?
3747
bool is_multiple, extended_select, unselect_others;
3748
EventFlagsToSelType(GetWindowStyleFlag(),
3750
event.ControlDown(),
3751
is_multiple, extended_select, unselect_others);
3753
// + : Expand (not on Win32)
3754
// - : Collaspe (not on Win32)
3755
// * : Expand all/Collapse all
3756
// ' ' | return : activate
3757
// up : go up (not last children!)
3759
// left : go to parent (or collapse on Win32)
3760
// right : open if parent and go next (or expand on Win32)
3761
// home : go to root
3762
// end : go to last item without opening parents
3763
switch (event.GetKeyCode())
3765
#ifndef __WXMSW__ // mimic the standard win32 tree ctrl
3768
if (m_current->HasPlus() && !IsExpanded(m_current))
3777
if ( !IsExpanded(m_current) )
3780
ExpandAll (m_current);
3783
//else: fall through to Collapse() it
3785
#ifndef __WXMSW__ // mimic the standard wxTreeCtrl behaviour
3788
if (IsExpanded(m_current))
3790
Collapse (m_current);
3798
wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
3800
event.SetItem( (void*) m_current);
3801
event.SetEventObject( /*this*/m_owner );
3802
m_owner->GetEventHandler()->ProcessEvent( event );
3806
// backspace goes to the parent, sends "root" activation
3809
wxTreeItemId prev = GetItemParent( m_current );
3810
if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
3812
// don't go to root if it is hidden
3813
prev = GetPrevSibling( m_current );
3817
SelectItem( prev, unselect_others, extended_select );
3818
EnsureVisible( prev );
3823
// up goes to the previous sibling or to the last
3824
// of its children if it's expanded
3827
wxTreeItemId prev = GetPrevSibling( m_key_current );
3830
prev = GetItemParent( m_key_current );
3831
if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
3833
break; // don't go to root if it is hidden
3837
#if !wxCHECK_VERSION(2, 5, 0)
3840
wxTreeItemIdValue cookie = 0;
3842
wxTreeItemId current = m_key_current;
3843
// TODO: Huh? If we get here, we'd better be the first child of our parent. How else could it be?
3844
if (current == GetFirstChild( prev, cookie ))
3846
// otherwise we return to where we came from
3847
SelectItem( prev, unselect_others, extended_select );
3848
m_key_current= (wxTreeListItem*) prev.m_pItem;
3849
EnsureVisible( prev );
3856
while ( IsExpanded(prev) && HasChildren(prev) )
3858
wxTreeItemId child = GetLastChild(prev);
3866
SelectItem( prev, unselect_others, extended_select );
3867
m_key_current=(wxTreeListItem*) prev.m_pItem;
3868
EnsureVisible( prev );
3873
// left arrow goes to the parent
3875
if (IsExpanded(m_current))
3877
Collapse(m_current);
3881
wxTreeItemId prev = GetItemParent( m_current );
3882
if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
3884
// don't go to root if it is hidden
3885
prev = GetPrevSibling( m_current );
3889
SelectItem( prev, unselect_others, extended_select );
3890
EnsureVisible( prev );
3896
#if defined(__WXMSW__) // mimic the standard win32 tree ctrl
3897
if (m_current->HasPlus() && !IsExpanded(m_current))
3904
// this works the same as the down arrow except that we
3905
// also expand the item if it wasn't expanded yet
3911
if (IsExpanded(m_key_current) && HasChildren(m_key_current))
3913
#if !wxCHECK_VERSION(2, 5, 0)
3916
wxTreeItemIdValue cookie = 0;
3918
wxTreeItemId child = GetFirstChild( m_key_current, cookie );
3920
SelectItem( child, unselect_others, extended_select );
3921
m_key_current=(wxTreeListItem*) child.m_pItem;
3922
EnsureVisible( child );
3926
wxTreeItemId next = GetNextSibling( m_key_current );
3929
wxTreeItemId current = m_key_current;
3930
while (current && !next)
3932
current = GetItemParent( current );
3933
if (current) next = GetNextSibling( current );
3938
SelectItem( next, unselect_others, extended_select );
3939
m_key_current=(wxTreeListItem*) next.m_pItem;
3940
EnsureVisible( next );
3945
// <End> selects the last visible tree item
3948
wxTreeItemId last = GetRootItem();
3950
while ( last.IsOk() && IsExpanded(last) )
3952
wxTreeItemId lastChild = GetLastChild(last);
3954
// it may happen if the item was expanded but then all of
3955
// its children have been deleted - so IsExpanded() returned
3956
// TRUE, but GetLastChild() returned invalid item
3965
SelectItem( last, unselect_others, extended_select );
3966
EnsureVisible( last );
3971
// <Home> selects the root item
3974
wxTreeItemId prev = GetRootItem();
3976
if (HasFlag(wxTR_HIDE_ROOT))
3978
#if !wxCHECK_VERSION(2, 5, 0)
3981
wxTreeItemIdValue cookie = 0;
3983
prev = GetFirstChild(prev, cookie);
3986
SelectItem( prev, unselect_others, extended_select );
3987
EnsureVisible( prev );
3992
if (event.m_keyCode >= (int)' ') {
3993
if (!m_findTimer->IsRunning()) m_findStr.Clear();
3994
m_findStr.Append (event.m_keyCode);
3995
m_findTimer->Start (500, wxTIMER_ONE_SHOT);
3996
wxTreeItemId dummy = (wxTreeItemId*)NULL;
3997
wxTreeItemId item = FindItem (dummy, m_findStr, wxTL_SEARCH_VISIBLE |
3998
wxTL_SEARCH_PARTIAL |
3999
wxTL_SEARCH_NOCASE);
4001
EnsureVisible (item);
4009
wxTreeItemId wxTreeListMainWindow::HitTest(const wxPoint& point, int& flags,
4012
// JACS: removed wxYieldIfNeeded() because it can cause the window
4013
// to be deleted from under us if a close window event is pending
4019
if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
4020
if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
4021
if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
4022
if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
4023
if (flags) return wxTreeItemId();
4025
if (m_anchor == NULL)
4027
flags = wxTREE_HITTEST_NOWHERE;
4028
return wxTreeItemId();
4031
wxTreeListItem *hit = m_anchor->HitTest(CalcUnscrolledPosition(point),
4032
this, flags, column, 0);
4035
flags = wxTREE_HITTEST_NOWHERE;
4036
return wxTreeItemId();
4041
// get the bounding rectangle of the item (or of its label only)
4042
bool wxTreeListMainWindow::GetBoundingRect(const wxTreeItemId& item,
4044
bool WXUNUSED(textOnly)) const
4046
wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxTreeListMainWindow::GetBoundingRect") );
4048
wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
4051
GetViewStart(& startX, & startY);
4053
rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
4054
rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
4055
rect.width = i->GetWidth();
4056
//rect.height = i->GetHeight();
4057
rect.height = GetLineHeight(i);
4064
void wxTreeListMainWindow::Edit( const wxTreeItemId& item )
4066
if (!item.IsOk()) return;
4068
m_currentEdit = (wxTreeListItem*) item.m_pItem;
4070
wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, m_owner->GetId() );
4071
te.SetItem( (void*) m_currentEdit);
4072
te.SetEventObject( /*this*/m_owner );
4073
m_owner->GetEventHandler()->ProcessEvent( te );
4075
if (!te.IsAllowed()) return;
4077
// We have to call this here because the label in
4078
// question might just have been added and no screen
4079
// update taken place.
4080
if (m_dirty) wxYieldIfNeeded();
4082
wxString s = m_currentEdit->GetText(/*ALB*/m_main_column);
4083
int x = m_currentEdit->GetX() + m_imgWidth2;
4084
int y = m_currentEdit->GetY();
4085
int w = wxMin (m_currentEdit->GetWidth(),
4086
m_owner->GetHeaderWindow()->GetWidth()) - m_imgWidth2;
4087
int h = m_currentEdit->GetHeight() + 2;
4088
wxClientDC dc(this);
4090
x = dc.LogicalToDeviceX( x );
4091
y = dc.LogicalToDeviceY( y );
4093
wxTreeListTextCtrl *text = new wxTreeListTextCtrl(this, -1,
4103
void wxTreeListMainWindow::OnRenameTimer()
4108
void wxTreeListMainWindow::OnRenameAccept()
4110
// TODO if the validator fails this causes a crash
4111
wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, m_owner->GetId() );
4112
le.SetItem( (void*)m_currentEdit );
4113
le.SetEventObject( /*this*/m_owner );
4114
le.SetLabel( m_renameRes );
4115
m_owner->GetEventHandler()->ProcessEvent( le );
4117
if (!le.IsAllowed()) return;
4119
SetItemText( m_currentEdit, m_renameRes );
4122
void wxTreeListMainWindow::OnMouse( wxMouseEvent &event )
4124
if ( !m_anchor ) return;
4126
wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
4128
// Is the mouse over a tree item button?
4130
wxTreeListItem *item = m_anchor->HitTest(pt, this, flags, 0);
4131
wxTreeListItem *underMouse = item;
4133
bool underMouseChanged = (underMouse != m_underMouse) ;
4134
#endif // wxUSE_TOOLTIPS
4136
if (underMouse && (flags & wxTREE_HITTEST_ONITEMBUTTON) &&
4137
!event.LeftIsDown() && !m_isDragging &&
4138
(!m_renameTimer || !m_renameTimer->IsRunning()))
4146
if (underMouse != m_underMouse)
4150
// unhighlight old item
4151
wxTreeListItem *tmp = m_underMouse;
4152
m_underMouse = NULL;
4156
m_underMouse = underMouse;
4158
RefreshLine( m_underMouse );
4162
// Determines what item we are hovering over and need a tooltip for
4163
wxTreeItemId hoverItem = item;
4165
// We do not want a tooltip if we are dragging, or if the rename timer is running
4166
if (underMouseChanged && hoverItem.IsOk() && !m_isDragging && (!m_renameTimer || !m_renameTimer->IsRunning()))
4168
// Ask the tree control what tooltip (if any) should be shown
4169
wxTreeEvent hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, GetId());
4170
hevent.SetItem(hoverItem);
4171
hevent.SetEventObject(this);
4173
if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
4175
SetToolTip(hevent.GetLabel());
4180
// we process left mouse up event (enables in-place edit), right down
4181
// (pass to the user code), left dbl click (activate item) and
4182
// dragging/moving events for items drag-and-drop
4183
if ( !(event.LeftDown() ||
4185
event.RightDown() ||
4186
event.LeftDClick() ||
4188
((event.Moving() || event.RightUp()) && m_isDragging)) )
4194
if ( event.LeftDown() )
4197
// wxClientDC dc(this);
4199
// wxCoord x = dc.DeviceToLogicalX( event.GetX() );
4200
// wxCoord y = dc.DeviceToLogicalY( event.GetY() );
4204
if ( event.Dragging() && !m_isDragging )
4206
if (m_dragCount == 0)
4207
m_dragStart = wxPoint(x,y);
4211
if (m_dragCount != 3)
4213
// wait until user drags a bit further...
4217
wxEventType command = event.RightIsDown()
4218
? wxEVT_COMMAND_TREE_BEGIN_RDRAG
4219
: wxEVT_COMMAND_TREE_BEGIN_DRAG;
4221
wxTreeEvent nevent( command,/*ALB*/ m_owner->GetId() );
4222
nevent.SetItem( (void*)m_current);
4223
nevent.SetEventObject(/*this*/m_owner); // ALB
4224
nevent.SetPoint(pt);
4226
// by default the dragging is not supported, the user code must
4227
// explicitly allow the event for it to take place
4230
if ( m_owner->GetEventHandler()->ProcessEvent(nevent) &&
4231
nevent.IsAllowed() )
4233
// we're going to drag this item
4234
m_isDragging = TRUE;
4236
// remember the old cursor because we will change it while
4238
m_oldCursor = m_cursor;
4240
// in a single selection control, hide the selection temporarily
4241
if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
4243
m_oldSelection = (wxTreeListItem*) GetSelection().m_pItem;
4245
if ( m_oldSelection )
4247
m_oldSelection->SetHilight(FALSE);
4248
RefreshLine(m_oldSelection);
4255
else if ( event.Moving() )
4257
if ( item != m_dropTarget )
4259
// unhighlight the previous drop target
4260
DrawDropEffect(m_dropTarget);
4262
m_dropTarget = item;
4264
// highlight the current drop target if any
4265
DrawDropEffect(m_dropTarget);
4270
else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
4272
// erase the highlighting
4273
DrawDropEffect(m_dropTarget);
4275
if ( m_oldSelection )
4277
m_oldSelection->SetHilight(TRUE);
4278
RefreshLine(m_oldSelection);
4279
m_oldSelection = (wxTreeListItem *)NULL;
4282
// generate the drag end event
4283
wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG,/*ALB*/m_owner->GetId());
4285
event.SetItem( (void*)item );
4286
event.SetPoint( wxPoint(x, y) );
4287
event.SetEventObject(/*this*/m_owner);
4289
(void)m_owner->GetEventHandler()->ProcessEvent(event);
4291
m_isDragging = FALSE;
4292
m_dropTarget = (wxTreeListItem *)NULL;
4296
SetCursor(m_oldCursor);
4302
// here we process only the messages which happen on tree items
4306
if ( item == NULL ) return; /* we hit the blank area */
4308
if ( event.RightDown() )
4311
wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK,
4313
nevent.SetItem( (void*)item );
4315
CalcScrolledPosition(x, y, &nx, &ny);
4316
nevent.SetPoint( wxPoint(nx, ny));
4317
nevent.SetEventObject(/*this*/m_owner);
4318
m_owner->GetEventHandler()->ProcessEvent(nevent);
4320
else if ( event.LeftUp() )
4324
if ( ( item == m_current ) &&
4325
( flags & wxTREE_HITTEST_ONITEMLABEL ) &&
4326
HasFlag(wxTR_EDIT_LABELS ) )
4328
if ( m_renameTimer->IsRunning() )
4329
m_renameTimer->Stop();
4331
m_renameTimer->Start( 100, TRUE );
4334
m_lastOnSame = FALSE;
4337
else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
4339
if ( event.LeftDown() )
4342
m_lastOnSame = item == m_current;
4345
if ((flags & wxTREE_HITTEST_ONITEMBUTTON) ||
4346
((flags & wxTREE_HITTEST_ONITEMICON)) &&
4347
!HasButtons() && item->HasPlus())
4349
// only toggle the item for a single click, double click on
4350
// the button doesn't do anything (it toggles the item twice)
4351
if ( event.LeftDown() )
4356
// don't select the item if the button was clicked
4360
// how should the selection work for this event?
4361
bool is_multiple, extended_select, unselect_others;
4362
EventFlagsToSelType(GetWindowStyleFlag(),
4364
event.ControlDown(),
4365
is_multiple, extended_select, unselect_others);
4367
SelectItem (item, unselect_others, extended_select);
4369
// For some reason, Windows isn't recognizing a left double-click,
4370
// so we need to simulate it here. Allow 200 milliseconds for now.
4371
if ( event.LeftDClick() )
4373
// double clicking should not start editing the item label
4374
m_renameTimer->Stop();
4375
m_lastOnSame = FALSE;
4377
// send activate event first
4378
wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
4380
nevent.SetItem( (void*)item );
4382
CalcScrolledPosition(x, y, &nx, &ny);
4383
nevent.SetPoint( wxPoint(nx, ny) );
4384
nevent.SetEventObject( /*this*/m_owner );
4385
if ( !m_owner->GetEventHandler()->ProcessEvent( nevent ) )
4387
// if the user code didn't process the activate event,
4388
// handle it ourselves by toggling the item when it is
4390
if ( item->HasPlus() )
4400
void wxTreeListMainWindow::OnIdle( wxIdleEvent &WXUNUSED(event) )
4402
/* after all changes have been done to the tree control,
4403
* we actually redraw the tree when everything is over */
4405
if (!m_dirty) return;
4409
CalculatePositions();
4411
AdjustMyScrollbars();
4414
void wxTreeListMainWindow::OnScroll(wxScrollWinEvent& event)
4417
#if defined(__WXGTK__) && !defined(__WXUNIVERSAL__)
4418
wxScrolledWindow::OnScroll(event);
4420
HandleOnScroll( event );
4423
if(event.GetOrientation() == wxHORIZONTAL)
4425
m_owner->GetHeaderWindow()->Refresh();
4426
m_owner->GetHeaderWindow()->Update();
4431
void wxTreeListMainWindow::CalculateSize( wxTreeListItem *item, wxDC &dc )
4437
dc.SetFont(m_boldFont);
4439
dc.GetTextExtent( item->GetText(/*ALB*/m_main_column), &text_w, &text_h );
4442
// restore normal font
4443
dc.SetFont( m_normalFont );
4445
int total_h = (m_imgHeight > text_h) ? m_imgHeight : text_h;
4447
item->SetHeight(total_h);
4448
if (total_h>m_lineHeight)
4449
m_lineHeight=total_h;
4451
item->SetWidth(m_imgWidth + text_w+2);
4454
// -----------------------------------------------------------------------------
4455
// for developper : y is now the top of the level
4456
// not the middle of it !
4457
void wxTreeListMainWindow::CalculateLevel( wxTreeListItem *item, wxDC &dc,
4458
int level, int &y, int x_colstart )
4460
// calculate position of vertical lines
4461
int x = x_colstart + MARGIN; // start of column
4462
if (HasFlag(wxTR_LINES_AT_ROOT)) x += LINEATROOT; // space for lines at root
4463
if (HasButtons()) x += m_btnWidth2; // space for buttons etc.
4464
if (!HasFlag(wxTR_HIDE_ROOT)) x += m_indent; // indent root as well
4465
x += m_indent * level; // indent according to level
4467
// a hidden root is not evaluated, but its children are always
4468
if (HasFlag(wxTR_HIDE_ROOT) && (level == 0)) goto Recurse;
4470
CalculateSize( item, dc );
4475
y += GetLineHeight(item);
4477
// we don't need to calculate collapsed branches
4478
if ( !item->IsExpanded() ) return;
4481
wxArrayTreeListItems& children = item->GetChildren();
4482
size_t n, count = children.Count();
4484
for (n = 0; n < count; ++n )
4485
CalculateLevel( children[n], dc, level, y, x_colstart ); // recurse
4488
void wxTreeListMainWindow::CalculatePositions()
4490
if ( !m_anchor ) return;
4492
wxClientDC dc(this);
4495
dc.SetFont( m_normalFont );
4497
dc.SetPen( m_dottedPen );
4498
//if(GetImageList() == NULL)
4499
// m_lineHeight = (int)(dc.GetCharHeight() + 4);
4503
for(size_t i = 0; i < GetMainColumn(); ++i) {
4504
if (!m_owner->GetHeaderWindow()->GetColumnShown(i)) continue;
4505
x_colstart += m_owner->GetHeaderWindow()->GetColumnWidth(i);
4507
CalculateLevel( m_anchor, dc, 0, y, x_colstart ); // start recursion
4510
void wxTreeListMainWindow::RefreshSubtree(wxTreeListItem *item)
4512
if (m_dirty) return;
4514
wxClientDC dc(this);
4519
GetVirtualSize( &cw, &ch );
4522
rect.x = dc.LogicalToDeviceX( 0 );
4524
rect.y = dc.LogicalToDeviceY( item->GetY() - 2 );
4527
Refresh( TRUE, &rect );
4529
AdjustMyScrollbars();
4532
void wxTreeListMainWindow::RefreshLine( wxTreeListItem *item )
4534
if (m_dirty) return;
4536
wxClientDC dc(this);
4541
GetVirtualSize( &cw, &ch );
4544
rect.x = dc.LogicalToDeviceX( 0 );
4545
rect.y = dc.LogicalToDeviceY( item->GetY() );
4547
rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
4549
Refresh( TRUE, &rect );
4552
void wxTreeListMainWindow::RefreshSelected()
4554
// TODO: this is awfully inefficient, we should keep the list of all
4555
// selected items internally, should be much faster
4557
RefreshSelectedUnder(m_anchor);
4560
void wxTreeListMainWindow::RefreshSelectedUnder(wxTreeListItem *item)
4562
if ( item->IsSelected() )
4565
const wxArrayTreeListItems& children = item->GetChildren();
4566
size_t count = children.GetCount();
4567
for ( size_t n = 0; n < count; n++ )
4569
RefreshSelectedUnder(children[n]);
4573
// ----------------------------------------------------------------------------
4574
// changing colours: we need to refresh the tree control
4575
// ----------------------------------------------------------------------------
4577
bool wxTreeListMainWindow::SetBackgroundColour(const wxColour& colour)
4579
if ( !wxWindow::SetBackgroundColour(colour) )
4587
bool wxTreeListMainWindow::SetForegroundColour(const wxColour& colour)
4589
if ( !wxWindow::SetForegroundColour(colour) )
4597
//----------- ALB -------------
4598
void wxTreeListMainWindow::SetItemText(const wxTreeItemId& item, size_t column,
4599
const wxString& text)
4601
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
4603
wxClientDC dc(this);
4604
wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
4605
pItem->SetText(column, text);
4606
CalculateSize(pItem, dc);
4610
wxString wxTreeListMainWindow::GetItemText(const wxTreeItemId& item,
4611
size_t column) const
4613
wxCHECK_MSG( item.IsOk(), wxT(""), wxT("invalid tree item") );
4615
return ((wxTreeListItem*) item.m_pItem)->GetText(column);
4618
void wxTreeListMainWindow::SetFocus()
4620
wxWindow::SetFocus();
4624
//-----------------------------------------------------------------------------
4626
//-----------------------------------------------------------------------------
4628
IMPLEMENT_DYNAMIC_CLASS(wxTreeListCtrl, wxControl)
4630
BEGIN_EVENT_TABLE(wxTreeListCtrl, wxControl)
4631
EVT_SIZE(wxTreeListCtrl::OnSize)
4632
EVT_TREE_ITEM_GETTOOLTIP(wxID_ANY, wxTreeListCtrl::OnGetToolTip)
4635
bool wxTreeListCtrl::Create(wxWindow *parent, wxWindowID id,
4638
long style, const wxValidator &validator,
4639
const wxString& name)
4641
long main_style = style & ~(wxRAISED_BORDER|wxSUNKEN_BORDER
4642
|wxSIMPLE_BORDER|wxNO_BORDER|wxDOUBLE_BORDER
4644
long ctrl_style = style & ~(wxVSCROLL|wxHSCROLL);
4646
if (!wxControl::Create(parent, id, pos, size, ctrl_style, validator, name)) {
4649
m_main_win = new wxTreeListMainWindow(this, -1, wxPoint(0, 0), size,
4650
main_style, validator);
4651
m_header_win = new wxTreeListHeaderWindow(this, -1, m_main_win,
4652
wxPoint(0, 0), wxDefaultSize,
4654
CalculateAndSetHeaderHeight();
4658
void wxTreeListCtrl::CalculateAndSetHeaderHeight()
4662
// we use 'g' to get the descent, too
4664
m_header_win->GetTextExtent(wxT("Hg"), &w, &h, &d);
4665
h += d + 2 * HEADER_OFFSET_Y + EXTRA_HEIGHT;
4667
// only update if changed
4668
if ( h != (int)m_headerHeight )
4670
m_headerHeight = (size_t)h;
4671
m_header_win->SetSize(m_header_win->GetSize().x, m_headerHeight);
4676
void wxTreeListCtrl::DoHeaderLayout()
4679
GetClientSize(&w, &h);
4682
m_header_win->SetSize(0, 0, w, m_headerHeight);
4683
m_header_win->Refresh(false);
4686
m_main_win->SetSize(0, m_headerHeight + 1, w, h - m_headerHeight - 1);
4689
void wxTreeListCtrl::OnSize(wxSizeEvent& WXUNUSED(event))
4695
size_t wxTreeListCtrl::GetCount() const { return m_main_win->GetCount(); }
4697
unsigned int wxTreeListCtrl::GetIndent() const
4698
{ return m_main_win->GetIndent(); }
4700
void wxTreeListCtrl::SetIndent(unsigned int indent)
4701
{ m_main_win->SetIndent(indent); }
4703
unsigned int wxTreeListCtrl::GetLineSpacing() const
4704
{ return m_main_win->GetLineSpacing(); }
4706
void wxTreeListCtrl::SetLineSpacing(unsigned int spacing)
4707
{ m_main_win->SetLineSpacing(spacing); }
4709
wxImageList* wxTreeListCtrl::GetImageList() const
4710
{ return m_main_win->GetImageList(); }
4712
wxImageList* wxTreeListCtrl::GetStateImageList() const
4713
{ return m_main_win->GetStateImageList(); }
4715
wxImageList* wxTreeListCtrl::GetButtonsImageList() const
4716
{ return m_main_win->GetButtonsImageList(); }
4718
void wxTreeListCtrl::SetImageList(wxImageList* imageList)
4719
{ m_main_win->SetImageList(imageList); }
4721
void wxTreeListCtrl::SetStateImageList(wxImageList* imageList)
4722
{ m_main_win->SetStateImageList(imageList); }
4724
void wxTreeListCtrl::SetButtonsImageList(wxImageList* imageList)
4725
{ m_main_win->SetButtonsImageList(imageList); }
4727
void wxTreeListCtrl::AssignImageList(wxImageList* imageList)
4728
{ m_main_win->AssignImageList(imageList); }
4730
void wxTreeListCtrl::AssignStateImageList(wxImageList* imageList)
4731
{ m_main_win->AssignStateImageList(imageList); }
4733
void wxTreeListCtrl::AssignButtonsImageList(wxImageList* imageList)
4734
{ m_main_win->AssignButtonsImageList(imageList); }
4736
wxString wxTreeListCtrl::GetItemText(const wxTreeItemId& item, size_t column)
4738
{ return m_main_win->GetItemText(item, column); }
4740
int wxTreeListCtrl::GetItemImage(const wxTreeItemId& item, size_t column,
4741
wxTreeItemIcon which) const
4742
{ return m_main_win->GetItemImage(item, column, which); }
4744
wxTreeItemData* wxTreeListCtrl::GetItemData(const wxTreeItemId& item) const
4745
{ return m_main_win->GetItemData(item); }
4747
bool wxTreeListCtrl::GetItemBold(const wxTreeItemId& item) const
4748
{ return m_main_win->GetItemBold(item); }
4750
wxColour wxTreeListCtrl::GetItemTextColour(const wxTreeItemId& item) const
4751
{ return m_main_win->GetItemTextColour(item); }
4753
wxColour wxTreeListCtrl::GetItemBackgroundColour(const wxTreeItemId& item)
4755
{ return m_main_win->GetItemBackgroundColour(item); }
4757
wxFont wxTreeListCtrl::GetItemFont(const wxTreeItemId& item) const
4758
{ return m_main_win->GetItemFont(item); }
4761
void wxTreeListCtrl::SetItemText(const wxTreeItemId& item, size_t column,
4762
const wxString& text)
4763
{ m_main_win->SetItemText(item, column, text); }
4765
void wxTreeListCtrl::SetItemImage(const wxTreeItemId& item,
4768
wxTreeItemIcon which)
4769
{ m_main_win->SetItemImage(item, column, image, which); }
4771
void wxTreeListCtrl::SetItemData(const wxTreeItemId& item,
4772
wxTreeItemData* data)
4773
{ m_main_win->SetItemData(item, data); }
4775
void wxTreeListCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
4776
{ m_main_win->SetItemHasChildren(item, has); }
4778
void wxTreeListCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
4779
{ m_main_win->SetItemBold(item, bold); }
4781
void wxTreeListCtrl::SetItemTextColour(const wxTreeItemId& item,
4782
const wxColour& col)
4783
{ m_main_win->SetItemTextColour(item, col); }
4785
void wxTreeListCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
4786
const wxColour& col)
4787
{ m_main_win->SetItemBackgroundColour(item, col); }
4789
void wxTreeListCtrl::SetItemFont(const wxTreeItemId& item,
4791
{ m_main_win->SetItemFont(item, font); }
4793
bool wxTreeListCtrl::SetFont(const wxFont& font)
4797
m_header_win->SetFont(font);
4798
CalculateAndSetHeaderHeight();
4801
return m_main_win->SetFont(font);
4805
void wxTreeListCtrl::SetWindowStyle(const long style)
4808
m_main_win->SetWindowStyle(style);
4809
// TODO: provide something like wxTL_NO_HEADERS to hide m_header_win
4812
long wxTreeListCtrl::GetWindowStyle() const
4814
long style = m_windowStyle;
4816
style |= m_main_win->GetWindowStyle();
4820
bool wxTreeListCtrl::IsVisible(const wxTreeItemId& item) const
4821
{ return m_main_win->IsVisible(item); }
4823
bool wxTreeListCtrl::ItemHasChildren(const wxTreeItemId& item) const
4824
{ return m_main_win->ItemHasChildren(item); }
4826
bool wxTreeListCtrl::IsExpanded(const wxTreeItemId& item) const
4827
{ return m_main_win->IsExpanded(item); }
4829
bool wxTreeListCtrl::IsSelected(const wxTreeItemId& item) const
4830
{ return m_main_win->IsSelected(item); }
4832
bool wxTreeListCtrl::IsBold(const wxTreeItemId& item) const
4833
{ return m_main_win->IsBold(item); }
4835
size_t wxTreeListCtrl::GetChildrenCount(const wxTreeItemId& item, bool rec)
4836
{ return m_main_win->GetChildrenCount(item, rec); }
4838
wxTreeItemId wxTreeListCtrl::GetRootItem() const
4839
{ return m_main_win->GetRootItem(); }
4841
wxTreeItemId wxTreeListCtrl::GetSelection() const
4842
{ return m_main_win->GetSelection(); }
4844
size_t wxTreeListCtrl::GetSelections(wxArrayTreeItemIds& arr) const
4845
{ return m_main_win->GetSelections(arr); }
4847
wxTreeItemId wxTreeListCtrl::GetItemParent(const wxTreeItemId& item) const
4848
{ return m_main_win->GetItemParent(item); }
4850
#if !wxCHECK_VERSION(2, 5, 0)
4851
wxTreeItemId wxTreeListCtrl::GetFirstChild(const wxTreeItemId& item,
4854
wxTreeItemId wxTreeListCtrl::GetFirstChild(const wxTreeItemId& item,
4855
wxTreeItemIdValue& cookie) const
4857
{ return m_main_win->GetFirstChild(item, cookie); }
4859
#if !wxCHECK_VERSION(2, 5, 0)
4860
wxTreeItemId wxTreeListCtrl::GetNextChild(const wxTreeItemId& item,
4863
wxTreeItemId wxTreeListCtrl::GetNextChild(const wxTreeItemId& item,
4864
wxTreeItemIdValue& cookie) const
4866
{ return m_main_win->GetNextChild(item, cookie); }
4868
#if !wxCHECK_VERSION(2, 5, 0)
4869
wxTreeItemId wxTreeListCtrl::GetPrevChild(const wxTreeItemId& item,
4872
wxTreeItemId wxTreeListCtrl::GetPrevChild(const wxTreeItemId& item,
4873
wxTreeItemIdValue& cookie) const
4875
{ return m_main_win->GetPrevChild(item, cookie); }
4877
wxTreeItemId wxTreeListCtrl::GetLastChild(const wxTreeItemId& item) const
4878
{ return m_main_win->GetLastChild(item); }
4880
wxTreeItemId wxTreeListCtrl::GetNextSibling(const wxTreeItemId& item) const
4881
{ return m_main_win->GetNextSibling(item); }
4883
wxTreeItemId wxTreeListCtrl::GetPrevSibling(const wxTreeItemId& item) const
4884
{ return m_main_win->GetPrevSibling(item); }
4886
wxTreeItemId wxTreeListCtrl::GetFirstVisibleItem() const
4887
{ return m_main_win->GetFirstVisibleItem(); }
4889
wxTreeItemId wxTreeListCtrl::GetNextVisible(const wxTreeItemId& item) const
4890
{ return m_main_win->GetNextVisible(item); }
4892
wxTreeItemId wxTreeListCtrl::GetPrevVisible(const wxTreeItemId& item) const
4893
{ return m_main_win->GetPrevVisible(item); }
4895
wxTreeItemId wxTreeListCtrl::GetNext(const wxTreeItemId& item) const
4896
{ return m_main_win->GetNext(item); }
4898
wxTreeItemId wxTreeListCtrl::AddRoot(const wxString& text, int image,
4899
int selectedImage, wxTreeItemData* data)
4900
{ return m_main_win->AddRoot(text, image, selectedImage, data); }
4902
wxTreeItemId wxTreeListCtrl::PrependItem(const wxTreeItemId& parent,
4903
const wxString& text, int image,
4905
wxTreeItemData* data)
4906
{ return m_main_win->PrependItem(parent, text, image, selectedImage, data); }
4908
wxTreeItemId wxTreeListCtrl::InsertItem(const wxTreeItemId& parent,
4909
const wxTreeItemId& previous,
4910
const wxString& text, int image,
4912
wxTreeItemData* data)
4914
return m_main_win->InsertItem(parent, previous, text, image,
4915
selectedImage, data);
4918
wxTreeItemId wxTreeListCtrl::InsertItem(const wxTreeItemId& parent,
4920
const wxString& text, int image,
4922
wxTreeItemData* data)
4924
return m_main_win->InsertItem(parent, index, text, image,
4925
selectedImage, data);
4928
wxTreeItemId wxTreeListCtrl::AppendItem(const wxTreeItemId& parent,
4929
const wxString& text, int image,
4931
wxTreeItemData* data)
4932
{ return m_main_win->AppendItem(parent, text, image, selectedImage, data); }
4934
void wxTreeListCtrl::Delete(const wxTreeItemId& item)
4935
{ m_main_win->Delete(item); }
4937
void wxTreeListCtrl::DeleteChildren(const wxTreeItemId& item)
4938
{ m_main_win->DeleteChildren(item); }
4940
void wxTreeListCtrl::DeleteAllItems()
4941
{ m_main_win->DeleteAllItems(); }
4943
void wxTreeListCtrl::Expand(const wxTreeItemId& item)
4944
{ m_main_win->Expand(item); }
4946
void wxTreeListCtrl::ExpandAll(const wxTreeItemId& item)
4947
{ m_main_win->ExpandAll(item); }
4949
void wxTreeListCtrl::Collapse(const wxTreeItemId& item)
4950
{ m_main_win->Collapse(item); }
4952
void wxTreeListCtrl::CollapseAndReset(const wxTreeItemId& item)
4953
{ m_main_win->CollapseAndReset(item); }
4955
void wxTreeListCtrl::Toggle(const wxTreeItemId& item)
4956
{ m_main_win->Toggle(item); }
4958
void wxTreeListCtrl::Unselect()
4959
{ m_main_win->Unselect(); }
4961
void wxTreeListCtrl::UnselectAll()
4962
{ m_main_win->UnselectAll(); }
4964
void wxTreeListCtrl::SelectItem(const wxTreeItemId& item, bool unselect_others,
4965
bool extended_select)
4966
{ m_main_win->SelectItem(item, unselect_others, extended_select); }
4968
void wxTreeListCtrl::SelectAll(bool extended_select)
4969
{ m_main_win->SelectAll(extended_select); }
4971
void wxTreeListCtrl::EnsureVisible(const wxTreeItemId& item)
4972
{ m_main_win->EnsureVisible(item); }
4974
void wxTreeListCtrl::ScrollTo(const wxTreeItemId& item)
4975
{ m_main_win->ScrollTo(item); }
4977
wxTreeItemId wxTreeListCtrl::HitTest(const wxPoint& pos, int& flags,
4980
return m_main_win->HitTest(pos, flags, column);
4983
bool wxTreeListCtrl::GetBoundingRect(const wxTreeItemId& item, wxRect& rect,
4984
bool textOnly) const
4985
{ return m_main_win->GetBoundingRect(item, rect, textOnly); }
4987
void wxTreeListCtrl::Edit(const wxTreeItemId& item)
4988
{ m_main_win->Edit(item); }
4990
int wxTreeListCtrl::OnCompareItems(const wxTreeItemId& item1,
4991
const wxTreeItemId& item2)
4993
// ALB: do the comparison here, and not delegate to m_main_win, in order
4994
// to let the user override it
4995
//return m_main_win->OnCompareItems(item1, item2);
4996
return wxStrcmp(GetItemText(item1), GetItemText(item2));
4999
void wxTreeListCtrl::SortChildren(const wxTreeItemId& item)
5000
{ m_main_win->SortChildren(item); }
5002
wxTreeItemId wxTreeListCtrl::FindItem (const wxTreeItemId& item, const wxString& str, int flags)
5003
{ return m_main_win->FindItem (item, str, flags); }
5005
bool wxTreeListCtrl::SetBackgroundColour(const wxColour& colour)
5007
if (!m_main_win) return false;
5008
return m_main_win->SetBackgroundColour(colour);
5011
bool wxTreeListCtrl::SetForegroundColour(const wxColour& colour)
5013
if (!m_main_win) return false;
5014
return m_main_win->SetForegroundColour(colour);
5017
size_t wxTreeListCtrl::GetColumnCount() const
5018
{ return m_main_win->GetColumnCount(); }
5020
void wxTreeListCtrl::SetColumnWidth(size_t column, size_t width)
5021
{ m_header_win->SetColumnWidth(column, width); }
5023
int wxTreeListCtrl::GetColumnWidth(size_t column) const
5024
{ return m_header_win->GetColumnWidth(column); }
5026
void wxTreeListCtrl::SetMainColumn(size_t column)
5027
{ m_main_win->SetMainColumn(column); }
5029
size_t wxTreeListCtrl::GetMainColumn() const
5030
{ return m_main_win->GetMainColumn(); }
5032
void wxTreeListCtrl::SetColumnText(size_t column, const wxString& text)
5034
m_header_win->SetColumnText(column, text);
5035
m_header_win->Refresh();
5038
wxString wxTreeListCtrl::GetColumnText(size_t column) const
5039
{ return m_header_win->GetColumnText(column); }
5041
void wxTreeListCtrl::AddColumn(const wxTreeListColumnInfo& col)
5043
m_header_win->AddColumn(col);
5047
void wxTreeListCtrl::InsertColumn(size_t before,
5048
const wxTreeListColumnInfo& col)
5049
{ m_header_win->InsertColumn(before, col); }
5051
void wxTreeListCtrl::RemoveColumn(size_t column)
5052
{ m_header_win->RemoveColumn(column); }
5054
void wxTreeListCtrl::SetColumn(size_t column, const wxTreeListColumnInfo& col)
5055
{ m_header_win->SetColumn(column, col); }
5057
const wxTreeListColumnInfo& wxTreeListCtrl::GetColumn(size_t column) const
5058
{ return m_header_win->GetColumn(column); }
5060
wxTreeListColumnInfo& wxTreeListCtrl::GetColumn(size_t column)
5061
{ return m_header_win->GetColumn(column); }
5063
void wxTreeListCtrl::SetColumnImage(size_t column, int image)
5065
m_header_win->SetColumn(column, GetColumn(column).SetImage(image));
5068
int wxTreeListCtrl::GetColumnImage(size_t column) const
5070
return m_header_win->GetColumn(column).GetImage();
5073
void wxTreeListCtrl::ShowColumn(size_t column, bool shown)
5075
wxASSERT_MSG( column != GetMainColumn(),
5076
wxT("The main column may not be hidden") );
5077
m_header_win->SetColumn(column, GetColumn(column).SetShown(GetMainColumn()? true: shown));
5080
bool wxTreeListCtrl::IsColumnShown(size_t column) const
5082
return m_header_win->GetColumn(column).GetShown();
5085
void wxTreeListCtrl::SetColumnAlignment(size_t column,
5086
wxTreeListColumnAlign align)
5088
m_header_win->SetColumn(column, GetColumn(column).SetAlignment(align));
5091
wxTreeListColumnAlign wxTreeListCtrl::GetColumnAlignment(size_t column) const
5093
return m_header_win->GetColumn(column).GetAlignment();
5096
void wxTreeListCtrl::Refresh(bool erase, const wxRect* rect)
5098
m_main_win->Refresh(erase, rect);
5099
m_header_win->Refresh(erase, rect);
5102
void wxTreeListCtrl::SetFocus()
5103
{ m_main_win->SetFocus(); }
5106
wxSize wxTreeListCtrl::DoGetBestSize() const
5108
// something is better than nothing...
5109
return wxSize(100,80);
5112
// Process the tooltip event, to speed up event processing.
5113
// Doesn't actually get a tooltip.
5114
void wxTreeListCtrl::OnGetToolTip( wxTreeEvent &event )
added
removed
wxPython/contrib/gizmos/wxCode/src/treelistctrl.cpp
