Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support for new native OS/2 tree control with drag-and-drop.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@18909 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
2003-01-24 22:31:41 +00:00
parent c0ae383ac0
commit 4fd899b671
13 changed files with 3769 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
include/wx/os2/dataform.h
View File

@@ -15,46 +15,37 @@
class wxDataFormat
{
public:
// the clipboard formats under GDK are GdkAtoms
typedef unsigned short NativeFormat;
wxDataFormat(unsigned int uFormat = wxDF_INVALID) { m_uFormat = uFormat; }
wxDataFormat(const wxChar* zFormat) { SetId(zFormat); }
wxDataFormat();
wxDataFormat(wxDataFormatId vType);
wxDataFormat(const wxString& rId);
wxDataFormat(const wxChar* pId);
wxDataFormat(NativeFormat vFormat);
wxDataFormat& operator=(unsigned int uFormat) { m_uFormat = uFormat; return(*this); }
wxDataFormat& operator=(const wxDataFormat& rFormat) {m_uFormat = rFormat.m_uFormat; return(*this); }
wxDataFormat& operator=(NativeFormat vFormat)
{ SetId(vFormat); return *this; }
//
// Comparison (must have both versions)
//
bool operator==(wxDataFormatId eFormat) const { return (m_uFormat == (unsigned int)eFormat); }
bool operator!=(wxDataFormatId eFormat) const { return (m_uFormat != (unsigned int)eFormat); }
bool operator==(const wxDataFormat& rFormat) const { return (m_uFormat == rFormat.m_uFormat); }
bool operator!=(const wxDataFormat& rFormat) const { return (m_uFormat != rFormat.m_uFormat); }
operator unsigned int(void) const { return m_uFormat; }
// comparison (must have both versions)
bool operator==(NativeFormat vFormat) const
{ return m_vFormat == (NativeFormat)vFormat; }
bool operator!=(NativeFormat vFormat) const
{ return m_vFormat != (NativeFormat)vFormat; }
unsigned int GetFormatId(void) const { return (unsigned int)m_uFormat; }
unsigned int GetType(void) const { return (unsigned int)m_uFormat; }
// explicit and implicit conversions to NativeFormat which is one of
// standard data types (implicit conversion is useful for preserving the
// compatibility with old code)
NativeFormat GetFormatId() const { return m_vFormat; }
operator NativeFormat() const { return m_vFormat; }
bool IsStandard(void) const;
void SetId(NativeFormat vFormat);
void SetType(unsigned int uType){ m_uFormat = uType; }
// string ids are used for custom types - this SetId() must be used for
//
// String ids are used for custom types - this SetId() must be used for
// application-specific formats
wxString GetId() const;
void SetId(const wxChar* pId);
// implementation
wxDataFormatId GetType() const;
//
wxString GetId(void) const;
void SetId(const wxChar* pId);
private:
wxDataFormatId m_vType;
NativeFormat m_vFormat;
void PrepareFormats();
void SetType(wxDataFormatId vType);
};
unsigned int m_uFormat;
}; // end of CLASS wxDataFormat
#endif // _WX_GTK_DATAFORM_H

16
include/wx/os2/dataobj.h
View File

@@ -1,7 +1,7 @@
///////////////////////////////////////////////////////////////////////////////
// Name: mac/dataobj.h
// Purpose: declaration of the wxDataObject
// Author: Stefan Csomor
// Author: Stefan Csomor
// Modified by:
// Created: 10/21/99
// RCS-ID: $Id$
@@ -24,8 +24,20 @@ class wxDataObject : public wxDataObjectBase
{
public:
wxDataObject();
virtual ~wxDataObject();
virtual bool IsSupportedFormat( const wxDataFormat& format, Direction dir = Get ) const;
virtual bool IsSupportedFormat( const wxDataFormat& eFormat
,Direction eDir = Get
) const
{
return(IsSupported( eFormat
,eDir
));
}
PDRAGITEM GetInterface(void) const {return m_pDataObject;}
private:
PDRAGITEM m_pDataObject;
};
#endif // _WX_MAC_DATAOBJ_H_

56
include/wx/os2/dnd.h
View File

@@ -23,6 +23,8 @@
#include <pmstddlg.h>
#endif
class CIDropTarget;
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
@@ -41,41 +43,57 @@ public:
/* start drag action */
virtual wxDragResult DoDragDrop(int flags = wxDrag_CopyOnly);
virtual bool GiveFeedback(wxDragResult eEffect);
protected:
void Init(void);
bool m_bLazyDrag;
DRAGIMAGE* m_pDragImage;
DRAGINFO* m_pDragInfo;
DRAGTRANSFER* m_pDragTransfer;
};
ULONG m_ulItems;
PDRAGINFO m_pDragInfo;
DRAGIMAGE m_vDragImage;
PDRAGITEM m_pDragItem;
wxWindow* m_pWindow;
}; // end of CLASS wxDropSource
//-------------------------------------------------------------------------
// wxDropTarget
//-------------------------------------------------------------------------
class WXDLLEXPORT wxDropTarget: public wxDropTargetBase
class WXDLLEXPORT wxDropTarget : public wxDropTargetBase
{
public:
wxDropTarget(wxDataObject *dataObject = (wxDataObject*)NULL);
wxDropTarget(wxDataObject* pDataObject = (wxDataObject*)NULL);
virtual ~wxDropTarget();
void Register(WXHWND hwnd);
void Revoke(WXHWND hwnd);
//
// These functions are called when data is moved over position (x, y) and
// may return either wxDragCopy, wxDragMove or wxDragNone depending on
// what would happen if the data were dropped here.
//
// The last parameter is what would happen by default and is determined by
// the platform-specific logic (for example, under Windows it's wxDragCopy
// if Ctrl key is pressed and wxDragMove otherwise) except that it will
// always be wxDragNone if the carried data is in an unsupported format.
//
// OnData must be implemented and other should be overridden by derived classes
//
virtual wxDragResult OnData( wxCoord vX
,wxCoord vY
,wxDragResult eResult
);
virtual bool OnDrop( wxCoord vX
,wxCoord vY
);
bool IsAcceptedData(PDRAGINFO pDataSource) const;
virtual wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
virtual bool OnDrop(wxCoord x, wxCoord y);
virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult vResult);
virtual bool GetData();
// implementation
protected:
virtual bool IsAcceptable(DRAGINFO* pInfo);
virtual bool GetData(void);
wxDataFormat GetSupportedFormat(PDRAGINFO pDataSource) const;
void Release(void);
DRAGINFO* m_pDragInfo;
DRAGTRANSFER* m_pDragTransfer;
};
private:
CIDropTarget* m_pDropTarget;
}; // end of CLASS wxDropTarget
#endif //__OS2DNDH__

2
include/wx/os2/textctrl.h
View File

@@ -12,6 +12,8 @@
#ifndef _WX_TEXTCTRL_H_
#define _WX_TEXTCTRL_H_
typedef int (wxCALLBACK *wxTreeCtrlCompare)(long lItem1, long lItem2, long lSortData);
class WXDLLEXPORT wxTextCtrl : public wxTextCtrlBase
{
public:

701
include/wx/os2/treectrl.h Normal file
View File

@@ -0,0 +1,701 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/os2/treectrl.h
// Purpose: wxTreeCtrl class
// Author: David Webster
// Modified by:
// Created: 01/23/03
// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TREECTRL_H_
#define _WX_TREECTRL_H_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma interface "treectrl.h"
#endif
#if wxUSE_TREECTRL
#include "wx/textctrl.h"
#include "wx/dynarray.h"
#include "wx/treebase.h"
// the type for "untyped" data
typedef long wxDataType;
// fwd decl
class WXDLLEXPORT wxImageList;
class WXDLLEXPORT wxDragImage;
struct WXDLLEXPORT wxTreeViewItem;
// 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 wxTreeItemData;
// flags for deprecated `Expand(int action)'
enum
{
wxTREE_EXPAND_EXPAND,
wxTREE_EXPAND_COLLAPSE,
wxTREE_EXPAND_COLLAPSE_RESET,
wxTREE_EXPAND_TOGGLE
};
// flags for deprecated InsertItem() variant
#define wxTREE_INSERT_FIRST 0xFFFF0001
#define wxTREE_INSERT_LAST 0xFFFF0002
// ----------------------------------------------------------------------------
// wxTreeCtrl
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxTreeCtrl : public wxControl
{
public:
// creation
// --------
wxTreeCtrl() { Init(); }
wxTreeCtrl( wxWindow* pParent
,wxWindowID vId = -1
,const wxPoint& rPos = wxDefaultPosition
,const wxSize& rSize = wxDefaultSize
,long lStyle = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT
,const wxValidator& rValidator = wxDefaultValidator
,const wxString& rsName = wxTreeCtrlNameStr
)
{
Create( pParent
,vId
,rPos
,rSize
,lStyle
,rValidator
,rsName
);
}
virtual ~wxTreeCtrl();
bool Create( wxWindow* pParent
,wxWindowID vId = -1
,const wxPoint& rPos = wxDefaultPosition
,const wxSize& rSize = wxDefaultSize
,long lStyle = wxTR_HAS_BUTTONS | wxTR_LINES_AT_ROOT
,const wxValidator& rValidator = wxDefaultValidator
,const wxString& rsName = wxTreeCtrlNameStr
);
//
// Accessors
// ---------
//
//
// Get the total number of items in the control
//
size_t GetCount(void) 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(void) const;
void SetIndent(unsigned int uIndent);
//
// Spacing is the number of pixels between the start and the Text
//
unsigned int GetSpacing(void) const { return 18; } // return wxGTK default
void SetSpacing(unsigned int uSpacing) { }
//
// 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.
//
// OS/2 doesn't really use imagelists as MSW does, but since the MSW
// control is the basis for this one, until I decide how to get rid of
// the need for them they are here for now.
//
wxImageList* GetImageList(void) const;
wxImageList* GetStateImageList(void) const;
void AssignImageList(wxImageList* pImageList);
void AssignStateImageList(wxImageList* pImageList);
void SetImageList(wxImageList* pImageList);
void SetStateImageList(wxImageList* pImageList);
//
// 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.
//
// Item's label
//
wxString GetItemText(const wxTreeItemId& rItem) const;
void SetItemText( const wxTreeItemId& rItem
,const wxString& rsText
);
//
// One of the images associated with the item (normal by default)
//
int GetItemImage( const wxTreeItemId& rItem
,wxTreeItemIcon vWhich = wxTreeItemIcon_Normal
) const;
void SetItemImage( const wxTreeItemId& rItem
,int nImage
,wxTreeItemIcon vWhich = wxTreeItemIcon_Normal
);
//
// Data associated with the item
//
wxTreeItemData* GetItemData(const wxTreeItemId& rItem) const;
void SetItemData( const wxTreeItemId& rItem
,wxTreeItemData* pData
);
//
// Item's text colour
//
wxColour GetItemTextColour(const wxTreeItemId& rItem) const;
void SetItemTextColour( const wxTreeItemId& rItem
,const wxColour& rColor
);
//
// Item's background colour
//
wxColour GetItemBackgroundColour(const wxTreeItemId& rItem) const;
void SetItemBackgroundColour( const wxTreeItemId& rItem
,const wxColour& rColour
);
//
// Item's font
//
wxFont GetItemFont(const wxTreeItemId& rItem) const;
void SetItemFont( const wxTreeItemId& rItem
,const wxFont& rFont
);
//
// Force appearance of [+] button near the item. This is useful to
// allow the user to expand the items which don't have any children now
// - but instead add them only when needed, thus minimizing memory
// usage and loading time.
//
void SetItemHasChildren( const wxTreeItemId& rItem
,bool bHas = TRUE
);
//
// The item will be shown in bold
//
void SetItemBold( const wxTreeItemId& rItem
,bool bBold = TRUE
);
//
// The item will be shown with a drop highlight
//
void SetItemDropHighlight( const wxTreeItemId& rItem
,bool bHighlight = TRUE
);
//
// Item status inquiries
// ---------------------
//
//
// Is the item visible (it might be outside the view or not expanded)?
//
bool IsVisible(const wxTreeItemId& rItem) const;
//
// Does the item has any children?
//
bool ItemHasChildren(const wxTreeItemId& rItem) const;
//
// Is the item expanded (only makes sense if HasChildren())?
//
bool IsExpanded(const wxTreeItemId& rItem) const;
//
// Is this item currently selected (the same as has focus)?
//
bool IsSelected(const wxTreeItemId& rItem) const;
//
// Is item text in bold font?
//
bool IsBold(const wxTreeItemId& rItem) 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& rItem
,bool bRecursively = TRUE
) const;
//
// Navigation
// ----------
//
//
// Get the root tree item
//
wxTreeItemId GetRootItem(void) const;
//
// Get the item currently selected (may return NULL if no selection)
//
wxTreeItemId GetSelection(void) const;
//
// Get the items currently selected, return the number of such item
//
size_t GetSelections(wxArrayTreeItemIds& rSelections) const;
//
// Get the parent of this item (may return NULL if root)
//
wxTreeItemId GetItemParent(const wxTreeItemId& rItem) const;
#if WXWIN_COMPATIBILITY_2_2
// deprecated: Use GetItemParent instead.
wxTreeItemId GetParent(const wxTreeItemId& rItem) const
{ return GetItemParent(rItem); }
// Expose the base class method hidden by the one above.
wxWindow* GetParent(void) const { return wxControl::GetParent(); }
#endif // WXWIN_COMPATIBILITY_2_2
//
// 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 first child of this item
//
wxTreeItemId GetFirstChild( const wxTreeItemId& rItem
,long& rCookie
) const;
//
// Get the next child
//
wxTreeItemId GetNextChild( const wxTreeItemId& rItem
,long& rCookie
) const;
//
// Get the last child of this item - this method doesn't use cookies
//
wxTreeItemId GetLastChild(const wxTreeItemId& rItem) const;
//
// Get the next sibling of this item
//
wxTreeItemId GetNextSibling(const wxTreeItemId& rItem) const;
//
// Get the previous sibling
//
wxTreeItemId GetPrevSibling(const wxTreeItemId& rItem) const;
//
// Get first visible item
//
wxTreeItemId GetFirstVisibleItem(void) const;
//
// Get the next visible item: item must be visible itself!
// see IsVisible() and wxTreeCtrl::GetFirstVisibleItem()
//
wxTreeItemId GetNextVisible(const wxTreeItemId& rItem) const;
//
// Get the previous visible item: item must be visible itself!
//
wxTreeItemId GetPrevVisible(const wxTreeItemId& rItem) const;
//
// Operations
// ----------
//
//
// Add the root node to the tree
//
wxTreeItemId AddRoot( const wxString& rsText
,int nImage = -1
,int nSelectedImage = -1
,wxTreeItemData* pData = NULL
);
//
// Insert a new item in as the first child of the parent
//
wxTreeItemId PrependItem( const wxTreeItemId& rParent
,const wxString& rsText
,int nImage = -1
,int nSelectedImage = -1
,wxTreeItemData* pData = NULL
);
//
// Insert a new item after a given one
//
wxTreeItemId InsertItem( const wxTreeItemId& rParent
,const wxTreeItemId& rIdPrevious
,const wxString& rsText
,int nImage = -1
,int nSelectedImage = -1
,wxTreeItemData* pData = NULL
);
//
// Insert a new item before the one with the given index
//
wxTreeItemId InsertItem( const wxTreeItemId& pParent
,size_t nIndex
,const wxString& rsText
,int nImage = -1
,int nSelectedImage = -1
,wxTreeItemData* pData = NULL
);
//
// Insert a new item in as the last child of the parent
//
wxTreeItemId AppendItem( const wxTreeItemId& rParent
,const wxString& rsText
,int nImage = -1
,int nSelectedImage = -1
,wxTreeItemData* pData = NULL
);
//
// Delete this item and associated data if any
//
void Delete(const wxTreeItemId& rItem);
//
// Delete all children (but don't delete the item itself)
//
void DeleteChildren(const wxTreeItemId& rItem);
//
// Delete all items from the tree
//
void DeleteAllItems(void);
//
// Expand this item
//
void Expand(const wxTreeItemId& rItem);
//
// Collapse the item without removing its children
//
void Collapse(const wxTreeItemId& rItem);
//
// Collapse the item and remove all children
//
void CollapseAndReset(const wxTreeItemId& rItem);
//
// Toggles the current state
//
void Toggle(const wxTreeItemId& rItem);
//
// Remove the selection from currently selected item (if any)
//
void Unselect(void);
//
// Unselect all items (only makes sense for multiple selection control)
//
void UnselectAll(void);
//
// Select this item
//
void SelectItem(const wxTreeItemId& rItem);
//
// Make sure this item is visible (expanding the parent item and/or
// scrolling to this item if necessary)
//
void EnsureVisible(const wxTreeItemId& rItem);
//
// Scroll to this item (but don't expand its parent)
//
void ScrollTo(const wxTreeItemId& rItem);
//
// OS/2 does not use a separate edit field for editting text. Here for
// interface compatibility, only.
//
wxTextCtrl* EditLabel( const wxTreeItemId& rItem
,wxClassInfo* pTextCtrlClass = CLASSINFO(wxTextCtrl)
);
//
// returns NULL for OS/2 in ALL cases
//
wxTextCtrl* GetEditControl(void) const {return (wxTextCtrl*)NULL;}
//
// End editing and accept or discard the changes to item label
//
void EndEditLabel( const wxTreeItemId& rItem
,bool bDiscardChanges = FALSE
);
//
// Sorting
// -------
//
//
// This function is called to compare 2 items and should return -1, 0
// or +1 if the first item is less than, equal to or greater than the
// second one. The base class version performs alphabetic comparaison
// of item labels (GetText)
//
virtual int OnCompareItems( const wxTreeItemId& rItem1
,const wxTreeItemId& rItem2
);
//
// Sort the children of this item using OnCompareItems
//
void SortChildren(const wxTreeItemId& rItem);
//
// Helpers
// -------
//
//
// Determine to which item (if any) belongs the given point (the
// coordinates specified are relative to the client area of tree ctrl)
// and fill the flags parameter with a bitmask of wxTREE_HITTEST_xxx
// constants.
//
// The first function is more portable (because easier to implement
// on other platforms), but the second one returns some extra info.
//
wxTreeItemId HitTest(const wxPoint& rPoint)
{ int nDummy = 0; return HitTest(rPoint, nDummy); }
wxTreeItemId HitTest( const wxPoint& rPoint
,int& rFlags
);
//
// Get the bounding rectangle of the item (or of its label only)
//
bool GetBoundingRect( const wxTreeItemId& rItem
,wxRect& rRect
,bool bTextOnly = FALSE
) const;
//
// Deprecated
// ----------
//
// These methods are deprecated and will be removed in future versions of
// wxWindows, 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
//
void ExpandItem( const wxTreeItemId& rItem
,int nAction
);
//
// Use AddRoot, PrependItem or AppendItem
//
wxTreeItemId InsertItem( const wxTreeItemId& pParent
,const wxString& rsText
,int nImage = -1
,int nSelImage = -1
,long lInsertAfter = wxTREE_INSERT_LAST
);
//
// Use Set/GetImageList and Set/GetStateImageList
//
wxImageList* GetImageList(int nVal) const
{ return GetImageList(); }
void SetImageList(wxImageList* pImageList, int nVal)
{ SetImageList(pImageList); }
//
// Use Set/GetItemImage directly
//
int GetItemSelectedImage(const wxTreeItemId& rItem) const
{ return GetItemImage(rItem, wxTreeItemIcon_Selected); }
void SetItemSelectedImage(const wxTreeItemId& rItem, int nImage)
{ SetItemImage(rItem, nImage, wxTreeItemIcon_Selected); }
//
// Implementation
// --------------
//
virtual MRESULT OS2WindowProc( WXUINT uMsg
,WXWPARAM wParam
,WXLPARAM lParam
);
virtual bool OS2Command( WXUINT uParam
,WXWORD wId
);
// virtual bool OMSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
//
// Override some base class virtuals
//
virtual bool SetBackgroundColour(const wxColour& rColour);
virtual bool SetForegroundColour(const wxColour& rColour);
//
// Get/set the check state for the item (only for wxTR_MULTIPLE)
//
bool IsItemChecked(const wxTreeItemId& rItem) const;
void SetItemCheck( const wxTreeItemId& rItem
,bool bCheck = TRUE
);
protected:
//
// SetImageList helper
//
void SetAnyImageList( wxImageList* pImageList
,int nWhich
);
//
// Refresh a single item
//
void RefreshItem(const wxTreeItemId& rItem);
wxImageList* m_pImageListNormal; // images for tree elements
wxImageList* m_pImageListState; // special images for app defined states
bool m_bOwnsImageListNormal;
bool m_bOwnsImageListState;
private:
//
// The common part of all ctors
//
void Init(void);
//
// Helper functions
//
inline bool DoGetItem(wxTreeViewItem* pTvItem) const;
inline void DoSetItem(wxTreeViewItem* pTvItem);
inline void DoExpand( const wxTreeItemId& rItem
,int nFlag
);
wxTreeItemId DoInsertItem( const wxTreeItemId& pParent
,wxTreeItemId hInsertAfter
,const wxString& rsText
,int nImage
,int nSelectedImage
,wxTreeItemData* pData
);
int DoGetItemImageFromData( const wxTreeItemId& rItem
,wxTreeItemIcon vWhich
) const;
void DoSetItemImageFromData( const wxTreeItemId& rItem
,int nImage
,wxTreeItemIcon vWhich
) const;
void DoSetItemImages( const wxTreeItemId& rItem
,int nImage
,int nImageSel
);
void DeleteTextCtrl() { };
//
// support for additional item images which we implement using
// wxTreeItemIndirectData technique - see the comments in msw/treectrl.cpp
//
void SetIndirectItemData( const wxTreeItemId& rItem
,class wxTreeItemIndirectData* pData
);
bool HasIndirectData(const wxTreeItemId& rItem) const;
bool IsDataIndirect(wxTreeItemData* pData) const
{ return pData && pData->GetId().m_pItem == 0; }
//
// The hash storing the items attributes (indexed by items ids)
//
wxHashTable m_vAttrs;
//
// TRUE if the hash above is not empty
//
bool m_bHasAnyAttr;
//
// Used for dragging
//
wxDragImage* m_pDragImage;
// Virtual root item, if wxTR_HIDE_ROOT is set.
// void* m_pVirtualRoot;
// the starting item for selection with Shift
// WXHTREEITEM m_htSelStart;
//
friend class wxTreeItemIndirectData;
friend class wxTreeSortHelper;
DECLARE_DYNAMIC_CLASS(wxTreeCtrl)
DECLARE_NO_COPY_CLASS(wxTreeCtrl)
}; // end of CLASS wxTreeCtrl
#endif // wxUSE_TREECTRL
#endif
// _WX_TREECTRL_H_