Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
treeitems.h
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 19k
Category:

Windows Kernel

Development Platform:

Visual C++

treeitems.h：Code Content
  1. //-------------------------------------------------------------------------//
  2. //
  3. //  TreeItems.h
  4. //
  5. //-------------------------------------------------------------------------//
  7. #ifndef __TREEITEMS_H__
  8. #define __TREEITEMS_H__
  10. #include "resource.h"
  11. #include "Dictionary.h"
  12. #include "PriorityLst.h"
  14. //-------------------------------------------------------------------------//
  15. //  Forwards
  16. class  CPropertyTreeCtl ;
  17. class  CPropertyTreeItem ;
  18. class  CPropertyFolder ;
  19. class  CProperty ;
  20. class  CMetrics ;
  22. //-------------------------------------------------------------------------//
  23. const int CCH_PROPERTY_TEXT = MAX_PATH ;
  25. //  Tier constants
  26. //  BUGBUG: These should be calculated on tree view insertion in order
  27. //  to support multilevel hierarchy.
  28. enum PROPTREE_TIERS {
  29.     NIL_TIER,
  30.     FOLDER_TIER,      
  31.     PROPERTY_TIER,   
  32. } ;
  34. //-------------------------------------------------------------------------//
  35. class CPropertyTreeItem
  36. //-------------------------------------------------------------------------//
  37. {
  38. public:
  39.     //  Construction, destruction, initialization
  40.     CPropertyTreeItem( CPropertyTreeCtl* pCtl ) ;
  41.     virtual ~CPropertyTreeItem() {}
  42.                                  
  43. public:
  44.     //  Utility Methods
  45.     static  CPropertyTreeItem*  GetTreeItem( const TV_ITEM& tvi ) ;
  46.     static  HINSTANCE           GetModuleInstance() ;
  47.     static  HINSTANCE           GetResourceInstance() ;
  48.     CPropertyTreeItem*          GetNext( PROPTREE_ITEM_TYPE type, BOOL bExpand ) const ;
  49.     CPropertyTreeItem*          GetPrev( PROPTREE_ITEM_TYPE type, BOOL bExpand ) const ;
  51.     operator HTREEITEM() const ;
  53.     //  General function and access methods
  54.     virtual USHORT     Type() const =0 ;
  56.             LPCTSTR    GetName() const ;
  57.             LPCTSTR    GetDisplayName() const ;
  58.             LPCTSTR    GetDescription() const ;
  59.     virtual ULONG      GetAccess() const =0 ;
  60.  
  61.     virtual int        ItemWidth( BOOL bTextOnly ) const;
  62.  
  63.     virtual void       SetName( LPCTSTR pszName ) ;
  64.     virtual void       SetDisplayName( LPCTSTR pszDisplayName ) ;
  65.     virtual void       SetDescription( LPCTSTR pszDescr ) ;
  66.     virtual BOOL       IsCompositeMismatch() const { return FALSE ; }
  67.     virtual BOOL       IsMultiline() ;
  68.     static  LPTSTR     MultilineToSingleline( LPCTSTR pszValue ) ;
  70.     virtual LPCTSTR    ValueText() ;
  71.     virtual BOOL       OnValueChanging( CPropVariant& varNew ) ;
  72.     virtual void       OnValueChanged( const CPropVariant& varNew ) ;
  73.     virtual BOOL       OnValueRestore()     { return FALSE ; }
  75.     //  Property source methods
  76.     virtual HRESULT    AddSource( const VARIANT* pvarSrc, ULONG dwAccess, const PROPVARIANT* pVal ) ;
  77.     virtual HRESULT    RemoveSource( const VARIANT* pvarSrc ) ;
  78.     virtual LONG       SourceCount() const ;
  79.     virtual BOOL       Reconcile( HWND hwndTree, LONG cMasterSourceCount ) ;
  81.     //  Tree View methods
  82.     virtual HTREEITEM  Insert( HWND hwndTree, HTREEITEM hParent, HTREEITEM hInsertAfter = TVI_LAST )=0 ;
  83.     virtual void       Remove() ;
  84.     virtual int        TierNumber() const = 0 ;
  85.     virtual int        InsertChildren() ;
  86.     virtual LRESULT    OnTreeItemCallback( TV_DISPINFO* pDI, BOOL& bHandled ) ;
  87.     virtual LRESULT    Draw( LPNMTVCUSTOMDRAW, CMetrics* ) ;
  88.     virtual void       HitTest( LPTVHITTESTINFO pHTI ) ;
  89.     virtual BOOL       GetLabelRect( OUT LPRECT prc, BOOL fTextBox = FALSE ) ;
  90.     virtual BOOL       GetValueRect( OUT LPRECT prc, BOOL fTextBox = FALSE ) ;
  91.     virtual BOOL       OnKillFocus( UINT uAction = TVC_UNKNOWN, CPropertyTreeItem* pItemNew = NULL ) ;
  93.     //  TreeView order index among siblings
  94.     virtual void       SetOrder( int i )=0 ;
  95.     virtual int        Order() const = 0 ;
  97.     //  Array of sort direction indicators for child items.
  98.     virtual HTREEITEM  GetSortTarget( int iCol )    { return m_hTreeItem ; }
  99.     int*               ChildSortDir() ;
  101.     //  Pend sort methods.
  102.     virtual void       PendChildSort()   {} // indicates that the item's children should be resorted.
  103.     virtual void       UnpendChildSort() {} // indicates that the item's children do not require a resort.
  104.     virtual BOOL       ChildSortPending() const ; // Retrieves the child sort pending status of the item.
  106.     //  In-Place Edit Control methods
  107.     virtual HWND       EditControl()  { return NULL ; }
  108.     virtual HWND       ShowEditControl( UINT nShowCmd, LPCRECT prcEdit, CMetrics* ) ;
  109.     virtual void       RepositionEditControl( LPCRECT prcEdit, CMetrics* ) ;
  110.     virtual LRESULT    OnEditControlCommand( UINT nID, UINT nCode, HWND hwndEdit, CMetrics*, BOOL& bHandled ) ;
  111.     virtual LRESULT    OnEditControlNotify( NMHDR* pHdr, CMetrics*, BOOL& bHandled ) ;
  113.     //  Miscellaneous methods:
  114.     virtual void       DisplayQtipText( HWND hwndQtip ) ;
  116.     //  Non-virtual TreeView implementation methods
  117. protected:
  118.     HTREEITEM          Insert( HWND hwndTree, TV_INSERTSTRUCT* pTVI ) ;
  119.     BOOL               UpdateChildCount( int cChildren ) ;
  120.     virtual BOOL       DrawValueText() ;
  121.     CPropertyTreeCtl*  Control() ;
  122.     const HWND&        TreeHwnd() const ;
  124.     //  Data
  125. protected:    
  126.     //  1st dimension indices and upper bound for m_szText array.
  127.     enum     {
  128.         iName,
  129.         iDisplayName,
  130.         iDescr,
  131.         cPropertyText   // array upper bound
  132.     } ;
  134.     TCHAR  m_szText[3][CCH_PROPERTY_TEXT] ;
  135.     int    m_xLabel, m_cxLabel,     // start, width of label text box
  136.            m_xValue, m_cxValue ;    // start, width of value text box.
  137.     int    m_iChildSortDir[2] ;
  138.     
  139. private:
  140.     CPropertyTreeCtl* m_pCtl ;
  141.     HTREEITEM         m_hTreeItem ;
  142.     static TCHAR      m_szCompositeMismatch[CCH_PROPERTY_TEXT] ;
  143. } ;
  145. //-------------------------------------------------------------------------//
  146. class CPropertyFolder  : public CPropertyTreeItem
  147. //-------------------------------------------------------------------------//
  148. {
  149. public:
  150.     CPropertyFolder( CPropertyTreeCtl* pCtl, const PROPFOLDERITEM& folder ) ;
  151.     virtual ~CPropertyFolder() ;
  153.     //  Overrides of CPropertyTreeItem:
  154.     virtual BOOL       Initialize() ;
  155.     virtual USHORT     Type() const     { return PIT_FOLDER ; }
  156.     virtual ULONG      GetAccess() const { return m_folderitem.dwAccess ; }
  157.     virtual HRESULT    AddSource( const VARIANT* pvarSrc, ULONG dwAccess, const PROPVARIANT* pvarVal = NULL ) ;
  158.     virtual HRESULT    RemoveSource( const VARIANT* pvarSrc ) ;
  159.     virtual LONG       SourceCount() const ;
  160.     virtual BOOL       Reconcile( HWND hwndTree, LONG cMasterSourceCount ) ;
  161.     virtual HTREEITEM  Insert( HWND hwndTree, HTREEITEM hParent = TVI_ROOT, HTREEITEM hInsertAfter = TVI_LAST ) ;
  162.     virtual int        InsertChildren() ;
  163.     virtual int        TierNumber() const  { return FOLDER_TIER ; }
  164.     virtual LRESULT    OnTreeItemCallback( TV_DISPINFO* pDI, BOOL& bHandled ) ;
  165.     virtual void       SetOrder( int i )    { m_folderitem.iOrder = i ; }
  166.     virtual HTREEITEM  GetSortTarget( int iCol ) ;
  167.     virtual int        Order() const        { return m_folderitem.iOrder ; }
  168.     virtual BOOL       ChildSortPending() const { return m_fSortPending ; }
  169.     virtual void       PendChildSort()          { m_fSortPending = TRUE ; } 
  170.     virtual void       UnpendChildSort()        { m_fSortPending = FALSE ; } 
  172. protected:
  173.     PROPFOLDERITEM          m_folderitem ;
  174.     CSourceDictionaryLite   m_srcs ;
  175.     BOOL                    m_fSortPending ;
  176. } ;
  178. //-------------------------------------------------------------------------//
  179. class CProperty  : public CPropertyTreeItem
  180. //-------------------------------------------------------------------------//
  181. {
  182. public:
  183.     CProperty( CPropertyTreeCtl* pCtl, const PROPERTYITEM& item ) ;
  184.     virtual ~CProperty() ;
  186.     virtual BOOL        Initialize() ;
  188.     const CPropVariant& Value() const               { return m_varComposite ; }
  189.     virtual void        SetDirty( BOOL bDirty ) ;
  190.     virtual BOOL        IsDirty() const             { return m_bDirty ; }
  191.     virtual HRESULT     Apply() ;
  192.     
  193.     //  Overrides of CPropertyTreeItem
  194. public:
  195.     virtual USHORT      Type() const      { return PIT_PROPERTY ; }
  196.     virtual ULONG       GetAccess() const { return m_propitem.dwAccess ; }
  197.     virtual BOOL        IsCompositeMismatch() const { return m_bCompositeMismatch ; }
  198.     virtual HTREEITEM   Insert( HWND hwndTree, HTREEITEM hParent, HTREEITEM hInsertAfter = TVI_LAST ) ;
  199.     virtual LRESULT     OnTreeItemCallback( TV_DISPINFO* pDI, BOOL& bHandled ) ;
  200.     virtual void        Remove() ;
  201.     virtual int         TierNumber() const { return PROPERTY_TIER ; }
  202.     virtual HRESULT     AddSource( const VARIANT* pvarSrc, ULONG dwAccess, const PROPVARIANT* pvarVal ) ;
  203.     virtual HRESULT     RemoveSource( const VARIANT* pvarSrc ) ;
  204.     virtual LONG        SourceCount() const ;
  205.     virtual BOOL        Reconcile( HWND hwndTree, LONG cMasterSourceCount ) ;
  206.     virtual LPCTSTR     ValueText() ;            // returns the cached formatted value text
  207.     virtual HRESULT     AssignValueFromText( BSTR bstrValue, BOOL bMakeDirty ) ;
  209.     virtual HRESULT     InitializeSelectionValues()     { return S_OK ; }
  210.     virtual HRESULT     AddSelectionValue( const PROPVARIANT* pvarVal, BSTR bstrDisplayText = NULL ) ;
  211.     virtual LONG        SelectionValueCount() const ;
  213.     virtual void        SetOrder( int i )    { m_propitem.iOrder = i ; }
  214.     virtual int         Order() const        { return m_propitem.iOrder ; }
  216. protected:
  217.     virtual void        HitTest( LPTVHITTESTINFO pHTI ) ;
  218.     virtual HWND        EditControl()  { return IsWindow( m_hwndEdit ) ? m_hwndEdit : NULL ; }
  219.     virtual HWND        ShowEditControl( UINT nShowCmd, LPCRECT prcEdit, CMetrics* ) ;
  220.     virtual void        RepositionEditControl( LPCRECT prcEdit, CMetrics* ) ;
  221.     virtual HWND        CreateEditControl( LPCRECT prc, CMetrics* ) ;
  222.     virtual void        PositionEditControl( HWND hwndCtl, LPCRECT prcItem, CMetrics* ) ;
  223.     virtual void        InitializeEditControl( HWND hwndCtl, CMetrics* ) ;
  224.     virtual LRESULT     OnEditControlCommand( UINT, UINT, HWND, CMetrics*, BOOL&) ;
  225.     virtual BOOL        OnKillFocus( UINT, CPropertyTreeItem* ) ;
  226.     virtual HRESULT     GetEditedValue( CPropVariant& varNew ) ;
  227.     virtual HRESULT     ConvertEditedValue( LPCTSTR pszVal, CPropVariant& varNew );
  228.     virtual BOOL        OnValueChanging( CPropVariant& varNew ) ;
  229.     virtual void        OnValueChanged( const CPropVariant& varNew ) ;
  230.     virtual BOOL        OnValueRestore() ;
  231.     virtual void        MakeCompositeValue() ;
  232.     virtual HRESULT     AddSelectionValue( CSelectionList&, const PROPVARIANT*, BSTR = NULL ) ;
  234.     virtual LPCTSTR     ValueTextFormat() ;      // returns the formatting string for the property's value.
  235.     virtual ULONG       ValueTextFormatFlags() ; // returns the formatting flags for the property's value.
  236.     virtual LPCTSTR     FormatValueText( ) ;     // formats the value text
  237.     virtual void        SetValueText( LPCTSTR pszText ) ;   // caches the formatted value text
  238.     virtual BOOL        DrawValueText() ;        // draws the cached formatted value text
  240.     virtual HRESULT     AssignValue( LPCTSTR pszValue, BOOL bMakeDirty = FALSE ) ;
  241.     virtual HRESULT     AssignValue( IN const CPropVariant* pvarValue, IN OPTIONAL LPCTSTR pszValue = NULL, IN OPTIONAL BOOL bMakeDirty = NULL ) ;
  243.     PROPERTYITEM        m_propitem ;
  244.     CValueDictionary    m_values ;
  245.     CPropVariant        m_varComposite ;
  246.     LPTSTR              m_pszValue ;
  247.     HWND                m_hwndEdit ;
  248.     BOOL                m_bDirty,
  249.                         m_bCompositeMismatch,
  250.                         m_bCtlInitialized ;
  251. } ;
  253. //-------------------------------------------------------------------------//
  254. class CComboBoxProperty  : public CProperty
  255. //-------------------------------------------------------------------------//
  256. {
  257. public:
  258.     CComboBoxProperty( CPropertyTreeCtl* pCtl, const PROPERTYITEM& propitem )
  259.         : CProperty( pCtl, propitem ) {}
  261. protected:
  262.     virtual int InsertUniqueComboValue( HWND hwndCbo, int idx, CPropVariant* pVar, LPCTSTR pszText ) ;
  263.     virtual int FindComboValue( HWND hwndCbo, const CPropVariant& var, ULONG uFlags ) const ;
  265.     virtual LRESULT  OnEditControlCommand( UINT, UINT, HWND, CMetrics*, BOOL& ) ;
  266. } ;
  268. //-------------------------------------------------------------------------//
  269. class CMruProperty  : public CComboBoxProperty
  270. //-------------------------------------------------------------------------//
  271. {
  272. public:
  273.     CMruProperty( CPropertyTreeCtl* pCtl, const PROPERTYITEM& propitem, int nLimit = 50 ) 
  274.         :  CComboBoxProperty( pCtl, propitem ), m_nLimit( nLimit ) {}
  276.     virtual  void  InitializeEditControl( HWND, CMetrics* ) ;
  278. protected:
  279.     virtual HRESULT InitializeSelectionValues() ;
  280.     virtual HRESULT AddSelectionValue( const PROPVARIANT*, BSTR = 0L ) ;
  281.     virtual LONG    SelectionValueCount() const  { return m_mru.Count() ; }
  282.     virtual HRESULT AssignValue( IN const CPropVariant* pvarValue, IN OPTIONAL LPCTSTR pszValue = NULL, IN OPTIONAL BOOL bMakeDirty = NULL ) ;
  284.     CSelectionList  m_mru ;
  285.     int             m_nLimit ;
  286. } ;
  288. //-------------------------------------------------------------------------//
  289. class CDateProperty : public CProperty
  290. //-------------------------------------------------------------------------//
  291. {
  292. public:
  293.     CDateProperty( CPropertyTreeCtl* pCtl, const PROPERTYITEM& propitem ) 
  294.         : CProperty( pCtl, propitem ) {}
  296. protected:
  297.     virtual HRESULT ConvertEditedValue( LPCTSTR pszVal, CPropVariant& varNew );
  298.     virtual void    InitializeEditControl( HWND hwndCtl, CMetrics* pMetrics ) ;
  299.     virtual ULONG   ValueTextFormatFlags()    { return VAR_DATEVALUEONLY ; }
  300. } ;
  302. //-------------------------------------------------------------------------//
  303. class CTextProperty : public CProperty
  304. //-------------------------------------------------------------------------//
  305. {
  306. public:
  307.     CTextProperty( CPropertyTreeCtl* pCtl, const PROPERTYITEM& propitem, int cchMax = 0xFF )
  308.         : CProperty( pCtl, propitem ), m_cchMax( cchMax ) {}
  310.     virtual BOOL IsMultiline() ;
  312. protected:
  313.     int m_cchMax ;
  315. } ;
  317. //-------------------------------------------------------------------------//
  318. class CEnumProperty : public CComboBoxProperty
  319. //-------------------------------------------------------------------------//
  320. {
  321. public:
  322.     CEnumProperty( CPropertyTreeCtl* pCtl, const PROPERTYITEM& propitem ) :
  323.         CComboBoxProperty( pCtl, propitem ) {}
  325.     virtual void    InitializeEditControl( HWND, CMetrics* ) ;
  326.     virtual BOOL    OnKillFocus( UINT, CPropertyTreeItem* ) ;
  327.     virtual BOOL    OnValueChanging( CPropVariant& varNew ) ;
  328.     virtual BOOL    OnValueRestore() ;
  329.     virtual HRESULT AssignValue( IN const CPropVariant* pvarValue, IN OPTIONAL LPCTSTR pszValue = NULL, IN OPTIONAL BOOL bMakeDirty = NULL ) ;
  331. protected:
  332.     virtual HRESULT AddSelectionValue( const PROPVARIANT*, BSTR = 0L ) ;
  333.     virtual LONG    SelectionValueCount() const  { return m_choices.Count() ; }
  334.     virtual LPCTSTR FormatValueText( ) ;     // formats the value text
  337.     CSelectionList  m_choices ;
  338. } ;
  340. //-------------------------------------------------------------------------//
  341. //  Inline implementation - CPropertyTreeItem
  342. inline CPropertyTreeItem::operator HTREEITEM() const { 
  343.     return m_hTreeItem ; 
  344. }
  345. inline CPropertyTreeItem* CPropertyTreeItem::GetTreeItem( const TV_ITEM& tvi ) { 
  346.     return (CPropertyTreeItem*)tvi.lParam ; 
  347. }
  348. inline CPropertyTreeCtl* CPropertyTreeItem::Control()   {
  349.     return m_pCtl ;
  350. }
  351. inline USHORT CPropertyTreeItem::Type() const  {
  352.     return PIT_NIL ;
  353. }
  354. inline LPCTSTR CPropertyTreeItem::GetName() const   { 
  355.     return m_szText[iName] ; 
  356. }
  357. inline LPCTSTR CPropertyTreeItem::GetDisplayName() const  { 
  358.     return m_szText[iDisplayName] ;
  359. }
  360. inline LPCTSTR CPropertyTreeItem::GetDescription() const  { 
  361.     return m_szText[iDescr] ;
  362. }
  363. inline int CPropertyTreeItem::ItemWidth( BOOL bTextOnly ) const  {
  364.     if( *m_szText[iDisplayName] == 0 ) return 0 ;
  365.     return bTextOnly ? m_cxValue + m_xValue : m_cxValue - m_xLabel ;
  366. }
  367. inline LRESULT CPropertyTreeItem::OnEditControlCommand( UINT, UINT, HWND, CMetrics*, BOOL& bHandled )    {
  368.     bHandled = FALSE ;
  369.     return 0L ;
  370. }
  371. inline LRESULT CPropertyTreeItem::OnEditControlNotify( NMHDR*, CMetrics*, BOOL& bHandled )    {
  372.     bHandled = FALSE ;
  373.     return 0L ;
  374. }
  375. inline HRESULT CPropertyTreeItem::AddSource( const VARIANT*, ULONG, const PROPVARIANT* ) { 
  376.     return E_NOTIMPL ; 
  377. }
  378. inline HRESULT CPropertyTreeItem::RemoveSource( const VARIANT* ) { 
  379.     return E_NOTIMPL ;
  380. }
  381. inline LONG CPropertyTreeItem::SourceCount() const { 
  382.     return 0 ;
  383. }
  384. inline BOOL CPropertyTreeItem::Reconcile( HWND, LONG )  {
  385.     return FALSE ;
  386. }
  387. inline int CPropertyTreeItem::InsertChildren()  { 
  388.     return 0 ;
  389. }
  390. inline void CPropertyTreeItem::Remove() {
  391.     HWND hwndTree = TreeHwnd() ;
  392.     if( hwndTree && TreeView_GetSelection( hwndTree )==m_hTreeItem && 
  393.         IsWindowVisible( hwndTree ) )
  394.         TreeView_SelectItem( hwndTree, NULL ) ;
  395.     m_hTreeItem = NULL ;
  396. }
  397. inline HWND CPropertyTreeItem::ShowEditControl( UINT, LPCRECT, CMetrics* ) { 
  398.     return NULL ; 
  399. }
  400. inline void CPropertyTreeItem::RepositionEditControl( LPCRECT, CMetrics* ) {
  401. }
  402. inline BOOL CPropertyTreeItem::OnKillFocus( UINT, CPropertyTreeItem* ) { 
  403.     return TRUE ;
  404. }
  405. inline LPCTSTR CPropertyTreeItem::ValueText() { 
  406.     return NULL ;
  407. }
  408. inline BOOL CPropertyTreeItem::OnValueChanging( CPropVariant& ) { 
  409.     return TRUE ;
  410. }
  411. inline void CPropertyTreeItem::OnValueChanged( const CPropVariant& ) {
  412. }
  413. inline int* CPropertyTreeItem::ChildSortDir()  { 
  414.     return m_iChildSortDir ;
  415. }
  416. inline BOOL CPropertyTreeItem::ChildSortPending() const { 
  417.     return FALSE ;
  418. }
  419. inline BOOL CPropertyTreeItem::DrawValueText() { 
  420.     return FALSE ;
  421. }
  423. #define ASSIGN_PROPITEM_TEXT(psz, i) 
  424.     if((psz)) lstrcpyn( m_szText[(i)], (psz), CCH_PROPERTY_TEXT ) ; 
  425.     else *m_szText[(i)] = (TCHAR)0
  427. inline void CPropertyTreeItem::SetName( LPCTSTR pszName )   { 
  428.     ASSIGN_PROPITEM_TEXT( pszName, iName ) ;
  429. }
  430. inline void CPropertyTreeItem::SetDisplayName( LPCTSTR pszDisplayName ) { 
  431.     ASSIGN_PROPITEM_TEXT( pszDisplayName, iDisplayName ) ;
  432. }
  433. inline void CPropertyTreeItem::SetDescription( LPCTSTR pszDescr )   { 
  434.     ASSIGN_PROPITEM_TEXT( pszDescr, iDescr ) ;
  435. }
  436. inline BOOL CPropertyTreeItem::IsMultiline() {
  437.     return FALSE ;
  438. }
  439. inline HRESULT CProperty::AddSelectionValue( const PROPVARIANT*, BSTR ) {
  440.     return S_OK ;
  441. }
  442. inline LONG CProperty::SelectionValueCount() const  {
  443.     return 0L ;
  444. }
  445. inline LPCTSTR CProperty::ValueTextFormat()    {
  446.     return NULL ;
  447. }
  448. inline ULONG CProperty::ValueTextFormatFlags() {
  449.     return 0L ;
  450. }
  451. inline LPCTSTR CProperty::ValueText()           { 
  452.     return m_pszValue ? m_pszValue : FormatValueText() ; 
  453. }
  455. #endif __TREEITEMS_H__