}
   BOOL SetItemValue(HPROPERTY prop, VARIANT* pValue)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(prop);
      ATLASSERT(pValue);
      if( prop == NULL || pValue == NULL ) return FALSE;
      // Assign value and repaint
      BOOL bRes = prop->SetValue(*pValue);
      // Thanks to Daniel Bowen for fixing the recreation of inplace editor here.
      int idx = FindProperty(prop);
      if( idx >= 0 ) {
         InvalidateItem(idx);
         if( idx == m_iInplaceIndex ) _SpawnInplaceWindow(prop, m_iInplaceIndex);
      }
      return bRes;
   }
   LPARAM GetItemData(HPROPERTY prop) const
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(prop);
      if( prop == NULL ) return 0;
      return prop->GetItemData();
   }
   void SetItemData(HPROPERTY prop, LPARAM dwData)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(prop);
      if( prop == NULL ) return;
      prop->SetItemData(dwData);
   }
   BOOL GetItemEnabled(HPROPERTY prop) const
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(prop);
      if( prop == NULL ) return FALSE;
      return prop->IsEnabled();
   }
   void SetItemEnabled(HPROPERTY prop, BOOL bEnable)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(prop);
      if( prop == NULL ) return;
      prop->SetEnabled(bEnable);
      InvalidateItem(FindProperty(prop));
   }
   BOOL ExpandItem(HPROPERTY prop)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(prop);
      if( prop == NULL ) return FALSE;
      if( prop->GetKind() != PROPKIND_CATEGORY ) return FALSE;
      CCategoryProperty* pCategory = static_cast<CCategoryProperty*>(prop);
      if( pCategory->Expand(FindProperty(prop)) ) {
         // Let owner know
         NMPROPERTYITEM nmh = { m_hWnd, GetDlgCtrlID(), PIN_EXPANDING, prop };
         ::SendMessage(GetParent(), WM_NOTIFY, nmh.hdr.idFrom, (LPARAM) &nmh);
      }
      return TRUE;
   }
   BOOL CollapseItem(HPROPERTY prop)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      ATLASSERT(prop);
      if( prop == NULL ) return FALSE;
      if( prop->GetKind() != PROPKIND_CATEGORY ) return FALSE;
      // Destroy in-place window
      _DestroyInplaceWindow(); 
      // Let property do actual collapse
      CCategoryProperty* pCategory = static_cast<CCategoryProperty*>(prop);
      if( pCategory->Collapse(FindProperty(prop)) ) {
         // Let owner know
         NMPROPERTYITEM nmh = { m_hWnd, GetDlgCtrlID(), PIN_COLLAPSING, prop };
         ::SendMessage(GetParent(), WM_NOTIFY, nmh.hdr.idFrom, (LPARAM) &nmh);
      }
      return TRUE;
   }
   int GetColumnWidth() const
   {
      return m_iMiddle;
   }
   void SetColumnWidth(int iWidth)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      m_iMiddle = iWidth;
      m_bColumnFixed = true;
      Invalidate();
   }
   void InvalidateItem(int idx)
   {
      ATLASSERT(::IsWindow(m_hWnd));
      if( idx == -1 ) return;
      RECT rc;
      GetItemRect(idx, &rc);
      InvalidateRect(&rc);
   }

   // Unsupported methods

   int AddString(LPCTSTR /*lpszItem*/)
   {
      ATLASSERT(false);
      return LB_ERR;
   }
   int InsertString(int /*nIndex*/, LPCTSTR /*lpszItem*/)
   {
      ATLASSERT(false);
      return LB_ERR;
   }
   int DeleteString(UINT /*nIndex*/)
   {
      ATLASSERT(false);
      return LB_ERR;
   }

   // Implementation

   void _Init()
   {
      ATLASSERT(::IsWindow(m_hWnd));
      // Needs LBS_OWNERDRAWVARIABLE and LBS_NOTIFY flags,
      // but don't want multiselect or multicolumn flags.
      ATLASSERT(GetStyle() & LBS_OWNERDRAWVARIABLE);
      ATLASSERT(GetStyle() & LBS_NOTIFY);
      ATLASSERT((GetStyle() & (LBS_MULTIPLESEL|LBS_NODATA|LBS_MULTICOLUMN))==0);
      SendMessage(WM_SIZE);
      SendMessage(WM_SETTINGCHANGE);
   }
   void _GetInPlaceRect(int idx, RECT& rc) const
   {
      GetItemRect(idx, &rc);
      if( m_dwExtStyle & PLS_EX_CATEGORIZED ) rc.left += CATEGORY_INDENT;
      rc.left += m_iMiddle + 1;
   }
   BOOL _SpawnInplaceWindow(IProperty* prop, int idx)
   {
      ATLASSERT(prop);
      // Destroy old editor
      _DestroyInplaceWindow();
      // Do we need an editor here?
      if( idx == -1 || idx != GetCurSel() ) return FALSE;
      if( !prop->IsEnabled() ) return FALSE;
      // Create a new editor window
      RECT rcValue;
      _GetInPlaceRect(idx, rcValue);
      ::InflateRect(&rcValue, 0, -1);
      m_hwndInplace = prop->CreateInplaceControl(m_hWnd, rcValue);
      if( m_hwndInplace != NULL ) {
         // Activate the new editor window
         ATLASSERT(::IsWindow(m_hwndInplace));
         // The similar VB6 IDE control doesn't immediately set focus to the new editor window.
         // One must click on the item again. So we added the SWP_NOACTIVATE flag to 
         // simulate this behaviour.
         ::SetWindowPos(m_hwndInplace, HWND_TOP, 0,0,0,0, SWP_SHOWWINDOW | SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);
         m_iInplaceIndex = idx;
      }
      return m_hwndInplace != NULL;
   }
   void _DestroyInplaceWindow()
   {
      if( m_hwndInplace && ::IsWindow(m_hwndInplace) ) {
         IProperty* prop = reinterpret_cast<IProperty*>(TBase::GetItemData(m_iInplaceIndex));
         ATLASSERT(prop);
         BYTE bKind = prop->GetKind();
         // Set focus back to our control
         if( GetFocus() != m_hWnd && IsChild(GetFocus()) ) SetFocus();
         // Destroy control
         switch( bKind ) {
         case PROPKIND_CONTROL:
            ::DestroyWindow(m_hwndInplace);
            break;
         default:
            ::PostMessage(m_hwndInplace, WM_CLOSE, 0,0);
         }
      }
      m_hwndInplace = NULL;
      m_iInplaceIndex = -1;
   }
   void _DrawGhostBar(int x)
   {
      if( m_iPrevious == 0 ) return;
      // PatBlt without clip children on
      CWindow wndParent = GetParent();
      DWORD dwOldStyle = wndParent.GetWindowLong(GWL_STYLE);
      wndParent.SetWindowLong(GWL_STYLE, dwOldStyle & ~WS_CLIPCHILDREN);
      
      RECT rcClient = { 0 };
      GetClientRect(&rcClient);
      rcClient.left = x;
      rcClient.right = x + 1;     
      MapWindowPoints(wndParent, &rcClient);

      // Invert the brush pattern (looks just like frame window sizing)
      CClientDC dc = wndParent;
      CBrush hbrHalfTone = CDCHandle::GetHalftoneBrush();
      HBRUSH hOldBrush = NULL;
      if( hbrHalfTone != NULL ) hOldBrush = dc.SelectBrush(hbrHalfTone);

      dc.PatBlt(rcClient.left, rcClient.top, 2, rcClient.bottom - rcClient.top, PATINVERT);

      dc.SelectBrush(hOldBrush);
      wndParent.SetWindowLong(GWL_STYLE, dwOldStyle);
   }
   long _GetDragPos(int x) const
   {
      RECT rcClient;
      GetClientRect(&rcClient);
      ::InflateRect(&rcClient, -10, 0);
      if( x > rcClient.right ) x = rcClient.right;
      if( x < rcClient.left ) x = rcClient.left;
      return x;
   }

   // Message map and handlers
   
   BEGIN_MSG_MAP(CPropertyListImpl)
      MESSAGE_HANDLER(WM_CREATE, OnCreate)
      MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
      MESSAGE_HANDLER(WM_SIZE, OnSize)
      MESSAGE_HANDLER(WM_VSCROLL, OnScroll)
      MESSAGE_HANDLER(WM_HSCROLL, OnScroll)
      MESSAGE_HANDLER(WM_MOUSEWHEEL, OnScroll)      
      MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown)
      MESSAGE_HANDLER(WM_CHAR, OnChar)
      MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
      MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
      MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
      MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnDblClick)
      MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
      MESSAGE_HANDLER(WM_SETCURSOR, OnSetCursor);
      MESSAGE_HANDLER(WM_USER_PROP_NAVIGATE, OnNavigate);
      MESSAGE_HANDLER(WM_USER_PROP_UPDATEPROPERTY, OnUpdateProperty);
      MESSAGE_HANDLER(WM_USER_PROP_CANCELPROPERTY, OnCancelProperty);
      MESSAGE_HANDLER(WM_USER_PROP_CHANGEDPROPERTY, OnChangedProperty);
      MESSAGE_HANDLER(WM_USER_PROP_EXPAND, OnExpand);
      MESSAGE_HANDLER(WM_USER_PROP_COLLAPSE, OnCollapse);
      REFLECTED_COMMAND_CODE_HANDLER(LBN_SELCHANGE, OnSelChange)
      CHAIN_MSG_MAP_ALT(COwnerDraw<CPropertyListImpl>, 1)
      DEFAULT_REFLECTION_HANDLER()
   END_MSG_MAP()

   LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
   {
      LRESULT lRes = DefWindowProc(uMsg, wParam, lParam);
      _Init();
      return lRes;
   }
   LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
   {
      ResetContent(); // Make sure to delete editor and item-data memory
      return 0;
   }
   LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
   {      
      // Size handler supplied by DJ (thank to this masked site reader)
      _DestroyInplaceWindow();
      // Calculate drag
      RECT rc;
      GetClientRect(&rc);
      if( !m_bColumnFixed ) m_iMiddle = (rc.right - rc.left) / 2;
      m_iPrevious = 0;
      BOOL bDummy;
      OnSelChange(0, 0, 0, bDummy);
      //
      bHandled = FALSE;
      return 0;
   }
   LRESULT OnScroll(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
   {      
      _DestroyInplaceWindow();
      bHandled = FALSE;
      return 0;
   }
   LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
   {
      switch( LOWORD(wParam) ) {
      case VK_TAB:
         {
            int idx = GetCurSel();
            if( idx != -1 ) {
               IProperty* prop = reinterpret_cast<IProperty*>(TBase::GetItemData(idx));
               ATLASSERT(prop);
               prop->Activate(PACT_TAB, 0);
            }
         }
         break;
      case VK_F2:
      case VK_SPACE:
         {
            int idx = GetCurSel();
            if( idx != -1 ) {
               IProperty* prop = reinterpret_cast<IProperty*>(TBase::GetItemData(idx));
               ATLASSERT(prop);
               if( prop->IsEnabled() ) prop->Activate(PACT_SPACE, 0);
            }
         }
         break;
      }
      bHandled = FALSE;
      return 0;
   }
   LRESULT OnChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
   {      
      // If the user is typeing stuff, we should spawn an editor right away
      // and simulate the keypress in the editor-window...
      if( wParam > _T(' ') ) {
         int idx = GetCurSel();
         if( idx != -1 ) {
            IProperty* prop = reinterpret_cast<IProperty*>(TBase::GetItemData(idx));
            ATLASSERT(prop);
            if( prop->IsEnabled() ) {
               if( _SpawnInplaceWindow(prop, idx) ) {
                  prop->Activate(PACT_SPACE, 0);
                  // Simulate typing in the inplace editor...
                  ::SendMessage(m_hwndInplace, WM_CHAR, wParam, 1L);
               }
            }
         }
         return 0;
      }
      // Kill the nasty BEEP sound!
      if( wParam == _T(' ') ) return 0;
      bHandled = FALSE;
      return 0;
   }
   LRESULT OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
   {
      if( ::GetFocus() != m_hWnd ) SetFocus();

      LRESULT lRes = DefWindowProc(uMsg, wParam, lParam);
        
      // Should we do some column resize?
      // NOTE: Apparently the ListBox control will internally do SetCapture() to
      //       capture all mouse-movements.
      m_iPrevious = 0;
      int iIndent = m_dwExtStyle & PLS_EX_CATEGORIZED ? CATEGORY_INDENT : 0;
      if( (m_dwExtStyle & PLS_EX_NOCOLUMNRESIZE) == 0 &&
          GET_X_LPARAM(lParam) == m_iMiddle + iIndent ) 
      {
         m_iPrevious = GET_X_LPARAM(lParam);
      }

      int idx = GetCurSel();
      if( idx != -1 ) {
         IProperty* prop = reinterpret_cast<IProperty*>(TBase::GetItemData(idx));
         ATLASSERT(prop);
         // Ask owner first
         NMPROPERTYITEM nmh = { m_hWnd, GetDlgCtrlID(), PIN_CLICK, prop };
         if( ::SendMessage(GetParent(), WM_NOTIFY, nmh.hdr.idFrom, (LPARAM) &nmh) == 0 ) {
            // Translate into action