X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b3887715e49225f7022858586dae58c0bee53180..8a31648287be0ef976f133de2786b137f1e98340:/src/generic/treectlg.cpp diff --git a/src/generic/treectlg.cpp b/src/generic/treectlg.cpp index 289d6a3cd3..7415dafd50 100644 --- a/src/generic/treectlg.cpp +++ b/src/generic/treectlg.cpp @@ -1,11 +1,11 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: treectlg.cpp +// Name: src/generic/treectlg.cpp // Purpose: generic tree control implementation // Author: Robert Roebling // Created: 01/02/97 // Modified: 22/10/98 - almost total rewrite, simpler interface (VZ) // Id: $Id$ -// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem +// Copyright: (c) 1998 Robert Roebling and Julian Smart // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -17,10 +17,6 @@ // headers // ----------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "treectlg.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -30,21 +26,32 @@ #if wxUSE_TREECTRL -#include "wx/treebase.h" +#include "wx/treectrl.h" + +#ifndef WX_PRECOMP + #include "wx/dcclient.h" + #include "wx/timer.h" + #include "wx/settings.h" + #include "wx/listbox.h" + #include "wx/textctrl.h" +#endif + #include "wx/generic/treectlg.h" -#include "wx/timer.h" -#include "wx/textctrl.h" #include "wx/imaglist.h" -#include "wx/settings.h" -#include "wx/dcclient.h" + +#include "wx/renderer.h" + +#ifdef __WXMAC__ + #include "wx/osx/private.h" +#endif // ----------------------------------------------------------------------------- // array types // ----------------------------------------------------------------------------- -class WXDLLEXPORT wxGenericTreeItem; +class WXDLLIMPEXP_FWD_CORE wxGenericTreeItem; -WX_DEFINE_EXPORTED_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems); +WX_DEFINE_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems); // ---------------------------------------------------------------------------- // constants @@ -54,53 +61,11 @@ static const int NO_IMAGE = -1; static const int PIXELS_PER_UNIT = 10; -// ---------------------------------------------------------------------------- -// Aqua arrows -// ---------------------------------------------------------------------------- - -/* XPM */ -static const char *aqua_arrow_right[] = { -/* columns rows colors chars-per-pixel */ -"13 11 4 1", -" c None", -"b c #C0C0C0", -"c c #707070", -"d c #A0A0A0", -/* pixels */ -" b ", -" ddb ", -" cccdb ", -" cccccd ", -" ccccccdb ", -" ccccccccd", -" ccccccdb ", -" cccccb ", -" cccdb ", -" ddb ", -" b " -}; +// the margin between the item state image and the item normal image +static const int MARGIN_BETWEEN_STATE_AND_IMAGE = 2; -/* XPM */ -static const char *aqua_arrow_down[] = { -/* columns rows colors chars-per-pixel */ -"13 11 4 1", -" c None", -"b c #C0C0C0", -"c c #707070", -"d c #A0A0A0", -/* pixels */ -" ", -" ", -" bdcccccccdb ", -" dcccccccd ", -" bcccccccb ", -" dcccccd ", -" bcccccb ", -" bcccd ", -" dcd ", -" bcb ", -" d " -}; +// the margin between the item image and the item text +static const int MARGIN_BETWEEN_IMAGE_AND_TEXT = 4; // ----------------------------------------------------------------------------- // private classes @@ -120,36 +85,36 @@ public: private: wxGenericTreeCtrl *m_owner; + + wxDECLARE_NO_COPY_CLASS(wxTreeRenameTimer); }; // control used for in-place edit class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl { public: - wxTreeTextCtrl( wxWindow *parent, - const wxWindowID id, - bool *accept, - wxString *res, - wxGenericTreeCtrl *owner, - const wxString &value = wxEmptyString, - const wxPoint &pos = wxDefaultPosition, - const wxSize &size = wxDefaultSize, - int style = wxSIMPLE_BORDER, - const wxValidator& validator = wxDefaultValidator, - const wxString &name = wxTextCtrlNameStr ); + wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item); + + void EndEdit( bool discardChanges ); + const wxGenericTreeItem* item() const { return m_itemEdited; } + +protected: void OnChar( wxKeyEvent &event ); void OnKeyUp( wxKeyEvent &event ); void OnKillFocus( wxFocusEvent &event ); + bool AcceptChanges(); + void Finish( bool setfocus ); + private: - bool *m_accept; - wxString *m_res; wxGenericTreeCtrl *m_owner; + wxGenericTreeItem *m_itemEdited; wxString m_startValue; - bool m_finished; + bool m_aboutToFinish; DECLARE_EVENT_TABLE() + wxDECLARE_NO_COPY_CLASS(wxTreeTextCtrl); }; // timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed @@ -166,6 +131,8 @@ public: private: wxGenericTreeCtrl *m_owner; + + wxDECLARE_NO_COPY_CLASS(wxTreeFindTimer); }; // a tree item @@ -173,7 +140,13 @@ class WXDLLEXPORT wxGenericTreeItem { public: // ctors & dtor - wxGenericTreeItem() { m_data = NULL; } + wxGenericTreeItem() + { + m_data = NULL; + m_widthText = + m_heightText = -1; + } + wxGenericTreeItem( wxGenericTreeItem *parent, const wxString& text, int image, @@ -189,18 +162,36 @@ public: int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const { return m_images[which]; } wxTreeItemData *GetData() const { return m_data; } + int GetState() const { return m_state; } // returns the current image for the item (depending on its // selected/expanded/whatever state) int GetCurrentImage() const; - void SetText( const wxString &text ); - void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; } + void SetText(const wxString& text) + { + m_text = text; + + ResetTextSize(); + } + + void SetImage(int image, wxTreeItemIcon which) + { + m_images[which] = image; + m_width = 0; + } + void SetData(wxTreeItemData *data) { m_data = data; } + void SetState(int state) { m_state = state; m_width = 0; } + + void SetHasPlus(bool has = true) { m_hasPlus = has; } - void SetHasPlus(bool has = TRUE) { m_hasPlus = has; } + void SetBold(bool bold) + { + m_isBold = bold; - void SetBold(bool bold) { m_isBold = bold; } + ResetTextSize(); + } int GetX() const { return m_x; } int GetY() const { return m_y; } @@ -208,39 +199,80 @@ public: void SetX(int x) { m_x = x; } void SetY(int y) { m_y = y; } - int GetHeight() const { return m_height; } - int GetWidth() const { return m_width; } + int GetHeight() const { return m_height; } + int GetWidth() const { return m_width; } - void SetHeight(int h) { m_height = h; } - void SetWidth(int w) { m_width = w; } + int GetTextHeight() const + { + wxASSERT_MSG( m_heightText != -1, "must call CalculateSize() first" ); + + return m_heightText; + } + + int GetTextWidth() const + { + wxASSERT_MSG( m_widthText != -1, "must call CalculateSize() first" ); + + return m_widthText; + } wxGenericTreeItem *GetParent() const { return m_parent; } + // sets the items font for the specified DC if it uses any special font or + // simply returns false otherwise + bool SetFont(wxGenericTreeCtrl *control, wxDC& dc) const + { + wxFont font; + + wxTreeItemAttr * const attr = GetAttributes(); + if ( attr && attr->HasFont() ) + font = attr->GetFont(); + else if ( IsBold() ) + font = control->m_boldFont; + else + return false; + + dc.SetFont(font); + return true; + } + // operations - // deletes all children notifying the treectrl about it if !NULL - // pointer given - void DeleteChildren(wxGenericTreeCtrl *tree = NULL); + + // deletes all children notifying the treectrl about it + void DeleteChildren(wxGenericTreeCtrl *tree); // get count of all children (and grand children if 'recursively') - size_t GetChildrenCount(bool recursively = TRUE) const; + size_t GetChildrenCount(bool recursively = true) const; void Insert(wxGenericTreeItem *child, size_t index) - { m_children.Insert(child, index); } + { m_children.Insert(child, index); } + + // calculate and cache the item size using either the provided DC (which is + // supposed to have wxGenericTreeCtrl::m_normalFont selected into it!) or a + // wxClientDC on the control window + void CalculateSize(wxGenericTreeCtrl *control, wxDC& dc) + { DoCalculateSize(control, dc, true /* dc uses normal font */); } + void CalculateSize(wxGenericTreeCtrl *control); void GetSize( int &x, int &y, const wxGenericTreeCtrl* ); + void ResetSize() { m_width = 0; } + void ResetTextSize() { m_width = 0; m_widthText = -1; } + void RecursiveResetSize(); + void RecursiveResetTextSize(); + // return the item at given position (or NULL if no item), onButton is - // TRUE if the point belongs to the item's button, otherwise it lies - // on the button's label + // true if the point belongs to the item's button, otherwise it lies + // on the item's label wxGenericTreeItem *HitTest( const wxPoint& point, const wxGenericTreeCtrl *, int &flags, int level ); - void Expand() { m_isCollapsed = FALSE; } - void Collapse() { m_isCollapsed = TRUE; } + void Expand() { m_isCollapsed = false; } + void Collapse() { m_isCollapsed = true; } - void SetHilight( bool set = TRUE ) { m_hasHilight = set; } + void SetHilight( bool set = true ) { m_hasHilight = set; } // status inquiries bool HasChildren() const { return !m_children.IsEmpty(); } @@ -258,7 +290,7 @@ public: if ( !m_attr ) { m_attr = new wxTreeItemAttr; - m_ownsAttr = TRUE; + m_ownsAttr = true; } return *m_attr; } @@ -267,23 +299,40 @@ public: { if ( m_ownsAttr ) delete m_attr; m_attr = attr; - m_ownsAttr = FALSE; + m_ownsAttr = false; + m_width = 0; + m_widthText = -1; } // set them and delete when done void AssignAttributes(wxTreeItemAttr *attr) { SetAttributes(attr); - m_ownsAttr = TRUE; + m_ownsAttr = true; + m_width = 0; + m_widthText = -1; } private: + // calculate the size of this item, i.e. set m_width, m_height and + // m_widthText and m_heightText properly + // + // if dcUsesNormalFont is true, the current dc font must be the normal tree + // control font + void DoCalculateSize(wxGenericTreeCtrl *control, + wxDC& dc, + bool dcUsesNormalFont); + // since there can be very many of these, we save size by chosing // the smallest representation for the elements and by ordering // the members to avoid padding. wxString m_text; // label to be rendered for item + int m_widthText; + int m_heightText; wxTreeItemData *m_data; // user-provided data + int m_state; // item state + wxArrayGenericTreeItems m_children; // list of children wxGenericTreeItem *m_parent; // parent of this item @@ -291,20 +340,22 @@ private: // tree ctrl images for the normal, selected, expanded and // expanded+selected states - short m_images[wxTreeItemIcon_Max]; + int m_images[wxTreeItemIcon_Max]; wxCoord m_x; // (virtual) offset from top - short m_y; // (virtual) offset from left - short m_width; // width of this item - unsigned char m_height; // height of this item + wxCoord m_y; // (virtual) offset from left + int m_width; // width of this item + int m_height; // height of this item // use bitfields to save size - int m_isCollapsed :1; - int m_hasHilight :1; // same as focused - int m_hasPlus :1; // used for item which doesn't have + unsigned int m_isCollapsed :1; + unsigned int m_hasHilight :1; // same as focused + unsigned int m_hasPlus :1; // used for item which doesn't have // children but has a [+] button - int m_isBold :1; // render the label in bold font - int m_ownsAttr :1; // delete attribute when done + unsigned int m_isBold :1; // render the label in bold font + unsigned int m_ownsAttr :1; // delete attribute when done + + wxDECLARE_NO_COPY_CLASS(wxGenericTreeItem); }; // ============================================================================= @@ -329,6 +380,24 @@ static void EventFlagsToSelType(long style, unselect_others = !(extended_select || (ctrlDown && is_multiple)); } +// check if the given item is under another one +static bool +IsDescendantOf(const wxGenericTreeItem *parent, const wxGenericTreeItem *item) +{ + while ( item ) + { + if ( item == parent ) + { + // item is a descendant of parent + return true; + } + + item = item->GetParent(); + } + + return false; +} + // ----------------------------------------------------------------------------- // wxTreeRenameTimer (internal) // ----------------------------------------------------------------------------- @@ -353,99 +422,148 @@ BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl) EVT_KILL_FOCUS (wxTreeTextCtrl::OnKillFocus) END_EVENT_TABLE() -wxTreeTextCtrl::wxTreeTextCtrl( wxWindow *parent, - const wxWindowID id, - bool *accept, - wxString *res, - wxGenericTreeCtrl *owner, - const wxString &value, - const wxPoint &pos, - const wxSize &size, - int style, - const wxValidator& validator, - const wxString &name ) - : wxTextCtrl( parent, id, value, pos, size, style, validator, name ) -{ - m_res = res; - m_accept = accept; +wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner, + wxGenericTreeItem *item) + : m_itemEdited(item), m_startValue(item->GetText()) +{ m_owner = owner; - (*m_accept) = FALSE; - (*m_res) = wxEmptyString; - m_startValue = value; - m_finished = FALSE; + m_aboutToFinish = false; + + wxRect rect; + m_owner->GetBoundingRect(m_itemEdited, rect, true); + + // corrects position and size for better appearance +#ifdef __WXMSW__ + rect.x -= 5; + rect.width += 10; +#elif defined(__WXGTK__) + rect.x -= 5; + rect.y -= 2; + rect.width += 8; + rect.height += 4; +#elif defined(wxOSX_USE_CARBON) && wxOSX_USE_CARBON + int bestHeight = GetBestSize().y - 8; + if ( rect.height > bestHeight ) + { + int diff = rect.height - bestHeight; + rect.height -= diff; + rect.y += diff / 2; + } +#endif // platforms + + (void)Create(m_owner, wxID_ANY, m_startValue, + rect.GetPosition(), rect.GetSize()); + + SetSelection(-1, -1); } -void wxTreeTextCtrl::OnChar( wxKeyEvent &event ) +void wxTreeTextCtrl::EndEdit(bool discardChanges) { - if (event.m_keyCode == WXK_RETURN) + m_aboutToFinish = true; + + if ( discardChanges ) + { + m_owner->OnRenameCancelled(m_itemEdited); + + Finish( true ); + } + else { - (*m_accept) = TRUE; - (*m_res) = GetValue(); + // Notify the owner about the changes + AcceptChanges(); - if ((*m_res) != m_startValue) - m_owner->OnRenameAccept(); + // Even if vetoed, close the control (consistent with MSW) + Finish( true ); + } +} - if (!wxPendingDelete.Member(this)) - wxPendingDelete.Append(this); +bool wxTreeTextCtrl::AcceptChanges() +{ + const wxString value = GetValue(); - m_finished = TRUE; - m_owner->SetFocus(); // This doesn't work. TODO. + if ( value == m_startValue ) + { + // nothing changed, always accept + // when an item remains unchanged, the owner + // needs to be notified that the user decided + // not to change the tree item label, and that + // the edit has been cancelled - return; + m_owner->OnRenameCancelled(m_itemEdited); + return true; } - if (event.m_keyCode == WXK_ESCAPE) + + if ( !m_owner->OnRenameAccept(m_itemEdited, value) ) { - (*m_accept) = FALSE; - (*m_res) = ""; + // vetoed by the user + return false; + } - if (!wxPendingDelete.Member(this)) - wxPendingDelete.Append(this); + // accepted, do rename the item + m_owner->SetItemText(m_itemEdited, value); - m_finished = TRUE; - m_owner->SetFocus(); // This doesn't work. TODO. + return true; +} - return; +void wxTreeTextCtrl::Finish( bool setfocus ) +{ + m_owner->ResetTextControl(); + + wxPendingDelete.Append(this); + + if (setfocus) + m_owner->SetFocus(); +} + +void wxTreeTextCtrl::OnChar( wxKeyEvent &event ) +{ + switch ( event.m_keyCode ) + { + case WXK_RETURN: + EndEdit( false ); + break; + + case WXK_ESCAPE: + EndEdit( true ); + break; + + default: + event.Skip(); } - event.Skip(); } void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event ) { - if (m_finished) + if ( !m_aboutToFinish ) { - event.Skip(); - return; + // auto-grow the textctrl: + wxSize parentSize = m_owner->GetSize(); + wxPoint myPos = GetPosition(); + wxSize mySize = GetSize(); + int sx, sy; + GetTextExtent(GetValue() + wxT("M"), &sx, &sy); + if (myPos.x + sx > parentSize.x) + sx = parentSize.x - myPos.x; + if (mySize.x > sx) + sx = mySize.x; + SetSize(sx, wxDefaultCoord); } - // auto-grow the textctrl: - wxSize parentSize = m_owner->GetSize(); - wxPoint myPos = GetPosition(); - wxSize mySize = GetSize(); - int sx, sy; - GetTextExtent(GetValue() + _T("M"), &sx, &sy); - if (myPos.x + sx > parentSize.x) sx = parentSize.x - myPos.x; - if (mySize.x > sx) sx = mySize.x; - SetSize(sx, -1); - event.Skip(); } void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event ) { - if (m_finished) + if ( !m_aboutToFinish ) { - event.Skip(); - return; - } + if ( !AcceptChanges() ) + m_owner->OnRenameCancelled( m_itemEdited ); - if (!wxPendingDelete.Member(this)) - wxPendingDelete.Append(this); - - (*m_accept) = TRUE; - (*m_res) = GetValue(); + Finish( false ); + } - if ((*m_res) != m_startValue) - m_owner->OnRenameAccept(); + // We should let the native text control handle focus, too. + event.Skip(); } // ----------------------------------------------------------------------------- @@ -464,21 +582,25 @@ wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent, m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE; m_data = data; + m_state = wxTREE_ITEMSTATE_NONE; m_x = m_y = 0; - m_isCollapsed = TRUE; - m_hasHilight = FALSE; - m_hasPlus = FALSE; - m_isBold = FALSE; + m_isCollapsed = true; + m_hasHilight = false; + m_hasPlus = false; + m_isBold = false; m_parent = parent; - m_attr = (wxTreeItemAttr *)NULL; - m_ownsAttr = FALSE; + m_attr = NULL; + m_ownsAttr = false; // We don't know the height here yet. m_width = 0; m_height = 0; + + m_widthText = -1; + m_heightText = -1; } wxGenericTreeItem::~wxGenericTreeItem() @@ -488,33 +610,29 @@ wxGenericTreeItem::~wxGenericTreeItem() if (m_ownsAttr) delete m_attr; wxASSERT_MSG( m_children.IsEmpty(), - wxT("please call DeleteChildren() before deleting the item") ); + "must call DeleteChildren() before deleting the item" ); } void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree) { - size_t count = m_children.Count(); + size_t count = m_children.GetCount(); for ( size_t n = 0; n < count; n++ ) { wxGenericTreeItem *child = m_children[n]; - if (tree) - tree->SendDeleteEvent(child); + tree->SendDeleteEvent(child); child->DeleteChildren(tree); + if ( child == tree->m_select_me ) + tree->m_select_me = NULL; delete child; } m_children.Empty(); } -void wxGenericTreeItem::SetText( const wxString &text ) -{ - m_text = text; -} - size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const { - size_t count = m_children.Count(); + size_t count = m_children.GetCount(); if ( !recursively ) return count; @@ -537,7 +655,7 @@ void wxGenericTreeItem::GetSize( int &x, int &y, if (IsExpanded()) { - size_t count = m_children.Count(); + size_t count = m_children.GetCount(); for ( size_t n = 0; n < count; ++n ) { m_children[n]->GetSize( x, y, theButton ); @@ -563,11 +681,19 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point, else flags |= wxTREE_HITTEST_ONITEMLOWERPART; - // 5 is the size of the plus sign int xCross = m_x - theCtrl->GetSpacing(); - if ((point.x > xCross-5) && (point.x < xCross+5) && - (point.y > y_mid-5) && (point.y < y_mid+5) && +#ifdef __WXMAC__ + // according to the drawing code the triangels are drawn + // at -4 , -4 from the position up to +10/+10 max + if ((point.x > xCross-4) && (point.x < xCross+10) && + (point.y > y_mid-4) && (point.y < y_mid+10) && + HasPlus() && theCtrl->HasButtons() ) +#else + // 5 is the size of the plus sign + if ((point.x > xCross-6) && (point.x < xCross+6) && + (point.y > y_mid-6) && (point.y < y_mid+6) && HasPlus() && theCtrl->HasButtons() ) +#endif { flags |= wxTREE_HITTEST_ONITEMBUTTON; return this; @@ -580,10 +706,29 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point, // assuming every image (normal and selected) has the same size! if ( (GetImage() != NO_IMAGE) && theCtrl->m_imageListNormal ) + { theCtrl->m_imageListNormal->GetSize(GetImage(), image_w, image_h); + } + + int state_w = -1; + int state_h; + + if ( (GetState() != wxTREE_ITEMSTATE_NONE) && + theCtrl->m_imageListState ) + { + theCtrl->m_imageListState->GetSize(GetState(), + state_w, state_h); + } - if ((image_w != -1) && (point.x <= m_x + image_w + 1)) + if ((state_w != -1) && (point.x <= m_x + state_w + 1)) + flags |= wxTREE_HITTEST_ONITEMSTATEICON; + else if ((image_w != -1) && + (point.x <= m_x + + (state_w != -1 ? state_w + + MARGIN_BETWEEN_STATE_AND_IMAGE + : 0) + + image_w + 1)) flags |= wxTREE_HITTEST_ONITEMICON; else flags |= wxTREE_HITTEST_ONITEMLABEL; @@ -600,11 +745,11 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point, } // if children are expanded, fall through to evaluate them - if (m_isCollapsed) return (wxGenericTreeItem*) NULL; + if (m_isCollapsed) return NULL; } // evaluate children - size_t count = m_children.Count(); + size_t count = m_children.GetCount(); for ( size_t n = 0; n < count; n++ ) { wxGenericTreeItem *res = m_children[n]->HitTest( point, @@ -615,7 +760,7 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point, return res; } - return (wxGenericTreeItem*) NULL; + return NULL; } int wxGenericTreeItem::GetCurrentImage() const @@ -648,39 +793,134 @@ int wxGenericTreeItem::GetCurrentImage() const return image; } +void wxGenericTreeItem::CalculateSize(wxGenericTreeCtrl* control) +{ + // check if we need to do anything before creating the DC + if ( m_width != 0 ) + return; + + wxClientDC dc(control); + DoCalculateSize(control, dc, false /* normal font not used */); +} + +void +wxGenericTreeItem::DoCalculateSize(wxGenericTreeCtrl* control, + wxDC& dc, + bool dcUsesNormalFont) +{ + if ( m_width != 0 ) // Size known, nothing to do + return; + + if ( m_widthText == -1 ) + { + bool fontChanged; + if ( SetFont(control, dc) ) + { + fontChanged = true; + } + else // we have no special font + { + if ( !dcUsesNormalFont ) + { + // but we do need to ensure that the normal font is used: notice + // that this doesn't count as changing the font as we don't need + // to restore it + dc.SetFont(control->m_normalFont); + } + + fontChanged = false; + } + + dc.GetTextExtent( GetText(), &m_widthText, &m_heightText ); + + // restore normal font if the DC used it previously and we changed it + if ( fontChanged ) + dc.SetFont(control->m_normalFont); + } + + int text_h = m_heightText + 2; + + int image_h = 0, image_w = 0; + int image = GetCurrentImage(); + if ( image != NO_IMAGE && control->m_imageListNormal ) + { + control->m_imageListNormal->GetSize(image, image_w, image_h); + image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT; + } + + int state_h = 0, state_w = 0; + int state = GetState(); + if ( state != wxTREE_ITEMSTATE_NONE && control->m_imageListState ) + { + control->m_imageListState->GetSize(state, state_w, state_h); + if ( image_w != 0 ) + state_w += MARGIN_BETWEEN_STATE_AND_IMAGE; + else + state_w += MARGIN_BETWEEN_IMAGE_AND_TEXT; + } + + int img_h = wxMax(state_h, image_h); + m_height = wxMax(img_h, text_h); + + if (m_height < 30) + m_height += 2; // at least 2 pixels + else + m_height += m_height / 10; // otherwise 10% extra spacing + + if (m_height > control->m_lineHeight) + control->m_lineHeight = m_height; + + m_width = state_w + image_w + m_widthText + 2; +} + +void wxGenericTreeItem::RecursiveResetSize() +{ + m_width = 0; + + const size_t count = m_children.Count(); + for (size_t i = 0; i < count; i++ ) + m_children[i]->RecursiveResetSize(); +} + +void wxGenericTreeItem::RecursiveResetTextSize() +{ + m_width = 0; + m_widthText = -1; + + const size_t count = m_children.Count(); + for (size_t i = 0; i < count; i++ ) + m_children[i]->RecursiveResetTextSize(); +} + // ----------------------------------------------------------------------------- // wxGenericTreeCtrl implementation // ----------------------------------------------------------------------------- -IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxScrolledWindow) +IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxControl) -BEGIN_EVENT_TABLE(wxGenericTreeCtrl,wxScrolledWindow) +BEGIN_EVENT_TABLE(wxGenericTreeCtrl, wxTreeCtrlBase) EVT_PAINT (wxGenericTreeCtrl::OnPaint) + EVT_SIZE (wxGenericTreeCtrl::OnSize) EVT_MOUSE_EVENTS (wxGenericTreeCtrl::OnMouse) + EVT_KEY_DOWN (wxGenericTreeCtrl::OnKeyDown) EVT_CHAR (wxGenericTreeCtrl::OnChar) EVT_SET_FOCUS (wxGenericTreeCtrl::OnSetFocus) EVT_KILL_FOCUS (wxGenericTreeCtrl::OnKillFocus) - EVT_IDLE (wxGenericTreeCtrl::OnIdle) + EVT_TREE_ITEM_GETTOOLTIP(wxID_ANY, wxGenericTreeCtrl::OnGetToolTip) END_EVENT_TABLE() -#if !defined(__WXMSW__) || defined(__WIN16__) || defined(__WXUNIVERSAL__) -/* - * wxTreeCtrl has to be a real class or we have problems with - * the run-time information. - */ - -IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl) -#endif - // ----------------------------------------------------------------------------- // construction/destruction // ----------------------------------------------------------------------------- void wxGenericTreeCtrl::Init() { - m_current = m_key_current = m_anchor = (wxGenericTreeItem *) NULL; - m_hasFocus = FALSE; - m_dirty = FALSE; + m_current = + m_key_current = + m_anchor = + m_select_me = NULL; + m_hasFocus = false; + m_dirty = false; m_lineHeight = 10; m_indent = 15; @@ -692,7 +932,7 @@ void wxGenericTreeCtrl::Init() ( wxSYS_COLOUR_HIGHLIGHT ), - wxSOLID + wxBRUSHSTYLE_SOLID ); m_hilightUnfocusedBrush = new wxBrush @@ -701,29 +941,35 @@ void wxGenericTreeCtrl::Init() ( wxSYS_COLOUR_BTNSHADOW ), - wxSOLID + wxBRUSHSTYLE_SOLID ); - m_imageListNormal = m_imageListButtons = - m_imageListState = (wxImageList *) NULL; - m_ownsImageListNormal = m_ownsImageListButtons = - m_ownsImageListState = FALSE; + m_imageListButtons = NULL; + m_ownsImageListButtons = false; m_dragCount = 0; - m_isDragging = FALSE; - m_dropTarget = m_oldSelection = (wxGenericTreeItem *)NULL; + m_isDragging = false; + m_dropTarget = m_oldSelection = NULL; + m_underMouse = NULL; + m_textCtrl = NULL; m_renameTimer = NULL; + m_findTimer = NULL; - m_lastOnSame = FALSE; + m_dropEffectAboveItem = false; + m_dndEffect = NoEffect; + m_dndEffectItem = NULL; + + m_lastOnSame = false; + +#if defined( __WXMAC__ ) + m_normalFont = wxFont(wxOSX_SYSTEM_FONT_VIEWS); +#else m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ); - m_boldFont = wxFont( m_normalFont.GetPointSize(), - m_normalFont.GetFamily(), - m_normalFont.GetStyle(), - wxBOLD, - m_normalFont.GetUnderlined()); +#endif + m_boldFont = m_normalFont.Bold(); } bool wxGenericTreeCtrl::Create(wxWindow *parent, @@ -731,36 +977,30 @@ bool wxGenericTreeCtrl::Create(wxWindow *parent, const wxPoint& pos, const wxSize& size, long style, - const wxValidator &validator, + const wxValidator& validator, const wxString& name ) { #ifdef __WXMAC__ - int major,minor; - wxGetOsVersion( &major, &minor ); + int major, minor; + wxGetOsVersion(&major, &minor); - if (style & wxTR_HAS_BUTTONS) style |= wxTR_MAC_BUTTONS; - if (style & wxTR_HAS_BUTTONS) style &= ~wxTR_HAS_BUTTONS; - style &= ~wxTR_LINES_AT_ROOT; - style |= wxTR_NO_LINES; if (major < 10) style |= wxTR_ROW_LINES; - if (major >= 10) - style |= wxTR_AQUA_BUTTONS; -#endif - if (style & wxTR_AQUA_BUTTONS) - { - m_arrowRight = new wxBitmap( aqua_arrow_right ); - m_arrowDown = new wxBitmap( aqua_arrow_down ); - } - else - { - m_arrowRight = NULL; - m_arrowDown = NULL; - } + if (style & wxTR_HAS_BUTTONS) + style |= wxTR_NO_LINES; +#endif // __WXMAC__ + +#ifdef __WXGTK20__ + if (style & wxTR_HAS_BUTTONS) + style |= wxTR_NO_LINES; +#endif - wxScrolledWindow::Create( parent, id, pos, size, - style|wxHSCROLL|wxVSCROLL, name ); + if ( !wxControl::Create( parent, id, pos, size, + style|wxHSCROLL|wxVSCROLL, + validator, + name ) ) + return false; // If the tree display has no buttons, but does have // connecting lines, we can use a narrower layout. @@ -771,17 +1011,24 @@ bool wxGenericTreeCtrl::Create(wxWindow *parent, m_spacing = 10; } -#if wxUSE_VALIDATORS - SetValidator( validator ); -#endif + wxVisualAttributes attr = GetDefaultAttributes(); + SetOwnForegroundColour( attr.colFg ); + SetOwnBackgroundColour( attr.colBg ); + if (!m_hasFont) + SetOwnFont(attr.font); - SetForegroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT) ); - SetBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX) ); + // this is a misnomer: it's called "dotted pen" but uses (default) wxSOLID + // style because we apparently get performance problems when using dotted + // pen for drawing in some ports -- but under MSW it seems to work fine +#ifdef __WXMSW__ + m_dottedPen = wxPen(*wxLIGHT_GREY, 0, wxPENSTYLE_DOT); +#else + m_dottedPen = *wxGREY_PEN; +#endif -// m_dottedPen = wxPen( "grey", 0, wxDOT ); too slow under XFree86 - m_dottedPen = wxPen( wxT("grey"), 0, 0 ); + SetInitialSize(size); - return TRUE; + return true; } wxGenericTreeCtrl::~wxGenericTreeCtrl() @@ -789,18 +1036,11 @@ wxGenericTreeCtrl::~wxGenericTreeCtrl() delete m_hilightBrush; delete m_hilightUnfocusedBrush; - delete m_arrowRight; - delete m_arrowDown; - DeleteAllItems(); delete m_renameTimer; delete m_findTimer; - if (m_ownsImageListNormal) - delete m_imageListNormal; - if (m_ownsImageListState) - delete m_imageListState; if (m_ownsImageListButtons) delete m_imageListButtons; } @@ -809,24 +1049,33 @@ wxGenericTreeCtrl::~wxGenericTreeCtrl() // accessors // ----------------------------------------------------------------------------- -size_t wxGenericTreeCtrl::GetCount() const +unsigned int wxGenericTreeCtrl::GetCount() const { - return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount(); + if ( !m_anchor ) + { + // the tree is empty + return 0; + } + + unsigned int count = m_anchor->GetChildrenCount(); + if ( !HasFlag(wxTR_HIDE_ROOT) ) + { + // take the root itself into account + count++; + } + + return count; } void wxGenericTreeCtrl::SetIndent(unsigned int indent) { m_indent = (unsigned short) indent; - m_dirty = TRUE; + m_dirty = true; } -void wxGenericTreeCtrl::SetSpacing(unsigned int spacing) -{ - m_spacing = (unsigned short) spacing; - m_dirty = TRUE; -} - -size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively) +size_t +wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, + bool recursively) const { wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") ); @@ -835,11 +1084,20 @@ size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recurs void wxGenericTreeCtrl::SetWindowStyle(const long styles) { - // right now, just sets the styles. Eventually, we may - // want to update the inherited styles, but right now - // none of the parents has updatable styles + // Do not try to expand the root node if it hasn't been created yet + if (m_anchor && !HasFlag(wxTR_HIDE_ROOT) && (styles & wxTR_HIDE_ROOT)) + { + // if we will hide the root, make sure children are visible + m_anchor->SetHasPlus(); + m_anchor->Expand(); + CalculatePositions(); + } + + // right now, just sets the styles. Eventually, we may + // want to update the inherited styles, but right now + // none of the parents has updatable styles m_windowStyle = styles; - m_dirty = TRUE; + m_dirty = true; } // ----------------------------------------------------------------------------- @@ -848,7 +1106,7 @@ void wxGenericTreeCtrl::SetWindowStyle(const long styles) wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const { - wxCHECK_MSG( item.IsOk(), wxT(""), wxT("invalid tree item") ); + wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") ); return ((wxGenericTreeItem*) item.m_pItem)->GetText(); } @@ -868,14 +1126,47 @@ wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const return ((wxGenericTreeItem*) item.m_pItem)->GetData(); } -void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text) +int wxGenericTreeCtrl::DoGetItemState(const wxTreeItemId& item) const +{ + wxCHECK_MSG( item.IsOk(), wxTREE_ITEMSTATE_NONE, wxT("invalid tree item") ); + + wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; + return pItem->GetState(); +} + +wxColour wxGenericTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const +{ + wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") ); + + wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; + return pItem->Attr().GetTextColour(); +} + +wxColour +wxGenericTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const +{ + wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") ); + + wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; + return pItem->Attr().GetBackgroundColour(); +} + +wxFont wxGenericTreeCtrl::GetItemFont(const wxTreeItemId& item) const +{ + wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") ); + + wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; + return pItem->Attr().GetFont(); +} + +void +wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text) { wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); - wxClientDC dc(this); wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; pItem->SetText(text); - CalculateSize(pItem, dc); + pItem->CalculateSize(this); RefreshLine(pItem); } @@ -887,19 +1178,31 @@ void wxGenericTreeCtrl::SetItemImage(const wxTreeItemId& item, wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; pItem->SetImage(image, which); - - wxClientDC dc(this); - CalculateSize(pItem, dc); + pItem->CalculateSize(this); RefreshLine(pItem); } -void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data) +void +wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data) { wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); + if (data) + data->SetId( item ); + ((wxGenericTreeItem*) item.m_pItem)->SetData(data); } +void wxGenericTreeCtrl::DoSetItemState(const wxTreeItemId& item, int state) +{ + wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); + + wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; + pItem->SetState(state); + pItem->CalculateSize(this); + RefreshLine(pItem); +} + void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has) { wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); @@ -918,10 +1221,33 @@ void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold) if ( pItem->IsBold() != bold ) { pItem->SetBold(bold); + + // recalculate the item size as bold and non bold fonts have different + // widths + pItem->CalculateSize(this); RefreshLine(pItem); } } +void wxGenericTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, + bool highlight) +{ + wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); + + wxColour fg, bg; + + if (highlight) + { + bg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT); + fg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT); + } + + wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; + pItem->Attr().SetTextColour(fg); + pItem->Attr().SetBackgroundColour(bg); + RefreshLine(pItem); +} + void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item, const wxColour& col) { @@ -942,27 +1268,29 @@ void wxGenericTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item, RefreshLine(pItem); } -void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font) +void +wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font) { wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; pItem->Attr().SetFont(font); + pItem->ResetTextSize(); + pItem->CalculateSize(this); RefreshLine(pItem); } bool wxGenericTreeCtrl::SetFont( const wxFont &font ) { - wxScrolledWindow::SetFont(font); + wxTreeCtrlBase::SetFont(font); - m_normalFont = font ; - m_boldFont = wxFont( m_normalFont.GetPointSize(), - m_normalFont.GetFamily(), - m_normalFont.GetStyle(), - wxBOLD, - m_normalFont.GetUnderlined()); + m_normalFont = font; + m_boldFont = m_normalFont.Bold(); - return TRUE; + if (m_anchor) + m_anchor->RecursiveResetTextSize(); + + return true; } @@ -972,7 +1300,7 @@ bool wxGenericTreeCtrl::SetFont( const wxFont &font ) bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const { - wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") ); + wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") ); // An item is only visible if it's not a descendant of a collapsed item wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem; @@ -980,7 +1308,7 @@ bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const while (parent) { if (!parent->IsExpanded()) - return FALSE; + return false; parent = parent->GetParent(); } @@ -991,20 +1319,20 @@ bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const wxRect rect; if (!GetBoundingRect(item, rect)) - return FALSE; + return false; if (rect.GetWidth() == 0 || rect.GetHeight() == 0) - return FALSE; + return false; if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y) - return FALSE; + return false; if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x) - return FALSE; + return false; - return TRUE; + return true; } bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const { - wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") ); + wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") ); // consider that the item does have children if it has the "+" button: it // might not have them (if it had never been expanded yet) but then it @@ -1016,21 +1344,21 @@ bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const { - wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") ); + wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") ); return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded(); } bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const { - wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") ); + wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") ); return ((wxGenericTreeItem*) item.m_pItem)->IsSelected(); } bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const { - wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") ); + wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") ); return ((wxGenericTreeItem*) item.m_pItem)->IsBold(); } @@ -1039,14 +1367,15 @@ bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const // navigation // ----------------------------------------------------------------------------- -wxTreeItemId wxGenericTreeCtrl::GetParent(const wxTreeItemId& item) const +wxTreeItemId wxGenericTreeCtrl::GetItemParent(const wxTreeItemId& item) const { wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") ); return ((wxGenericTreeItem*) item.m_pItem)->GetParent(); } -wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const +wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, + wxTreeItemIdValue& cookie) const { wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") ); @@ -1054,14 +1383,20 @@ wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& co return GetNextChild(item, cookie); } -wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const +wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item, + wxTreeItemIdValue& cookie) const { wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") ); - wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren(); - if ( (size_t)cookie < children.Count() ) + wxArrayGenericTreeItems& + children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren(); + + // it's ok to cast cookie to size_t, we never have indices big enough to + // overflow "void *" + size_t *pIndex = (size_t *)&cookie; + if ( *pIndex < children.GetCount() ) { - return children.Item((size_t)cookie++); + return children.Item((*pIndex)++); } else { @@ -1074,8 +1409,9 @@ wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const { wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") ); - wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren(); - return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last())); + wxArrayGenericTreeItems& + children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren(); + return children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()); } wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const @@ -1095,7 +1431,8 @@ wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent? size_t n = (size_t)(index + 1); - return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]); + return n == siblings.GetCount() ? wxTreeItemId() + : wxTreeItemId(siblings[n]); } wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const @@ -1139,7 +1476,7 @@ wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const do { toFind = GetNextSibling(p); - p = GetParent(p); + p = GetItemParent(p); } while (p.IsOk() && !toFind.IsOk()); return toFind; } @@ -1147,16 +1484,16 @@ wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const { - wxTreeItemId id = GetRootItem(); - if (!id.IsOk()) - return id; + wxTreeItemId itemid = GetRootItem(); + if (!itemid.IsOk()) + return itemid; do { - if (IsVisible(id)) - return id; - id = GetNext(id); - } while (id.IsOk()); + if (IsVisible(itemid)) + return itemid; + itemid = GetNext(itemid); + } while (itemid.IsOk()); return wxTreeItemId(); } @@ -1164,6 +1501,7 @@ wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const { wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") ); + wxASSERT_MSG( IsVisible(item), wxT("this item itself should be visible") ); wxTreeItemId id = item; if (id.IsOk()) @@ -1180,10 +1518,43 @@ wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const { wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") ); + wxASSERT_MSG( IsVisible(item), wxT("this item itself should be visible") ); - wxFAIL_MSG(wxT("not implemented")); + // find out the starting point + wxTreeItemId prevItem = GetPrevSibling(item); + if ( !prevItem.IsOk() ) + { + prevItem = GetItemParent(item); + } - return wxTreeItemId(); + // find the first visible item after it + while ( prevItem.IsOk() && !IsVisible(prevItem) ) + { + prevItem = GetNext(prevItem); + if ( !prevItem.IsOk() || prevItem == item ) + { + // there are no visible items before item + return wxTreeItemId(); + } + } + + // from there we must be able to navigate until this item + while ( prevItem.IsOk() ) + { + const wxTreeItemId nextItem = GetNextVisible(prevItem); + if ( !nextItem.IsOk() || nextItem == item ) + break; + + prevItem = nextItem; + } + + return prevItem; +} + +// called by wxTextTreeCtrl when it marks itself for deletion +void wxGenericTreeCtrl::ResetTextControl() +{ + m_textCtrl = NULL; } // find the first item starting with the given prefix after the given item @@ -1195,14 +1566,44 @@ wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent, // would be too bothersome wxString prefix = prefixOrig.Lower(); - wxTreeItemId id = idParent; + // determine the starting point: we shouldn't take the current item (this + // allows to switch between two items starting with the same letter just by + // pressing it) but we shouldn't jump to the next one if the user is + // continuing to type as otherwise he might easily skip the item he wanted + wxTreeItemId itemid = idParent; + if ( prefix.length() == 1 ) + { + itemid = GetNext(itemid); + } + + // look for the item starting with the given prefix after it + while ( itemid.IsOk() && !GetItemText(itemid).Lower().StartsWith(prefix) ) + { + itemid = GetNext(itemid); + } - while ( id.IsOk() && !GetItemText(id).Lower().StartsWith(prefix) ) + // if we haven't found anything... + if ( !itemid.IsOk() ) { - id = GetNext(id); + // ... wrap to the beginning + itemid = GetRootItem(); + if ( HasFlag(wxTR_HIDE_ROOT) ) + { + // can't select virtual root + itemid = GetNext(itemid); + } + + // and try all the items (stop when we get to the one we started from) + while ( itemid.IsOk() && itemid != idParent && + !GetItemText(itemid).Lower().StartsWith(prefix) ) + { + itemid = GetNext(itemid); + } + // If we haven't found the item, id.IsOk() will be false, as per + // documentation } - return id; + return itemid; } // ----------------------------------------------------------------------------- @@ -1210,10 +1611,11 @@ wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent, // ----------------------------------------------------------------------------- wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId, - size_t previous, - const wxString& text, - int image, int selImage, - wxTreeItemData *data) + size_t previous, + const wxString& text, + int image, + int selImage, + wxTreeItemData *data) { wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem; if ( !parent ) @@ -1222,34 +1624,37 @@ wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId, return AddRoot(text, image, selImage, data); } - m_dirty = TRUE; // do this first so stuff below doesn't cause flicker + m_dirty = true; // do this first so stuff below doesn't cause flicker wxGenericTreeItem *item = new wxGenericTreeItem( parent, text, image, selImage, data ); if ( data != NULL ) { - data->m_pItem = (long) item; + data->m_pItem = item; } - parent->Insert( item, previous ); + parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size() + : previous ); + InvalidateBestSize(); return item; } wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text, - int image, int selImage, - wxTreeItemData *data) + int image, + int selImage, + wxTreeItemData *data) { - wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") ); + wxCHECK_MSG( !m_anchor, wxTreeItemId(), "tree can have only one root" ); - m_dirty = TRUE; // do this first so stuff below doesn't cause flicker + m_dirty = true; // do this first so stuff below doesn't cause flicker - m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text, + m_anchor = new wxGenericTreeItem(NULL, text, image, selImage, data); if ( data != NULL ) { - data->m_pItem = (long) m_anchor; + data->m_pItem = m_anchor; } if (HasFlag(wxTR_HIDE_ROOT)) @@ -1264,25 +1669,18 @@ wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text, if (!HasFlag(wxTR_MULTIPLE)) { m_current = m_key_current = m_anchor; - m_current->SetHilight( TRUE ); + m_current->SetHilight( true ); } + InvalidateBestSize(); return m_anchor; } -wxTreeItemId wxGenericTreeCtrl::PrependItem(const wxTreeItemId& parent, - const wxString& text, - int image, int selImage, - wxTreeItemData *data) -{ - return DoInsertItem(parent, 0u, text, image, selImage, data); -} - -wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId, - const wxTreeItemId& idPrevious, - const wxString& text, - int image, int selImage, - wxTreeItemData *data) +wxTreeItemId wxGenericTreeCtrl::DoInsertAfter(const wxTreeItemId& parentId, + const wxTreeItemId& idPrevious, + const wxString& text, + int image, int selImage, + wxTreeItemData *data) { wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem; if ( !parent ) @@ -1294,110 +1692,141 @@ wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId, int index = -1; if (idPrevious.IsOk()) { - index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem); + index = parent->GetChildren().Index( + (wxGenericTreeItem*) idPrevious.m_pItem); wxASSERT_MSG( index != wxNOT_FOUND, - wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") ); + "previous item in wxGenericTreeCtrl::InsertItem() " + "is not a sibling" ); } return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data); } -wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId, - size_t before, - const wxString& text, - int image, int selImage, - wxTreeItemData *data) -{ - wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem; - if ( !parent ) - { - // should we give a warning here? - return AddRoot(text, image, selImage, data); - } - return DoInsertItem(parentId, before, text, image, selImage, data); +void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item) +{ + wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, this, item); + GetEventHandler()->ProcessEvent( event ); } -wxTreeItemId wxGenericTreeCtrl::AppendItem(const wxTreeItemId& parentId, - const wxString& text, - int image, int selImage, - wxTreeItemData *data) +// Don't leave edit or selection on a child which is about to disappear +void wxGenericTreeCtrl::ChildrenClosing(wxGenericTreeItem* item) { - wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem; - if ( !parent ) + if ( m_textCtrl && item != m_textCtrl->item() && + IsDescendantOf(item, m_textCtrl->item()) ) { - // should we give a warning here? - return AddRoot(text, image, selImage, data); + m_textCtrl->EndEdit( true ); } - return DoInsertItem( parent, parent->GetChildren().Count(), text, - image, selImage, data); -} + if ( item != m_key_current && IsDescendantOf(item, m_key_current) ) + { + m_key_current = NULL; + } -void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item) -{ - wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() ); - event.m_item = (long) item; - event.SetEventObject( this ); - ProcessEvent( event ); + if ( IsDescendantOf(item, m_select_me) ) + { + m_select_me = item; + } + + if ( item != m_current && IsDescendantOf(item, m_current) ) + { + m_current->SetHilight( false ); + m_current = NULL; + m_select_me = item; + } } void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId) { - m_dirty = TRUE; // do this first so stuff below doesn't cause flicker + m_dirty = true; // do this first so stuff below doesn't cause flicker wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem; + ChildrenClosing(item); item->DeleteChildren(this); + InvalidateBestSize(); } void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId) { - m_dirty = TRUE; // do this first so stuff below doesn't cause flicker + m_dirty = true; // do this first so stuff below doesn't cause flicker wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem; - // don't stay with invalid m_key_current or we will crash in - // the next call to OnChar() - bool changeKeyCurrent = FALSE; - wxGenericTreeItem *itemKey = m_key_current; - while ( itemKey ) + if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item())) { - if ( itemKey == item ) - { - // m_key_current is a descendant of the item being deleted - changeKeyCurrent = TRUE; - break; - } - itemKey = itemKey->GetParent(); + // can't delete the item being edited, cancel editing it first + m_textCtrl->EndEdit( true ); } wxGenericTreeItem *parent = item->GetParent(); + + // if the selected item will be deleted, select the parent ... + wxGenericTreeItem *to_be_selected = parent; + if (parent) + { + // .. unless there is a next sibling like wxMSW does it + int pos = parent->GetChildren().Index( item ); + if ((int)(parent->GetChildren().GetCount()) > pos+1) + to_be_selected = parent->GetChildren().Item( pos+1 ); + } + + // don't keep stale pointers around! + if ( IsDescendantOf(item, m_key_current) ) + { + // Don't silently change the selection: + // do it properly in idle time, so event + // handlers get called. + + // m_key_current = parent; + m_key_current = NULL; + } + + // m_select_me records whether we need to select + // a different item, in idle time. + if ( m_select_me && IsDescendantOf(item, m_select_me) ) + { + m_select_me = to_be_selected; + } + + if ( IsDescendantOf(item, m_current) ) + { + // Don't silently change the selection: + // do it properly in idle time, so event + // handlers get called. + + // m_current = parent; + m_current = NULL; + m_select_me = to_be_selected; + } + + // remove the item from the tree if ( parent ) { parent->GetChildren().Remove( item ); // remove by value } - - if ( changeKeyCurrent ) + else // deleting the root { - // may be NULL or not - m_key_current = parent; + // nothing will be left in the tree + m_anchor = NULL; } + // and delete all of its children and the item itself now item->DeleteChildren(this); SendDeleteEvent(item); + + if (item == m_select_me) + m_select_me = NULL; + delete item; + + InvalidateBestSize(); } void wxGenericTreeCtrl::DeleteAllItems() { if ( m_anchor ) { - m_dirty = TRUE; - - m_anchor->DeleteChildren(this); - delete m_anchor; - - m_anchor = NULL; + Delete(m_anchor); } } @@ -1405,9 +1834,9 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId) { wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem; - wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") ); + wxCHECK_RET( item, wxT("invalid item in wxGenericTreeCtrl::Expand") ); wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(), - _T("can't expand hidden root") ); + wxT("can't expand hidden root") ); if ( !item->HasPlus() ) return; @@ -1415,65 +1844,53 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId) if ( item->IsExpanded() ) return; - wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() ); - event.m_item = (long) item; - event.SetEventObject( this ); + wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDING, this, item); - if ( ProcessEvent( event ) && !event.IsAllowed() ) + if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() ) { // cancelled by program return; } item->Expand(); - CalculatePositions(); - - RefreshSubtree(item); - - event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED); - ProcessEvent( event ); -} - -void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item) -{ - Expand(item); - if ( IsExpanded(item) ) + if ( !IsFrozen() ) { - long cookie; - wxTreeItemId child = GetFirstChild(item, cookie); - while ( child.IsOk() ) - { - ExpandAll(child); + CalculatePositions(); - child = GetNextChild(item, cookie); - } + RefreshSubtree(item); + } + else // frozen + { + m_dirty = true; } + + event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED); + GetEventHandler()->ProcessEvent( event ); } void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId) { wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(), - _T("can't collapse hidden root") ); + wxT("can't collapse hidden root") ); wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem; if ( !item->IsExpanded() ) return; - wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() ); - event.m_item = (long) item; - event.SetEventObject( this ); - if ( ProcessEvent( event ) && !event.IsAllowed() ) + wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, this, item); + if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() ) { // cancelled by program return; } + ChildrenClosing(item); item->Collapse(); #if 0 // TODO why should items be collapsed recursively? wxArrayGenericTreeItems& children = item->GetChildren(); - size_t count = children.Count(); + size_t count = children.GetCount(); for ( size_t n = 0; n < count; n++ ) { Collapse(children[n]); @@ -1485,7 +1902,7 @@ void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId) RefreshSubtree(item); event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED); - ProcessEvent( event ); + GetEventHandler()->ProcessEvent( event ); } void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item) @@ -1508,23 +1925,40 @@ void wxGenericTreeCtrl::Unselect() { if (m_current) { - m_current->SetHilight( FALSE ); + m_current->SetHilight( false ); RefreshLine( m_current ); + + m_current = NULL; + m_select_me = NULL; } } +void wxGenericTreeCtrl::ClearFocusedItem() +{ + wxTreeItemId item = GetFocusedItem(); + if ( item.IsOk() ) + SelectItem(item, false); +} + +void wxGenericTreeCtrl::SetFocusedItem(const wxTreeItemId& item) +{ + wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); + + SelectItem(item, true); +} + void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item) { if (item->IsSelected()) { - item->SetHilight(FALSE); + item->SetHilight(false); RefreshLine(item); } if (item->HasChildren()) { wxArrayGenericTreeItems& children = item->GetChildren(); - size_t count = children.Count(); + size_t count = children.GetCount(); for ( size_t n = 0; n < count; ++n ) { UnselectAllChildren(children[n]); @@ -1543,13 +1977,52 @@ void wxGenericTreeCtrl::UnselectAll() } } +void wxGenericTreeCtrl::SelectChildren(const wxTreeItemId& parent) +{ + wxCHECK_RET( HasFlag(wxTR_MULTIPLE), + "this only works with multiple selection controls" ); + + UnselectAll(); + + if ( !HasChildren(parent) ) + return; + + + wxArrayGenericTreeItems& + children = ((wxGenericTreeItem*) parent.m_pItem)->GetChildren(); + size_t count = children.GetCount(); + + wxGenericTreeItem * + item = (wxGenericTreeItem*) ((wxTreeItemId)children[0]).m_pItem; + wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item); + event.m_itemOld = m_current; + + if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() ) + return; + + for ( size_t n = 0; n < count; ++n ) + { + m_current = m_key_current = children[n]; + m_current->SetHilight(true); + RefreshSelected(); + } + + + event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED); + GetEventHandler()->ProcessEvent( event ); +} + + // Recursive function ! // To stop we must have crt_itemGetParent(); @@ -1560,53 +2033,51 @@ bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTr int index = children.Index(crt_item); wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent? - size_t count = children.Count(); + size_t count = children.GetCount(); for (size_t n=(size_t)(index+1); nSetHilight(select); RefreshLine(crt_item); if (crt_item==last_item) - return TRUE; + return true; if (crt_item->HasChildren()) { wxArrayGenericTreeItems& children = crt_item->GetChildren(); - size_t count = children.Count(); + size_t count = children.GetCount(); for ( size_t n = 0; n < count; ++n ) { if (TagAllChildrenUntilLast(children[n], last_item, select)) - return TRUE; + return true; } } - return FALSE; + return false; } -void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2) +void +wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, + wxGenericTreeItem *item2) { - // item2 is not necessary after item1 - wxGenericTreeItem *first=NULL, *last=NULL; + m_select_me = NULL; + // item2 is not necessary after item1 // choice first' and 'last' between item1 and item2 - if (item1->GetY()GetY()) - { - first=item1; - last=item2; - } - else - { - first=item2; - last=item1; - } + wxGenericTreeItem *first= (item1->GetY()GetY()) ? item1 : item2; + wxGenericTreeItem *last = (item1->GetY()GetY()) ? item2 : item1; bool select = m_current->IsSelected(); @@ -1616,12 +2087,14 @@ void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeI TagNextChildren(first,last,select); } -void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, - bool unselect_others, - bool extended_select) +void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId, + bool unselect_others, + bool extended_select) { wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") ); + m_select_me = NULL; + bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE); wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem; @@ -1633,8 +2106,8 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, { if (item->IsSelected()) return; // nothing to do - unselect_others = TRUE; - extended_select = FALSE; + unselect_others = true; + extended_select = false; } else if ( unselect_others && item->IsSelected() ) { @@ -1644,26 +2117,22 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, return; } - wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() ); - event.m_item = (long) item; - event.m_itemOld = (long) m_current; - event.SetEventObject( this ); + wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item); + event.m_itemOld = m_current; // TODO : Here we don't send any selection mode yet ! if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() ) return; - wxTreeItemId parent = GetParent( itemId ); + wxTreeItemId parent = GetItemParent( itemId ); while (parent.IsOk()) { if (!IsExpanded(parent)) Expand( parent ); - parent = GetParent( parent ); + parent = GetItemParent( parent ); } - EnsureVisible( itemId ); - // ctrl press if (unselect_others) { @@ -1676,7 +2145,8 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, { if ( !m_current ) { - m_current = m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem; + m_current = + m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem; } // don't change the mark (m_current) @@ -1684,7 +2154,7 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, } else { - bool select=TRUE; // the default + bool select = true; // the default // Check if we need to toggle hilight (ctrl mode) if (!unselect_others) @@ -1695,10 +2165,39 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, RefreshLine( m_current ); } + // This can cause idle processing to select the root + // if no item is selected, so it must be after the + // selection is set + EnsureVisible( itemId ); + event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED); GetEventHandler()->ProcessEvent( event ); } +void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, bool select) +{ + wxGenericTreeItem * const item = (wxGenericTreeItem*) itemId.m_pItem; + wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") ); + + if ( select ) + { + if ( !item->IsSelected() ) + DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE)); + } + else // deselect + { + wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item); + if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() ) + return; + + item->SetHilight(false); + RefreshLine(item); + + event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED); + GetEventHandler()->ProcessEvent( event ); + } +} + void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item, wxArrayTreeItemIds &array) const { @@ -1724,11 +2223,13 @@ size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const } //else: the tree is empty, so no selections - return array.Count(); + return array.GetCount(); } void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item) { + wxCHECK_RET( item.IsOk(), wxT("invalid tree item") ); + if (!item.IsOk()) return; wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem; @@ -1738,7 +2239,7 @@ void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item) if ( HasFlag(wxTR_HIDE_ROOT) ) { - while ( parent != m_anchor ) + while ( parent && parent != m_anchor ) { Expand(parent); parent = parent->GetParent(); @@ -1760,52 +2261,42 @@ void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item) void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item) { - if (!item.IsOk()) return; + if (!item.IsOk()) + return; - // We have to call this here because the label in - // question might just have been added and no screen - // update taken place. - if (m_dirty) wxYieldIfNeeded(); + // update the control before scrolling it + if (m_dirty) +#if defined( __WXMSW__ ) || defined(__WXMAC__) + Update(); +#else + DoDirtyProcessing(); +#endif wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem; - // now scroll to the item - int item_y = gitem->GetY(); + int itemY = gitem->GetY(); int start_x = 0; int start_y = 0; GetViewStart( &start_x, &start_y ); - start_y *= PIXELS_PER_UNIT; - int client_h = 0; - int client_w = 0; - GetClientSize( &client_w, &client_h ); + const int clientHeight = GetClientSize().y; + + const int itemHeight = GetLineHeight(gitem) + 2; - if (item_y < start_y+3) + if ( itemY + itemHeight > start_y*PIXELS_PER_UNIT + clientHeight ) { - // going down - int x = 0; - int y = 0; - m_anchor->GetSize( x, y, this ); - y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels - x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels - int x_pos = GetScrollPos( wxHORIZONTAL ); - // Item should appear at top - SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT ); + // need to scroll up by enough to show this item fully + itemY += itemHeight - clientHeight; } - else if (item_y+GetLineHeight(gitem) > start_y+client_h) + else if ( itemY > start_y*PIXELS_PER_UNIT ) { - // going up - int x = 0; - int y = 0; - m_anchor->GetSize( x, y, this ); - y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels - x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels - item_y += PIXELS_PER_UNIT+2; - int x_pos = GetScrollPos( wxHORIZONTAL ); - // Item should appear at bottom - 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 ); + // item is already fully visible, don't do anything + return; } + //else: scroll down to make this item the top one displayed + + Scroll(-1, itemY/PIXELS_PER_UNIT); } // FIXME: tree sorting functions are not reentrant and not MT-safe! @@ -1814,17 +2305,12 @@ static wxGenericTreeCtrl *s_treeBeingSorted = NULL; static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1, wxGenericTreeItem **item2) { - wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") ); + wxCHECK_MSG( s_treeBeingSorted, 0, + "bug in wxGenericTreeCtrl::SortChildren()" ); return s_treeBeingSorted->OnCompareItems(*item1, *item2); } -int wxGenericTreeCtrl::OnCompareItems(const wxTreeItemId& item1, - const wxTreeItemId& item2) -{ - return wxStrcmp(GetItemText(item1), GetItemText(item2)); -} - void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId) { wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") ); @@ -1835,9 +2321,9 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId) wxT("wxGenericTreeCtrl::SortChildren is not reentrant") ); wxArrayGenericTreeItems& children = item->GetChildren(); - if ( children.Count() > 1 ) + if ( children.GetCount() > 1 ) { - m_dirty = TRUE; + m_dirty = true; s_treeBeingSorted = this; children.Sort(tree_ctrl_compare_func); @@ -1846,21 +2332,6 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId) //else: don't make the tree dirty as nothing changed } -wxImageList *wxGenericTreeCtrl::GetImageList() const -{ - return m_imageListNormal; -} - -wxImageList *wxGenericTreeCtrl::GetButtonsImageList() const -{ - return m_imageListButtons; -} - -wxImageList *wxGenericTreeCtrl::GetStateImageList() const -{ - return m_imageListState; -} - void wxGenericTreeCtrl::CalculateLineHeight() { wxClientDC dc(this); @@ -1880,6 +2351,20 @@ void wxGenericTreeCtrl::CalculateLineHeight() } } + if ( m_imageListState ) + { + // Calculate a m_lineHeight value from the state Image sizes. + // May be toggle off. Then wxGenericTreeCtrl will spread when + // necessary (which might look ugly). + int n = m_imageListState->GetImageCount(); + for (int i = 0; i < n ; i++) + { + int width = 0, height = 0; + m_imageListState->GetSize(i, width, height); + if (height > m_lineHeight) m_lineHeight = height; + } + } + if (m_imageListButtons) { // Calculate a m_lineHeight value from the Button image sizes. @@ -1904,8 +2389,12 @@ void wxGenericTreeCtrl::SetImageList(wxImageList *imageList) { if (m_ownsImageListNormal) delete m_imageListNormal; m_imageListNormal = imageList; - m_ownsImageListNormal = FALSE; - m_dirty = TRUE; + m_ownsImageListNormal = false; + m_dirty = true; + + if (m_anchor) + m_anchor->RecursiveResetSize(); + // Don't do any drawing if we're setting the list to NULL, // since we may be in the process of deleting the tree control. if (imageList) @@ -1916,34 +2405,35 @@ void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList) { if (m_ownsImageListState) delete m_imageListState; m_imageListState = imageList; - m_ownsImageListState = FALSE; + m_ownsImageListState = false; + m_dirty = true; + + if (m_anchor) + m_anchor->RecursiveResetSize(); + + // Don't do any drawing if we're setting the list to NULL, + // since we may be in the process of deleting the tree control. + if (imageList) + CalculateLineHeight(); } void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList) { if (m_ownsImageListButtons) delete m_imageListButtons; m_imageListButtons = imageList; - m_ownsImageListButtons = FALSE; - m_dirty = TRUE; - CalculateLineHeight(); -} + m_ownsImageListButtons = false; + m_dirty = true; -void wxGenericTreeCtrl::AssignImageList(wxImageList *imageList) -{ - SetImageList(imageList); - m_ownsImageListNormal = TRUE; -} + if (m_anchor) + m_anchor->RecursiveResetSize(); -void wxGenericTreeCtrl::AssignStateImageList(wxImageList *imageList) -{ - SetStateImageList(imageList); - m_ownsImageListState = TRUE; + CalculateLineHeight(); } void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList) { SetButtonsImageList(imageList); - m_ownsImageListButtons = TRUE; + m_ownsImageListButtons = true; } // ----------------------------------------------------------------------------- @@ -1960,7 +2450,9 @@ void wxGenericTreeCtrl::AdjustMyScrollbars() x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels int x_pos = GetScrollPos( wxHORIZONTAL ); int y_pos = GetScrollPos( wxVERTICAL ); - SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos ); + SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, + x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, + x_pos, y_pos ); } else { @@ -1978,16 +2470,10 @@ int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc) { - // TODO implement "state" icon on items - - wxTreeItemAttr *attr = item->GetAttributes(); - if ( attr && attr->HasFont() ) - dc.SetFont(attr->GetFont()); - else if (item->IsBold()) - dc.SetFont(m_boldFont); + item->SetFont(this, dc); + item->CalculateSize(this, dc); - long text_w = 0, text_h = 0; - dc.GetTextExtent( item->GetText(), &text_w, &text_h ); + wxCoord text_h = item->GetTextHeight(); int image_h = 0, image_w = 0; int image = item->GetCurrentImage(); @@ -1995,8 +2481,8 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc) { if ( m_imageListNormal ) { - m_imageListNormal->GetSize( image, image_w, image_h ); - image_w += 4; + m_imageListNormal->GetSize(image, image_w, image_h); + image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT; } else { @@ -2004,71 +2490,208 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc) } } + int state_h = 0, state_w = 0; + int state = item->GetState(); + if ( state != wxTREE_ITEMSTATE_NONE ) + { + if ( m_imageListState ) + { + m_imageListState->GetSize(state, state_w, state_h); + if ( image_w != 0 ) + state_w += MARGIN_BETWEEN_STATE_AND_IMAGE; + else + state_w += MARGIN_BETWEEN_IMAGE_AND_TEXT; + } + else + { + state = wxTREE_ITEMSTATE_NONE; + } + } + int total_h = GetLineHeight(item); + bool drawItemBackground = false, + hasBgColour = false; if ( item->IsSelected() ) { dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush)); + drawItemBackground = true; } else { wxColour colBg; + wxTreeItemAttr * const attr = item->GetAttributes(); if ( attr && attr->HasBackgroundColour() ) + { + drawItemBackground = + hasBgColour = true; colBg = attr->GetBackgroundColour(); + } else - colBg = m_backgroundColour; - dc.SetBrush(wxBrush(colBg, wxSOLID)); + { + colBg = GetBackgroundColour(); + } + dc.SetBrush(wxBrush(colBg, wxBRUSHSTYLE_SOLID)); } int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0; if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) ) { - int x, y, w, h; + int x, w, h; + x=0; + GetVirtualSize(&w, &h); + wxRect rect( x, item->GetY()+offset, w, total_h-offset); + if (!item->IsSelected()) + { + dc.DrawRectangle(rect); + } + else + { + int flags = wxCONTROL_SELECTED; + if (m_hasFocus +#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__) && wxOSX_USE_CARBON // TODO CS + && IsControlActive( (ControlRef)GetHandle() ) +#endif + ) + flags |= wxCONTROL_FOCUSED; + if ((item == m_current) && (m_hasFocus)) + flags |= wxCONTROL_CURRENT; - DoGetPosition(&x, &y); - DoGetSize(&w, &h); - dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset); + wxRendererNative::Get(). + DrawItemSelectionRect(this, dc, rect, flags); + } } - else + else // no full row highlight { - if ( item->IsSelected() && image != NO_IMAGE ) + if ( item->IsSelected() && + (state != wxTREE_ITEMSTATE_NONE || image != NO_IMAGE) ) { - // If it's selected, and there's an image, then we should - // take care to leave the area under the image painted in the - // background colour. - dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset, - item->GetWidth() - image_w + 2, total_h-offset ); + // If it's selected, and there's an state image or normal image, + // then we should take care to leave the area under the image + // painted in the background colour. + wxRect rect( item->GetX() + state_w + image_w - 2, + item->GetY() + offset, + item->GetWidth() - state_w - image_w + 2, + total_h - offset ); +#if !defined(__WXGTK20__) && !defined(__WXMAC__) + dc.DrawRectangle( rect ); +#else + rect.x -= 1; + rect.width += 2; + + int flags = wxCONTROL_SELECTED; + if (m_hasFocus) + flags |= wxCONTROL_FOCUSED; + if ((item == m_current) && (m_hasFocus)) + flags |= wxCONTROL_CURRENT; + wxRendererNative::Get(). + DrawItemSelectionRect(this, dc, rect, flags); +#endif } - else + // On GTK+ 2, drawing a 'normal' background is wrong for themes that + // don't allow backgrounds to be customized. Not drawing the background, + // except for custom item backgrounds, works for both kinds of theme. + else if (drawItemBackground) { - dc.DrawRectangle( item->GetX()-2, item->GetY()+offset, - item->GetWidth()+2, total_h-offset ); + wxRect rect( item->GetX() + state_w + image_w - 2, + item->GetY() + offset, + item->GetWidth() - state_w - image_w + 2, + total_h - offset ); + if ( hasBgColour ) + { + dc.DrawRectangle( rect ); + } + else // no specific background colour + { + rect.x -= 1; + rect.width += 2; + + int flags = wxCONTROL_SELECTED; + if (m_hasFocus) + flags |= wxCONTROL_FOCUSED; + if ((item == m_current) && (m_hasFocus)) + flags |= wxCONTROL_CURRENT; + wxRendererNative::Get(). + DrawItemSelectionRect(this, dc, rect, flags); + } } } + if ( state != wxTREE_ITEMSTATE_NONE ) + { + dc.SetClippingRegion( item->GetX(), item->GetY(), state_w, total_h ); + m_imageListState->Draw( state, dc, + item->GetX(), + item->GetY() + + (total_h > state_h ? (total_h-state_h)/2 + : 0), + wxIMAGELIST_DRAW_TRANSPARENT ); + dc.DestroyClippingRegion(); + } + if ( image != NO_IMAGE ) { - dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h ); + dc.SetClippingRegion(item->GetX() + state_w, item->GetY(), + image_w, total_h); m_imageListNormal->Draw( image, dc, - item->GetX(), - item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0), + item->GetX() + state_w, + item->GetY() + + (total_h > image_h ? (total_h-image_h)/2 + : 0), wxIMAGELIST_DRAW_TRANSPARENT ); dc.DestroyClippingRegion(); } - dc.SetBackgroundMode(wxTRANSPARENT); + dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT); int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0; dc.DrawText( item->GetText(), - (wxCoord)(image_w + item->GetX()), + (wxCoord)(state_w + image_w + item->GetX()), (wxCoord)(item->GetY() + extraH)); // restore normal font dc.SetFont( m_normalFont ); + + if (item == m_dndEffectItem) + { + dc.SetPen( *wxBLACK_PEN ); + // DnD visual effects + switch (m_dndEffect) + { + case BorderEffect: + { + dc.SetBrush(*wxTRANSPARENT_BRUSH); + int w = item->GetWidth() + 2; + int h = total_h + 2; + dc.DrawRectangle( item->GetX() - 1, item->GetY() - 1, w, h); + break; + } + case AboveEffect: + { + int x = item->GetX(), + y = item->GetY(); + dc.DrawLine( x, y, x + item->GetWidth(), y); + break; + } + case BelowEffect: + { + int x = item->GetX(), + y = item->GetY(); + y += total_h - 1; + dc.DrawLine( x, y, x + item->GetWidth(), y); + break; + } + case NoEffect: + break; + } + } } -// Now y stands for the top of the item, whereas it used to stand for middle ! -void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y ) +void +wxGenericTreeCtrl::PaintLevel(wxGenericTreeItem *item, + wxDC &dc, + int level, + int &y) { int x = level*m_indent; if (!HasFlag(wxTR_HIDE_ROOT)) @@ -2080,7 +2703,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level // always expand hidden root int origY = y; wxArrayGenericTreeItems& children = item->GetChildren(); - int count = children.Count(); + int count = children.GetCount(); if (count > 0) { int n = 0, oldY; @@ -2089,7 +2712,8 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level PaintLevel(children[n], dc, 1, y); } while (++n < count); - if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0) + if ( !HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) + && count > 0 ) { // draw line down to last child origY += GetLineHeight(children[0])>>1; @@ -2113,7 +2737,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level if (IsExposed(exposed_x, exposed_y, 10000, h)) // 10000 = very much { - wxPen *pen = + const wxPen *pen = #ifndef __WXMAC__ // don't draw rect outline if we already have the // background color under Mac @@ -2122,9 +2746,24 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level wxTRANSPARENT_PEN; wxColour colText; - if ( item->IsSelected() ) + if ( item->IsSelected() +#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__) && wxOSX_USE_CARBON // TODO CS + // On wxMac, if the tree doesn't have the focus we draw an empty + // rectangle, so we want to make sure that the text is visible + // against the normal background, not the highlightbackground, so + // don't use the highlight text colour unless we have the focus. + && m_hasFocus && IsControlActive( (ControlRef)GetHandle() ) +#endif + ) { - colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT); +#ifdef __WXMAC__ + colText = *wxWHITE; +#else + if (m_hasFocus) + colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT); + else + colText = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT); +#endif } else { @@ -2157,100 +2796,66 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level dc.SetPen(m_dottedPen); dc.SetTextForeground(*wxBLACK); - if (item->HasPlus() && HasButtons()) // should the item show a button? + if ( !HasFlag(wxTR_NO_LINES) ) { - if (!HasFlag(wxTR_NO_LINES)) - { - if (x > (signed)m_indent) - dc.DrawLine(x - m_indent, y_mid, x - 5, y_mid); - else if (HasFlag(wxTR_LINES_AT_ROOT)) - dc.DrawLine(3, y_mid, x - 5, y_mid); - dc.DrawLine(x + 5, y_mid, x + m_spacing, y_mid); - } + // draw the horizontal line here + int x_start = x; + if (x > (signed)m_indent) + x_start -= m_indent; + else if (HasFlag(wxTR_LINES_AT_ROOT)) + x_start = 3; + dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid); + } - if (m_imageListButtons != NULL) + // should the item show a button? + if ( item->HasPlus() && HasButtons() ) + { + if ( m_imageListButtons ) { // draw the image button here - int image_h = 0, image_w = 0, image = wxTreeItemIcon_Normal; - if (item->IsExpanded()) image = wxTreeItemIcon_Expanded; - if (item->IsSelected()) + int image_h = 0, + image_w = 0; + int image = item->IsExpanded() ? wxTreeItemIcon_Expanded + : wxTreeItemIcon_Normal; + if ( item->IsSelected() ) image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal; + m_imageListButtons->GetSize(image, image_w, image_h); - int xx = x - (image_w>>1); - int yy = y_mid - (image_h>>1); - dc.SetClippingRegion(xx, yy, image_w, image_h); + int xx = x - image_w/2; + int yy = y_mid - image_h/2; + + wxDCClipper clip(dc, xx, yy, image_w, image_h); m_imageListButtons->Draw(image, dc, xx, yy, wxIMAGELIST_DRAW_TRANSPARENT); - dc.DestroyClippingRegion(); - } - else if (HasFlag(wxTR_TWIST_BUTTONS)) - { - // draw the twisty button here - - if (HasFlag(wxTR_AQUA_BUTTONS)) - { - if (item->IsExpanded()) - dc.DrawBitmap( *m_arrowDown, x-5, y_mid-6, TRUE ); - else - dc.DrawBitmap( *m_arrowRight, x-5, y_mid-6, TRUE ); - } - else - { - dc.SetBrush(*m_hilightBrush); - dc.SetPen(*wxBLACK_PEN); - wxPoint button[3]; - - if (item->IsExpanded()) - { - button[0].x = x-5; - button[0].y = y_mid-2; - button[1].x = x+5; - button[1].y = y_mid-2; - button[2].x = x; - button[2].y = y_mid+3; - } - else - { - button[0].y = y_mid-5; - button[0].x = x-2; - button[1].y = y_mid+5; - button[1].x = x-2; - button[2].y = y_mid; - button[2].x = x+3; - } - dc.DrawPolygon(3, button); - dc.SetPen(m_dottedPen); - } } - else // if (HasFlag(wxTR_HAS_BUTTONS)) + else // no custom buttons { - // draw the plus sign here - dc.SetPen(*wxGREY_PEN); - dc.SetBrush(*wxWHITE_BRUSH); - dc.DrawRectangle(x-5, y_mid-4, 11, 9); - dc.SetPen(*wxBLACK_PEN); - dc.DrawLine(x-2, y_mid, x+3, y_mid); - if (!item->IsExpanded()) - dc.DrawLine(x, y_mid-2, x, y_mid+3); - dc.SetPen(m_dottedPen); + static const int wImage = 9; + static const int hImage = 9; + + int flag = 0; + if (item->IsExpanded()) + flag |= wxCONTROL_EXPANDED; + if (item == m_underMouse) + flag |= wxCONTROL_CURRENT; + + wxRendererNative::Get().DrawTreeItemButton + ( + this, + dc, + wxRect(x - wImage/2, + y_mid - hImage/2, + wImage, hImage), + flag + ); } } - else if (!HasFlag(wxTR_NO_LINES)) // no button; maybe a line? - { - // draw the horizontal line here - int x_start = x; - if (x > (signed)m_indent) - x_start -= m_indent; - else if (HasFlag(wxTR_LINES_AT_ROOT)) - x_start = 3; - dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid); - } } if (item->IsExpanded()) { wxArrayGenericTreeItems& children = item->GetChildren(); - int count = children.Count(); + int count = children.GetCount(); if (count > 0) { int n = 0, oldY; @@ -2265,7 +2870,24 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level // draw line down to last child oldY += GetLineHeight(children[n-1])>>1; if (HasButtons()) y_mid += 5; - dc.DrawLine(x, y_mid, x, oldY); + + // Only draw the portion of the line that is visible, in case + // it is huge + wxCoord xOrigin=0, yOrigin=0, width, height; + dc.GetDeviceOrigin(&xOrigin, &yOrigin); + yOrigin = abs(yOrigin); + GetClientSize(&width, &height); + + // Move end points to the begining/end of the view? + if (y_mid < yOrigin) + y_mid = yOrigin; + if (oldY > yOrigin + height) + oldY = yOrigin + height; + + // after the adjustments if y_mid is larger than oldY then the + // line isn't visible at all so don't draw anything + if (y_mid < oldY) + dc.DrawLine(x, y_mid, x, oldY); } } } @@ -2284,10 +2906,10 @@ void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item) { // draw a line under the drop target because the item will be // dropped there - DrawLine(item, TRUE /* below */); + DrawLine(item, !m_dropEffectAboveItem ); } - SetCursor(wxCURSOR_BULLSEYE); + SetCursor(*wxSTANDARD_CURSOR); } else { @@ -2298,45 +2920,65 @@ void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item) void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item) { - wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") ); + wxCHECK_RET( item.IsOk(), "invalid item in wxGenericTreeCtrl::DrawLine" ); wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem; - wxClientDC dc(this); - PrepareDC( dc ); - dc.SetLogicalFunction(wxINVERT); - dc.SetBrush(*wxTRANSPARENT_BRUSH); - - int w = i->GetWidth() + 2; - int h = GetLineHeight(i) + 2; + if (m_dndEffect == NoEffect) + { + m_dndEffect = BorderEffect; + m_dndEffectItem = i; + } + else + { + m_dndEffect = NoEffect; + m_dndEffectItem = NULL; + } - dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h); + wxRect rect( i->GetX()-1, i->GetY()-1, i->GetWidth()+2, GetLineHeight(i)+2 ); + CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y ); + RefreshRect( rect ); } void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below) { - wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") ); + wxCHECK_RET( item.IsOk(), "invalid item in wxGenericTreeCtrl::DrawLine" ); wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem; - wxClientDC dc(this); - PrepareDC( dc ); - dc.SetLogicalFunction(wxINVERT); - - int x = i->GetX(), - y = i->GetY(); - if ( below ) + if (m_dndEffect == NoEffect) + { + if (below) + m_dndEffect = BelowEffect; + else + m_dndEffect = AboveEffect; + m_dndEffectItem = i; + } + else { - y += GetLineHeight(i) - 1; + m_dndEffect = NoEffect; + m_dndEffectItem = NULL; } - dc.DrawLine( x, y, x + i->GetWidth(), y); + wxRect rect( i->GetX()-1, i->GetY()-1, i->GetWidth()+2, GetLineHeight(i)+2 ); + CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y ); + RefreshRect( rect ); } // ----------------------------------------------------------------------------- -// wxWindows callbacks +// wxWidgets callbacks // ----------------------------------------------------------------------------- +void wxGenericTreeCtrl::OnSize( wxSizeEvent &event ) +{ +#ifdef __WXGTK__ + if (HasFlag( wxTR_FULL_ROW_HIGHLIGHT) && m_current) + RefreshLine( m_current ); +#endif + + event.Skip(true); +} + void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) ) { wxPaintDC dc(this); @@ -2358,7 +3000,7 @@ void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) ) void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event ) { - m_hasFocus = TRUE; + m_hasFocus = true; RefreshSelected(); @@ -2367,24 +3009,26 @@ void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event ) void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event ) { - m_hasFocus = FALSE; + m_hasFocus = false; RefreshSelected(); event.Skip(); } -void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) +void wxGenericTreeCtrl::OnKeyDown( wxKeyEvent &event ) { - wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() ); + // send a tree event + wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, this); te.m_evtKey = event; - te.SetEventObject( this ); if ( GetEventHandler()->ProcessEvent( te ) ) - { - // intercepted by the user code return; - } + event.Skip(); +} + +void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) +{ if ( (m_current == 0) || (m_key_current == 0) ) { event.Skip(); @@ -2395,9 +3039,17 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) bool is_multiple, extended_select, unselect_others; EventFlagsToSelType(GetWindowStyleFlag(), event.ShiftDown(), - event.ControlDown(), + event.CmdDown(), is_multiple, extended_select, unselect_others); + if (GetLayoutDirection() == wxLayout_RightToLeft) + { + if (event.GetKeyCode() == WXK_RIGHT) + event.m_keyCode = WXK_LEFT; + else if (event.GetKeyCode() == WXK_LEFT) + event.m_keyCode = WXK_RIGHT; + } + // + : Expand // - : Collaspe // * : Expand all/Collapse all @@ -2409,7 +3061,22 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) // home : go to root // end : go to last item without opening parents // alnum : start or continue searching for the item with this prefix - int keyCode = event.KeyCode(); + int keyCode = event.GetKeyCode(); + +#ifdef __WXOSX__ + // Make the keys work as they do in the native control: + // right => expand + // left => collapse if current item is expanded + if (keyCode == WXK_RIGHT) + { + keyCode = '+'; + } + else if (keyCode == WXK_LEFT && IsExpanded(m_current)) + { + keyCode = '-'; + } +#endif // __WXOSX__ + switch ( keyCode ) { case '+': @@ -2425,7 +3092,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) if ( !IsExpanded(m_current) ) { // expand all - ExpandAll(m_current); + ExpandAllChildren(m_current); break; } //else: fall through to Collapse() it @@ -2438,14 +3105,38 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) } break; + case WXK_MENU: + { + // Use the item's bounding rectangle to determine position for + // the event + wxRect ItemRect; + GetBoundingRect(m_current, ItemRect, true); + + wxTreeEvent + eventMenu(wxEVT_COMMAND_TREE_ITEM_MENU, this, m_current); + // Use the left edge, vertical middle + eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(), + ItemRect.GetY() + + ItemRect.GetHeight() / 2); + GetEventHandler()->ProcessEvent( eventMenu ); + } + break; + case ' ': case WXK_RETURN: + if ( !event.HasModifiers() ) { - wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() ); - event.m_item = (long) m_current; - event.SetEventObject( this ); - GetEventHandler()->ProcessEvent( event ); + wxTreeEvent + eventAct(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, m_current); + GetEventHandler()->ProcessEvent( eventAct ); } + + // in any case, also generate the normal key event for this key, + // even if we generated the ACTIVATED event above: this is what + // wxMSW does and it makes sense because you might not want to + // process ACTIVATED event at all and handle Space and Return + // directly (and differently) which would be impossible otherwise + event.Skip(); break; // up goes to the previous sibling or to the last @@ -2455,21 +3146,24 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) wxTreeItemId prev = GetPrevSibling( m_key_current ); if (!prev) { - prev = GetParent( m_key_current ); + prev = GetItemParent( m_key_current ); if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT)) { break; // don't go to root if it is hidden } if (prev) { - long cookie = 0; + wxTreeItemIdValue cookie; wxTreeItemId current = m_key_current; - // TODO: Huh? If we get here, we'd better be the first child of our parent. How else could it be? + // TODO: Huh? If we get here, we'd better be the first + // child of our parent. How else could it be? if (current == GetFirstChild( prev, cookie )) { // otherwise we return to where we came from - SelectItem( prev, unselect_others, extended_select ); - m_key_current= (wxGenericTreeItem*) prev.m_pItem; + DoSelectItem(prev, + unselect_others, + extended_select); + m_key_current = (wxGenericTreeItem*) prev.m_pItem; break; } } @@ -2485,7 +3179,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) } } - SelectItem( prev, unselect_others, extended_select ); + DoSelectItem( prev, unselect_others, extended_select ); m_key_current=(wxGenericTreeItem*) prev.m_pItem; } } @@ -2494,7 +3188,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) // left arrow goes to the parent case WXK_LEFT: { - wxTreeItemId prev = GetParent( m_current ); + wxTreeItemId prev = GetItemParent( m_current ); if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT)) { // don't go to root if it is hidden @@ -2502,7 +3196,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) } if (prev) { - SelectItem( prev, unselect_others, extended_select ); + DoSelectItem( prev, unselect_others, extended_select ); } } break; @@ -2510,16 +3204,23 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) case WXK_RIGHT: // this works the same as the down arrow except that we // also expand the item if it wasn't expanded yet - Expand(m_current); + if (m_current != GetRootItem().m_pItem || !HasFlag(wxTR_HIDE_ROOT)) + Expand(m_current); + //else: don't try to expand hidden root item (which can be the + // current one when the tree is empty) + // fall through case WXK_DOWN: { if (IsExpanded(m_key_current) && HasChildren(m_key_current)) { - long cookie = 0; + wxTreeItemIdValue cookie; wxTreeItemId child = GetFirstChild( m_key_current, cookie ); - SelectItem( child, unselect_others, extended_select ); + if ( !child ) + break; + + DoSelectItem( child, unselect_others, extended_select ); m_key_current=(wxGenericTreeItem*) child.m_pItem; } else @@ -2528,15 +3229,15 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) if (!next) { wxTreeItemId current = m_key_current; - while (current && !next) + while (current.IsOk() && !next) { - current = GetParent( current ); + current = GetItemParent( current ); if (current) next = GetNextSibling( current ); } } if (next) { - SelectItem( next, unselect_others, extended_select ); + DoSelectItem( next, unselect_others, extended_select ); m_key_current=(wxGenericTreeItem*) next.m_pItem; } } @@ -2554,7 +3255,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) // it may happen if the item was expanded but then all of // its children have been deleted - so IsExpanded() returned - // TRUE, but GetLastChild() returned invalid item + // true, but GetLastChild() returned invalid item if ( !lastChild ) break; @@ -2563,7 +3264,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) if ( last.IsOk() ) { - SelectItem( last, unselect_others, extended_select ); + DoSelectItem( last, unselect_others, extended_select ); } } break; @@ -2577,24 +3278,27 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) if ( HasFlag(wxTR_HIDE_ROOT) ) { - long dummy; - prev = GetFirstChild(prev, dummy); + wxTreeItemIdValue cookie; + prev = GetFirstChild(prev, cookie); if (!prev) break; } - SelectItem( prev, unselect_others, extended_select ); + DoSelectItem( prev, unselect_others, extended_select ); } break; default: // do not use wxIsalnum() here - if ( !event.HasModifiers() && isalnum(keyCode) ) + if ( !event.HasModifiers() && + ((keyCode >= '0' && keyCode <= '9') || + (keyCode >= 'a' && keyCode <= 'z') || + (keyCode >= 'A' && keyCode <= 'Z' ))) { // find the next item starting with the given prefix - char ch = (char)keyCode; + wxChar ch = (wxChar)keyCode; - wxTreeItemId id = FindItem(m_current, m_findPrefix + (wxChar)ch); + wxTreeItemId id = FindItem(m_current, m_findPrefix + ch); if ( !id.IsOk() ) { // no such item @@ -2622,11 +3326,9 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event ) } } -wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags) +wxTreeItemId +wxGenericTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags) const { - // JACS: removed wxYieldIfNeeded() because it can cause the window - // to be deleted from under us if a close window event is pending - int w, h; GetSize(&w, &h); flags=0; @@ -2654,108 +3356,196 @@ wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags) // get the bounding rectangle of the item (or of its label only) bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item, - wxRect& rect, - bool WXUNUSED(textOnly)) const + wxRect& rect, + bool textOnly) const { - wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") ); + wxCHECK_MSG( item.IsOk(), false, + "invalid item in wxGenericTreeCtrl::GetBoundingRect" ); wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem; - int startX, startY; - GetViewStart(& startX, & startY); + if ( textOnly ) + { + int image_h = 0, image_w = 0; + int image = ((wxGenericTreeItem*) item.m_pItem)->GetCurrentImage(); + if ( image != NO_IMAGE && m_imageListNormal ) + { + m_imageListNormal->GetSize( image, image_w, image_h ); + image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT; + } - rect.x = i->GetX() - startX*PIXELS_PER_UNIT; - rect.y = i->GetY() - startY*PIXELS_PER_UNIT; - rect.width = i->GetWidth(); - //rect.height = i->GetHeight(); + int state_h = 0, state_w = 0; + int state = ((wxGenericTreeItem*) item.m_pItem)->GetState(); + if ( state != wxTREE_ITEMSTATE_NONE && m_imageListState ) + { + m_imageListState->GetSize( state, state_w, state_h ); + if ( image_w != 0 ) + state_w += MARGIN_BETWEEN_STATE_AND_IMAGE; + else + state_w += MARGIN_BETWEEN_IMAGE_AND_TEXT; + } + + rect.x = i->GetX() + state_w + image_w; + rect.width = i->GetWidth() - state_w - image_w; + + } + else // the entire line + { + rect.x = 0; + rect.width = GetClientSize().x; + } + + rect.y = i->GetY(); rect.height = GetLineHeight(i); - return TRUE; -} + // we have to return the logical coordinates, not physical ones + rect.SetTopLeft(CalcScrolledPosition(rect.GetTopLeft())); -/* **** */ + return true; +} -void wxGenericTreeCtrl::Edit( const wxTreeItemId& item ) +wxTextCtrl *wxGenericTreeCtrl::EditLabel(const wxTreeItemId& item, + wxClassInfo * WXUNUSED(textCtrlClass)) { - if (!item.IsOk()) return; - - m_currentEdit = (wxGenericTreeItem*) item.m_pItem; + wxCHECK_MSG( item.IsOk(), NULL, wxT("can't edit an invalid item") ); - wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() ); - te.m_item = (long) m_currentEdit; - te.SetEventObject( this ); - GetEventHandler()->ProcessEvent( te ); + wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem; - if (!te.IsAllowed()) return; + wxTreeEvent te(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, this, itemEdit); + if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() ) + { + // vetoed by user + return NULL; + } // We have to call this here because the label in // question might just have been added and no screen // update taken place. - if (m_dirty) wxYieldIfNeeded(); + if ( m_dirty ) +#if defined( __WXMSW__ ) || defined(__WXMAC__) + Update(); +#else + DoDirtyProcessing(); +#endif - wxString s = m_currentEdit->GetText(); - int w = m_currentEdit->GetWidth(); - int h = m_currentEdit->GetHeight(); - int x, y; - CalcScrolledPosition(m_currentEdit->GetX(), m_currentEdit->GetY(), &x, &y); + // TODO: use textCtrlClass here to create the control of correct class + m_textCtrl = new wxTreeTextCtrl(this, itemEdit); - int image_h = 0; - int image_w = 0; + m_textCtrl->SetFocus(); - int image = m_currentEdit->GetCurrentImage(); - if ( image != NO_IMAGE ) - { - if ( m_imageListNormal ) - { - m_imageListNormal->GetSize( image, image_w, image_h ); - image_w += 4; - } - else - { - wxFAIL_MSG(_T("you must create an image list to use images!")); - } - } - x += image_w; - w -= image_w + 4; // I don't know why +4 is needed + return m_textCtrl; +} - wxTreeTextCtrl *text = new wxTreeTextCtrl(this, -1, - &m_renameAccept, - &m_renameRes, - this, - s, - wxPoint(x-4,y-4), - wxSize(w+11,h+8)); - text->SetFocus(); +// returns a pointer to the text edit control if the item is being +// edited, NULL otherwise (it's assumed that no more than one item may +// be edited simultaneously) +wxTextCtrl* wxGenericTreeCtrl::GetEditControl() const +{ + return m_textCtrl; } -void wxGenericTreeCtrl::OnRenameTimer() +void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item), + bool discardChanges) { - Edit( m_current ); + wxCHECK_RET( m_textCtrl, wxT("not editing label") ); + + m_textCtrl->EndEdit(discardChanges); } -void wxGenericTreeCtrl::OnRenameAccept() +bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item, + const wxString& value) { - // TODO if the validator fails this causes a crash - wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() ); - le.m_item = (long) m_currentEdit; - le.SetEventObject( this ); - le.m_label = m_renameRes; - GetEventHandler()->ProcessEvent( le ); + wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item); + le.m_label = value; + le.m_editCancelled = false; + + return !GetEventHandler()->ProcessEvent( le ) || le.IsAllowed(); +} + +void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item) +{ + // let owner know that the edit was cancelled + wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item); + le.m_label = wxEmptyString; + le.m_editCancelled = true; - if (!le.IsAllowed()) return; + GetEventHandler()->ProcessEvent( le ); +} - SetItemText( m_currentEdit, m_renameRes ); +void wxGenericTreeCtrl::OnRenameTimer() +{ + EditLabel( m_current ); } void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) { - if ( !m_anchor ) return; + if ( !m_anchor )return; + + wxPoint pt = CalcUnscrolledPosition(event.GetPosition()); + + // Is the mouse over a tree item button? + int flags = 0; + wxGenericTreeItem *thisItem = m_anchor->HitTest(pt, this, flags, 0); + wxGenericTreeItem *underMouse = thisItem; +#if wxUSE_TOOLTIPS + bool underMouseChanged = (underMouse != m_underMouse) ; +#endif // wxUSE_TOOLTIPS + + if ((underMouse) && + (flags & wxTREE_HITTEST_ONITEMBUTTON) && + (!event.LeftIsDown()) && + (!m_isDragging) && + (!m_renameTimer || !m_renameTimer->IsRunning())) + { + } + else + { + underMouse = NULL; + } - // we process left mouse up event (enables in-place edit), right down + if (underMouse != m_underMouse) + { + if (m_underMouse) + { + // unhighlight old item + wxGenericTreeItem *tmp = m_underMouse; + m_underMouse = NULL; + RefreshLine( tmp ); + } + + m_underMouse = underMouse; + if (m_underMouse) + RefreshLine( m_underMouse ); + } + +#if wxUSE_TOOLTIPS + // Determines what item we are hovering over and need a tooltip for + wxTreeItemId hoverItem = thisItem; + + // We do not want a tooltip if we are dragging, or if the rename timer is + // running + if ( underMouseChanged && + hoverItem.IsOk() && + !m_isDragging && + (!m_renameTimer || !m_renameTimer->IsRunning()) ) + { + // Ask the tree control what tooltip (if any) should be shown + wxTreeEvent + hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, this, hoverItem); + + if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() ) + { + SetToolTip(hevent.m_label); + } + } +#endif + + // we process left mouse up event (enables in-place edit), middle/right down // (pass to the user code), left dbl click (activate item) and // dragging/moving events for items drag-and-drop if ( !(event.LeftDown() || event.LeftUp() || + event.MiddleDown() || event.RightDown() || event.LeftDClick() || event.Dragging() || @@ -2766,9 +3556,8 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) return; } - wxPoint pt = CalcUnscrolledPosition(event.GetPosition()); - int flags = 0; + flags = 0; wxGenericTreeItem *item = m_anchor->HitTest(pt, this, flags, 0); if ( event.Dragging() && !m_isDragging ) @@ -2788,9 +3577,8 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) ? wxEVT_COMMAND_TREE_BEGIN_RDRAG : wxEVT_COMMAND_TREE_BEGIN_DRAG; - wxTreeEvent nevent( command, GetId() ); - nevent.m_item = (long) m_current; - nevent.SetEventObject(this); + wxTreeEvent nevent(command, this, m_current); + nevent.SetPoint(CalcScrolledPosition(pt)); // by default the dragging is not supported, the user code must // explicitly allow the event for it to take place @@ -2799,7 +3587,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() ) { // we're going to drag this item - m_isDragging = TRUE; + m_isDragging = true; // remember the old cursor because we will change it while // dragging @@ -2812,7 +3600,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) if ( m_oldSelection ) { - m_oldSelection->SetHilight(FALSE); + m_oldSelection->SetHilight(false); RefreshLine(m_oldSelection); } } @@ -2820,7 +3608,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) CaptureMouse(); } } - else if ( event.Moving() ) + else if ( event.Dragging() ) { if ( item != m_dropTarget ) { @@ -2832,41 +3620,63 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) // highlight the current drop target if any DrawDropEffect(m_dropTarget); +#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK20__) + Update(); +#else + // TODO: remove this call or use wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI) + // instead (needs to be tested!) wxYieldIfNeeded(); +#endif } } else if ( (event.LeftUp() || event.RightUp()) && m_isDragging ) { + ReleaseMouse(); + // erase the highlighting DrawDropEffect(m_dropTarget); if ( m_oldSelection ) { - m_oldSelection->SetHilight(TRUE); + m_oldSelection->SetHilight(true); RefreshLine(m_oldSelection); - m_oldSelection = (wxGenericTreeItem *)NULL; + m_oldSelection = NULL; } // generate the drag end event - wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId()); + wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, this, item); - event.m_item = (long) item; - event.m_pointDrag = pt; - event.SetEventObject(this); + eventEndDrag.m_pointDrag = CalcScrolledPosition(pt); - (void)GetEventHandler()->ProcessEvent(event); + (void)GetEventHandler()->ProcessEvent(eventEndDrag); - m_isDragging = FALSE; - m_dropTarget = (wxGenericTreeItem *)NULL; - - ReleaseMouse(); + m_isDragging = false; + m_dropTarget = NULL; SetCursor(m_oldCursor); +#if defined( __WXMSW__ ) || defined(__WXMAC__) || defined(__WXGTK20__) + Update(); +#else + // TODO: remove this call or use wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI) + // instead (needs to be tested!) wxYieldIfNeeded(); +#endif } else { + // If we got to this point, we are not dragging or moving the mouse. + // Because the code in carbon/toplevel.cpp will only set focus to the + // tree if we skip for EVT_LEFT_DOWN, we MUST skip this event here for + // focus to work. + // We skip even if we didn't hit an item because we still should + // restore focus to the tree control even if we didn't exactly hit an + // item. + if ( event.LeftDown() ) + { + event.Skip(); + } + // here we process only the messages which happen on tree items m_dragCount = 0; @@ -2875,14 +3685,56 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) if ( event.RightDown() ) { - wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId()); - nevent.m_item = (long) item; + // If the item is already selected, do not update the selection. + // Multi-selections should not be cleared if a selected item is + // clicked. + if (!IsSelected(item)) + { + DoSelectItem(item, true, false); + } + + wxTreeEvent + nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, this, item); + nevent.m_pointDrag = CalcScrolledPosition(pt); + event.Skip(!GetEventHandler()->ProcessEvent(nevent)); + + // Consistent with MSW (for now), send the ITEM_MENU *after* + // the RIGHT_CLICK event. TODO: This behaviour may change. + wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU, this, item); + nevent2.m_pointDrag = CalcScrolledPosition(pt); + GetEventHandler()->ProcessEvent(nevent2); + } + else if ( event.MiddleDown() ) + { + wxTreeEvent + nevent(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK, this, item); nevent.m_pointDrag = CalcScrolledPosition(pt); - nevent.SetEventObject(this); - GetEventHandler()->ProcessEvent(nevent); + event.Skip(!GetEventHandler()->ProcessEvent(nevent)); } else if ( event.LeftUp() ) { + if (flags & wxTREE_HITTEST_ONITEMSTATEICON) + { + wxTreeEvent + nevent(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK, this, item); + GetEventHandler()->ProcessEvent(nevent); + } + + // this facilitates multiple-item drag-and-drop + + if ( /* item && */ HasFlag(wxTR_MULTIPLE)) + { + wxArrayTreeItemIds selections; + size_t count = GetSelections(selections); + + if (count > 1 && + !event.CmdDown() && + !event.ShiftDown()) + { + DoSelectItem(item, true, false); + } + } + if ( m_lastOnSame ) { if ( (item == m_current) && @@ -2899,14 +3751,15 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) m_renameTimer = new wxTreeRenameTimer( this ); } - m_renameTimer->Start( wxTreeRenameTimer::DELAY, TRUE ); + m_renameTimer->Start( wxTreeRenameTimer::DELAY, true ); } - m_lastOnSame = FALSE; + m_lastOnSame = false; } } - else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick() + else // !RightDown() && !MiddleDown() && !LeftUp() { + // ==> LeftDown() || LeftDClick() if ( event.LeftDown() ) { m_lastOnSame = item == m_current; @@ -2925,14 +3778,26 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) return; } - // how should the selection work for this event? - bool is_multiple, extended_select, unselect_others; - EventFlagsToSelType(GetWindowStyleFlag(), - event.ShiftDown(), - event.ControlDown(), - is_multiple, extended_select, unselect_others); - SelectItem(item, unselect_others, extended_select); + // clear the previously selected items, if the + // user clicked outside of the present selection. + // otherwise, perform the deselection on mouse-up. + // this allows multiple drag and drop to work. + // but if Cmd is down, toggle selection of the clicked item + if (!IsSelected(item) || event.CmdDown()) + { + // how should the selection work for this event? + bool is_multiple, extended_select, unselect_others; + EventFlagsToSelType(GetWindowStyleFlag(), + event.ShiftDown(), + event.CmdDown(), + is_multiple, + extended_select, + unselect_others); + + DoSelectItem(item, unselect_others, extended_select); + } + // For some reason, Windows isn't recognizing a left double-click, // so we need to simulate it here. Allow 200 milliseconds for now. @@ -2942,13 +3807,12 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) if ( m_renameTimer ) m_renameTimer->Stop(); - m_lastOnSame = FALSE; + m_lastOnSame = false; // send activate event first - wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() ); - nevent.m_item = (long) item; + wxTreeEvent + nevent(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, item); nevent.m_pointDrag = CalcScrolledPosition(pt); - nevent.SetEventObject( this ); if ( !GetEventHandler()->ProcessEvent( nevent ) ) { // if the user code didn't process the activate event, @@ -2964,67 +3828,33 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event ) } } -void wxGenericTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) ) +void wxGenericTreeCtrl::OnInternalIdle() { - /* after all changes have been done to the tree control, - * we actually redraw the tree when everything is over */ + wxWindow::OnInternalIdle(); - if (!m_dirty) return; - - m_dirty = FALSE; - - CalculatePositions(); - Refresh(); - AdjustMyScrollbars(); -} - -void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc ) -{ - wxCoord text_w = 0; - wxCoord text_h = 0; - - wxTreeItemAttr *attr = item->GetAttributes(); - if ( attr && attr->HasFont() ) - dc.SetFont(attr->GetFont()); - else if ( item->IsBold() ) - dc.SetFont(m_boldFont); - - dc.GetTextExtent( item->GetText(), &text_w, &text_h ); - text_h+=2; - - // restore normal font - dc.SetFont( m_normalFont ); - - int image_h = 0; - int image_w = 0; - int image = item->GetCurrentImage(); - if ( image != NO_IMAGE ) + // Check if we need to select the root item + // because nothing else has been selected. + // Delaying it means that we can invoke event handlers + // as required, when a first item is selected. + if (!HasFlag(wxTR_MULTIPLE) && !GetSelection().IsOk()) { - if ( m_imageListNormal ) - { - m_imageListNormal->GetSize( image, image_w, image_h ); - image_w += 4; - } + if (m_select_me) + SelectItem(m_select_me); + else if (GetRootItem().IsOk()) + SelectItem(GetRootItem()); } - int total_h = (image_h > text_h) ? image_h : text_h; - - if (total_h < 30) - total_h += 2; // at least 2 pixels - else - total_h += total_h/10; // otherwise 10% extra spacing - - item->SetHeight(total_h); - if (total_h>m_lineHeight) - m_lineHeight=total_h; - - item->SetWidth(image_w+text_w+2); + // after all changes have been done to the tree control, + // actually redraw the tree when everything is over + if (m_dirty) + DoDirtyProcessing(); } -// ----------------------------------------------------------------------------- -// for developper : y is now the top of the level -// not the middle of it ! -void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y ) +void +wxGenericTreeCtrl::CalculateLevel(wxGenericTreeItem *item, + wxDC &dc, + int level, + int &y ) { int x = level*m_indent; if (!HasFlag(wxTR_HIDE_ROOT)) @@ -3038,7 +3868,7 @@ void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int l goto Recurse; } - CalculateSize( item, dc ); + item->CalculateSize(this, dc); // set its position item->SetX( x+m_spacing ); @@ -3053,7 +3883,7 @@ void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int l Recurse: wxArrayGenericTreeItems& children = item->GetChildren(); - size_t n, count = children.Count(); + size_t n, count = children.GetCount(); ++level; for (n = 0; n < count; ++n ) CalculateLevel( children[n], dc, level, y ); // recurse @@ -3076,9 +3906,16 @@ void wxGenericTreeCtrl::CalculatePositions() CalculateLevel( m_anchor, dc, 0, y ); // start recursion } +void wxGenericTreeCtrl::Refresh(bool eraseBackground, const wxRect *rect) +{ + if ( !IsFrozen() ) + wxTreeCtrlBase::Refresh(eraseBackground, rect); +} + void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item) { - if (m_dirty) return; + if (m_dirty || IsFrozen() ) + return; wxSize client = GetClientSize(); @@ -3087,25 +3924,29 @@ void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item) rect.width = client.x; rect.height = client.y; - Refresh(TRUE, &rect); + Refresh(true, &rect); AdjustMyScrollbars(); } void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item ) { - if (m_dirty) return; + if (m_dirty || IsFrozen() ) + return; wxRect rect; CalcScrolledPosition(0, item->GetY(), NULL, &rect.y); rect.width = GetClientSize().x; rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6; - Refresh(TRUE, &rect); + Refresh(true, &rect); } void wxGenericTreeCtrl::RefreshSelected() { + if (IsFrozen()) + return; + // TODO: this is awfully inefficient, we should keep the list of all // selected items internally, should be much faster if ( m_anchor ) @@ -3114,6 +3955,9 @@ void wxGenericTreeCtrl::RefreshSelected() void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item) { + if (IsFrozen()) + return; + if ( item->IsSelected() ) RefreshLine(item); @@ -3125,6 +3969,16 @@ void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item) } } +void wxGenericTreeCtrl::DoThaw() +{ + wxTreeCtrlBase::DoThaw(); + + if ( m_dirty ) + DoDirtyProcessing(); + else + Refresh(); +} + // ---------------------------------------------------------------------------- // changing colours: we need to refresh the tree control // ---------------------------------------------------------------------------- @@ -3132,21 +3986,96 @@ void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item) bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour) { if ( !wxWindow::SetBackgroundColour(colour) ) - return FALSE; + return false; Refresh(); - return TRUE; + return true; } bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour) { if ( !wxWindow::SetForegroundColour(colour) ) - return FALSE; + return false; Refresh(); - return TRUE; + return true; +} + +// Process the tooltip event, to speed up event processing. +// Doesn't actually get a tooltip. +void wxGenericTreeCtrl::OnGetToolTip( wxTreeEvent &event ) +{ + event.Veto(); +} + + +// NOTE: If using the wxListBox visual attributes works everywhere then this can +// be removed, as well as the #else case below. +#define _USE_VISATTR 0 + +//static +wxVisualAttributes +#if _USE_VISATTR +wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant) +#else +wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) +#endif +{ +#if _USE_VISATTR + // Use the same color scheme as wxListBox + return wxListBox::GetClassDefaultAttributes(variant); +#else + wxVisualAttributes attr; + attr.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXTEXT); + attr.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX); + attr.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); + return attr; +#endif +} + +void wxGenericTreeCtrl::DoDirtyProcessing() +{ + if (IsFrozen()) + return; + + m_dirty = false; + + CalculatePositions(); + Refresh(); + AdjustMyScrollbars(); +} + +wxSize wxGenericTreeCtrl::DoGetBestSize() const +{ + // make sure all positions are calculated as normally this only done during + // idle time but we need them for base class DoGetBestSize() to return the + // correct result + wxConstCast(this, wxGenericTreeCtrl)->CalculatePositions(); + + wxSize size = wxTreeCtrlBase::DoGetBestSize(); + + // there seems to be an implicit extra border around the items, although + // I'm not really sure where does it come from -- but without this, the + // scrollbars appear in a tree with default/best size + size.IncBy(4, 4); + + // and the border has to be rounded up to a multiple of PIXELS_PER_UNIT or + // scrollbars still appear + const wxSize& borderSize = GetWindowBorderSize(); + + int dx = (size.x - borderSize.x) % PIXELS_PER_UNIT; + if ( dx ) + size.x += PIXELS_PER_UNIT - dx; + int dy = (size.y - borderSize.y) % PIXELS_PER_UNIT; + if ( dy ) + size.y += PIXELS_PER_UNIT - dy; + + // we need to update the cache too as the base class cached its own value + CacheBestSize(size); + + return size; } #endif // wxUSE_TREECTRL