// Author: Robert Roebling
// Created: 01/02/97
// Modified: 22/10/98 - almost total rewrite, simpler interface (VZ)
-// Id: $Id$
// Copyright: (c) 1998 Robert Roebling and Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#include "wx/renderer.h"
#ifdef __WXMAC__
- #include "wx/mac/private.h"
+ #include "wx/osx/private.h"
#endif
// -----------------------------------------------------------------------------
// array types
// -----------------------------------------------------------------------------
-class WXDLLEXPORT wxGenericTreeItem;
+class WXDLLIMPEXP_FWD_CORE wxGenericTreeItem;
-WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
+WX_DEFINE_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
// ----------------------------------------------------------------------------
// constants
static const int PIXELS_PER_UNIT = 10;
+// the margin between the item state image and the item normal image
+static const int MARGIN_BETWEEN_STATE_AND_IMAGE = 2;
+
// the margin between the item image and the item text
static const int MARGIN_BETWEEN_IMAGE_AND_TEXT = 4;
private:
wxGenericTreeCtrl *m_owner;
- DECLARE_NO_COPY_CLASS(wxTreeRenameTimer)
+ wxDECLARE_NO_COPY_CLASS(wxTreeRenameTimer);
};
// control used for in-place edit
public:
wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item);
- void EndEdit(bool discardChanges = false)
- {
- if ( discardChanges )
- {
- StopEditing();
- }
- else
- {
- m_aboutToFinish = true;
-
- // Notify the owner about the changes
- AcceptChanges();
-
- // Even if vetoed, close the control (consistent with MSW)
- Finish();
- }
- }
+ void EndEdit( bool discardChanges );
- void StopEditing()
- {
- Finish();
- m_owner->OnRenameCancelled(m_itemEdited);
- }
const wxGenericTreeItem* item() const { return m_itemEdited; }
protected:
void OnKillFocus( wxFocusEvent &event );
bool AcceptChanges();
- void Finish();
+ void Finish( bool setfocus );
private:
wxGenericTreeCtrl *m_owner;
wxGenericTreeItem *m_itemEdited;
wxString m_startValue;
- bool m_finished;
bool m_aboutToFinish;
DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxTreeTextCtrl)
+ wxDECLARE_NO_COPY_CLASS(wxTreeTextCtrl);
};
// timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed
wxTreeFindTimer( wxGenericTreeCtrl *owner ) { m_owner = owner; }
- virtual void Notify() { m_owner->m_findPrefix.clear(); }
+ virtual void Notify() { m_owner->ResetFindState(); }
private:
wxGenericTreeCtrl *m_owner;
- DECLARE_NO_COPY_CLASS(wxTreeFindTimer)
+ wxDECLARE_NO_COPY_CLASS(wxTreeFindTimer);
};
// a tree item
{
public:
// ctors & dtor
- wxGenericTreeItem() { m_data = NULL; }
+ wxGenericTreeItem()
+ {
+ m_data = NULL;
+ m_widthText =
+ m_heightText = -1;
+ }
+
wxGenericTreeItem( wxGenericTreeItem *parent,
const wxString& text,
int image,
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 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; }
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; }
+
+ 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" );
- void SetHeight(int h) { m_height = h; }
- void SetWidth(int w) { m_width = w; }
+ 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
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 item's label
if ( m_ownsAttr ) delete m_attr;
m_attr = attr;
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_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
unsigned int m_isBold :1; // render the label in bold font
unsigned int m_ownsAttr :1; // delete attribute when done
- DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
+ wxDECLARE_NO_COPY_CLASS(wxGenericTreeItem);
};
// =============================================================================
}
// check if the given item is under another one
-static bool IsDescendantOf(const wxGenericTreeItem *parent, const wxGenericTreeItem *item)
+static bool
+IsDescendantOf(const wxGenericTreeItem *parent, const wxGenericTreeItem *item)
{
while ( item )
{
END_EVENT_TABLE()
wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
- wxGenericTreeItem *item)
- : m_itemEdited(item), m_startValue(item->GetText())
+ wxGenericTreeItem *itm)
+ : m_itemEdited(itm), m_startValue(itm->GetText())
{
m_owner = owner;
- m_finished = false;
m_aboutToFinish = false;
- int w = m_itemEdited->GetWidth(),
- h = m_itemEdited->GetHeight();
+ 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
- int x, y;
- m_owner->CalcScrolledPosition(item->GetX(), item->GetY(), &x, &y);
+ (void)Create(m_owner, wxID_ANY, m_startValue,
+ rect.GetPosition(), rect.GetSize());
- int image_h = 0,
- image_w = 0;
+ SelectAll();
+}
- int image = item->GetCurrentImage();
- if ( image != NO_IMAGE )
- {
- if ( m_owner->m_imageListNormal )
- {
- m_owner->m_imageListNormal->GetSize( image, image_w, image_h );
- image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
- }
- else
- {
- wxFAIL_MSG(_T("you must create an image list to use images!"));
- }
- }
+void wxTreeTextCtrl::EndEdit(bool discardChanges)
+{
+ m_aboutToFinish = true;
- // FIXME: what are all these hardcoded 4, 8 and 11s really?
- x += image_w;
- w -= image_w + 4;
-#ifdef __WXMAC__
- wxSize bs = DoGetBestSize() ;
- // edit control height
- if ( h > bs.y - 8 )
+ if ( discardChanges )
{
- int diff = h - ( bs.y - 8 ) ;
- h -= diff ;
- y += diff / 2 ;
+ m_owner->OnRenameCancelled(m_itemEdited);
+
+ Finish( true );
}
-#endif
+ else
+ {
+ // Notify the owner about the changes
+ AcceptChanges();
- (void)Create(m_owner, wxID_ANY, m_startValue,
- wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));
+ // Even if vetoed, close the control (consistent with MSW)
+ Finish( true );
+ }
}
bool wxTreeTextCtrl::AcceptChanges()
return true;
}
-void wxTreeTextCtrl::Finish()
+void wxTreeTextCtrl::Finish( bool setfocus )
{
- if ( !m_finished )
- {
- m_owner->ResetTextControl();
+ m_owner->ResetTextControl();
- wxPendingDelete.Append(this);
-
- m_finished = true;
+ wxPendingDelete.Append(this);
+ if (setfocus)
m_owner->SetFocus();
- }
}
void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
switch ( event.m_keyCode )
{
case WXK_RETURN:
- EndEdit();
+ EndEdit( false );
break;
case WXK_ESCAPE:
- StopEditing();
+ EndEdit( true );
break;
default:
void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
{
- if ( !m_finished )
+ if ( !m_aboutToFinish )
{
// auto-grow the textctrl:
wxSize parentSize = m_owner->GetSize();
wxPoint myPos = GetPosition();
wxSize mySize = GetSize();
int sx, sy;
- GetTextExtent(GetValue() + _T("M"), &sx, &sy);
+ GetTextExtent(GetValue() + wxT("M"), &sx, &sy);
if (myPos.x + sx > parentSize.x)
sx = parentSize.x - myPos.x;
if (mySize.x > sx)
void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
{
- if ( !m_finished && !m_aboutToFinish )
+ if ( !m_aboutToFinish )
{
- // We must finish regardless of success, otherwise we'll get
- // focus problems:
- Finish();
-
if ( !AcceptChanges() )
m_owner->OnRenameCancelled( m_itemEdited );
+
+ Finish( false );
}
- // We must let the native text control handle focus, too, otherwise
- // it could have problems with the cursor (e.g., in wxGTK).
+ // We should let the native text control handle focus, too.
event.Skip();
}
m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
m_data = data;
+ m_state = wxTREE_ITEMSTATE_NONE;
m_x = m_y = 0;
m_isCollapsed = true;
m_parent = parent;
- m_attr = (wxTreeItemAttr *)NULL;
+ 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()
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];
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;
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 );
// 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;
}
// 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,
return res;
}
- return (wxGenericTreeItem*) NULL;
+ return NULL;
}
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
// -----------------------------------------------------------------------------
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_TREE_ITEM_GETTOOLTIP(wxID_ANY, wxGenericTreeCtrl::OnGetToolTip)
END_EVENT_TABLE()
-#if !defined(__WXMSW__) || 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
// -----------------------------------------------------------------------------
m_current =
m_key_current =
m_anchor =
- m_select_me = (wxGenericTreeItem *) NULL;
+ m_select_me = NULL;
m_hasFocus = false;
m_dirty = false;
(
wxSYS_COLOUR_HIGHLIGHT
),
- wxSOLID
+ wxBRUSHSTYLE_SOLID
);
m_hilightUnfocusedBrush = new wxBrush
(
wxSYS_COLOUR_BTNSHADOW
),
- wxSOLID
+ wxBRUSHSTYLE_SOLID
);
m_imageListButtons = NULL;
m_textCtrl = NULL;
m_renameTimer = NULL;
- m_freezeCount = 0;
m_findTimer = NULL;
+ m_findBell = 0; // default is to not ring bell at all
m_dropEffectAboveItem = false;
+ m_dndEffect = NoEffect;
+ m_dndEffectItem = NULL;
+
m_lastOnSame = false;
-#ifdef __WXMAC_CARBON__
- m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
+#if defined( __WXMAC__ )
+ m_normalFont = wxFont(wxOSX_SYSTEM_FONT_VIEWS);
#else
m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
#endif
- m_boldFont = wxFont(m_normalFont.GetPointSize(),
- m_normalFont.GetFamily(),
- m_normalFont.GetStyle(),
- wxBOLD,
- m_normalFont.GetUnderlined(),
- m_normalFont.GetFaceName(),
- m_normalFont.GetEncoding());
+ m_boldFont = m_normalFont.Bold();
}
bool wxGenericTreeCtrl::Create(wxWindow *parent,
const wxString& name )
{
#ifdef __WXMAC__
- int major,minor;
- wxGetOsVersion( &major, &minor );
+ int major, minor;
+ wxGetOsVersion(&major, &minor);
- style &= ~wxTR_LINES_AT_ROOT;
- style |= wxTR_NO_LINES;
if (major < 10)
style |= wxTR_ROW_LINES;
+
+ if (style & wxTR_HAS_BUTTONS)
+ style |= wxTR_NO_LINES;
#endif // __WXMAC__
+#ifdef __WXGTK20__
+ if (style & wxTR_HAS_BUTTONS)
+ style |= wxTR_NO_LINES;
+#endif
+
if ( !wxControl::Create( parent, id, pos, size,
- style|wxHSCROLL|wxVSCROLL,
+ style|wxHSCROLL|wxVSCROLL|wxWANTS_CHARS,
validator,
name ) )
return false;
if (!m_hasFont)
SetOwnFont(attr.font);
- m_dottedPen = wxPen( wxT("grey"), 0, 0 );
+ // 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
- SetBestSize(size);
+ SetInitialSize(size);
return true;
}
delete m_imageListButtons;
}
+void wxGenericTreeCtrl::EnableBellOnNoMatch( bool on )
+{
+ m_findBell = on;
+}
+
// -----------------------------------------------------------------------------
// accessors
// -----------------------------------------------------------------------------
return ((wxGenericTreeItem*) item.m_pItem)->GetData();
}
+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") );
return pItem->Attr().GetTextColour();
}
-wxColour wxGenericTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
+wxColour
+wxGenericTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
{
wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
return pItem->Attr().GetFont();
}
-void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
+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);
}
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") );
((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") );
// recalculate the item size as bold and non bold fonts have different
// widths
- wxClientDC dc(this);
- CalculateSize(pItem, dc);
-
+ pItem->CalculateSize(this);
RefreshLine(pItem);
}
}
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);
}
{
wxTreeCtrlBase::SetFont(font);
- m_normalFont = font ;
- m_boldFont = wxFont(m_normalFont.GetPointSize(),
- m_normalFont.GetFamily(),
- m_normalFont.GetStyle(),
- wxBOLD,
- m_normalFont.GetUnderlined(),
- m_normalFont.GetFaceName(),
- m_normalFont.GetEncoding());
+ m_normalFont = font;
+ m_boldFont = m_normalFont.Bold();
+
+ if (m_anchor)
+ m_anchor->RecursiveResetTextSize();
return true;
}
{
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
- wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
+ 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.Count() )
+ if ( *pIndex < children.GetCount() )
{
return children.Item((*pIndex)++);
}
}
}
-#if WXWIN_COMPATIBILITY_2_4
-
-wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
- long& cookie) const
-{
- wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
-
- cookie = 0;
- return GetNextChild(item, cookie);
-}
-
-wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
- long& cookie) const
-{
- wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
-
- wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
- if ( (size_t)cookie < children.Count() )
- {
- return children.Item((size_t)cookie++);
- }
- else
- {
- // there are no more of them
- return wxTreeItemId();
- }
-}
-
-#endif // WXWIN_COMPATIBILITY_2_4
-
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
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
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();
}
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())
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
m_textCtrl = NULL;
}
+void wxGenericTreeCtrl::ResetFindState()
+{
+ m_findPrefix.clear();
+ if ( m_findBell )
+ m_findBell = 1;
+}
+
// find the first item starting with the given prefix after the given item
wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent,
const wxString& prefixOrig) const
// 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 id = idParent;
+ wxTreeItemId itemid = idParent;
if ( prefix.length() == 1 )
{
- id = GetNext(id);
+ itemid = GetNext(itemid);
}
// look for the item starting with the given prefix after it
- while ( id.IsOk() && !GetItemText(id).Lower().StartsWith(prefix) )
+ while ( itemid.IsOk() && !GetItemText(itemid).Lower().StartsWith(prefix) )
{
- id = GetNext(id);
+ itemid = GetNext(itemid);
}
// if we haven't found anything...
- if ( !id.IsOk() )
+ if ( !itemid.IsOk() )
{
// ... wrap to the beginning
- id = GetRootItem();
+ itemid = GetRootItem();
if ( HasFlag(wxTR_HIDE_ROOT) )
{
// can't select virtual root
- id = GetNext(id);
+ itemid = GetNext(itemid);
}
// and try all the items (stop when we get to the one we started from)
- while ( id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
+ while ( itemid.IsOk() && itemid != idParent &&
+ !GetItemText(itemid).Lower().StartsWith(prefix) )
{
- id = GetNext(id);
+ itemid = GetNext(itemid);
+ }
+ // If we haven't found the item but wrapped back to the one we started
+ // from, id.IsOk() must be false
+ if ( itemid == idParent )
+ {
+ itemid = wxTreeItemId();
}
}
- return id;
+ return itemid;
}
// -----------------------------------------------------------------------------
parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size()
: previous );
+ InvalidateBestSize();
return item;
}
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_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text,
+ m_anchor = new wxGenericTreeItem(NULL, text,
image, selImage, data);
if ( data != NULL )
{
m_current->SetHilight( true );
}
+ InvalidateBestSize();
return m_anchor;
}
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);
void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
{
- wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, this, item);
- ProcessEvent( event );
+ wxTreeEvent event(wxEVT_TREE_DELETE_ITEM, this, item);
+ GetEventHandler()->ProcessEvent( event );
}
// Don't leave edit or selection on a child which is about to disappear
void wxGenericTreeCtrl::ChildrenClosing(wxGenericTreeItem* item)
{
- if (m_textCtrl != NULL && item != m_textCtrl->item() && IsDescendantOf(item, m_textCtrl->item())) {
- m_textCtrl->StopEditing();
+ if ( m_textCtrl && item != m_textCtrl->item() &&
+ IsDescendantOf(item, m_textCtrl->item()) )
+ {
+ m_textCtrl->EndEdit( true );
}
- if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
+
+ if ( item != m_key_current && IsDescendantOf(item, m_key_current) )
+ {
m_key_current = NULL;
}
- if (IsDescendantOf(item, m_select_me)) {
+
+ if ( IsDescendantOf(item, m_select_me) )
+ {
m_select_me = item;
}
- if (item != m_current && IsDescendantOf(item, m_current)) {
+
+ if ( item != m_current && IsDescendantOf(item, m_current) )
+ {
m_current->SetHilight( false );
m_current = NULL;
m_select_me = item;
wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
ChildrenClosing(item);
item->DeleteChildren(this);
+ InvalidateBestSize();
}
void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item()))
{
// can't delete the item being edited, cancel editing it first
- m_textCtrl->StopEditing();
+ 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) )
{
// a different item, in idle time.
if ( m_select_me && IsDescendantOf(item, m_select_me) )
{
- m_select_me = parent;
+ m_select_me = to_be_selected;
}
if ( IsDescendantOf(item, m_current) )
// m_current = parent;
m_current = NULL;
- m_select_me = parent;
+ m_select_me = to_be_selected;
}
// remove the item from the tree
m_select_me = NULL;
delete item;
+
+ InvalidateBestSize();
}
void wxGenericTreeCtrl::DeleteAllItems()
{
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;
if ( item->IsExpanded() )
return;
- wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDING, this, item);
+ wxTreeEvent event(wxEVT_TREE_ITEM_EXPANDING, this, item);
- if ( ProcessEvent( event ) && !event.IsAllowed() )
+ if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
{
// cancelled by program
return;
}
item->Expand();
- CalculatePositions();
+ if ( !IsFrozen() )
+ {
+ CalculatePositions();
- RefreshSubtree(item);
+ RefreshSubtree(item);
+ }
+ else // frozen
+ {
+ m_dirty = true;
+ }
- event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
- ProcessEvent( event );
+ event.SetEventType(wxEVT_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, this, item);
- if ( ProcessEvent( event ) && !event.IsAllowed() )
+ wxTreeEvent event(wxEVT_TREE_ITEM_COLLAPSING, this, item);
+ if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
{
// cancelled by program
return;
#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]);
RefreshSubtree(item);
- event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
- ProcessEvent( event );
+ event.SetEventType(wxEVT_TREE_ITEM_COLLAPSED);
+ GetEventHandler()->ProcessEvent( event );
}
void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
}
}
+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())
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]);
}
}
+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_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_TREE_SEL_CHANGED);
+ GetEventHandler()->ProcessEvent( event );
+}
+
+
// Recursive function !
// To stop we must have crt_item<last_item
// Algorithm :
// Tag all next children, when no more children,
// Move to parent (not to tag)
// Keep going... if we found last_item, we stop.
-bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
+bool
+wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item,
+ wxGenericTreeItem *last_item,
+ bool select)
{
wxGenericTreeItem *parent = crt_item->GetParent();
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); n<count; ++n)
{
- if (TagAllChildrenUntilLast(children[n], last_item, select)) return true;
+ if ( TagAllChildrenUntilLast(children[n], last_item, select) )
+ return true;
}
return TagNextChildren(parent, last_item, select);
}
-bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
+bool
+wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item,
+ wxGenericTreeItem *last_item,
+ bool select)
{
crt_item->SetHilight(select);
RefreshLine(crt_item);
if (crt_item==last_item)
return true;
- if (crt_item->HasChildren())
+ // We should leave the not shown children of collapsed items alone.
+ if (crt_item->HasChildren() && crt_item->IsExpanded())
{
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 false;
}
-void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
+void
+wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1,
+ wxGenericTreeItem *item2)
{
m_select_me = NULL;
return;
}
- wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
+ wxTreeEvent event(wxEVT_TREE_SEL_CHANGING, this, item);
event.m_itemOld = m_current;
// TODO : Here we don't send any selection mode yet !
{
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)
// selection is set
EnsureVisible( itemId );
- event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
+ event.SetEventType(wxEVT_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 )
{
- DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));
+ if ( !item->IsSelected() )
+ DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));
}
else // deselect
{
- wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
- wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
+ wxTreeEvent event(wxEVT_TREE_SEL_CHANGING, this, item);
+ if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
+ return;
item->SetHilight(false);
RefreshLine(item);
+
+ event.SetEventType(wxEVT_TREE_SEL_CHANGED);
+ GetEventHandler()->ProcessEvent( event );
}
}
}
//else: the tree is empty, so no selections
- return array.Count();
+ return array.GetCount();
}
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.
+ // update the control before scrolling it
if (m_dirty)
-#if defined( __WXMSW__ ) || defined(__WXMAC__)
+ {
+#if defined( __WXMSW__ )
Update();
+#elif defined(__WXMAC__)
+ Update();
+ DoDirtyProcessing();
#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;
+#ifdef __WXOSX__
+ // because itemY below will be divided by PIXELS_PER_UNIT it may
+ // be rounded down, with the result of the item still only being
+ // partially visible, so make sure we are rounding up
+ itemY += PIXELS_PER_UNIT-1;
+#endif
}
- 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!
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);
}
wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
wxArrayGenericTreeItems& children = item->GetChildren();
- if ( children.Count() > 1 )
+ if ( children.GetCount() > 1 )
{
m_dirty = true;
}
}
+ 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.
m_imageListNormal = imageList;
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)
if (m_ownsImageListState) delete m_imageListState;
m_imageListState = imageList;
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)
m_imageListButtons = imageList;
m_ownsImageListButtons = false;
m_dirty = true;
+
+ if (m_anchor)
+ m_anchor->RecursiveResetSize();
+
CalculateLineHeight();
}
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
{
void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
{
- // TODO implement "state" icon on items
+ item->SetFont(this, dc);
+ item->CalculateSize(this, dc);
- wxTreeItemAttr *attr = item->GetAttributes();
- if ( attr && attr->HasFont() )
- dc.SetFont(attr->GetFont());
- else if (item->IsBold())
- dc.SetFont(m_boldFont);
-
- 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();
{
if ( m_imageListNormal )
{
- m_imageListNormal->GetSize( image, image_w, image_h );
+ m_imageListNormal->GetSize(image, image_w, image_h);
image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
}
else
}
}
- int total_h = GetLineHeight(item);
- bool drawItemBackground = false;
-
- if ( item->IsSelected() )
+ int state_h = 0, state_w = 0;
+ int state = item->GetState();
+ if ( state != wxTREE_ITEMSTATE_NONE )
{
-// under mac selections are only a rectangle in case they don't have the focus
-#ifdef __WXMAC__
- if ( !m_hasFocus )
+ if ( m_imageListState )
{
- dc.SetBrush( *wxTRANSPARENT_BRUSH ) ;
- dc.SetPen( wxPen( wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT ) , 1 , wxSOLID ) ) ;
+ 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
{
- dc.SetBrush( *m_hilightBrush ) ;
+ state = wxTREE_ITEMSTATE_NONE;
}
-#else
+ }
+
+ int total_h = GetLineHeight(item);
+ bool drawItemBackground = false,
+ hasBgColour = false;
+
+ if ( item->IsSelected() )
+ {
dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
-#endif
drawItemBackground = true;
}
else
{
wxColour colBg;
+ wxTreeItemAttr * const attr = item->GetAttributes();
if ( attr && attr->HasBackgroundColour() )
{
- drawItemBackground = true;
+ drawItemBackground =
+ hasBgColour = true;
colBg = attr->GetBackgroundColour();
}
else
{
colBg = GetBackgroundColour();
}
- dc.SetBrush(wxBrush(colBg, wxSOLID));
+ 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
}
// 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))
// 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;
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;
wxColour colText;
if ( item->IsSelected()
-#ifdef __WXMAC__
+#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
+ && 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
{
if (item->IsExpanded())
{
wxArrayGenericTreeItems& children = item->GetChildren();
- int count = children.Count();
+ int count = children.GetCount();
if (count > 0)
{
int n = 0, oldY;
oldY += GetLineHeight(children[n-1])>>1;
if (HasButtons()) y_mid += 5;
- // Only draw the portion of the line that is visible, in case it is huge
+ // 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?
+ // Move end points to the beginning/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
+ // 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);
}
DrawLine(item, !m_dropEffectAboveItem );
}
- SetCursor(wxCURSOR_BULLSEYE);
+ SetCursor(*wxSTANDARD_CURSOR);
}
else
{
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)
{
- y += GetLineHeight(i) - 1;
+ if (below)
+ m_dndEffect = BelowEffect;
+ else
+ m_dndEffect = AboveEffect;
+ m_dndEffectItem = i;
+ }
+ else
+ {
+ 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 );
}
// -----------------------------------------------------------------------------
// 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);
event.Skip();
}
-void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
+void wxGenericTreeCtrl::OnKeyDown( wxKeyEvent &event )
{
- wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, this);
+ // send a tree event
+ wxTreeEvent te( wxEVT_TREE_KEY_DOWN, this);
te.m_evtKey = event;
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();
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
// end : go to last item without opening parents
// alnum : start or continue searching for the item with this prefix
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 '+':
case WXK_MENU:
{
- // Use the item's bounding rectangle to determine position for the event
+ // 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);
+ wxTreeEvent
+ eventMenu(wxEVT_TREE_ITEM_MENU, this, m_current);
// Use the left edge, vertical middle
eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(),
- ItemRect.GetY() + ItemRect.GetHeight() / 2);
+ ItemRect.GetY() +
+ ItemRect.GetHeight() / 2);
GetEventHandler()->ProcessEvent( eventMenu );
}
break;
case WXK_RETURN:
if ( !event.HasModifiers() )
{
- wxTreeEvent eventAct(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, m_current);
+ wxTreeEvent
+ eventAct(wxEVT_TREE_ITEM_ACTIVATED, this, m_current);
GetEventHandler()->ProcessEvent( eventAct );
}
{
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
- DoSelectItem( 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;
}
}
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:
{
wxTreeItemIdValue cookie;
wxTreeItemId child = GetFirstChild( m_key_current, cookie );
+ if ( !child )
+ break;
+
DoSelectItem( child, unselect_others, extended_select );
m_key_current=(wxGenericTreeItem*) child.m_pItem;
}
if ( !event.HasModifiers() &&
((keyCode >= '0' && keyCode <= '9') ||
(keyCode >= 'a' && keyCode <= 'z') ||
- (keyCode >= 'A' && keyCode <= 'Z' )))
+ (keyCode >= 'A' && keyCode <= 'Z') ||
+ (keyCode == '_')))
{
// find the next item starting with the given prefix
wxChar ch = (wxChar)keyCode;
+ wxTreeItemId id;
- wxTreeItemId id = FindItem(m_current, m_findPrefix + ch);
- if ( !id.IsOk() )
+ // if the same character is typed multiple times then go to the
+ // next entry starting with that character instead of searching
+ // for an item starting with multiple copies of this character,
+ // this is more useful and is how it works under Windows.
+ if ( m_findPrefix.length() == 1 && m_findPrefix[0] == ch )
{
- // no such item
- break;
+ id = FindItem(m_current, ch);
+ }
+ else
+ {
+ const wxString newPrefix(m_findPrefix + ch);
+ id = FindItem(m_current, newPrefix);
+ if ( id.IsOk() )
+ m_findPrefix = newPrefix;
}
-
- SelectItem(id);
-
- m_findPrefix += ch;
// also start the timer to reset the current prefix if the user
// doesn't press any more alnum keys soon -- we wouldn't want
m_findTimer = new wxTreeFindTimer(this);
}
+ // Notice that we should start the timer even if we didn't find
+ // anything to make sure we reset the search state later.
m_findTimer->Start(wxTreeFindTimer::DELAY, wxTIMER_ONE_SHOT);
+
+ if ( id.IsOk() )
+ {
+ SelectItem(id);
+
+ // Reset the bell flag if it had been temporarily disabled
+ // before.
+ if ( m_findBell )
+ m_findBell = 1;
+ }
+ else // No such item
+ {
+ // Signal it with a bell if enabled.
+ if ( m_findBell == 1 )
+ {
+ ::wxBell();
+
+ // Disable it for the next unsuccessful match, we only
+ // beep once, this is usually enough and continuing to
+ // do it would be annoying.
+ m_findBell = -1;
+ }
+ }
}
else
{
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;
if ( textOnly )
{
- rect.x = i->GetX();
- rect.width = i->GetWidth();
+ 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;
+ }
- if ( m_imageListNormal )
+ int state_h = 0, state_w = 0;
+ int state = ((wxGenericTreeItem*) item.m_pItem)->GetState();
+ if ( state != wxTREE_ITEMSTATE_NONE && m_imageListState )
{
- int image_w, image_h;
- m_imageListNormal->GetSize( 0, image_w, image_h );
- rect.width += image_w + MARGIN_BETWEEN_IMAGE_AND_TEXT;
+ 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
{
wxTextCtrl *wxGenericTreeCtrl::EditLabel(const wxTreeItemId& item,
wxClassInfo * WXUNUSED(textCtrlClass))
{
- wxCHECK_MSG( item.IsOk(), NULL, _T("can't edit an invalid item") );
+ wxCHECK_MSG( item.IsOk(), NULL, wxT("can't edit an invalid item") );
wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem;
- wxTreeEvent te(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, this, itemEdit);
+ wxTreeEvent te(wxEVT_TREE_BEGIN_LABEL_EDIT, this, itemEdit);
if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
{
// vetoed by user
// question might just have been added and no screen
// update taken place.
if ( m_dirty )
-#if defined( __WXMSW__ ) || defined(__WXMAC__)
- Update();
-#else
DoDirtyProcessing();
-#endif
// TODO: use textCtrlClass here to create the control of correct class
m_textCtrl = new wxTreeTextCtrl(this, itemEdit);
void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item),
bool discardChanges)
{
- wxCHECK_RET( m_textCtrl, _T("not editing label") );
+ wxCHECK_RET( m_textCtrl, wxT("not editing label") );
m_textCtrl->EndEdit(discardChanges);
}
bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
const wxString& value)
{
- wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);
+ wxTreeEvent le(wxEVT_TREE_END_LABEL_EDIT, this, item);
le.m_label = value;
le.m_editCancelled = false;
void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
{
// let owner know that the edit was cancelled
- wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);
+ wxTreeEvent le(wxEVT_TREE_END_LABEL_EDIT, this, item);
le.m_label = wxEmptyString;
le.m_editCancelled = true;
// 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()))
+ // 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() )
+ wxTreeEvent
+ hevent(wxEVT_TREE_ITEM_GETTOOLTIP, this, hoverItem);
+
+ // setting a tooltip upon leaving a view is getting the tooltip displayed
+ // on the neighbouring view ...
+#ifdef __WXOSX__
+ if ( event.Leaving() )
+ SetToolTip(NULL);
+ else
+#endif
+ if ( GetEventHandler()->ProcessEvent(hevent) )
{
- SetToolTip(hevent.m_label);
+ // If the user permitted the tooltip change, update it, otherwise
+ // remove any old tooltip we might have.
+ if ( hevent.IsAllowed() )
+ SetToolTip(hevent.m_label);
+ else
+ SetToolTip(NULL);
}
}
#endif
}
wxEventType command = event.RightIsDown()
- ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
- : wxEVT_COMMAND_TREE_BEGIN_DRAG;
+ ? wxEVT_TREE_BEGIN_RDRAG
+ : wxEVT_TREE_BEGIN_DRAG;
wxTreeEvent nevent(command, this, m_current);
nevent.SetPoint(CalcScrolledPosition(pt));
#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
}
{
m_oldSelection->SetHilight(true);
RefreshLine(m_oldSelection);
- m_oldSelection = (wxGenericTreeItem *)NULL;
+ m_oldSelection = NULL;
}
// generate the drag end event
- wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, this, item);
+ wxTreeEvent eventEndDrag(wxEVT_TREE_END_DRAG, this, item);
eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);
(void)GetEventHandler()->ProcessEvent(eventEndDrag);
m_isDragging = false;
- m_dropTarget = (wxGenericTreeItem *)NULL;
+ m_dropTarget = NULL;
SetCursor(m_oldCursor);
-#if defined( __WXMSW__ ) || defined(__WXMAC__)
+#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.
+ // 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.
+ // restore focus to the tree control even if we didn't exactly hit an
+ // item.
if ( event.LeftDown() )
{
event.Skip();
if ( event.RightDown() )
{
// If the item is already selected, do not update the selection.
- // Multi-selections should not be cleared if a selected item is clicked.
+ // 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);
+ wxTreeEvent
+ nevent(wxEVT_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 behavior may change.
- wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU, this, item);
+ // the RIGHT_CLICK event. TODO: This behaviour may change.
+ wxTreeEvent nevent2(wxEVT_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);
+ wxTreeEvent
+ nevent(wxEVT_TREE_ITEM_MIDDLE_CLICK, this, item);
nevent.m_pointDrag = CalcScrolledPosition(pt);
event.Skip(!GetEventHandler()->ProcessEvent(nevent));
}
else if ( event.LeftUp() )
{
+ if (flags & wxTREE_HITTEST_ONITEMSTATEICON)
+ {
+ wxTreeEvent
+ nevent(wxEVT_TREE_STATE_IMAGE_CLICK, this, item);
+ GetEventHandler()->ProcessEvent(nevent);
+ }
+
// this facilitates multiple-item drag-and-drop
if ( /* item && */ HasFlag(wxTR_MULTIPLE))
m_lastOnSame = false;
}
}
- else // !RightDown() && !MiddleDown() && !LeftUp() ==> LeftDown() || LeftDClick()
+ else // !RightDown() && !MiddleDown() && !LeftUp()
{
+ // ==> LeftDown() || LeftDClick()
if ( event.LeftDown() )
{
- m_lastOnSame = item == m_current;
+ // If we click on an already selected item but do it to return
+ // the focus to the control, it shouldn't start editing the
+ // item label because it's too easy to start editing
+ // accidentally (and also because nobody else does it like
+ // this). So only set this flag, used to decide whether we
+ // should start editing the label later, if we already have
+ // focus.
+ m_lastOnSame = item == m_current && HasFocus();
}
if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
EventFlagsToSelType(GetWindowStyleFlag(),
event.ShiftDown(),
event.CmdDown(),
- is_multiple, extended_select, unselect_others);
+ is_multiple,
+ extended_select,
+ unselect_others);
DoSelectItem(item, unselect_others, extended_select);
}
m_lastOnSame = false;
// send activate event first
- wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, item);
+ wxTreeEvent
+ nevent(wxEVT_TREE_ITEM_ACTIVATED, this, item);
nevent.m_pointDrag = CalcScrolledPosition(pt);
if ( !GetEventHandler()->ProcessEvent( nevent ) )
{
DoDirtyProcessing();
}
-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);
- else
- dc.SetFont(m_normalFont);
-
- 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 )
- {
- if ( m_imageListNormal )
- {
- m_imageListNormal->GetSize( image, image_w, image_h );
- image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
- }
- }
-
- 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);
-}
-
-// -----------------------------------------------------------------------------
-// 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))
goto Recurse;
}
- CalculateSize( item, dc );
+ item->CalculateSize(this, dc);
// set its position
item->SetX( x+m_spacing );
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
void wxGenericTreeCtrl::Refresh(bool eraseBackground, const wxRect *rect)
{
- if ( !m_freezeCount )
+ if ( !IsFrozen() )
wxTreeCtrlBase::Refresh(eraseBackground, rect);
}
void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
{
- if (m_dirty || m_freezeCount)
+ if (m_dirty || IsFrozen() )
return;
wxSize client = GetClientSize();
void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
{
- if (m_dirty || m_freezeCount)
+ if (m_dirty || IsFrozen() )
return;
wxRect rect;
void wxGenericTreeCtrl::RefreshSelected()
{
- if (m_freezeCount)
+ if (IsFrozen())
return;
// TODO: this is awfully inefficient, we should keep the list of all
void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
{
- if (m_freezeCount)
+ if (IsFrozen())
return;
if ( item->IsSelected() )
}
}
-void wxGenericTreeCtrl::Freeze()
-{
- m_freezeCount++;
-}
-
-void wxGenericTreeCtrl::Thaw()
+void wxGenericTreeCtrl::DoThaw()
{
- wxCHECK_RET( m_freezeCount > 0, _T("thawing unfrozen tree control?") );
+ wxTreeCtrlBase::DoThaw();
- if ( --m_freezeCount == 0 )
- {
+ if ( m_dirty )
+ DoDirtyProcessing();
+ else
Refresh();
- }
}
// ----------------------------------------------------------------------------
return true;
}
-// Process the tooltip event, to speed up event processing.
-// Doesn't actually get a tooltip.
void wxGenericTreeCtrl::OnGetToolTip( wxTreeEvent &event )
{
- event.Veto();
+#if wxUSE_TOOLTIPS
+ wxTreeItemId itemId = event.GetItem();
+ const wxGenericTreeItem* const pItem = (wxGenericTreeItem*)itemId.m_pItem;
+
+ // Check if the item fits into the client area:
+ if ( pItem->GetX() + pItem->GetWidth() > GetClientSize().x )
+ {
+ // If it doesn't, show its full text in the tooltip.
+ event.SetLabel(pItem->GetText());
+ }
+ else
+#endif // wxUSE_TOOLTIPS
+ {
+ // veto processing the event, nixing any tooltip
+ event.Veto();
+ }
}
return wxListBox::GetClassDefaultAttributes(variant);
#else
wxVisualAttributes attr;
- attr.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
+ 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
}
-#if WXWIN_COMPATIBILITY_2_4
-
-int wxGenericTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
-{
- return GetItemImage(item, wxTreeItemIcon_Selected);
-}
-
-void wxGenericTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
-{
- SetItemImage(item, image, wxTreeItemIcon_Selected);
-}
-
-#endif // WXWIN_COMPATIBILITY_2_4
-
void wxGenericTreeCtrl::DoDirtyProcessing()
{
- if (m_freezeCount)
+ if (IsFrozen())
return;
m_dirty = false;
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
projects / wxWidgets.git / blobdiff