src/parsec/disk-image/parsec/parsec-benchmark/pkgs/tools/cmake/src/Source/MFCDialog/PropertyList.cpp - public/gem5-resources - Git at Google

 // PropertyList.cpp : implementation file
 //

 #include "stdafx.h"
 #include "shellapi.h"
 #include "CMakeSetup.h"
 #include "CMakeSetupDialog.h"
 #include "PathDialog.h"
 #include "../cmCacheManager.h"
 #include "../cmSystemTools.h"
 #include "../cmake.h"
 #define IDC_PROPCMBBOX   712
 #define IDC_PROPEDITBOX  713
 #define IDC_PROPBTNCTRL  714
 #define IDC_PROPCHECKBOXCTRL 715

 /////////////////////////////////////////////////////////////////////////////
 // CPropertyList

 CPropertyList::CPropertyList()
 {
   m_Dirty = false;
   m_ShowAdvanced = false;
   m_curSel = -1;
 }

 CPropertyList::~CPropertyList()
 {
   for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
       i != m_PropertyItems.end(); ++i)
     {
     delete *i;
     }
 }


 BEGIN_MESSAGE_MAP(CPropertyList, CListBox)
   //{{AFX_MSG_MAP(CPropertyList)
   ON_WM_CREATE()
   ON_WM_VSCROLL()
   ON_CONTROL_REFLECT(LBN_SELCHANGE, OnSelchange)
   ON_WM_LBUTTONUP()
   ON_WM_KILLFOCUS()
   ON_WM_LBUTTONDOWN()
   ON_WM_RBUTTONUP()
   ON_WM_MOUSEMOVE()
   //}}AFX_MSG_MAP
   ON_CBN_KILLFOCUS(IDC_PROPCMBBOX, OnKillfocusCmbBox)
   ON_CBN_SELCHANGE(IDC_PROPCMBBOX, OnSelchangeCmbBox)
   ON_EN_KILLFOCUS(IDC_PROPEDITBOX, OnKillfocusEditBox)
   ON_EN_CHANGE(IDC_PROPEDITBOX, OnChangeEditBox)
   ON_BN_CLICKED(IDC_PROPBTNCTRL, OnButton)
   ON_BN_CLICKED(IDC_PROPCHECKBOXCTRL, OnCheckBox)
   ON_COMMAND(42, OnDelete)
   ON_COMMAND(43, OnHelp)
   ON_COMMAND(44, OnIgnore)
 END_MESSAGE_MAP()

 /////////////////////////////////////////////////////////////////////////////
 // CPropertyList message handlers

 BOOL CPropertyList::PreCreateWindow(CREATESTRUCT& cs)
 {
   if (!CListBox::PreCreateWindow(cs))
     return FALSE;

   cs.style &= ~(LBS_OWNERDRAWVARIABLE | LBS_SORT);
   cs.style |= LBS_OWNERDRAWFIXED;

   m_bTracking = FALSE;
   m_nDivider = 0;
   m_bDivIsSet = FALSE;

   return TRUE;
 }

 void CPropertyList::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
 {
   lpMeasureItemStruct->itemHeight = 20; //pixels
 }


 void CPropertyList::DrawItem(LPDRAWITEMSTRUCT lpDIS)
 {
   CDC dc;
   dc.Attach(lpDIS->hDC);
   CRect rectFull = lpDIS->rcItem;
   CRect rect = rectFull;
   if (m_nDivider==0)
     m_nDivider = rect.Width() / 2;
   rect.left = m_nDivider;
   CRect rect2 = rectFull;
   rect2.right = rect.left - 1;
   UINT nIndex = lpDIS->itemID;

   if (nIndex != (UINT) -1)
     {
     //get the CPropertyItem for the current row
     CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(nIndex);
     //draw two rectangles, one for each row column
     if(pItem->m_NewValue)
       {
       dc.FillSolidRect(rect2,RGB(255,100, 100));
       }
     else
       {
       dc.FillSolidRect(rect2,RGB(192,192,192));
       }

     dc.DrawEdge(rect2,EDGE_SUNKEN,BF_BOTTOMRIGHT);
     dc.DrawEdge(rect,EDGE_SUNKEN,BF_BOTTOM);


     //write the property name in the first rectangle
     dc.SetBkMode(TRANSPARENT);
     dc.DrawText(pItem->m_propName,CRect(rect2.left+3,rect2.top+3,
                                         rect2.right-3,rect2.bottom+3),
                 DT_LEFT | DT_SINGLELINE);

     //write the initial property value in the second rectangle
     dc.DrawText(pItem->m_curValue,CRect(rect.left+3,rect.top+3,
                                         rect.right+3,rect.bottom+3),
                 DT_LEFT | DT_SINGLELINE);
     }
   dc.Detach();
 }

 int CPropertyList::AddItem(CString txt)
 {
   int nIndex = AddString(txt);
   return nIndex;
 }
 // order = 0 sorted
 // order = 1 add to top
 // order = 2 add to bottom
 int CPropertyList::AddPropItem(CPropertyItem* pItem, int order)
 {
   if(pItem->m_Advanced && ! m_ShowAdvanced)
     {
     m_PropertyItems.insert(pItem);
     return 0;
     }
   this->HideControls();
   int nIndex;
   if(order)
     {
     if(order == 1)
       {
       order = 0;
       }
     if(order == 2)
       {
       order = -1;
       }
     nIndex = InsertString(order, _T(""));
     }
   else
     {
     nIndex = AddString(pItem->m_propName);
     }
   SetItemDataPtr(nIndex,pItem);
   m_PropertyItems.insert(pItem);
   return nIndex;
 }

 void CPropertyList::AddProperty(const char* name,
                                 const char* value,
                                 const char* helpString,
                                 int type,
                                 const char* comboItems,
                                 bool reverseOrder,
                                 bool advanced)
 {
   CPropertyItem* pItem = 0;
   for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
       i != m_PropertyItems.end(); ++i)
     {
     CPropertyItem* item = *i;
     if(item->m_propName == name)
       {
       pItem = item;
       if(pItem->m_curValue != value)
         {
         pItem->m_curValue = value;
         pItem->m_HelpString = helpString;
         InvalidateList();
         }
       pItem->m_Advanced = advanced;
       return;
       }
     }
   // if it is not found, then create a new one
   if(!pItem)
     {
     pItem = new CPropertyItem(name, value, helpString, type, comboItems);
     pItem->m_NewValue = true;
     }
   pItem->m_Advanced = advanced;
   int order = 0;
   if(reverseOrder)
     {
     order = 1;
     }
   this->AddPropItem(pItem, order);
   return;
 }

 int CPropertyList::OnCreate(LPCREATESTRUCT lpCreateStruct)
 {
   if (CListBox::OnCreate(lpCreateStruct) == -1)
     return -1;

   m_bDivIsSet = FALSE;
   m_nDivider = 0;
   m_bTracking = FALSE;

   m_hCursorSize = AfxGetApp()->LoadStandardCursor(IDC_SIZEWE);
   m_hCursorArrow = AfxGetApp()->LoadStandardCursor(IDC_ARROW);

   m_SSerif8Font.CreatePointFont(80,_T("MS Sans Serif"));

   return 0;
 }

 void CPropertyList::OnSelchange()
 {
   CRect rect;
   CString lBoxSelText;

   GetItemRect(m_curSel,rect);
   rect.left = m_nDivider;

   CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);

   if (m_btnCtrl)
     m_btnCtrl.ShowWindow(SW_HIDE);
   if (m_CheckBoxControl)
     m_CheckBoxControl.ShowWindow(SW_HIDE);

   if (pItem->m_nItemType==CPropertyList::COMBO)
     {
     //display the combo box.  If the combo box has already been
     //created then simply move it to the new location, else create it
     m_nLastBox = 0;
     if (m_cmbBox)
       m_cmbBox.MoveWindow(rect);
     else
       {
       rect.bottom += 100;
       m_cmbBox.Create(CBS_DROPDOWNLIST
                       | CBS_NOINTEGRALHEIGHT | WS_VISIBLE
                       | WS_CHILD | WS_BORDER,
                       rect,this,IDC_PROPCMBBOX);
       m_cmbBox.SetFont(&m_SSerif8Font);
       }

     //add the choices for this particular property
     CString cmbItems = pItem->m_cmbItems;
     lBoxSelText = pItem->m_curValue;

     m_cmbBox.ResetContent();
     int i,i2;
     i=0;
     while ((i2=cmbItems.Find('|',i)) != -1)
       {
       m_cmbBox.AddString(cmbItems.Mid(i,i2-i));
       i=i2+1;
       }
     if(i != 0)
       m_cmbBox.AddString(cmbItems.Mid(i));

     m_cmbBox.ShowWindow(SW_SHOW);
     m_cmbBox.SetFocus();

     //jump to the property's current value in the combo box
     int j = m_cmbBox.FindStringExact(0,lBoxSelText);
     if (j != CB_ERR)
       m_cmbBox.SetCurSel(j);
     else
       m_cmbBox.SetCurSel(0);
     }
   else if (pItem->m_nItemType==CPropertyList::EDIT)
     {
     //display edit box
     m_nLastBox = 1;
     m_prevSel = m_curSel;
     rect.bottom -= 3;
     if (m_editBox)
       m_editBox.MoveWindow(rect);
     else
       {
       m_editBox.Create(ES_LEFT | ES_AUTOHSCROLL | WS_VISIBLE
                        | WS_CHILD | WS_BORDER,
                        rect,this,IDC_PROPEDITBOX);
       m_editBox.SetFont(&m_SSerif8Font);
       }

     lBoxSelText = pItem->m_curValue;

     m_editBox.ShowWindow(SW_SHOW);
     m_editBox.SetFocus();
     //set the text in the edit box to the property's current value
     m_editBox.SetWindowText(lBoxSelText);
     }
   else if (pItem->m_nItemType == CPropertyList::CHECKBOX)
     {
     rect.bottom -= 3;
     if (m_CheckBoxControl)
       m_CheckBoxControl.MoveWindow(rect);
     else
       {
       m_CheckBoxControl.Create("check",BS_CHECKBOX
                                | BM_SETCHECK |BS_LEFTTEXT
                                | WS_VISIBLE | WS_CHILD,
                                rect,this,IDC_PROPCHECKBOXCTRL);
       m_CheckBoxControl.SetFont(&m_SSerif8Font);
       }

     lBoxSelText = pItem->m_curValue;

     m_CheckBoxControl.ShowWindow(SW_SHOW);
     m_CheckBoxControl.SetFocus();
     //set the text in the edit box to the property's current value
     if(lBoxSelText == "ON")
       {
       m_CheckBoxControl.SetCheck(1);
       }
     else
       {
       m_CheckBoxControl.SetCheck(0);
       }
     }

   else
     {
     DisplayButton(rect);
     m_nLastBox = 1;
     m_prevSel = m_curSel;
     rect.bottom -= 3;
     rect.right -= 25;
     if (m_editBox)
       {
       m_editBox.MoveWindow(rect);
       }
     else
       {
       m_editBox.Create(ES_LEFT | ES_AUTOHSCROLL | WS_VISIBLE
                        | WS_CHILD | WS_BORDER,
                        rect,this,IDC_PROPEDITBOX);
       m_editBox.SetFont(&m_SSerif8Font);
       }

     lBoxSelText = pItem->m_curValue;

     m_editBox.ShowWindow(SW_SHOW);
     m_editBox.SetFocus();
     //set the text in the edit box to the property's current value
     m_editBox.SetWindowText(lBoxSelText);
     }
 }

 void CPropertyList::DisplayButton(CRect region)
 {
   //displays a button if the property is a file/color/font chooser
   m_nLastBox = 2;
   m_prevSel = m_curSel;

   if (region.Width() > 25)
     region.left = region.right - 25;
   region.bottom -= 3;

   if (m_btnCtrl)
     m_btnCtrl.MoveWindow(region);
   else
     {
     m_btnCtrl.Create("...",BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD,
                      region,this,IDC_PROPBTNCTRL);
     m_btnCtrl.SetFont(&m_SSerif8Font);
     }

   m_btnCtrl.ShowWindow(SW_SHOW);
   m_btnCtrl.SetFocus();
 }

 void CPropertyList::OnKillFocus(CWnd* pNewWnd)
 {
   //m_btnCtrl.ShowWindow(SW_HIDE);

   CListBox::OnKillFocus(pNewWnd);
 }

 void CPropertyList::OnKillfocusCmbBox()
 {
   m_cmbBox.ShowWindow(SW_HIDE);

   Invalidate();
 }

 void CPropertyList::OnKillfocusEditBox()
 {
   CString newStr;
   m_editBox.ShowWindow(SW_HIDE);

   Invalidate();
 }

 void CPropertyList::OnSelchangeCmbBox()
 {
   CString selStr;
   if (m_cmbBox)
     {
     m_cmbBox.GetLBText(m_cmbBox.GetCurSel(),selStr);
     CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
     pItem->m_curValue = selStr;
     m_Dirty = true;
     }
 }

 void CPropertyList::OnChangeEditBox()
 {
   CString newStr;
   m_editBox.GetWindowText(newStr);

   CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
   if(pItem->m_curValue != newStr)
     {
     pItem->m_curValue = newStr;
     m_Dirty = true;
     }
 }

 void CPropertyList::HideControls()
 {
   if(m_editBox)
     {
     m_editBox.ShowWindow(SW_HIDE);
     }
   if(m_cmbBox)
     {
     m_cmbBox.ShowWindow(SW_HIDE);
     }
   if(m_CheckBoxControl)
     {
     m_CheckBoxControl.ShowWindow(SW_HIDE);
     }
   if(m_btnCtrl)
     {
     m_btnCtrl.ShowWindow(SW_HIDE);
     }
 }

 void CPropertyList::OnVScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
 {
   this->HideControls();
   CListBox::OnVScroll(nSBCode, nPos, pScrollBar);
 }

 void CPropertyList::OnCheckBox()
 {
   CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
   if(m_CheckBoxControl.GetCheck())
     {
     pItem->m_curValue = "ON";
     }
   else
     {
     pItem->m_curValue = "OFF";
     }
   m_Dirty = true;
 }


 void CPropertyList::OnButton()
 {
   if(m_PropertyItems.size() == 0)
     {
     return;
     }

   CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);

   // The dialogs might change the working directory.  Save it.
   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();

   //display the appropriate common dialog depending on what type
   //of chooser is associated with the property

   if (pItem->m_nItemType == CPropertyList::FILE)
     {
     CString SelectedFile;
     CString Filter("All Files (*.*)||");

     CFileDialog FileDlg(TRUE, NULL, NULL, NULL,
                         Filter);
     CString initialDir;
     CString currPath = pItem->m_curValue;
     if (currPath.Right(9) == "-NOTFOUND" || currPath == "NOTFOUND")
       {
       currPath = "";
       }
     if (currPath.GetLength() > 0)
       {
       int endSlash = currPath.ReverseFind('\\');
       if(endSlash == -1)
         {
         endSlash = currPath.ReverseFind('/');
         }
       initialDir = currPath.Left(endSlash);
       }
     initialDir.Replace("/", "\\");
     FileDlg.m_ofn.lpstrTitle = "Select file";
     if (currPath.GetLength() > 0)
       FileDlg.m_ofn.lpstrInitialDir = initialDir;

     if(IDOK == FileDlg.DoModal())
       {
       SelectedFile = FileDlg.GetPathName();

       m_btnCtrl.ShowWindow(SW_HIDE);
       std::string path = SelectedFile;
       cmSystemTools::ConvertToUnixSlashes(path);
       pItem->m_curValue = path.c_str();
       m_Dirty = true;
       InvalidateList();
       }
     }
    else if (pItem->m_nItemType == CPropertyList::PATH)
     {
     CString initialDir = pItem->m_curValue;
     // convert back to windos style path
     initialDir.Replace("/", "\\");
     CString title = "Setting Cache Value: ";
     title += pItem->m_propName;
     CPathDialog dlg("Select Path", title, initialDir);
     if(dlg.DoModal()==IDOK)
       {
       CString SelectedFile = dlg.GetPathName();
       m_btnCtrl.ShowWindow(SW_HIDE);
       std::string path = SelectedFile;
       cmSystemTools::ConvertToUnixSlashes(path);
       pItem->m_curValue = path.c_str();
       m_Dirty = true;
       InvalidateList();
       }
     }

   cmSystemTools::ChangeDirectory(cwd.c_str());
 }

 void CPropertyList::OnLButtonUp(UINT nFlags, CPoint point)
 {
   if (m_bTracking)
     {
     //if columns were being resized then this indicates
     //that mouse is up so resizing is done.  Need to redraw
     //columns to reflect their new widths.

     m_bTracking = FALSE;
     //if mouse was captured then release it
     if (GetCapture()==this)
       ::ReleaseCapture();

     ::ClipCursor(NULL);

     CClientDC dc(this);
     InvertLine(&dc,CPoint(point.x,m_nDivTop),CPoint(point.x,m_nDivBtm));
     //set the divider position to the new value
     m_nDivider = point.x;

     //redraw
     Invalidate();
     }
   else
     {
     BOOL loc;
     int i = ItemFromPoint(point,loc);
     m_curSel = i;
     CListBox::OnLButtonUp(nFlags, point);
     }
 }

 void CPropertyList::OnLButtonDown(UINT nFlags, CPoint point)
 {
   if ((point.x>=m_nDivider-5) && (point.x<=m_nDivider+5))
     {
     //if mouse clicked on divider line, then start resizing

     ::SetCursor(m_hCursorSize);

     CRect windowRect;
     GetWindowRect(windowRect);
     windowRect.left += 10; windowRect.right -= 10;
     //do not let mouse leave the list box boundary
     ::ClipCursor(windowRect);

     if (m_cmbBox)
       m_cmbBox.ShowWindow(SW_HIDE);
     if (m_editBox)
       m_editBox.ShowWindow(SW_HIDE);

     CRect clientRect;
     GetClientRect(clientRect);

     m_bTracking = TRUE;
     m_nDivTop = clientRect.top;
     m_nDivBtm = clientRect.bottom;
     m_nOldDivX = point.x;

     CClientDC dc(this);
     InvertLine(&dc,CPoint(m_nOldDivX,m_nDivTop),CPoint(m_nOldDivX,m_nDivBtm));

     //capture the mouse
     SetCapture();
     }
   else
     {
     m_bTracking = FALSE;
     CListBox::OnLButtonDown(nFlags, point);
     }
 }

 void CPropertyList::OnMouseMove(UINT nFlags, CPoint point)
 {
   if (m_bTracking)
     {
     //move divider line to the mouse pos. if columns are
     //currently being resized
     CClientDC dc(this);
     //remove old divider line
     InvertLine(&dc,CPoint(m_nOldDivX,m_nDivTop),CPoint(m_nOldDivX,m_nDivBtm));
     //draw new divider line
     InvertLine(&dc,CPoint(point.x,m_nDivTop),CPoint(point.x,m_nDivBtm));
     m_nOldDivX = point.x;
     }
   else if ((point.x >= m_nDivider-5) && (point.x <= m_nDivider+5))
     //set the cursor to a sizing cursor if the cursor is over the row divider
     ::SetCursor(m_hCursorSize);
   else
     {
     BOOL loc;
     int curSel = ItemFromPoint(point,loc);
     if(!loc && curSel < 65535)
       {
       CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(curSel);
       m_CMakeSetupDialog->SetDlgItemText(IDC_PROGRESS, pItem->m_HelpString);
       }
     CListBox::OnMouseMove(nFlags, point);
     }

 }

 void CPropertyList::InvertLine(CDC* pDC,CPoint ptFrom,CPoint ptTo)
 {
   int nOldMode = pDC->SetROP2(R2_NOT);

   pDC->MoveTo(ptFrom);
   pDC->LineTo(ptTo);

   pDC->SetROP2(nOldMode);
 }

 void CPropertyList::PreSubclassWindow()
 {
   m_bDivIsSet = FALSE;
   m_nDivider = 0;
   m_bTracking = FALSE;
   m_curSel = 1;

   m_hCursorSize = AfxGetApp()->LoadStandardCursor(IDC_SIZEWE);
   m_hCursorArrow = AfxGetApp()->LoadStandardCursor(IDC_ARROW);

   m_SSerif8Font.CreatePointFont(80,_T("MS Sans Serif"));
 }

 CPropertyItem* CPropertyList::GetItem(int index)
 {
   return (CPropertyItem*)GetItemDataPtr(index);
 }

 void CPropertyList::OnRButtonUp( UINT /* nFlags */, CPoint point )
 {
   CMenu menu;
   CRect rect;
   this->GetWindowRect(&rect);
   BOOL loc;
   m_curSel = ItemFromPoint(point,loc);
   menu.CreatePopupMenu();
   menu.AppendMenu(MF_STRING | MF_ENABLED, 44, "Ignore Cache Entry");
   menu.AppendMenu(MF_STRING | MF_ENABLED, 42, "Delete Cache Entry");
   menu.AppendMenu(MF_STRING | MF_ENABLED, 43, "Help For Cache Entry");
   menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,
                       rect.TopLeft().x + point.x,
                       rect.TopLeft().y + point.y, this, NULL);
 }

 void CPropertyList::RemoveProperty(const char* name)
 {
   this->HideControls();
   for(int i =0; i < this->GetCount(); ++i)
     {
     CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(i);
     if(pItem->m_propName == name)
       {
       m_PropertyItems.erase(pItem);
       delete pItem;
       this->DeleteString(i);
       return;
       }
     }
 }

 void CPropertyList::OnIgnore()
 {
   if(m_curSel == -1 || this->GetCount() <= 0)
     {
     return;
     }
   CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
   pItem->m_curValue = "IGNORE";
   InvalidateList();
 }


 void CPropertyList::OnDelete()
 {
   if(m_curSel == -1 || this->GetCount() <= 0)
     {
     return;
     }
   CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
   m_CMakeSetupDialog->GetCMakeInstance()->GetCacheManager()->RemoveCacheEntry(pItem->m_propName);
   m_PropertyItems.erase(pItem);
   delete pItem;
   this->DeleteString(m_curSel);
   this->HideControls();
   this->SetTopIndex(0);
   InvalidateList();
   m_curSel += 1;
   if(m_curSel > this->GetCount())
     {
     m_curSel = this->GetCount();
     }
   this->SetCurSel(m_curSel);
 }

 void CPropertyList::OnHelp()
 {
   if(m_curSel == -1 || this->GetCount() <= 0)
     {
     return;
     }
   CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
   MessageBox(pItem->m_HelpString, pItem->m_propName, MB_OK|MB_ICONINFORMATION);
 }

 void CPropertyList::RemoveAll()
 {
   int c = this->GetCount();
   for(int i =0; i < c; ++i)
     {
     this->DeleteString(0);
     }
   for(std::set<CPropertyItem*>::iterator ii = m_PropertyItems.begin();
       ii != m_PropertyItems.end(); ++ii)
     {
     delete *ii;
     }
   m_PropertyItems.clear();
   m_Dirty = false;
   this->HideControls();
   InvalidateList();
 }

 void CPropertyList::InvalidateList()
 {
   Invalidate();
   m_Dirty = true;
 }

 void CPropertyList::ShowAdvanced()
 {
   this->SetRedraw(FALSE);
   this->ResetContent();
   m_ShowAdvanced = true;
   std::map<std::string, CPropertyItem*> sortProps;
   for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
       i != m_PropertyItems.end(); ++i)
     {
     sortProps[(const char*)(*i)->m_propName] = *i;
     }
   for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
       i != sortProps.end(); ++i)
     {
     CPropertyItem* item = i->second;
     if(item->m_NewValue)
       {
       this->AddPropItem(item, 2);
       }
     }
   for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
       i != sortProps.end(); ++i)
     {
     CPropertyItem* item = i->second;
     if(!item->m_NewValue)
       {
       this->AddPropItem(item, 2);
       }
     }
   this->SetRedraw(TRUE);
   this->InvalidateList();
 }


 void CPropertyList::HideAdvanced()
 {
   this->SetRedraw(FALSE);
   this->ResetContent();
   m_ShowAdvanced = false;
   std::map<std::string, CPropertyItem*> sortProps;
   for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
       i != m_PropertyItems.end(); ++i)
     {
     sortProps[(const char*)(*i)->m_propName] = *i;
     }
   for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
       i != sortProps.end(); ++i)
     {
     CPropertyItem* item = i->second;
     if(item->m_NewValue && !item->m_Advanced)
       {
       this->AddPropItem(item, 2);
       }
     }
   for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
       i != sortProps.end(); ++i)
     {
     CPropertyItem* item = i->second;
     if(!item->m_Advanced && !item->m_NewValue)
       {
       this->AddPropItem(item, 2);
       }
     }
   this->SetRedraw(TRUE);
   this->InvalidateList();
 }
	// PropertyList.cpp : implementation file
	//

	#include "stdafx.h"
	#include "shellapi.h"
	#include "CMakeSetup.h"
	#include "CMakeSetupDialog.h"
	#include "PathDialog.h"
	#include "../cmCacheManager.h"
	#include "../cmSystemTools.h"
	#include "../cmake.h"
	#define IDC_PROPCMBBOX 712
	#define IDC_PROPEDITBOX 713
	#define IDC_PROPBTNCTRL 714
	#define IDC_PROPCHECKBOXCTRL 715

	/////////////////////////////////////////////////////////////////////////////
	// CPropertyList

	CPropertyList::CPropertyList()
	{
	m_Dirty = false;
	m_ShowAdvanced = false;
	m_curSel = -1;
	}

	CPropertyList::~CPropertyList()
	{
	for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
	i != m_PropertyItems.end(); ++i)
	{
	delete *i;
	}
	}


	BEGIN_MESSAGE_MAP(CPropertyList, CListBox)
	//{{AFX_MSG_MAP(CPropertyList)
	ON_WM_CREATE()
	ON_WM_VSCROLL()
	ON_CONTROL_REFLECT(LBN_SELCHANGE, OnSelchange)
	ON_WM_LBUTTONUP()
	ON_WM_KILLFOCUS()
	ON_WM_LBUTTONDOWN()
	ON_WM_RBUTTONUP()
	ON_WM_MOUSEMOVE()
	//}}AFX_MSG_MAP
	ON_CBN_KILLFOCUS(IDC_PROPCMBBOX, OnKillfocusCmbBox)
	ON_CBN_SELCHANGE(IDC_PROPCMBBOX, OnSelchangeCmbBox)
	ON_EN_KILLFOCUS(IDC_PROPEDITBOX, OnKillfocusEditBox)
	ON_EN_CHANGE(IDC_PROPEDITBOX, OnChangeEditBox)
	ON_BN_CLICKED(IDC_PROPBTNCTRL, OnButton)
	ON_BN_CLICKED(IDC_PROPCHECKBOXCTRL, OnCheckBox)
	ON_COMMAND(42, OnDelete)
	ON_COMMAND(43, OnHelp)
	ON_COMMAND(44, OnIgnore)
	END_MESSAGE_MAP()

	/////////////////////////////////////////////////////////////////////////////
	// CPropertyList message handlers

	BOOL CPropertyList::PreCreateWindow(CREATESTRUCT& cs)
	{
	if (!CListBox::PreCreateWindow(cs))
	return FALSE;

	cs.style &= ~(LBS_OWNERDRAWVARIABLE \| LBS_SORT);
	cs.style \|= LBS_OWNERDRAWFIXED;

	m_bTracking = FALSE;
	m_nDivider = 0;
	m_bDivIsSet = FALSE;

	return TRUE;
	}

	void CPropertyList::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
	{
	lpMeasureItemStruct->itemHeight = 20; //pixels
	}


	void CPropertyList::DrawItem(LPDRAWITEMSTRUCT lpDIS)
	{
	CDC dc;
	dc.Attach(lpDIS->hDC);
	CRect rectFull = lpDIS->rcItem;
	CRect rect = rectFull;
	if (m_nDivider==0)
	m_nDivider = rect.Width() / 2;
	rect.left = m_nDivider;
	CRect rect2 = rectFull;
	rect2.right = rect.left - 1;
	UINT nIndex = lpDIS->itemID;

	if (nIndex != (UINT) -1)
	{
	//get the CPropertyItem for the current row
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(nIndex);
	//draw two rectangles, one for each row column
	if(pItem->m_NewValue)
	{
	dc.FillSolidRect(rect2,RGB(255,100, 100));
	}
	else
	{
	dc.FillSolidRect(rect2,RGB(192,192,192));
	}

	dc.DrawEdge(rect2,EDGE_SUNKEN,BF_BOTTOMRIGHT);
	dc.DrawEdge(rect,EDGE_SUNKEN,BF_BOTTOM);


	//write the property name in the first rectangle
	dc.SetBkMode(TRANSPARENT);
	dc.DrawText(pItem->m_propName,CRect(rect2.left+3,rect2.top+3,
	rect2.right-3,rect2.bottom+3),
	DT_LEFT \| DT_SINGLELINE);

	//write the initial property value in the second rectangle
	dc.DrawText(pItem->m_curValue,CRect(rect.left+3,rect.top+3,
	rect.right+3,rect.bottom+3),
	DT_LEFT \| DT_SINGLELINE);
	}
	dc.Detach();
	}

	int CPropertyList::AddItem(CString txt)
	{
	int nIndex = AddString(txt);
	return nIndex;
	}
	// order = 0 sorted
	// order = 1 add to top
	// order = 2 add to bottom
	int CPropertyList::AddPropItem(CPropertyItem* pItem, int order)
	{
	if(pItem->m_Advanced && ! m_ShowAdvanced)
	{
	m_PropertyItems.insert(pItem);
	return 0;
	}
	this->HideControls();
	int nIndex;
	if(order)
	{
	if(order == 1)
	{
	order = 0;
	}
	if(order == 2)
	{
	order = -1;
	}
	nIndex = InsertString(order, _T(""));
	}
	else
	{
	nIndex = AddString(pItem->m_propName);
	}
	SetItemDataPtr(nIndex,pItem);
	m_PropertyItems.insert(pItem);
	return nIndex;
	}

	void CPropertyList::AddProperty(const char* name,
	const char* value,
	const char* helpString,
	int type,
	const char* comboItems,
	bool reverseOrder,
	bool advanced)
	{
	CPropertyItem* pItem = 0;
	for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
	i != m_PropertyItems.end(); ++i)
	{
	CPropertyItem* item = *i;
	if(item->m_propName == name)
	{
	pItem = item;
	if(pItem->m_curValue != value)
	{
	pItem->m_curValue = value;
	pItem->m_HelpString = helpString;
	InvalidateList();
	}
	pItem->m_Advanced = advanced;
	return;
	}
	}
	// if it is not found, then create a new one
	if(!pItem)
	{
	pItem = new CPropertyItem(name, value, helpString, type, comboItems);
	pItem->m_NewValue = true;
	}
	pItem->m_Advanced = advanced;
	int order = 0;
	if(reverseOrder)
	{
	order = 1;
	}
	this->AddPropItem(pItem, order);
	return;
	}

	int CPropertyList::OnCreate(LPCREATESTRUCT lpCreateStruct)
	{
	if (CListBox::OnCreate(lpCreateStruct) == -1)
	return -1;

	m_bDivIsSet = FALSE;
	m_nDivider = 0;
	m_bTracking = FALSE;

	m_hCursorSize = AfxGetApp()->LoadStandardCursor(IDC_SIZEWE);
	m_hCursorArrow = AfxGetApp()->LoadStandardCursor(IDC_ARROW);

	m_SSerif8Font.CreatePointFont(80,_T("MS Sans Serif"));

	return 0;
	}

	void CPropertyList::OnSelchange()
	{
	CRect rect;
	CString lBoxSelText;

	GetItemRect(m_curSel,rect);
	rect.left = m_nDivider;

	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);

	if (m_btnCtrl)
	m_btnCtrl.ShowWindow(SW_HIDE);
	if (m_CheckBoxControl)
	m_CheckBoxControl.ShowWindow(SW_HIDE);

	if (pItem->m_nItemType==CPropertyList::COMBO)
	{
	//display the combo box. If the combo box has already been
	//created then simply move it to the new location, else create it
	m_nLastBox = 0;
	if (m_cmbBox)
	m_cmbBox.MoveWindow(rect);
	else
	{
	rect.bottom += 100;
	m_cmbBox.Create(CBS_DROPDOWNLIST
	\| CBS_NOINTEGRALHEIGHT \| WS_VISIBLE
	\| WS_CHILD \| WS_BORDER,
	rect,this,IDC_PROPCMBBOX);
	m_cmbBox.SetFont(&m_SSerif8Font);
	}

	//add the choices for this particular property
	CString cmbItems = pItem->m_cmbItems;
	lBoxSelText = pItem->m_curValue;

	m_cmbBox.ResetContent();
	int i,i2;
	i=0;
	while ((i2=cmbItems.Find('\|',i)) != -1)
	{
	m_cmbBox.AddString(cmbItems.Mid(i,i2-i));
	i=i2+1;
	}
	if(i != 0)
	m_cmbBox.AddString(cmbItems.Mid(i));

	m_cmbBox.ShowWindow(SW_SHOW);
	m_cmbBox.SetFocus();

	//jump to the property's current value in the combo box
	int j = m_cmbBox.FindStringExact(0,lBoxSelText);
	if (j != CB_ERR)
	m_cmbBox.SetCurSel(j);
	else
	m_cmbBox.SetCurSel(0);
	}
	else if (pItem->m_nItemType==CPropertyList::EDIT)
	{
	//display edit box
	m_nLastBox = 1;
	m_prevSel = m_curSel;
	rect.bottom -= 3;
	if (m_editBox)
	m_editBox.MoveWindow(rect);
	else
	{
	m_editBox.Create(ES_LEFT \| ES_AUTOHSCROLL \| WS_VISIBLE
	\| WS_CHILD \| WS_BORDER,
	rect,this,IDC_PROPEDITBOX);
	m_editBox.SetFont(&m_SSerif8Font);
	}

	lBoxSelText = pItem->m_curValue;

	m_editBox.ShowWindow(SW_SHOW);
	m_editBox.SetFocus();
	//set the text in the edit box to the property's current value
	m_editBox.SetWindowText(lBoxSelText);
	}
	else if (pItem->m_nItemType == CPropertyList::CHECKBOX)
	{
	rect.bottom -= 3;
	if (m_CheckBoxControl)
	m_CheckBoxControl.MoveWindow(rect);
	else
	{
	m_CheckBoxControl.Create("check",BS_CHECKBOX
	\| BM_SETCHECK \|BS_LEFTTEXT
	\| WS_VISIBLE \| WS_CHILD,
	rect,this,IDC_PROPCHECKBOXCTRL);
	m_CheckBoxControl.SetFont(&m_SSerif8Font);
	}

	lBoxSelText = pItem->m_curValue;

	m_CheckBoxControl.ShowWindow(SW_SHOW);
	m_CheckBoxControl.SetFocus();
	//set the text in the edit box to the property's current value
	if(lBoxSelText == "ON")
	{
	m_CheckBoxControl.SetCheck(1);
	}
	else
	{
	m_CheckBoxControl.SetCheck(0);
	}
	}

	else
	{
	DisplayButton(rect);
	m_nLastBox = 1;
	m_prevSel = m_curSel;
	rect.bottom -= 3;
	rect.right -= 25;
	if (m_editBox)
	{
	m_editBox.MoveWindow(rect);
	}
	else
	{
	m_editBox.Create(ES_LEFT \| ES_AUTOHSCROLL \| WS_VISIBLE
	\| WS_CHILD \| WS_BORDER,
	rect,this,IDC_PROPEDITBOX);
	m_editBox.SetFont(&m_SSerif8Font);
	}

	lBoxSelText = pItem->m_curValue;

	m_editBox.ShowWindow(SW_SHOW);
	m_editBox.SetFocus();
	//set the text in the edit box to the property's current value
	m_editBox.SetWindowText(lBoxSelText);
	}
	}

	void CPropertyList::DisplayButton(CRect region)
	{
	//displays a button if the property is a file/color/font chooser
	m_nLastBox = 2;
	m_prevSel = m_curSel;

	if (region.Width() > 25)
	region.left = region.right - 25;
	region.bottom -= 3;

	if (m_btnCtrl)
	m_btnCtrl.MoveWindow(region);
	else
	{
	m_btnCtrl.Create("...",BS_PUSHBUTTON \| WS_VISIBLE \| WS_CHILD,
	region,this,IDC_PROPBTNCTRL);
	m_btnCtrl.SetFont(&m_SSerif8Font);
	}

	m_btnCtrl.ShowWindow(SW_SHOW);
	m_btnCtrl.SetFocus();
	}

	void CPropertyList::OnKillFocus(CWnd* pNewWnd)
	{
	//m_btnCtrl.ShowWindow(SW_HIDE);

	CListBox::OnKillFocus(pNewWnd);
	}

	void CPropertyList::OnKillfocusCmbBox()
	{
	m_cmbBox.ShowWindow(SW_HIDE);

	Invalidate();
	}

	void CPropertyList::OnKillfocusEditBox()
	{
	CString newStr;
	m_editBox.ShowWindow(SW_HIDE);

	Invalidate();
	}

	void CPropertyList::OnSelchangeCmbBox()
	{
	CString selStr;
	if (m_cmbBox)
	{
	m_cmbBox.GetLBText(m_cmbBox.GetCurSel(),selStr);
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
	pItem->m_curValue = selStr;
	m_Dirty = true;
	}
	}

	void CPropertyList::OnChangeEditBox()
	{
	CString newStr;
	m_editBox.GetWindowText(newStr);

	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
	if(pItem->m_curValue != newStr)
	{
	pItem->m_curValue = newStr;
	m_Dirty = true;
	}
	}

	void CPropertyList::HideControls()
	{
	if(m_editBox)
	{
	m_editBox.ShowWindow(SW_HIDE);
	}
	if(m_cmbBox)
	{
	m_cmbBox.ShowWindow(SW_HIDE);
	}
	if(m_CheckBoxControl)
	{
	m_CheckBoxControl.ShowWindow(SW_HIDE);
	}
	if(m_btnCtrl)
	{
	m_btnCtrl.ShowWindow(SW_HIDE);
	}
	}

	void CPropertyList::OnVScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
	{
	this->HideControls();
	CListBox::OnVScroll(nSBCode, nPos, pScrollBar);
	}

	void CPropertyList::OnCheckBox()
	{
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
	if(m_CheckBoxControl.GetCheck())
	{
	pItem->m_curValue = "ON";
	}
	else
	{
	pItem->m_curValue = "OFF";
	}
	m_Dirty = true;
	}


	void CPropertyList::OnButton()
	{
	if(m_PropertyItems.size() == 0)
	{
	return;
	}

	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);

	// The dialogs might change the working directory. Save it.
	std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();

	//display the appropriate common dialog depending on what type
	//of chooser is associated with the property

	if (pItem->m_nItemType == CPropertyList::FILE)
	{
	CString SelectedFile;
	CString Filter("All Files (.)\|\|");

	CFileDialog FileDlg(TRUE, NULL, NULL, NULL,
	Filter);
	CString initialDir;
	CString currPath = pItem->m_curValue;
	if (currPath.Right(9) == "-NOTFOUND" \|\| currPath == "NOTFOUND")
	{
	currPath = "";
	}
	if (currPath.GetLength() > 0)
	{
	int endSlash = currPath.ReverseFind('\\');
	if(endSlash == -1)
	{
	endSlash = currPath.ReverseFind('/');
	}
	initialDir = currPath.Left(endSlash);
	}
	initialDir.Replace("/", "\\");
	FileDlg.m_ofn.lpstrTitle = "Select file";
	if (currPath.GetLength() > 0)
	FileDlg.m_ofn.lpstrInitialDir = initialDir;

	if(IDOK == FileDlg.DoModal())
	{
	SelectedFile = FileDlg.GetPathName();

	m_btnCtrl.ShowWindow(SW_HIDE);
	std::string path = SelectedFile;
	cmSystemTools::ConvertToUnixSlashes(path);
	pItem->m_curValue = path.c_str();
	m_Dirty = true;
	InvalidateList();
	}
	}
	else if (pItem->m_nItemType == CPropertyList::PATH)
	{
	CString initialDir = pItem->m_curValue;
	// convert back to windos style path
	initialDir.Replace("/", "\\");
	CString title = "Setting Cache Value: ";
	title += pItem->m_propName;
	CPathDialog dlg("Select Path", title, initialDir);
	if(dlg.DoModal()==IDOK)
	{
	CString SelectedFile = dlg.GetPathName();
	m_btnCtrl.ShowWindow(SW_HIDE);
	std::string path = SelectedFile;
	cmSystemTools::ConvertToUnixSlashes(path);
	pItem->m_curValue = path.c_str();
	m_Dirty = true;
	InvalidateList();
	}
	}

	cmSystemTools::ChangeDirectory(cwd.c_str());
	}

	void CPropertyList::OnLButtonUp(UINT nFlags, CPoint point)
	{
	if (m_bTracking)
	{
	//if columns were being resized then this indicates
	//that mouse is up so resizing is done. Need to redraw
	//columns to reflect their new widths.

	m_bTracking = FALSE;
	//if mouse was captured then release it
	if (GetCapture()==this)
	::ReleaseCapture();

	::ClipCursor(NULL);

	CClientDC dc(this);
	InvertLine(&dc,CPoint(point.x,m_nDivTop),CPoint(point.x,m_nDivBtm));
	//set the divider position to the new value
	m_nDivider = point.x;

	//redraw
	Invalidate();
	}
	else
	{
	BOOL loc;
	int i = ItemFromPoint(point,loc);
	m_curSel = i;
	CListBox::OnLButtonUp(nFlags, point);
	}
	}

	void CPropertyList::OnLButtonDown(UINT nFlags, CPoint point)
	{
	if ((point.x>=m_nDivider-5) && (point.x<=m_nDivider+5))
	{
	//if mouse clicked on divider line, then start resizing

	::SetCursor(m_hCursorSize);

	CRect windowRect;
	GetWindowRect(windowRect);
	windowRect.left += 10; windowRect.right -= 10;
	//do not let mouse leave the list box boundary
	::ClipCursor(windowRect);

	if (m_cmbBox)
	m_cmbBox.ShowWindow(SW_HIDE);
	if (m_editBox)
	m_editBox.ShowWindow(SW_HIDE);

	CRect clientRect;
	GetClientRect(clientRect);

	m_bTracking = TRUE;
	m_nDivTop = clientRect.top;
	m_nDivBtm = clientRect.bottom;
	m_nOldDivX = point.x;

	CClientDC dc(this);
	InvertLine(&dc,CPoint(m_nOldDivX,m_nDivTop),CPoint(m_nOldDivX,m_nDivBtm));

	//capture the mouse
	SetCapture();
	}
	else
	{
	m_bTracking = FALSE;
	CListBox::OnLButtonDown(nFlags, point);
	}
	}

	void CPropertyList::OnMouseMove(UINT nFlags, CPoint point)
	{
	if (m_bTracking)
	{
	//move divider line to the mouse pos. if columns are
	//currently being resized
	CClientDC dc(this);
	//remove old divider line
	InvertLine(&dc,CPoint(m_nOldDivX,m_nDivTop),CPoint(m_nOldDivX,m_nDivBtm));
	//draw new divider line
	InvertLine(&dc,CPoint(point.x,m_nDivTop),CPoint(point.x,m_nDivBtm));
	m_nOldDivX = point.x;
	}
	else if ((point.x >= m_nDivider-5) && (point.x <= m_nDivider+5))
	//set the cursor to a sizing cursor if the cursor is over the row divider
	::SetCursor(m_hCursorSize);
	else
	{
	BOOL loc;
	int curSel = ItemFromPoint(point,loc);
	if(!loc && curSel < 65535)
	{
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(curSel);
	m_CMakeSetupDialog->SetDlgItemText(IDC_PROGRESS, pItem->m_HelpString);
	}
	CListBox::OnMouseMove(nFlags, point);
	}

	}

	void CPropertyList::InvertLine(CDC* pDC,CPoint ptFrom,CPoint ptTo)
	{
	int nOldMode = pDC->SetROP2(R2_NOT);

	pDC->MoveTo(ptFrom);
	pDC->LineTo(ptTo);

	pDC->SetROP2(nOldMode);
	}

	void CPropertyList::PreSubclassWindow()
	{
	m_bDivIsSet = FALSE;
	m_nDivider = 0;
	m_bTracking = FALSE;
	m_curSel = 1;

	m_hCursorSize = AfxGetApp()->LoadStandardCursor(IDC_SIZEWE);
	m_hCursorArrow = AfxGetApp()->LoadStandardCursor(IDC_ARROW);

	m_SSerif8Font.CreatePointFont(80,_T("MS Sans Serif"));
	}

	CPropertyItem* CPropertyList::GetItem(int index)
	{
	return (CPropertyItem*)GetItemDataPtr(index);
	}

	void CPropertyList::OnRButtonUp( UINT /* nFlags */, CPoint point )
	{
	CMenu menu;
	CRect rect;
	this->GetWindowRect(&rect);
	BOOL loc;
	m_curSel = ItemFromPoint(point,loc);
	menu.CreatePopupMenu();
	menu.AppendMenu(MF_STRING \| MF_ENABLED, 44, "Ignore Cache Entry");
	menu.AppendMenu(MF_STRING \| MF_ENABLED, 42, "Delete Cache Entry");
	menu.AppendMenu(MF_STRING \| MF_ENABLED, 43, "Help For Cache Entry");
	menu.TrackPopupMenu(TPM_LEFTALIGN \| TPM_RIGHTBUTTON,
	rect.TopLeft().x + point.x,
	rect.TopLeft().y + point.y, this, NULL);
	}

	void CPropertyList::RemoveProperty(const char* name)
	{
	this->HideControls();
	for(int i =0; i < this->GetCount(); ++i)
	{
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(i);
	if(pItem->m_propName == name)
	{
	m_PropertyItems.erase(pItem);
	delete pItem;
	this->DeleteString(i);
	return;
	}
	}
	}

	void CPropertyList::OnIgnore()
	{
	if(m_curSel == -1 \|\| this->GetCount() <= 0)
	{
	return;
	}
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
	pItem->m_curValue = "IGNORE";
	InvalidateList();
	}



	void CPropertyList::OnDelete()
	{
	if(m_curSel == -1 \|\| this->GetCount() <= 0)
	{
	return;
	}
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
	m_CMakeSetupDialog->GetCMakeInstance()->GetCacheManager()->RemoveCacheEntry(pItem->m_propName);
	m_PropertyItems.erase(pItem);
	delete pItem;
	this->DeleteString(m_curSel);
	this->HideControls();
	this->SetTopIndex(0);
	InvalidateList();
	m_curSel += 1;
	if(m_curSel > this->GetCount())
	{
	m_curSel = this->GetCount();
	}
	this->SetCurSel(m_curSel);
	}

	void CPropertyList::OnHelp()
	{
	if(m_curSel == -1 \|\| this->GetCount() <= 0)
	{
	return;
	}
	CPropertyItem* pItem = (CPropertyItem*) GetItemDataPtr(m_curSel);
	MessageBox(pItem->m_HelpString, pItem->m_propName, MB_OK\|MB_ICONINFORMATION);
	}

	void CPropertyList::RemoveAll()
	{
	int c = this->GetCount();
	for(int i =0; i < c; ++i)
	{
	this->DeleteString(0);
	}
	for(std::set<CPropertyItem*>::iterator ii = m_PropertyItems.begin();
	ii != m_PropertyItems.end(); ++ii)
	{
	delete *ii;
	}
	m_PropertyItems.clear();
	m_Dirty = false;
	this->HideControls();
	InvalidateList();
	}

	void CPropertyList::InvalidateList()
	{
	Invalidate();
	m_Dirty = true;
	}

	void CPropertyList::ShowAdvanced()
	{
	this->SetRedraw(FALSE);
	this->ResetContent();
	m_ShowAdvanced = true;
	std::map<std::string, CPropertyItem*> sortProps;
	for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
	i != m_PropertyItems.end(); ++i)
	{
	sortProps[(const char)(i)->m_propName] = *i;
	}
	for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
	i != sortProps.end(); ++i)
	{
	CPropertyItem* item = i->second;
	if(item->m_NewValue)
	{
	this->AddPropItem(item, 2);
	}
	}
	for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
	i != sortProps.end(); ++i)
	{
	CPropertyItem* item = i->second;
	if(!item->m_NewValue)
	{
	this->AddPropItem(item, 2);
	}
	}
	this->SetRedraw(TRUE);
	this->InvalidateList();
	}


	void CPropertyList::HideAdvanced()
	{
	this->SetRedraw(FALSE);
	this->ResetContent();
	m_ShowAdvanced = false;
	std::map<std::string, CPropertyItem*> sortProps;
	for(std::set<CPropertyItem*>::iterator i = m_PropertyItems.begin();
	i != m_PropertyItems.end(); ++i)
	{
	sortProps[(const char)(i)->m_propName] = *i;
	}
	for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
	i != sortProps.end(); ++i)
	{
	CPropertyItem* item = i->second;
	if(item->m_NewValue && !item->m_Advanced)
	{
	this->AddPropItem(item, 2);
	}
	}
	for(std::map<std::string, CPropertyItem*>::iterator i = sortProps.begin();
	i != sortProps.end(); ++i)
	{
	CPropertyItem* item = i->second;
	if(!item->m_Advanced && !item->m_NewValue)
	{
	this->AddPropItem(item, 2);
	}
	}
	this->SetRedraw(TRUE);
	this->InvalidateList();
	}