#endif
#ifndef WX_PRECOMP
- #include "wx.h"
+ #include "wx/wx.h"
#endif
#if defined(__WIN95__)
#include "wx/log.h"
+#include "wx/dynarray.h"
#include "wx/imaglist.h"
+#include "wx/msw/treectrl.h"
#include "wx/msw/private.h"
-#ifndef __GNUWIN32__
+#if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__)
#include <commctrl.h>
#endif
-#define wxHTREEITEM_DEFINED // flag used in wx/msw/treectrl.h
-#include "wx/treectrl.h"
+#ifdef GetFirstChild
+#undef GetFirstChild
+#endif
+
+#ifdef GetNextChild
+#undef GetNextChild
+#endif
+
+#ifdef GetNextSibling
+#undef GetNextSibling
+#endif
+
+#ifdef GetClassInfo
+#undef GetClassInfo
+#endif
// Bug in headers, sometimes
#ifndef TVIS_FOCUSED
{
mask = mask_;
stateMask = stateMask_;
- hItem = (HTREEITEM)item;
+ hItem = (HTREEITEM) (WXHTREEITEM) item;
}
};
#endif
// hide the ugly cast (of course, the macro is _quite_ ugly too...)
-#define hwnd ((HWND)m_hWnd)
+#define wxhWnd ((HWND)m_hWnd)
// ----------------------------------------------------------------------------
// variables
bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
{
- if ( !TreeView_GetItem(hwnd, tvItem) )
+ if ( !TreeView_GetItem(wxhWnd, tvItem) )
{
wxLogLastError("TreeView_GetItem");
void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
{
- if ( TreeView_SetItem(hwnd, tvItem) == -1 )
+ if ( TreeView_SetItem(wxhWnd, tvItem) == -1 )
{
wxLogLastError("TreeView_SetItem");
}
size_t wxTreeCtrl::GetCount() const
{
- return (size_t)TreeView_GetCount(hwnd);
+ return (size_t)TreeView_GetCount(wxhWnd);
}
unsigned int wxTreeCtrl::GetIndent() const
{
- return TreeView_GetIndent(hwnd);
+ return TreeView_GetIndent(wxhWnd);
}
void wxTreeCtrl::SetIndent(unsigned int indent)
{
- TreeView_SetIndent(hwnd, indent);
+ TreeView_SetIndent(wxhWnd, indent);
}
wxImageList *wxTreeCtrl::GetImageList() const
void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
{
// no error return
- TreeView_SetImageList(hwnd,
+ TreeView_SetImageList(wxhWnd,
imageList ? imageList->GetHIMAGELIST() : 0,
which);
}
SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
}
+size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
+{
+ long cookie;
+
+ size_t result = 0;
+
+ wxArrayLong children;
+ wxTreeItemId child = GetFirstChild(item, cookie);
+ while ( child.IsOk() )
+ {
+ if ( recursively )
+ {
+ // recursive call
+ result += GetChildrenCount(child, TRUE);
+ }
+
+ // add the child to the result in any case
+ result++;
+
+ child = GetNextChild(item, cookie);
+ }
+
+ return result;
+}
+
// ----------------------------------------------------------------------------
// Item access
// ----------------------------------------------------------------------------
return NULL;
}
- wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
- if ( data != NULL )
- {
- // the data object should know about its id
- data->m_itemId = item;
- }
-
- return data;
+ return (wxTreeItemData *)tvItem.lParam;
}
void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
DoSetItem(&tvItem);
}
+void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
+{
+ wxTreeViewItem tvItem(item, TVIF_CHILDREN);
+ tvItem.cChildren = (int)has;
+ DoSetItem(&tvItem);
+}
+
+void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
+{
+ wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
+ tvItem.state = bold ? TVIS_BOLD : 0;
+ DoSetItem(&tvItem);
+}
+
// ----------------------------------------------------------------------------
// Item status
// ----------------------------------------------------------------------------
bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
{
+ // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
RECT rect;
- return TreeView_GetItemRect(hwnd, (HTREEITEM)item, &rect, FALSE) != 0;
+ return SendMessage(wxhWnd, TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
+
}
bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
return (tvItem.state & TVIS_SELECTED) != 0;
}
+bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
+{
+ wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
+ DoGetItem(&tvItem);
+
+ return (tvItem.state & TVIS_BOLD) != 0;
+}
+
// ----------------------------------------------------------------------------
// navigation
// ----------------------------------------------------------------------------
wxTreeItemId wxTreeCtrl::GetRootItem() const
{
- return wxTreeItemId(TreeView_GetRoot(hwnd));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(wxhWnd));
}
wxTreeItemId wxTreeCtrl::GetSelection() const
{
- return wxTreeItemId(TreeView_GetSelection(hwnd));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(wxhWnd));
}
wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
{
- return wxTreeItemId(TreeView_GetParent(hwnd, item));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetParent(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
}
wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
- long& cookie) const
+ long& _cookie) const
{
// remember the last child returned in 'cookie'
- cookie = (long)TreeView_GetChild(hwnd, (HTREEITEM)item);
+ _cookie = (long)TreeView_GetChild(wxhWnd, (HTREEITEM) (WXHTREEITEM)item);
- return wxTreeItemId((HTREEITEM)cookie);
+ return wxTreeItemId((WXHTREEITEM)_cookie);
}
wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
- long& cookie) const
+ long& _cookie) const
{
- return wxTreeItemId(TreeView_GetNextSibling(hwnd,
- (HTREEITEM)cookie));
+ wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(wxhWnd,
+ (HTREEITEM)(WXHTREEITEM)_cookie));
+ _cookie = (long)l;
+
+ return l;
+}
+
+wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
+{
+ // can this be done more efficiently?
+ long cookie;
+
+ wxTreeItemId childLast,
+ child = GetFirstChild(item, cookie);
+ while ( child.IsOk() )
+ {
+ childLast = child;
+ child = GetNextChild(item, cookie);
+ }
+
+ return childLast;
}
wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
{
- return wxTreeItemId(TreeView_GetNextSibling(hwnd, item));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
}
wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
{
- return wxTreeItemId(TreeView_GetPrevSibling(hwnd, item));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
}
wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
{
- return wxTreeItemId(TreeView_GetFirstVisible(hwnd));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(wxhWnd));
}
wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
wxASSERT_MSG( IsVisible(item), "The item you call GetNextVisible() "
"for must be visible itself!");
- return wxTreeItemId(TreeView_GetNextVisible(hwnd, item));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
}
wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
wxASSERT_MSG( IsVisible(item), "The item you call GetPrevVisible() "
"for must be visible itself!");
- return wxTreeItemId(TreeView_GetPrevVisible(hwnd, item));
+ return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));
}
// ----------------------------------------------------------------------------
wxTreeItemData *data)
{
TV_INSERTSTRUCT tvIns;
- tvIns.hParent = (HTREEITEM)parent;
- tvIns.hInsertAfter = hInsertAfter;
+ tvIns.hParent = (HTREEITEM) (WXHTREEITEM)parent;
+ tvIns.hInsertAfter = (HTREEITEM) (WXHTREEITEM) hInsertAfter;
UINT mask = 0;
if ( !text.IsEmpty() )
{
{
mask |= TVIF_IMAGE;
tvIns.item.iImage = image;
+
+ if ( selectedImage == -1 )
+ {
+ // take the same image for selected icon if not specified
+ selectedImage = image;
+ }
}
if ( selectedImage != -1 )
tvIns.item.mask = mask;
- HTREEITEM id = TreeView_InsertItem(hwnd, &tvIns);
+ HTREEITEM id = (HTREEITEM) TreeView_InsertItem(wxhWnd, &tvIns);
if ( id == 0 )
{
wxLogLastError("TreeView_InsertItem");
}
- return wxTreeItemId(id);
+ if ( data != NULL )
+ {
+ // associate the application tree item with Win32 tree item handle
+ data->SetId((WXHTREEITEM)id);
+ }
+
+ return wxTreeItemId((WXHTREEITEM)id);
}
// for compatibility only
int image, int selImage,
long insertAfter)
{
- return DoInsertItem(parent, (HTREEITEM)insertAfter, text,
+ return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
image, selImage, NULL);
}
int image, int selectedImage,
wxTreeItemData *data)
{
- return DoInsertItem(wxTreeItemId(0), 0,
+ return DoInsertItem(wxTreeItemId((WXHTREEITEM) 0), (WXHTREEITEM) 0,
text, image, selectedImage, data);
}
int image, int selectedImage,
wxTreeItemData *data)
{
- return DoInsertItem(parent, TVI_FIRST,
+ return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,
text, image, selectedImage, data);
}
int image, int selectedImage,
wxTreeItemData *data)
{
- return DoInsertItem(parent, TVI_LAST,
+ return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,
text, image, selectedImage, data);
}
void wxTreeCtrl::Delete(const wxTreeItemId& item)
{
- wxTreeItemData *data = GetItemData(item);
- delete data; // may be NULL, ok
-
- if ( !TreeView_DeleteItem(hwnd, (HTREEITEM)item) )
+ if ( !TreeView_DeleteItem(wxhWnd, (HTREEITEM)(WXHTREEITEM)item) )
{
wxLogLastError("TreeView_DeleteItem");
}
}
+// delete all children (but don't delete the item itself)
+void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
+{
+ long cookie;
+
+ wxArrayLong children;
+ wxTreeItemId child = GetFirstChild(item, cookie);
+ while ( child.IsOk() )
+ {
+ children.Add((long)(WXHTREEITEM)child);
+
+ child = GetNextChild(item, cookie);
+ }
+
+ size_t nCount = children.Count();
+ for ( size_t n = 0; n < nCount; n++ )
+ {
+ if ( !TreeView_DeleteItem(wxhWnd, (HTREEITEM)children[n]) )
+ {
+ wxLogLastError("TreeView_DeleteItem");
+ }
+ }
+}
+
void wxTreeCtrl::DeleteAllItems()
{
- if ( !TreeView_DeleteAllItems(hwnd) )
+ if ( !TreeView_DeleteAllItems(wxhWnd) )
{
wxLogLastError("TreeView_DeleteAllItems");
}
// TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
// emulate them
- if ( TreeView_Expand(hwnd, item, flag) != 0 )
+ if ( TreeView_Expand(wxhWnd, (HTREEITEM) (WXHTREEITEM) item, flag) != 0 )
{
wxTreeEvent event(wxEVT_NULL, m_windowId);
event.m_item = item;
DoExpand(item, TVE_TOGGLE);
}
+void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
+{
+ DoExpand(item, action);
+}
+
void wxTreeCtrl::Unselect()
{
- SelectItem(wxTreeItemId(0));
+ SelectItem(wxTreeItemId((WXHTREEITEM) 0));
}
void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
{
- if ( !TreeView_SelectItem(hwnd, item) )
+ if ( !TreeView_SelectItem(wxhWnd, (HTREEITEM) (WXHTREEITEM) item) )
{
wxLogLastError("TreeView_SelectItem");
}
void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
{
// no error return
- TreeView_EnsureVisible(hwnd, item);
+ TreeView_EnsureVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item);
}
void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
{
- if ( !TreeView_SelectSetFirstVisible(hwnd, item) )
+ if ( !TreeView_SelectSetFirstVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item) )
{
wxLogLastError("TreeView_SelectSetFirstVisible");
}
{
wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
- HWND hWnd = TreeView_EditLabel(hwnd, item);
+ HWND hWnd = (HWND) TreeView_EditLabel(wxhWnd, (HTREEITEM) (WXHTREEITEM) item);
wxCHECK_MSG( hWnd, NULL, "Can't edit tree ctrl label" );
// End label editing, optionally cancelling the edit
void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
{
- TreeView_EndEditLabelNow(hwnd, discardChanges);
+ TreeView_EndEditLabelNow(wxhWnd, discardChanges);
DeleteTextCtrl();
}
hitTestInfo.pt.x = (int)point.x;
hitTestInfo.pt.y = (int)point.y;
- TreeView_HitTest(hwnd, &hitTestInfo);
+ TreeView_HitTest(wxhWnd, &hitTestInfo);
flags = 0;
#undef TRANSLATE_FLAG
- return wxTreeItemId(hitTestInfo.hItem);
+ return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
}
-void wxTreeCtrl::SortChildren(const wxTreeItemId& item,
- wxTreeItemCmpFunc *cmpFunction)
+// ----------------------------------------------------------------------------
+// sorting stuff
+// ----------------------------------------------------------------------------
+static int CALLBACK TreeView_CompareCallback(wxTreeItemData *pItem1,
+ wxTreeItemData *pItem2,
+ wxTreeCtrl *tree)
+{
+ return tree->OnCompareItems(pItem1->GetId(), pItem2->GetId());
+}
+
+int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
+ const wxTreeItemId& item2)
{
- if ( cmpFunction == NULL )
+ return strcmp(GetItemText(item1), GetItemText(item2));
+}
+
+void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
+{
+ // rely on the fact that TreeView_SortChildren does the same thing as our
+ // default behaviour, i.e. sorts items alphabetically and so call it
+ // directly if we're not in derived class (much more efficient!)
+ if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
{
- TreeView_SortChildren(hwnd, item, 0);
+ TreeView_SortChildren(wxhWnd, (HTREEITEM)(WXHTREEITEM)item, 0);
}
else
{
- // TODO: use TreeView_SortChildrenCB
- wxFAIL_MSG("wxTreeCtrl::SortChildren not implemented");
+ TV_SORTCB tvSort;
+ tvSort.hParent = (HTREEITEM)(WXHTREEITEM)item;
+ tvSort.lpfnCompare = (PFNTVCOMPARE)TreeView_CompareCallback;
+ tvSort.lParam = (LPARAM)this;
+ TreeView_SortChildrenCB(wxhWnd, &tvSort, 0 /* reserved */);
}
}
}
// process WM_NOTIFY Windows message
-bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
+bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam, WXLPARAM *result)
{
wxTreeEvent event(wxEVT_NULL, m_windowId);
wxEventType eventType = wxEVT_NULL;
NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
- event.m_item = tv->itemNew.hItem;
+ event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
break;
}
eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
TV_DISPINFO *info = (TV_DISPINFO *)lParam;
- event.m_item = info->item.hItem;
+ event.m_item = (WXHTREEITEM) info->item.hItem;
break;
}
eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
- event.m_item = tv->itemOld.hItem;
+ event.m_item = (WXHTREEITEM) tv->itemOld.hItem;
break;
}
eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
TV_DISPINFO *info = (TV_DISPINFO *)lParam;
- event.m_item = info->item.hItem;
+ event.m_item = (WXHTREEITEM) info->item.hItem;
break;
}
TV_DISPINFO *info = (TV_DISPINFO *)lParam;
- event.m_item = info->item.hItem;
+ event.m_item = (WXHTREEITEM) info->item.hItem;
break;
}
"message", tv->action);
}
- bool ing = hdr->code == TVN_ITEMEXPANDING;
+ bool ing = (hdr->code == TVN_ITEMEXPANDING);
eventType = g_events[expand][ing];
- event.m_item = tv->itemNew.hItem;
+ event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
break;
}
TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
event.m_code = wxCharCodeMSWToWX(info->wVKey);
+
+ // a separate event for this case
+ if ( info->wVKey == VK_SPACE || info->wVKey == VK_RETURN )
+ {
+ wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
+ m_windowId);
+ event2.SetEventObject(this);
+
+ GetEventHandler()->ProcessEvent(event2);
+ }
break;
}
NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
- event.m_item = tv->itemNew.hItem;
- event.m_itemOld = tv->itemOld.hItem;
+ event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
+ event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
break;
}
default:
- return wxControl::MSWNotify(wParam, lParam);
+ return wxControl::MSWNotify(wParam, lParam, result);
}
event.SetEventObject(this);
event.SetEventType(eventType);
- bool rc = GetEventHandler()->ProcessEvent(event);
+ bool processed = GetEventHandler()->ProcessEvent(event);
// post processing
- switch ( hdr->code )
+ if ( hdr->code == TVN_DELETEITEM )
{
// NB: we might process this message using wxWindows event tables, but
// due to overhead of wxWin event system we prefer to do it here
// (otherwise deleting a tree with many items is just too slow)
- case TVN_DELETEITEM:
- {
- NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
- wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
- delete data; // may be NULL, ok
- }
- break;
-
- case TVN_ITEMEXPANDING:
- // if user called Veto(), don't allow expansion/collapse by
- // returning TRUE from here
- rc = event.m_code != 0;
- break;
+ NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
+ wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
+ delete data; // may be NULL, ok
}
- return rc;
+ *result = !event.IsAllowed();
+
+ return processed;
}
// ----------------------------------------------------------------------------
// Tree event
// ----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxCommandEvent)
+IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)
- : wxCommandEvent(commandType, id)
+ : wxNotifyEvent(commandType, id)
{
m_code = 0;
m_itemOld = 0;
projects / wxWidgets.git / blobdiff