// array types
// -----------------------------------------------------------------------------
-class WXDLLEXPORT wxGenericTreeItem;
+class WXDLLIMPEXP_FWD_CORE wxGenericTreeItem;
WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
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 StopEditing()
- {
- Finish();
- m_owner->OnRenameCancelled(m_itemEdited);
- }
+ void EndEdit( bool discardChanges );
+
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()
: m_itemEdited(item), m_startValue(item->GetText())
{
m_owner = owner;
- m_finished = false;
m_aboutToFinish = false;
int w = m_itemEdited->GetWidth(),
wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));
}
+void wxTreeTextCtrl::EndEdit(bool discardChanges)
+{
+ m_aboutToFinish = true;
+
+ if ( discardChanges )
+ {
+ m_owner->OnRenameCancelled(m_itemEdited);
+
+ Finish( true );
+ }
+ else
+ {
+ // Notify the owner about the changes
+ AcceptChanges();
+
+ // Even if vetoed, close the control (consistent with MSW)
+ Finish( true );
+ }
+}
+
bool wxTreeTextCtrl::AcceptChanges()
{
const wxString value = GetValue();
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();
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();
}
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,
m_textCtrl = NULL;
m_renameTimer = NULL;
- m_freezeCount = 0;
m_findTimer = NULL;
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
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
SetInitialSize(size);
// 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)++);
}
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
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, this, item);
- ProcessEvent( event );
+ 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();
+ m_textCtrl->EndEdit( true );
}
if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
m_key_current = NULL;
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();
m_select_me = NULL;
delete item;
+
+ InvalidateBestSize();
}
void wxGenericTreeCtrl::DeleteAllItems()
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();
+ if ( !IsFrozen() )
+ {
+ CalculatePositions();
- RefreshSubtree(item);
+ RefreshSubtree(item);
+ }
+ else // frozen
+ {
+ m_dirty = true;
+ }
event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
- ProcessEvent( event );
+ GetEventHandler()->ProcessEvent( event );
}
void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
return;
wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, this, item);
- if ( ProcessEvent( event ) && !event.IsAllowed() )
+ 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))
}
//else: the tree is empty, so no selections
- return array.Count();
+ return array.GetCount();
}
void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
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;
{
int flags = wxCONTROL_SELECTED;
if (m_hasFocus
-#ifdef __WXMAC__
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
&& IsControlActive( (ControlRef)GetHandle() )
#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;
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
if (item->IsExpanded())
{
wxArrayGenericTreeItems& children = item->GetChildren();
- int count = children.Count();
+ int count = children.GetCount();
if (count > 0)
{
int n = 0, oldY;
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;
}
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()
+void wxGenericTreeCtrl::DoThaw()
{
- m_freezeCount++;
-}
-
-void wxGenericTreeCtrl::Thaw()
-{
- wxCHECK_RET( m_freezeCount > 0, _T("thawing unfrozen tree control?") );
-
- if ( --m_freezeCount == 0 )
- {
+ if ( m_dirty )
+ DoDirtyProcessing();
+ else
Refresh();
- }
}
// ----------------------------------------------------------------------------
void wxGenericTreeCtrl::DoDirtyProcessing()
{
- if (m_freezeCount)
+ if (IsFrozen())
return;
m_dirty = false;
projects / wxWidgets.git / blobdiff