/////////////////////////////////////////////////////////////////////////////
-// Name: treectlg.cpp
+// Name: src/generic/treectlg.cpp
// Purpose: generic tree control implementation
// Author: Robert Roebling
// Created: 01/02/97
#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"
// array types
// -----------------------------------------------------------------------------
-class WXDLLEXPORT wxGenericTreeItem;
+class WXDLLIMPEXP_FWD_CORE wxGenericTreeItem;
WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
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];
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 );
}
// 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,
BEGIN_EVENT_TABLE(wxGenericTreeCtrl, wxTreeCtrlBase)
EVT_PAINT (wxGenericTreeCtrl::OnPaint)
+ EVT_SIZE (wxGenericTreeCtrl::OnSize)
EVT_MOUSE_EVENTS (wxGenericTreeCtrl::OnMouse)
EVT_CHAR (wxGenericTreeCtrl::OnChar)
EVT_SET_FOCUS (wxGenericTreeCtrl::OnSetFocus)
m_lastOnSame = false;
-#ifdef __WXMAC_CARBON__
- m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
+#ifdef __WXMAC__
+ m_normalFont.MacCreateFromThemeFont( kThemeViewsFont ) ;
#else
m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
#endif
style |= wxTR_NO_LINES;
if (major < 10)
style |= wxTR_ROW_LINES;
+
+ if (style == 0 || style & wxTR_DEFAULT_STYLE)
+ style |= wxTR_FULL_ROW_HIGHLIGHT;
+
#endif // __WXMAC__
+#ifdef __WXGTK20__
+ style |= wxTR_NO_LINES;
+#endif
if ( !wxControl::Create( parent, id, pos, size,
style|wxHSCROLL|wxVSCROLL,
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, wxDOT);
+#else
+ m_dottedPen = *wxGREY_PEN;
+#endif
- SetBestSize(size);
+ SetInitialSize(size);
return true;
}
if ( pItem->IsBold() != bold )
{
pItem->SetBold(bold);
+
+ // recalculate the item size as bold and non bold fonts have different
+ // widths
+ wxClientDC dc(this);
+ CalculateSize(pItem, dc);
+
RefreshLine(pItem);
}
}
// 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") );
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::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
}
// and try all the items (stop when we get to the one we started from)
- while ( id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
+ while (id.IsOk() && id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
{
id = GetNext(id);
}
+ // If we haven't found the item, id.IsOk() will be false, as per
+ // documentation
}
return id;
parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size()
: previous );
+ InvalidateBestSize();
return item;
}
m_current->SetHilight( true );
}
+ InvalidateBestSize();
return m_anchor;
}
void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
{
- wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
- event.m_item = item;
- event.SetEventObject( this );
- ProcessEvent( event );
+ wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, this, item);
+ GetEventHandler()->ProcessEvent( event );
}
// Don't leave edit or selection on a child which is about to disappear
wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
ChildrenClosing(item);
item->DeleteChildren(this);
+ InvalidateBestSize();
}
void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
m_select_me = NULL;
delete item;
+
+ InvalidateBestSize();
}
void wxGenericTreeCtrl::DeleteAllItems()
if ( item->IsExpanded() )
return;
- wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
- event.m_item = 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)
-{
- if ( !HasFlag(wxTR_HIDE_ROOT) || item != GetRootItem())
+ if ( !m_freezeCount )
{
- Expand(item);
- if ( !IsExpanded(item) )
- return;
- }
+ CalculatePositions();
- wxTreeItemIdValue cookie;
- wxTreeItemId child = GetFirstChild(item, cookie);
- while ( child.IsOk() )
+ RefreshSubtree(item);
+ }
+ else // frozen
{
- ExpandAll(child);
-
- child = GetNextChild(item, cookie);
+ m_dirty = true;
}
+
+ event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
+ GetEventHandler()->ProcessEvent( event );
}
void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
if ( !item->IsExpanded() )
return;
- wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
- event.m_item = 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;
#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 );
+ GetEventHandler()->ProcessEvent( event );
}
void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& 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]);
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 (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;
}
- wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
- event.m_item = item;
+ wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
event.m_itemOld = m_current;
- event.SetEventObject( this );
// TODO : Here we don't send any selection mode yet !
if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
{
wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
+
+ 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 );
}
}
}
//else: the tree is empty, so no selections
- return array.Count();
+ return array.GetCount();
}
void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
#if defined( __WXMSW__ ) || defined(__WXMAC__)
Update();
#else
- wxYieldIfNeeded();
+ DoDirtyProcessing();
#endif
wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
wxArrayGenericTreeItems& children = item->GetChildren();
- if ( children.Count() > 1 )
+ if ( children.GetCount() > 1 )
{
m_dirty = true;
else if (item->IsBold())
dc.SetFont(m_boldFont);
- long text_w = 0, text_h = 0;
+ wxCoord text_w = 0, text_h = 0;
dc.GetTextExtent( item->GetText(), &text_w, &text_h );
int image_h = 0, image_w = 0;
if ( item->IsSelected() )
{
-// under mac selections are only a rectangle in case they don't have the focus
-#ifdef __WXMAC__
- if ( !m_hasFocus )
- {
- dc.SetBrush( *wxTRANSPARENT_BRUSH ) ;
- dc.SetPen( wxPen( wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT ) , 1 , wxSOLID ) ) ;
- }
- else
- {
- dc.SetBrush( *m_hilightBrush ) ;
- }
-#else
dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
-#endif
drawItemBackground = true;
}
else
if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
{
- int x, y, w, h;
-
- DoGetPosition(&x, &y);
- DoGetSize(&w, &h);
- dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
+ int x, w, h;
+ x=0;
+ GetVirtualSize(&w, &h);
+ wxRect rect( x, item->GetY()+offset, w, total_h-offset);
+#if !defined(__WXGTK20__) && !defined(__WXMAC__)
+ dc.DrawRectangle(rect);
+#else
+ if (!item->IsSelected())
+ {
+ dc.DrawRectangle(rect);
+ }
+ else
+ {
+ int flags = wxCONTROL_SELECTED;
+ if (m_hasFocus
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
+ && IsControlActive( (ControlRef)GetHandle() )
+#endif
+ )
+ flags |= wxCONTROL_FOCUSED;
+ if ((item == m_current) && (m_hasFocus))
+ flags |= wxCONTROL_CURRENT;
+ wxRendererNative::Get().DrawItemSelectionRect( this, dc, rect, flags );
+ }
+#endif
}
else
{
// 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 );
+ wxRect rect( item->GetX() + image_w - 2, item->GetY()+offset,
+ item->GetWidth() - 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()-2, item->GetY()+offset,
+ item->GetWidth()+2, total_h-offset );
+#if !defined(__WXGTK20__) && !defined(__WXMAC__)
+ dc.DrawRectangle( rect );
+#else
+ if ( attr && attr->HasBackgroundColour() )
+ {
+ 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
}
}
// 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;
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
wxColour colText;
if ( item->IsSelected()
-#ifdef __WXMAC__
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
// 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
)
{
+#ifdef __WXMAC__
+ colText = *wxWHITE;
+#else
colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+#endif
}
else
{
if (item->IsExpanded())
{
wxArrayGenericTreeItems& children = item->GetChildren();
- int count = children.Count();
+ int count = children.GetCount();
if (count > 0)
{
int n = 0, oldY;
// 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);
void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
{
- wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
+ wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, this);
te.m_evtKey = event;
- te.SetEventObject( this );
if ( GetEventHandler()->ProcessEvent( te ) )
{
// intercepted by the user code
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
if ( !IsExpanded(m_current) )
{
// expand all
- ExpandAll(m_current);
+ ExpandAllChildren(m_current);
break;
}
//else: fall through to Collapse() it
wxRect ItemRect;
GetBoundingRect(m_current, ItemRect, true);
- wxTreeEvent eventMenu( wxEVT_COMMAND_TREE_ITEM_MENU, GetId() );
- eventMenu.m_item = m_current;
+ 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);
- eventMenu.SetEventObject( this );
GetEventHandler()->ProcessEvent( eventMenu );
- break;
}
+ break;
+
case ' ':
case WXK_RETURN:
if ( !event.HasModifiers() )
{
- wxTreeEvent eventAct( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
- eventAct.m_item = m_current;
- eventAct.SetEventObject( this );
+ wxTreeEvent eventAct(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, m_current);
GetEventHandler()->ProcessEvent( eventAct );
}
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;
}
}
}
-wxTreeItemId wxGenericTreeCtrl::DoTreeHitTest(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;
wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem;
- wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
- te.m_item = itemEdit;
- te.SetEventObject( this );
+ wxTreeEvent te(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, this, itemEdit);
if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
{
// vetoed by user
#if defined( __WXMSW__ ) || defined(__WXMAC__)
Update();
#else
- wxYieldIfNeeded();
+ DoDirtyProcessing();
#endif
// TODO: use textCtrlClass here to create the control of correct class
bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
const wxString& value)
{
- wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
- le.m_item = item;
- le.SetEventObject( this );
+ wxTreeEvent le(wxEVT_COMMAND_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, GetId() );
- le.m_item = item;
- le.SetEventObject( this );
+ wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);
le.m_label = wxEmptyString;
le.m_editCancelled = true;
void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
{
- if ( !m_anchor ) return;
+ if ( !m_anchor )return;
wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
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, GetId());
- hevent.m_item = hoverItem;
- hevent.SetEventObject(this);
+ wxTreeEvent hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, this, hoverItem);
if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
{
}
#endif
- // we process left mouse up event (enables in-place edit), right down
+ // 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() ||
? wxEVT_COMMAND_TREE_BEGIN_RDRAG
: wxEVT_COMMAND_TREE_BEGIN_DRAG;
- wxTreeEvent nevent( command, GetId() );
- nevent.m_item = 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
}
// generate the drag end event
- wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, GetId());
+ wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, this, item);
- eventEndDrag.m_item = item;
eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);
- eventEndDrag.SetEventObject(this);
(void)GetEventHandler()->ProcessEvent(eventEndDrag);
DoSelectItem(item, true, false);
}
- wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
- nevent.m_item = item;
+ wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, this, item);
nevent.m_pointDrag = CalcScrolledPosition(pt);
- nevent.SetEventObject(this);
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, GetId());
- nevent2.m_item = item;
+ wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU, this, item);
nevent2.m_pointDrag = CalcScrolledPosition(pt);
- nevent2.SetEventObject(this);
GetEventHandler()->ProcessEvent(nevent2);
}
+ else if ( event.MiddleDown() )
+ {
+ wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK, this, item);
+ nevent.m_pointDrag = CalcScrolledPosition(pt);
+ event.Skip(!GetEventHandler()->ProcessEvent(nevent));
+ }
else if ( event.LeftUp() )
{
// this facilitates multiple-item drag-and-drop
m_lastOnSame = false;
}
}
- else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
+ else // !RightDown() && !MiddleDown() && !LeftUp() ==> LeftDown() || LeftDClick()
{
if ( event.LeftDown() )
{
m_lastOnSame = false;
// send activate event first
- wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
- nevent.m_item = 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,
SelectItem(GetRootItem());
}
- /* after all changes have been done to the tree control,
- * we actually redraw the tree when everything is over */
-
- if (!m_dirty) return;
- if (m_freezeCount) return;
-
- m_dirty = false;
-
- CalculatePositions();
- Refresh();
- AdjustMyScrollbars();
+ // after all changes have been done to the tree control,
+ // actually redraw the tree when everything is over
+ if (m_dirty)
+ DoDirtyProcessing();
}
void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
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
CalculateLevel( m_anchor, dc, 0, y ); // start recursion
}
+void wxGenericTreeCtrl::Refresh(bool eraseBackground, const wxRect *rect)
+{
+ if ( !m_freezeCount )
+ wxTreeCtrlBase::Refresh(eraseBackground, rect);
+}
+
void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
{
- if (m_dirty) return;
- if (m_freezeCount) return;
+ if (m_dirty || m_freezeCount)
+ return;
wxSize client = GetClientSize();
void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
{
- if (m_dirty) return;
- if (m_freezeCount) return;
+ if (m_dirty || m_freezeCount)
+ return;
wxRect rect;
CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
void wxGenericTreeCtrl::RefreshSelected()
{
- if (m_freezeCount) return;
+ if (m_freezeCount)
+ return;
// TODO: this is awfully inefficient, we should keep the list of all
// selected items internally, should be much faster
void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
{
- if (m_freezeCount) return;
+ if (m_freezeCount)
+ return;
if ( item->IsSelected() )
RefreshLine(item);
if ( --m_freezeCount == 0 )
{
- Refresh();
+ if ( m_dirty )
+ DoDirtyProcessing();
+ else
+ Refresh();
}
}
if ( !wxWindow::SetBackgroundColour(colour) )
return false;
- if (m_freezeCount) return true;
-
Refresh();
return true;
if ( !wxWindow::SetForegroundColour(colour) )
return false;
- if (m_freezeCount) return true;
-
Refresh();
return true;
// be removed, as well as the #else case below.
#define _USE_VISATTR 0
-#if _USE_VISATTR
-#include "wx/listbox.h"
-#endif
-
//static
wxVisualAttributes
#if _USE_VISATTR
#endif
}
-#if WXWIN_COMPATIBILITY_2_4
-
-int wxGenericTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
+void wxGenericTreeCtrl::DoDirtyProcessing()
{
- return GetItemImage(item, wxTreeItemIcon_Selected);
+ if (m_freezeCount)
+ return;
+
+ m_dirty = false;
+
+ CalculatePositions();
+ Refresh();
+ AdjustMyScrollbars();
}
-void wxGenericTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
+wxSize wxGenericTreeCtrl::DoGetBestSize() const
{
- SetItemImage(item, image, wxTreeItemIcon_Selected);
-}
+ // 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();
-#endif // WXWIN_COMPATIBILITY_2_4
+ // 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