+}
+
+bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
+
+ return !item.m_pItem->GetChildren().IsEmpty();
+}
+
+bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
+
+ return item.m_pItem->IsExpanded();
+}
+
+bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
+
+ return item.m_pItem->HasHilight();
+}
+
+bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
+
+ return item.m_pItem->IsBold();
+}
+
+// -----------------------------------------------------------------------------
+// navigation
+// -----------------------------------------------------------------------------
+
+wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ return item.m_pItem->GetParent();
+}
+
+wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ cookie = 0;
+ return GetNextChild(item, cookie);
+}
+
+wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ wxArrayGenericTreeItems& children = item.m_pItem->GetChildren();
+ if ( (size_t)cookie < children.Count() )
+ {
+ return children.Item(cookie++);
+ }
+ else
+ {
+ // there are no more of them
+ return wxTreeItemId();
+ }
+}
+
+wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ wxArrayGenericTreeItems& children = item.m_pItem->GetChildren();
+ return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
+}
+
+wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ wxGenericTreeItem *i = item.m_pItem;
+ wxGenericTreeItem *parent = i->GetParent();
+ if ( parent == NULL )
+ {
+ // root item doesn't have any siblings
+ return wxTreeItemId();
+ }
+
+ wxArrayGenericTreeItems& siblings = parent->GetChildren();
+ int index = siblings.Index(i);
+ 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]);
+}
+
+wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ wxGenericTreeItem *i = item.m_pItem;
+ wxGenericTreeItem *parent = i->GetParent();
+ if ( parent == NULL )
+ {
+ // root item doesn't have any siblings
+ return wxTreeItemId();
+ }
+
+ wxArrayGenericTreeItems& siblings = parent->GetChildren();
+ int index = siblings.Index(i);
+ wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
+
+ return index == 0 ? wxTreeItemId()
+ : wxTreeItemId(siblings[(size_t)(index - 1)]);
+}
+
+wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
+{
+ wxFAIL_MSG(_T("not implemented"));
+
+ return wxTreeItemId();
+}
+
+wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ wxFAIL_MSG(_T("not implemented"));
+
+ return wxTreeItemId();
+}
+
+wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
+{
+ wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
+
+ wxFAIL_MSG(_T("not implemented"));
+
+ return wxTreeItemId();
+}
+
+// -----------------------------------------------------------------------------
+// operations
+// -----------------------------------------------------------------------------
+
+wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
+ size_t previous,
+ const wxString& text,
+ int image, int selImage,
+ wxTreeItemData *data)
+{
+ wxGenericTreeItem *parent = parentId.m_pItem;
+ if ( !parent )
+ {
+ // should we give a warning here?
+ return AddRoot(text, image, selImage, data);
+ }
+
+ wxClientDC dc(this);
+ wxGenericTreeItem *item = new wxGenericTreeItem(parent,
+ text, dc,
+ image, selImage,
+ data);
+
+ if ( data != NULL )
+ {
+ data->m_pItem = item;
+ }
+
+ parent->Insert( item, previous );
+
+ m_dirty = TRUE;
+
+ return item;
+}
+
+wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
+ int image, int selImage,
+ wxTreeItemData *data)
+{
+ wxCHECK_MSG( !m_anchor, wxTreeItemId(), _T("tree can have only one root") );
+
+ wxClientDC dc(this);
+ m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text, dc,
+ image, selImage, data);
+ if ( data != NULL )
+ {
+ data->m_pItem = m_anchor;
+ }
+
+ Refresh();
+ AdjustMyScrollbars();
+
+ return m_anchor;
+}
+
+wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
+ const wxString& text,
+ int image, int selImage,
+ wxTreeItemData *data)
+{
+ return DoInsertItem(parent, 0u, text, image, selImage, data);
+}
+
+wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parentId,
+ const wxTreeItemId& idPrevious,
+ const wxString& text,
+ int image, int selImage,
+ wxTreeItemData *data)
+{
+ wxGenericTreeItem *parent = parentId.m_pItem;
+ if ( !parent )
+ {
+ // should we give a warning here?
+ return AddRoot(text, image, selImage, data);
+ }
+
+ int index = parent->GetChildren().Index(idPrevious.m_pItem);
+ wxASSERT_MSG( index != wxNOT_FOUND,
+ _T("previous item in wxTreeCtrl::InsertItem() is not a sibling") );
+ return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
+}
+
+wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parentId,
+ const wxString& text,
+ int image, int selImage,
+ wxTreeItemData *data)
+{
+ wxGenericTreeItem *parent = parentId.m_pItem;
+ if ( !parent )
+ {
+ // should we give a warning here?
+ return AddRoot(text, image, selImage, data);
+ }
+
+ return DoInsertItem(parent, parent->GetChildren().Count(), text,
+ image, selImage, data);
+}
+
+void wxTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
+{
+ wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
+ event.m_item = item;
+ event.SetEventObject( this );
+ ProcessEvent( event );
+}
+
+void wxTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
+{
+ wxGenericTreeItem *item = itemId.m_pItem;
+ item->DeleteChildren(this);
+
+ m_dirty = TRUE;
+}
+
+void wxTreeCtrl::Delete(const wxTreeItemId& itemId)
+{
+ wxGenericTreeItem *item = itemId.m_pItem;
+ wxGenericTreeItem *parent = item->GetParent();
+
+ if ( parent )
+ {
+ parent->GetChildren().Remove(item);
+ }
+
+ item->DeleteChildren(this);
+ SendDeleteEvent(item);
+ delete item;
+
+ m_dirty = TRUE;
+}
+
+void wxTreeCtrl::DeleteAllItems()
+{
+ if ( m_anchor )
+ {
+ m_anchor->DeleteChildren(this);
+ delete m_anchor;
+
+ m_anchor = NULL;
+
+ m_dirty = TRUE;
+ }
+}
+
+void wxTreeCtrl::Expand(const wxTreeItemId& itemId)
+{
+ wxGenericTreeItem *item = itemId.m_pItem;
+
+ if ( !item->HasPlus() )
+ return;
+
+ if ( item->IsExpanded() )
+ return;
+
+ wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
+ event.m_item = item;
+ event.SetEventObject( this );
+ if ( ProcessEvent( event ) && event.m_code )
+ {
+ // cancelled by program
+ return;
+ }
+
+ item->Expand();
+ CalculatePositions();
+
+ RefreshSubtree(item);
+
+ event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
+ ProcessEvent( event );
+}
+
+void wxTreeCtrl::Collapse(const wxTreeItemId& itemId)
+{
+ wxGenericTreeItem *item = itemId.m_pItem;
+
+ if ( !item->IsExpanded() )
+ return;
+
+ wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
+ event.m_item = item;
+ event.SetEventObject( this );
+ if ( ProcessEvent( event ) && event.m_code )
+ {
+ // cancelled by program
+ return;
+ }
+
+ item->Collapse();
+
+ wxArrayGenericTreeItems& children = item->GetChildren();
+ size_t count = children.Count();
+ for ( size_t n = 0; n < count; n++ )
+ {
+ Collapse(children[n]);
+ }
+
+ CalculatePositions();
+
+ RefreshSubtree(item);
+
+ event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
+ ProcessEvent( event );
+}
+
+void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
+{
+ Collapse(item);
+ DeleteChildren(item);
+}
+
+void wxTreeCtrl::Toggle(const wxTreeItemId& itemId)
+{
+ wxGenericTreeItem *item = itemId.m_pItem;
+
+ if ( item->IsExpanded() )
+ Collapse(itemId);
+ else
+ Expand(itemId);
+}
+
+void wxTreeCtrl::Unselect()
+{
+ if ( m_current )
+ {
+ m_current->SetHilight( FALSE );
+ RefreshLine( m_current );
+ }
+}
+
+void wxTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
+{
+ item->SetHilight(FALSE);
+ RefreshLine(item);
+
+ if (item->HasChildren())
+ {
+ wxArrayGenericTreeItems& children = item->GetChildren();
+ size_t count = children.Count();
+ for ( size_t n = 0; n < count; ++n )
+ UnselectAllChildren(children[n]);
+ }
+}
+
+void wxTreeCtrl::UnselectAll()
+{
+ UnselectAllChildren(GetRootItem().m_pItem);
+}
+
+// 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 wxTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
+{
+ wxGenericTreeItem *parent = crt_item->GetParent();
+
+ if ( parent == NULL ) // This is root item
+ return TagAllChildrenUntilLast(crt_item, last_item, select);
+
+ wxArrayGenericTreeItems& children = parent->GetChildren();
+ int index = children.Index(crt_item);
+ wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
+
+ size_t count = children.Count();
+ for (size_t n=(size_t)(index+1); n<count; ++n)
+ if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
+
+ return TagNextChildren(parent, last_item, select);
+}
+
+bool wxTreeCtrl::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())
+ {
+ wxArrayGenericTreeItems& children = crt_item->GetChildren();
+ size_t count = children.Count();
+ for ( size_t n = 0; n < count; ++n )
+ if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
+ }
+
+ return FALSE;
+}
+
+void wxTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
+{
+ // item2 is not necessary after item1
+ wxGenericTreeItem *first=NULL, *last=NULL;
+
+ // choice first' and 'last' between item1 and item2
+ if (item1->GetY()<item2->GetY())
+ {
+ first=item1;
+ last=item2;
+ }
+ else
+ {
+ first=item2;
+ last=item1;
+ }
+
+ bool select=m_current->HasHilight();
+
+ if (TagAllChildrenUntilLast(first,last,select)) return;
+
+ TagNextChildren(first,last,select);
+}
+
+void wxTreeCtrl::SelectItem(const wxTreeItemId& itemId,
+ bool unselect_others,
+ bool extended_select)
+{
+ wxCHECK_RET( itemId.IsOk(), _T("invalid tree item") );
+
+ bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
+
+ //wxCHECK_RET( ( (!unselect_others) && is_single),
+ // _T("this is a single selection tree") );
+
+ // to keep going anyhow !!!
+ if (is_single)
+ {
+ unselect_others=TRUE;
+ extended_select=FALSE;
+ }
+
+ wxGenericTreeItem *item = itemId.m_pItem;
+
+ wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
+ event.m_item = 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() )
+ return;
+
+ // ctrl press
+ if (unselect_others)
+ {
+ if (is_single) Unselect(); // to speed up thing
+ else UnselectAll();
+ }
+
+ // shift press
+ if (extended_select)
+ {
+ if (m_current == NULL) m_current=m_key_current=GetRootItem().m_pItem;
+ // don't change the mark (m_current)
+ SelectItemRange(m_current, item);
+ }
+ else
+ {
+ bool select=TRUE; // the default
+
+ // Check if we need to toggle hilight (ctrl mode)
+ if (!unselect_others)
+ select=!item->HasHilight();
+
+ m_current = m_key_current = item;
+ m_current->SetHilight(select);
+ RefreshLine( m_current );
+ }
+
+ event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
+ GetEventHandler()->ProcessEvent( event );
+}
+
+void wxTreeCtrl::FillArray(wxGenericTreeItem *item, wxArrayTreeItemIds &array) const
+{
+ if (item->HasHilight()) array.Add(wxTreeItemId(item));
+
+ if (item->HasChildren())
+ {
+ wxArrayGenericTreeItems& children = item->GetChildren();
+ size_t count = children.Count();
+ for ( size_t n = 0; n < count; ++n )
+ FillArray(children[n],array);
+ }
+}
+
+size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
+{
+ array.Empty();
+ FillArray(GetRootItem().m_pItem, array);
+
+ return array.Count();
+}
+
+void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
+{
+ if (!item.IsOk()) return;
+
+ wxGenericTreeItem *gitem = item.m_pItem;
+
+ // first expand all parent branches
+ wxGenericTreeItem *parent = gitem->GetParent();
+ while ( parent && !parent->IsExpanded() )
+ {
+ Expand(parent);
+
+ parent = parent->GetParent();
+ }
+
+ if (parent) CalculatePositions();
+
+ ScrollTo(item);
+}
+
+void wxTreeCtrl::ScrollTo(const wxTreeItemId &item)
+{
+ if (!item.IsOk()) return;
+
+ wxGenericTreeItem *gitem = item.m_pItem;
+
+ // now scroll to the item
+ int item_y = gitem->GetY();
+
+ int start_x = 0;
+ int start_y = 0;
+ ViewStart( &start_x, &start_y );
+ start_y *= PIXELS_PER_UNIT;
+
+ int client_h = 0;
+ int client_w = 0;
+ GetClientSize( &client_w, &client_h );
+
+ if (item_y < start_y+3)
+ {
+ // 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
+ 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 );
+ }
+ else if (item_y+GetLineHeight(gitem) > start_y+client_h)
+ {
+ // 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
+ 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 );
+ }
+}
+
+// FIXME: tree sorting functions are not reentrant and not MT-safe!
+static wxTreeCtrl *s_treeBeingSorted = NULL;
+
+static int tree_ctrl_compare_func(wxGenericTreeItem **item1,
+ wxGenericTreeItem **item2)
+{
+ wxCHECK_MSG( s_treeBeingSorted, 0, _T("bug in wxTreeCtrl::SortChildren()") );
+
+ return s_treeBeingSorted->OnCompareItems(*item1, *item2);
+}
+
+int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
+ const wxTreeItemId& item2)
+{
+ return wxStrcmp(GetItemText(item1), GetItemText(item2));
+}
+
+void wxTreeCtrl::SortChildren(const wxTreeItemId& itemId)
+{
+ wxCHECK_RET( itemId.IsOk(), _T("invalid tree item") );
+
+ wxGenericTreeItem *item = itemId.m_pItem;
+
+ wxCHECK_RET( !s_treeBeingSorted,
+ _T("wxTreeCtrl::SortChildren is not reentrant") );
+
+ wxArrayGenericTreeItems& children = item->GetChildren();
+ if ( children.Count() > 1 )
+ {
+ s_treeBeingSorted = this;
+ children.Sort(tree_ctrl_compare_func);
+ s_treeBeingSorted = NULL;
+
+ m_dirty = TRUE;
+ }
+ //else: don't make the tree dirty as nothing changed
+}
projects / wxWidgets.git / blobdiff