X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4540e33bb6bf41cc0c951d0345dd093179d9af05..d77df9f7d023b026a7bbe995ddd36cfdbe07e3d5:/include/wx/gtk1/treectrl.h?ds=sidebyside diff --git a/include/wx/gtk1/treectrl.h b/include/wx/gtk1/treectrl.h index ff47d7c803..453f1f735e 100644 --- a/include/wx/gtk1/treectrl.h +++ b/include/wx/gtk1/treectrl.h @@ -1,334 +1,406 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: treectrl.h -// Purpose: +// Name: wx/gtk1/treectrl.h +// Purpose: wxTreeCtrl class // Author: Denis Pershin +// Modified by: // Created: 08/08/98 -// Id: $Id$ -// Copyright: (c) 1998 Denis Pershin and Julian Smart +// RCS-ID: $Id$ +// Copyright: (c) Denis Pershin // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifndef __GTKTREECTRL_H__ -#define __GTKTREECTRL_H__ +#ifndef _WX_TREECTRL_H_ +#define _WX_TREECTRL_H_ -#ifdef __GNUG__ -#pragma interface "treectrl.h" -#endif - -#include "wx/defs.h" -#include "wx/string.h" -#include "wx/list.h" -#include "wx/control.h" -#include "wx/event.h" +#include "wx/textctrl.h" #include "wx/imaglist.h" -#include "wx/scrolwin.h" -#include "wx/dcclient.h" #include -//----------------------------------------------------------------------------- -// classes -//----------------------------------------------------------------------------- +// the type for "untyped" data +typedef long wxDataType; -class wxTreeItem; -class wxTreeCtrl; -class wxTreeEvent; +// fwd decl +class WXDLLIMPEXP_CORE wxImageList; +struct wxTreeViewItem; -class wxImageList; +// a callback function used for sorting tree items, it should return -1 if the +// first item precedes the second, +1 if the second precedes the first or 0 if +// they're equivalent +class WXDLLIMPEXP_FWD_CORE wxTreeItemData; +typedef int (*wxTreeItemCmpFunc)(wxTreeItemData *item1, wxTreeItemData *item2); -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- // constants -//----------------------------------------------------------------------------- - -// WXDLLEXPORT extern const char *wxTreeNameStr; - -#define wxTREE_MASK_HANDLE 0x0001 -#define wxTREE_MASK_STATE 0x0002 -#define wxTREE_MASK_TEXT 0x0004 -#define wxTREE_MASK_IMAGE 0x0008 -#define wxTREE_MASK_SELECTED_IMAGE 0x0010 -#define wxTREE_MASK_CHILDREN 0x0020 -#define wxTREE_MASK_DATA 0x0040 - -#define wxTREE_STATE_BOLD 0x0001 -#define wxTREE_STATE_DROPHILITED 0x0002 -#define wxTREE_STATE_EXPANDED 0x0004 -#define wxTREE_STATE_EXPANDEDONCE 0x0008 -#define wxTREE_STATE_FOCUSED 0x0010 -#define wxTREE_STATE_SELECTED 0x0020 -#define wxTREE_STATE_CUT 0x0040 - -#define wxTREE_HITTEST_ABOVE 0x0001 // Above the client area. -#define wxTREE_HITTEST_BELOW 0x0002 // Below the client area. -#define wxTREE_HITTEST_NOWHERE 0x0004 // In the client area but below the last item. -#define wxTREE_HITTEST_ONITEMBUTTON 0x0010 // On the button associated with an item. -#define wxTREE_HITTEST_ONITEMICON 0x0020 // On the bitmap associated with an item. -#define wxTREE_HITTEST_ONITEMINDENT 0x0040 // In the indentation associated with an item. -#define wxTREE_HITTEST_ONITEMLABEL 0x0080 // On the label (string) associated with an item. -#define wxTREE_HITTEST_ONITEMRIGHT 0x0100 // In the area to the right of an item. -#define wxTREE_HITTEST_ONITEMSTATEICON 0x0200 // On the state icon for a tree view item that is in a user-defined state. -#define wxTREE_HITTEST_TOLEFT 0x0400 // To the right of the client area. -#define wxTREE_HITTEST_TORIGHT 0x0800 // To the left of the client area. - -#define wxTREE_HITTEST_ONITEM (wxTREE_HITTEST_ONITEMICON | wxTREE_HITTEST_ONITEMLABEL | wxTREE_HITTEST_ONITEMSTATEICON) - -// Flags for GetNextItem -enum { - wxTREE_NEXT_CARET, // Retrieves the currently selected item. - wxTREE_NEXT_CHILD, // Retrieves the first child item. The hItem parameter must be NULL. - wxTREE_NEXT_DROPHILITE, // Retrieves the item that is the target of a drag-and-drop operation. - wxTREE_NEXT_FIRSTVISIBLE, // Retrieves the first visible item. - wxTREE_NEXT_NEXT, // Retrieves the next sibling item. - wxTREE_NEXT_NEXTVISIBLE, // Retrieves the next visible item that follows the specified item. - wxTREE_NEXT_PARENT, // Retrieves the parent of the specified item. - wxTREE_NEXT_PREVIOUS, // Retrieves the previous sibling item. - wxTREE_NEXT_PREVIOUSVISIBLE, // Retrieves the first visible item that precedes the specified item. - wxTREE_NEXT_ROOT // Retrieves the first child item of the root item of which the specified item is a part. -}; - -// Flags for ExpandItem -enum { - wxTREE_EXPAND_EXPAND, - wxTREE_EXPAND_COLLAPSE, - wxTREE_EXPAND_COLLAPSE_RESET, - wxTREE_EXPAND_TOGGLE -}; - -// Flags for InsertItem -enum { - wxTREE_INSERT_LAST = -1, - wxTREE_INSERT_FIRST = -2, - wxTREE_INSERT_SORT = -3 -}; - -//----------------------------------------------------------------------------- -// wxTreeItem -//----------------------------------------------------------------------------- - +// ---------------------------------------------------------------------------- + +// values for the `flags' parameter of wxTreeCtrl::HitTest() which determine +// where exactly the specified point is situated: + // above the client area. +static const int wxTREE_HITTEST_ABOVE = 0x0001; + // below the client area. +static const int wxTREE_HITTEST_BELOW = 0x0002; + // in the client area but below the last item. +static const int wxTREE_HITTEST_NOWHERE = 0x0004; + // on the button associated with an item. +static const int wxTREE_HITTEST_ONITEMBUTTON = 0x0010; + // on the bitmap associated with an item. +static const int wxTREE_HITTEST_ONITEMICON = 0x0020; + // in the indentation associated with an item. +static const int wxTREE_HITTEST_ONITEMINDENT = 0x0040; + // on the label (string) associated with an item. +static const int wxTREE_HITTEST_ONITEMLABEL = 0x0080; + // in the area to the right of an item. +static const int wxTREE_HITTEST_ONITEMRIGHT = 0x0100; + // on the state icon for a tree view item that is in a user-defined state. +static const int wxTREE_HITTEST_ONITEMSTATEICON = 0x0200; + // to the right of the client area. +static const int wxTREE_HITTEST_TOLEFT = 0x0400; + // to the left of the client area. +static const int wxTREE_HITTEST_TORIGHT = 0x0800; + // anywhere on the item +static const int wxTREE_HITTEST_ONITEM = wxTREE_HITTEST_ONITEMICON | + wxTREE_HITTEST_ONITEMLABEL | + wxTREE_HITTEST_ONITEMSTATEICON; + +#if WXWIN_COMPATIBILITY_2_6 + // NB: all the following flags are for compatbility only and will be removed in + // next versions + // flags for deprecated InsertItem() variant + #define wxTREE_INSERT_FIRST 0xFFFF0001 + #define wxTREE_INSERT_LAST 0xFFFF0002 +#endif -class WXDLLEXPORT wxTreeItem: public wxObject -{ +// ---------------------------------------------------------------------------- +// wxTreeItemId identifies an element of the tree. In this implementation, it's +// just a trivial wrapper around GTK GtkTreeItem *. It's opaque for the +// application. +// ---------------------------------------------------------------------------- +class WXDLLIMPEXP_CORE wxTreeItemId { public: - wxTreeCtrl *m_owner; - GtkWidget *m_parentwidget; - GtkTreeItem *m_widget; - GtkTree *m_tree; - long m_mask; - long m_itemId; - long m_state; - long m_stateMask; - wxString m_text; - int m_image; - int m_selectedImage; - int m_children; - wxList m_childlist; - long m_data; - - wxTreeItem(); - wxTreeItem(GtkWidget *parent, const wxTreeItem &item); - ~wxTreeItem(); - - void Create(); - - void AddChild(wxTreeItem *child); - void DeleteChildren(); - bool HasChildren(); - wxTreeItem *FindItem(long itemId) const; - wxTreeItem *FindItem(GtkTreeItem *item) const; - - // Accessors - inline long GetMask() const { return m_mask; } - inline long GetItemId() const { return m_itemId; } - inline long GetState() const { return m_state; } - inline long GetStateMask() const { return m_stateMask; } - inline wxString GetText() const { return m_text; } - inline int GetImage() const { return m_image; } - inline int GetSelectedImage() const { return m_selectedImage; } - inline const wxList &GetChildren() const { return m_childlist; } - inline long GetData() const { return m_data; } - - inline void SetMask(long mask) { m_mask = mask; } - inline void SetItemId(long id) { m_itemId = m_itemId = id; } - inline void GetState(long state) { m_state = state; } - inline void SetStateMask(long stateMask) { m_stateMask = stateMask; } - inline void GetText(const wxString& text) { m_text = text; } - inline void SetImage(int image) { m_image = image; } - inline void SetSelectedImage(int selImage) { m_selectedImage = selImage; } - inline void SetChildren(const wxList &children) { m_childlist = children; } - inline void SetData(long data) { m_data = data; } - - int NumberOfVisibleDescendents(); -private: - friend wxTreeCtrl; - friend void gtk_treeitem_expand_callback(GtkWidget *widget, wxTreeItem *treeitem); - friend void gtk_treeitem_collapse_callback(GtkWidget *widget, wxTreeItem *treeitem); - friend void gtk_treeitem_select_callback( GtkWidget *WXUNUSED(widget), wxTreeItem *treeitem); - friend void gtk_treeitem_deselect_callback( GtkWidget *WXUNUSED(widget), wxTreeItem *treeitem); - - void AddSubtree(); - void PrepareEvent(wxTreeEvent &event); - void SendDelete(wxWindow *target); - void SendExpand(wxWindow *target); - void SendExpanding(wxWindow *target); - void SendCollapse(wxWindow *target); - void SendCollapsing(wxWindow *target); - void SendSelChanged(wxWindow *target); - void SendSelChanging(wxWindow *target); - - inline wxTreeItem *GetChild(long no) { - return (wxTreeItem *)(m_childlist.Nth(no)->Data()); - } - inline long GetChildrenNumber() { - return m_childlist.Number(); - } - - guint expand_handler; - guint collapse_handler; + // ctors + wxTreeItemId() { m_itemId = NULL; } -// It is a quick hack to make TreeCtrl working... I do not know why -// but signals is GTK does not disconnected... - bool ignore; + // default copy ctor/assignment operator are ok for us - DECLARE_DYNAMIC_CLASS(wxTreeItem) -}; + // accessors + // is this a valid tree item? + bool IsOk() const { return m_itemId != NULL; } -//----------------------------------------------------------------------------- -// wxTreeCtrl -//----------------------------------------------------------------------------- + // conversion to/from either real (system-dependent) tree item id or + // to "long" which used to be the type for tree item ids in previous + // versions of wxWidgets -class wxTreeCtrl: public wxScrolledWindow { -public: - GtkTree *m_tree; - - wxTreeCtrl(); - wxTreeCtrl(wxWindow *parent, const wxWindowID id = -1, - const wxPoint& pos = wxDefaultPosition, - const wxSize& size = wxDefaultSize, - long style = wxTR_HAS_BUTTONS, - const wxString& name = "wxTreeCtrl" ); - ~wxTreeCtrl(); - bool Create(wxWindow *parent, const wxWindowID id = -1, - const wxPoint& pos = wxDefaultPosition, - const wxSize& size = wxDefaultSize, - long style = wxTR_HAS_BUTTONS, - const wxString& name = "wxTreeCtrl"); - - int GetCount() const; - - long InsertItem( long parent, const wxString& label, - int image = -1, int selImage = -1, - long insertAfter = wxTREE_INSERT_LAST ); - - long InsertItem( long parent, wxTreeItem &info, - long insertAfter = wxTREE_INSERT_LAST ); - void DeleteItem( long item ); - void DeleteChildren( long item ); - bool DeleteAllItems(); - - bool ExpandItem(long item) { return ExpandItem(item, wxTREE_EXPAND_EXPAND); } - bool ExpandItem( long item, int action ); - - bool CollapseItem(long item) { return ExpandItem(item, wxTREE_EXPAND_COLLAPSE); } - bool ToggleItem(long item) { return ExpandItem(item, wxTREE_EXPAND_TOGGLE); } - - // is the item expanded now? - bool IsItemExpanded(long item) - { - wxTreeItem *pItem = FindItem(item); - return pItem && (pItem->GetState() & wxTREE_STATE_EXPANDED); - } + // for wxTreeCtrl usage only + wxTreeItemId(GtkTreeItem *itemId) { m_itemId = itemId; } + operator GtkTreeItem *() const { return m_itemId; } + void operator =(GtkTreeItem *item) { m_itemId = item; } -/* - bool GetItem( wxTreeItem &info ) const; -*/ - - long GetItemData( long item ) const; - wxString GetItemText( long item ) const; - int GetItemImage(long item) const; - long GetParent( long item ) const; - long GetRootItem() const; -/* - long GetSelection() const; - bool SelectItem( long item ); -*/ - - bool ItemHasChildren( long item ) const; - void SetIndent( int indent ); - int GetIndent() const; - -/* - bool SetItem( wxTreeItem &info ); - bool SetItemData( long item, long data ); - bool SetItemText( long item, const wxString &text ); - void SetItemImage(long item, int image, int imageSel) const; - long HitTest( const wxPoint& point, int &flags ); -*/ - - wxTreeItem *FindItem(GtkTreeItem *item) const; - - wxImageList *GetImageList(int which = wxIMAGE_LIST_NORMAL) const; - void SetImageList(wxImageList *imageList, int which = wxIMAGE_LIST_NORMAL); - -private: - // set the selection to the specified item generating appropriate event(s) if - // not disabled - void SelectItem(wxTreeItem *item, bool bDoEvents = TRUE); - - wxTreeItem *m_anchor; - wxTreeItem *m_current; - int m_indent; - long m_lastId; - bool m_isCreated; - wxImageList *m_imageList; - wxImageList *m_smallImageList; - - void CalculateLevel( wxTreeItem *item, wxPaintDC &dc, int level, int &y ); - void CalculatePositions(); - wxTreeItem *FindItem( long itemId ) const; - -// DECLARE_EVENT_TABLE() - DECLARE_DYNAMIC_CLASS(wxTreeCtrl) +protected: + GtkTreeItem *m_itemId; }; -//----------------------------------------------------------------------------- -// wxTreeEvent -//----------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// wxTreeItemData is some (arbitrary) user class associated with some item. The +// main advantage of having this class (compared to old untyped interface) is +// that wxTreeItemData's are destroyed automatically by the tree and, as this +// class has virtual dtor, it means that the memory will be automatically +// freed. OTOH, we don't just use wxObject instead of wxTreeItemData because +// the size of this class is critical: in any real application, each tree leaf +// will have wxTreeItemData associated with it and number of leaves may be +// quite big. +// +// Because the objects of this class are deleted by the tree, they should +// always be allocated on the heap! +// ---------------------------------------------------------------------------- +class WXDLLIMPEXP_CORE wxTreeItemData : private wxTreeItemId { +public: + // default ctor/copy ctor/assignment operator are ok -class WXDLLEXPORT wxTreeEvent: public wxCommandEvent -{ - DECLARE_DYNAMIC_CLASS(wxTreeEvent) + // dtor is virtual and all the items are deleted by the tree control when + // it's deleted, so you normally don't have to care about freeing memory + // allocated in your wxTreeItemData-derived class + virtual ~wxTreeItemData() { } - public: - wxTreeEvent(wxEventType commandType = wxEVT_NULL, int id = 0); + // accessors: set/get the item associated with this node + void SetId(const wxTreeItemId& id) { m_itemId = id; } + const wxTreeItemId& GetId() const { return (wxTreeItemId&) m_itemId; } +}; - int m_code; - wxTreeItem m_item; - long m_oldItem; - wxPoint m_pointDrag; +class WXDLLIMPEXP_CORE wxTreeCtrl: public wxControl { +public: + // creation + // -------- + wxTreeCtrl() { Init(); } + + wxTreeCtrl(wxWindow *parent, wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = "wxTreeCtrl") { + Create(parent, id, pos, size, style, validator, name); + } - inline long GetOldItem() const { return m_oldItem; } - inline wxTreeItem& GetItem() const { return (wxTreeItem&) m_item; } - inline wxPoint GetPoint() const { return m_pointDrag; } - inline void SetCode(int code) { m_code = code; } - inline int GetCode() const { return m_code; } + virtual ~wxTreeCtrl(); + + bool Create(wxWindow *parent, wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = "wxTreeCtrl"); + + // accessors + // --------- + + // get the total number of items in the control + virtual unsigned int GetCount() const; + + // indent is the number of pixels the children are indented relative to + // the parents position. SetIndent() also redraws the control + // immediately. + unsigned int GetIndent() const; + void SetIndent(unsigned int indent); + + // image list: these functions allow to associate an image list with + // the control and retrieve it. Note that the control does _not_ delete + // the associated image list when it's deleted in order to allow image + // lists to be shared between different controls. + // + // The normal image list is for the icons which correspond to the + // normal tree item state (whether it is selected or not). + // Additionally, the application might choose to show a state icon + // which corresponds to an app-defined item state (for example, + // checked/unchecked) which are taken from the state image list. + wxImageList *GetImageList() const; + wxImageList *GetStateImageList() const; + + void SetImageList(wxImageList *imageList); + void SetStateImageList(wxImageList *imageList); + + // Functions to work with tree ctrl items. Unfortunately, they can _not_ be + // member functions of wxTreeItem because they must know the tree the item + // belongs to for Windows implementation and storing the pointer to + // wxTreeCtrl in each wxTreeItem is just too much waste. + + // accessors + // --------- + + // retrieve items label + wxString GetItemText(const wxTreeItemId& item) const; + // get the normal item image + int GetItemImage(const wxTreeItemId& item) const; + // get the data associated with the item + wxTreeItemData *GetItemData(const wxTreeItemId& item) const; + + // modifiers + // --------- + + // set items label + void SetItemText(const wxTreeItemId& item, const wxString& text); + // set the normal item image + void SetItemImage(const wxTreeItemId& item, int image); + // associate some data with the item + void SetItemData(const wxTreeItemId& item, wxTreeItemData *data); + + // item status inquiries + // --------------------- + + // is the item visible (it might be outside the view or not expanded)? + bool IsVisible(const wxTreeItemId& item) const; + // does the item has any children? + bool ItemHasChildren(const wxTreeItemId& item) const; + // is the item expanded (only makes sense if HasChildren())? + bool IsExpanded(const wxTreeItemId& item) const; + // is this item currently selected (the same as has focus)? + bool IsSelected(const wxTreeItemId& item) const; + + // number of children + // ------------------ + + // if 'recursively' is false, only immediate children count, otherwise + // the returned number is the number of all items in this branch + size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = true); + + // navigation + // ---------- + + // wxTreeItemId.IsOk() will return false if there is no such item + + // get the root tree item + wxTreeItemId GetRootItem() const; + + // get the item currently selected (may return NULL if no selection) + wxTreeItemId GetSelection() const; + + // get the parent of this item (may return NULL if root) + wxTreeItemId GetItemParent(const wxTreeItemId& item) const; + + // for this enumeration function you must pass in a "cookie" parameter + // which is opaque for the application but is necessary for the library + // to make these functions reentrant (i.e. allow more than one + // enumeration on one and the same object simultaneously). Of course, + // the "cookie" passed to GetFirstChild() and GetNextChild() should be + // the same! + + // get the last child of this item - this method doesn't use cookies + wxTreeItemId GetLastChild(const wxTreeItemId& item) const; + + // get the next sibling of this item + wxTreeItemId GetNextSibling(const wxTreeItemId& item) const; + // get the previous sibling + wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const; + + // get first visible item + wxTreeItemId GetFirstVisibleItem() const; + // get the next visible item: item must be visible itself! + // see IsVisible() and wxTreeCtrl::GetFirstVisibleItem() + wxTreeItemId GetNextVisible(const wxTreeItemId& item) const; + // get the previous visible item: item must be visible itself! + wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const; + + // operations + // ---------- + + // add the root node to the tree + wxTreeItemId AddRoot(const wxString& text, + int image = -1, int selectedImage = -1, + wxTreeItemData *data = NULL); + + // insert a new item in as the first child of the parent + wxTreeItemId PrependItem(const wxTreeItemId& parent, + const wxString& text, + int image = -1, int selectedImage = -1, + wxTreeItemData *data = NULL); + + // insert a new item after a given one + wxTreeItemId InsertItem(const wxTreeItemId& parent, + const wxTreeItemId& idPrevious, + const wxString& text, + int image = -1, int selectedImage = -1, + wxTreeItemData *data = NULL); + + // insert a new item in as the last child of the parent + wxTreeItemId AppendItem(const wxTreeItemId& parent, + const wxString& text, + int image = -1, int selectedImage = -1, + wxTreeItemData *data = NULL); + + // delete this item and associated data if any + void Delete(const wxTreeItemId& item); + // delete all items from the tree + void DeleteAllItems(); + + // expand this item + void Expand(const wxTreeItemId& item); + // collapse the item without removing its children + void Collapse(const wxTreeItemId& item); + // collapse the item and remove all children + void CollapseAndReset(const wxTreeItemId& item); + // toggles the current state + void Toggle(const wxTreeItemId& item); + + // remove the selection from currently selected item (if any) + void Unselect(); + // select this item + void SelectItem(const wxTreeItemId& item); + // make sure this item is visible (expanding the parent item and/or + // scrolling to this item if necessary) + void EnsureVisible(const wxTreeItemId& item); + // scroll to this item (but don't expand its parent) + void ScrollTo(const wxTreeItemId& item); + + // start editing the item label: this (temporarily) replaces the item + // with a one line edit control. The item will be selected if it hadn't + // been before. textCtrlClass parameter allows you to create an edit + // control of arbitrary user-defined class deriving from wxTextCtrl. + wxTextCtrl* EditLabel(const wxTreeItemId& item, + wxClassInfo* textCtrlClass = CLASSINFO(wxTextCtrl)); + // returns the same pointer as StartEdit() if the item is being edited, + // NULL otherwise (it's assumed that no more than one item may be + // edited simultaneously) + wxTextCtrl* GetEditControl() const; + // end editing and accept or discard the changes to item label + void EndEditLabel(const wxTreeItemId& item, bool discardChanges = false); + + // sort the children of this item using the specified callback function + // (it should return -1, 0 or +1 as usual), if it's not specified + // alphabetical comparaison is performed. + // + // NB: this function is not reentrant! + void SortChildren(const wxTreeItemId& item, + wxTreeItemCmpFunc *cmpFunction = NULL); + + // deprecated + // ---------- + +#if WXWIN_COMPATIBILITY_2_6 + // these methods are deprecated and will be removed in future versions of + // wxWidgets, they're here for compatibility only, don't use them in new + // code (the comments indicate why these methods are now useless and how to + // replace them) + + // use Expand, Collapse, CollapseAndReset or Toggle + wxDEPRECATED( void ExpandItem(const wxTreeItemId& item, int action) ); + + // use SetImageList + wxDEPRECATED( void SetImageList(wxImageList *imageList, int) ) + { SetImageList(imageList); } + + // use Set/GetItemImage directly + wxDEPRECATED( int GetItemSelectedImage(const wxTreeItemId& item) const ); + wxDEPRECATED( void SetItemSelectedImage(const wxTreeItemId& item, int image) ); + + // get the first child of this item + wxDEPRECATED( wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& cookie) const ); + // get the next child (after GetFirstChild or GetNextChild) + wxDEPRECATED( wxTreeItemId GetNextChild(const wxTreeItemId& item, long& cookie) const ); + + // use AddRoot, PrependItem or AppendItem + wxDEPRECATED( wxTreeItemId InsertItem(const wxTreeItemId& parent, + const wxString& text, + int image = -1, int selImage = -1, + long insertAfter = wxTREE_INSERT_LAST) ); + +#endif // WXWIN_COMPATIBILITY_2_6 + + // use Set/GetImageList and Set/GetStateImageList + wxImageList *GetImageList(int) const + { return GetImageList(); } + + void SendExpanding(const wxTreeItemId& item); + void SendExpanded(const wxTreeItemId& item); + void SendCollapsing(const wxTreeItemId& item); + void SendCollapsed(const wxTreeItemId& item); + void SendSelChanging(const wxTreeItemId& item); + void SendSelChanged(const wxTreeItemId& item); + +protected: + + wxTreeItemId m_editItem; + GtkTree *m_tree; + GtkTreeItem *m_anchor; + wxTextCtrl* m_textCtrl; + wxImageList* m_imageListNormal; + wxImageList* m_imageListState; + + long m_curitemId; + + void SendMessage(wxEventType command, const wxTreeItemId& item); +// GtkTreeItem *findGtkTreeItem(wxTreeCtrlId &id) const; + + // the common part of all ctors + void Init(); + // insert a new item in as the last child of the parent + wxTreeItemId p_InsertItem(GtkTreeItem *p, + const wxString& text, + int image, int selectedImage, + wxTreeItemData *data); + + + DECLARE_DYNAMIC_CLASS(wxTreeCtrl) }; -typedef void (wxEvtHandler::*wxTreeEventFunction)(wxTreeEvent&); - -#define EVT_TREE_BEGIN_DRAG(id, fn) { wxEVT_COMMAND_TREE_BEGIN_DRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_BEGIN_RDRAG(id, fn) { wxEVT_COMMAND_TREE_BEGIN_RDRAG, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_BEGIN_LABEL_EDIT(id, fn) { wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn , NULL }, -#define EVT_TREE_END_LABEL_EDIT(id, fn) { wxEVT_COMMAND_TREE_END_LABEL_EDIT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_DELETE_ITEM(id, fn) { wxEVT_COMMAND_TREE_DELETE_ITEM, id, -1, ( wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_GET_INFO(id, fn) { wxEVT_COMMAND_TREE_GET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_SET_INFO(id, fn) { wxEVT_COMMAND_TREE_SET_INFO, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_ITEM_EXPANDED(id, fn) { wxEVT_COMMAND_TREE_ITEM_EXPANDED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_ITEM_EXPANDING(id, fn) { wxEVT_COMMAND_TREE_ITEM_EXPANDING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_ITEM_COLLAPSED(id, fn) { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_ITEM_COLLAPSING(id, fn) { wxEVT_COMMAND_TREE_ITEM_COLLAPSING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_SEL_CHANGED(id, fn) { wxEVT_COMMAND_TREE_SEL_CHANGED, id, -1, ( wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_SEL_CHANGING(id, fn) { wxEVT_COMMAND_TREE_SEL_CHANGING, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, -#define EVT_TREE_KEY_DOWN(id, fn) { wxEVT_COMMAND_TREE_KEY_DOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxTreeEventFunction) & fn, NULL }, - #endif - // __GTKTREECTRL_H__ + // _WX_TREECTRL_H_