home *** CD-ROM | disk | FTP | other *** search
/ CD/PC Actual 76 / DVD Actual 1 Marzo 2003.iso / Trial / TurboCAD 7.1 Pro / Data.Cab / F24360_PropDialog.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-11-10  |  14.9 KB  |  631 lines
  1. // PropDialog.cpp : implementation file
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include "LTSample.h"
  6. #include "PropDialog.h"
  7. #include "PropModify.h"
  8. #include "AddProperty.h"
  9.  
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif
  15.  
  16. CString VariantToText(VARIANT *pvarVal, UINT IDS_ARRAY)
  17. {
  18.     CString cstrText;
  19.     if (pvarVal != NULL)
  20.     {
  21.         
  22.         switch (pvarVal->vt)
  23.         {
  24.             case VT_EMPTY:
  25.                 cstrText = "Empty";
  26.             break;
  27.             case VT_I2:
  28.                 cstrText.Format("%#X", pvarVal->iVal);
  29.             break;
  30.             case VT_I4:
  31.                 cstrText.Format("%#X", pvarVal->lVal);
  32.             break;
  33.             case VT_R4:
  34.                 cstrText.Format("%f", pvarVal->fltVal);
  35.             break;
  36.             case VT_R8:
  37.                 cstrText.Format("%f", pvarVal->dblVal);
  38.             break;    
  39.             case VT_CY:
  40.             {
  41.                 COleCurrency currency((const VARIANT&)pvarVal);
  42.                 cstrText = currency.Format();
  43.             }
  44.             break;
  45.             case VT_DATE:
  46.             {
  47.                 COleDateTime time((const VARIANT&)pvarVal);
  48.                 cstrText = time.Format();
  49.             }
  50.             break;
  51.             case VT_BSTR:
  52.                 cstrText = pvarVal->bstrVal;
  53. //                ::SysFreeString(pvarVal->bstrVal);
  54.             break;
  55.             case VT_BOOL:
  56.                 cstrText = pvarVal->bVal ? "TRUE" : "FALSE";
  57.             break;
  58.             case VT_ARRAY | VT_I2:
  59.             case VT_ARRAY | VT_I4:
  60.             case VT_ARRAY | VT_R4:
  61.             case VT_ARRAY | VT_R8:
  62.             case VT_ARRAY | VT_CY:
  63.             case VT_ARRAY | VT_DATE:
  64.             case VT_ARRAY | VT_BSTR:
  65.             case VT_ARRAY | VT_BOOL:
  66.                 cstrText.LoadString(IDS_ARRAY);
  67.             break;
  68.             default:
  69.                 cstrText = "Unknown type";
  70.         }
  71.     }
  72.     return cstrText;
  73. }
  74.  
  75. void TextToVariant(CString& cstrText, VARIANT *pvarVal, VARTYPE vt)
  76. {
  77.     if (pvarVal != NULL)
  78.     {
  79.         ::VariantInit(pvarVal);
  80.         switch (vt)
  81.         {
  82.             case VT_I2:
  83.                 pvarVal->vt = vt;
  84.                 pvarVal->iVal = atoi(cstrText);
  85.             break;
  86.             case VT_I4:
  87.                 pvarVal->vt = vt;
  88.                 pvarVal->lVal = atol(cstrText);
  89.             break;
  90.             case VT_R4:
  91.                 pvarVal->vt = vt;
  92.                 pvarVal->fltVal = (float)atof(cstrText);
  93.             break;
  94.             case VT_R8:
  95.                 pvarVal->vt = vt;
  96.                 pvarVal->dblVal = atof(cstrText);
  97.             break;    
  98.             case VT_CY:
  99.             {
  100.                 COleCurrency currency;
  101.                 if (currency.ParseCurrency(cstrText))
  102.                 {
  103.                     pvarVal->vt = vt;
  104.                     pvarVal->cyVal = currency;
  105.                 }
  106.             }
  107.             break;
  108.             case VT_DATE:
  109.             {
  110.                 COleDateTime time;
  111.                 if (time.ParseDateTime(cstrText));
  112.                 {
  113.                     pvarVal->vt = vt;
  114.                     pvarVal->date = time;
  115.                 }
  116.             }
  117.             break;
  118.             case VT_BSTR:
  119.                 pvarVal->vt = vt;
  120.                 pvarVal->bstrVal = cstrText.AllocSysString();
  121.             break;
  122.             case VT_BOOL:
  123.                 if (cstrText.CompareNoCase("True"))
  124.                 {
  125.                     pvarVal->vt = vt;
  126.                     pvarVal->bVal = TRUE;
  127.                 }
  128.                 else if (cstrText.CompareNoCase("False"))
  129.                 {
  130.                     pvarVal->vt = vt;
  131.                     pvarVal->bVal = FALSE;
  132.                 }
  133.             break;
  134.         }
  135.     }
  136. }
  137.  
  138. CString VartypeToText(SHORT vt)
  139. {
  140.     CString cstrText;
  141.     SHORT vtL = vt & 0x0FFF;
  142.     SHORT vtH = vt & 0xF000;
  143.  
  144.     switch (vtH)
  145.     {
  146.         case VT_RESERVED:
  147.             cstrText = "VT_RESERVED";
  148.         break;
  149.         case VT_BYREF:
  150.             cstrText = "VT_BYREF";
  151.         break;
  152.         case VT_ARRAY:
  153.             cstrText = "VT_ARRAY";
  154.         break;
  155.     }
  156.  
  157.     if (!cstrText.IsEmpty())
  158.         cstrText += " | ";
  159.  
  160.     switch (vtL)
  161.     {
  162.         case VT_EMPTY:
  163.             cstrText += "VT_EMPTY";
  164.         break;
  165.         case VT_NULL:
  166.             cstrText += "VT_NULL";
  167.         break;
  168.         case VT_I2:
  169.             cstrText += "VT_I2";
  170.         break;
  171.         case VT_I4:
  172.             cstrText += "VT_I4";
  173.         break;
  174.         case VT_R4:
  175.             cstrText += "VT_R4";
  176.         break;
  177.         case VT_R8:
  178.             cstrText += "VT_R8";
  179.         break;
  180.         case VT_CY:
  181.             cstrText += "VT_CY";
  182.         break;
  183.         case VT_DATE:
  184.             cstrText += "VT_DATE";
  185.         break;
  186.         case VT_BSTR:
  187.             cstrText += "VT_BSTR";
  188.         break;
  189.         case VT_DISPATCH:
  190.             cstrText += "VT_DISPATCH";
  191.         break;
  192.         case VT_ERROR:
  193.             cstrText += "VT_ERROR";
  194.         break;
  195.         case VT_BOOL:
  196.             cstrText += "VT_BOOL";
  197.         break;
  198.         case VT_VARIANT:
  199.             cstrText += "VT_VARIANT";
  200.         break;
  201.         case VT_UNKNOWN:
  202.             cstrText += "VT_UNKNOWN";
  203.         break;
  204.         case VT_UI1:
  205.             cstrText += "VT_UI1";
  206.         break;
  207.     }
  208.     return cstrText;
  209. }
  210.  
  211. VARTYPE TextToVartype(CString& cstrText)
  212. {
  213.     VARTYPE vt = VT_EMPTY;
  214.  
  215.     if (cstrText.Find("VT_RESERVED") >= 0)
  216.         vt |= VT_RESERVED;
  217.  
  218.     if (cstrText.Find("VT_BYREF") >= 0)
  219.         vt |= VT_BYREF;
  220.             
  221.     if (cstrText.Find("VT_ARRAY") >= 0)
  222.         vt |= VT_ARRAY;
  223.  
  224.     if (cstrText.Find("VT_EMPTY") >= 0)
  225.         vt |= VT_EMPTY;
  226.  
  227.     if (cstrText.Find("VT_NULL") >= 0)
  228.         vt |= VT_NULL;
  229.  
  230.     if (cstrText.Find("VT_I2") >= 0)
  231.         vt |= VT_I2;
  232.  
  233.     if (cstrText.Find("VT_I4") >= 0)
  234.         vt |= VT_I4;
  235.  
  236.     if (cstrText.Find("VT_R4") >= 0)
  237.         vt |= VT_R4;
  238.  
  239.     if (cstrText.Find("VT_R8") >= 0)
  240.         vt |= VT_R8;
  241.  
  242.     if (cstrText.Find("VT_CY") >= 0)
  243.         vt |= VT_CY;
  244.  
  245.     if (cstrText.Find("VT_DATE") >= 0)
  246.         vt |= VT_DATE;
  247.  
  248.     if (cstrText.Find("VT_BSTR") >= 0)
  249.         vt |= VT_BSTR;
  250.  
  251.     if (cstrText.Find("VT_DISPATCH") >= 0)
  252.         vt |= VT_DISPATCH;
  253.  
  254.     if (cstrText.Find("VT_ERROR") >= 0)
  255.         vt |= VT_ERROR;
  256.  
  257.     if (cstrText.Find("VT_BOOL") >= 0)
  258.         vt |= VT_BOOL;
  259.  
  260.     if (cstrText.Find("VT_VARIANT") >= 0)
  261.         vt |= VT_VARIANT;
  262.  
  263.     if (cstrText.Find("VT_UNKNOWN") >= 0)
  264.         vt |= VT_UNKNOWN;
  265.  
  266.     if (cstrText.Find("VT_UI1") >= 0)
  267.         vt |= VT_UI1;
  268.  
  269.     return vt;
  270. }
  271.  
  272. /////////////////////////////////////////////////////////////////////////////
  273. // CPropDialog dialog
  274.  
  275.  
  276. CPropDialog::CPropDialog(Properties *pProps, CWnd* pParent /*=NULL*/)
  277.     : CDialog(CPropDialog::IDD, pParent)
  278. {
  279.     //{{AFX_DATA_INIT(CPropDialog)
  280.         // NOTE: the ClassWizard will add member initialization here
  281.     //}}AFX_DATA_INIT
  282.     m_pProps = pProps;
  283. }
  284.  
  285.  
  286. void CPropDialog::DoDataExchange(CDataExchange* pDX)
  287. {
  288.     CDialog::DoDataExchange(pDX);
  289.     //{{AFX_DATA_MAP(CPropDialog)
  290.         // NOTE: the ClassWizard will add DDX and DDV calls here
  291.     //}}AFX_DATA_MAP
  292. }
  293.  
  294.  
  295. BEGIN_MESSAGE_MAP(CPropDialog, CDialog)
  296.     //{{AFX_MSG_MAP(CPropDialog)
  297.     ON_BN_CLICKED(IDC_MODIFY, OnModify)
  298.     ON_BN_CLICKED(IDC_NEW, OnAdd)
  299.     //}}AFX_MSG_MAP
  300. END_MESSAGE_MAP()
  301.  
  302. /////////////////////////////////////////////////////////////////////////////
  303. // CPropDialog message handlers
  304. #define W_COLUMN    20
  305.  
  306. #define IND_SUBITEMINDEX    0
  307. #define IND_SUBITEMID        1
  308. #define IND_SUBITEMNAME        2
  309. #define IND_SUBITEMREADONLY    3
  310. #define IND_SUBITEMTYPE        4
  311. #define IND_SUBITEMVALUE    5
  312.  
  313. #define IND_COLUMNINDEX        0
  314. #define IND_COLUMNID        1
  315. #define IND_COLUMNAME        2
  316. #define IND_COLUMNREADONLY    3
  317. #define IND_COLUMNTYPE        4
  318. #define IND_COLUMNVALUE        5
  319.  
  320.  
  321. BOOL CPropDialog::OnInitDialog() 
  322. {
  323.     CDialog::OnInitDialog();
  324.  
  325.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  326.     
  327.     if (pPropsList != NULL)
  328.     {
  329.         LV_COLUMN lvcolumn;
  330.         lvcolumn.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH;
  331.         lvcolumn.fmt = LVCFMT_LEFT;
  332.  
  333.         CString sResString;
  334.         sResString.LoadString(IDS_PROPERTY_INDEX);
  335.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  336.  
  337.         lvcolumn.iSubItem = IND_SUBITEMINDEX;
  338.         lvcolumn.cx = W_COLUMN * 4;
  339.         pPropsList->InsertColumn(IND_COLUMNINDEX, &lvcolumn);  // assumes return value is OK.
  340.  
  341.         sResString.LoadString(IDS_PROPERTY_ID);
  342.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  343.         lvcolumn.iSubItem = IND_SUBITEMID;
  344.         lvcolumn.cx = W_COLUMN * 3;
  345.         pPropsList->InsertColumn(IND_COLUMNID, &lvcolumn);  // assumes return value is OK.
  346.  
  347.         sResString.LoadString(IDS_PROPERTY_NAME);
  348.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  349.         lvcolumn.cx = W_COLUMN * 5;
  350.         lvcolumn.iSubItem = IND_SUBITEMNAME;
  351.         pPropsList->InsertColumn(IND_COLUMNAME, &lvcolumn);  // assumes return value is OK.
  352.  
  353.         sResString.LoadString(IDS_PROPERTY_READONLY);
  354.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  355.         lvcolumn.cx = W_COLUMN * 4;
  356.         lvcolumn.iSubItem = IND_SUBITEMREADONLY;
  357.         pPropsList->InsertColumn(IND_COLUMNREADONLY, &lvcolumn);  // assumes return value is OK.
  358.  
  359.         sResString.LoadString(IDS_PROPERTY_TYPE);
  360.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  361.         lvcolumn.cx = W_COLUMN * 4;
  362.         lvcolumn.iSubItem = IND_SUBITEMTYPE;
  363.         pPropsList->InsertColumn(IND_COLUMNTYPE, &lvcolumn);  // assumes return value is OK.
  364.  
  365.         sResString.LoadString(IDS_PROPERTY_VALUE);
  366.         lvcolumn.pszText = (LPTSTR)(LPCTSTR)sResString;
  367.         lvcolumn.cx = W_COLUMN * 4;
  368.         lvcolumn.iSubItem = IND_SUBITEMVALUE;
  369.         pPropsList->InsertColumn(IND_COLUMNVALUE, &lvcolumn);  // assumes return value is OK.
  370.     }
  371.  
  372.  
  373.     if (m_pProps != NULL)
  374.     {
  375.  
  376.         long lCount = 0;
  377.         HRESULT hRes = m_pProps->get_Count(&lCount);
  378.         if (SUCCEEDED(hRes))
  379.         {
  380.  
  381.             Property *pProp = NULL;
  382.             CString cstrText;
  383.             BSTR bstrVal = NULL;
  384.             long lVal = 0;
  385.             long lID = 0;
  386.             BOOL bVal = FALSE;
  387.             COleVariant *pvarVal;
  388.             SHORT iVal = 0;
  389.  
  390.  
  391.             VARIANT varIndex;
  392.             ::VariantInit(&varIndex);
  393.             varIndex.vt = VT_I4;
  394.  
  395.             LV_ITEM            lvitem;
  396.             int                index = 0;
  397.  
  398.             for (long iItem = 0; iItem < lCount; iItem++)
  399.             {
  400.  
  401.                 varIndex.lVal = iItem;
  402.                 hRes = m_pProps->get_Item(&varIndex, &pProp);
  403.                 if (SUCCEEDED(hRes))
  404.                 {
  405.                     ASSERT(pProp != NULL);
  406.  
  407.                     lvitem.mask = LVIF_TEXT;
  408.                     lvitem.iItem = index;
  409.  
  410.                     hRes = pProp->get_ID(&lID);
  411.                     if (SUCCEEDED(hRes))
  412.                     {
  413.                         lvitem.iSubItem = IND_SUBITEMINDEX;
  414.                         hRes = pProp->get_Index(&lVal);
  415.                         if (SUCCEEDED(hRes))
  416.                             cstrText.Format("%d", lVal);
  417.                         else
  418.                             cstrText = "?";
  419.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  420.                         index = pPropsList->InsertItem(&lvitem);
  421.                         ASSERT(index >= 0);
  422.  
  423.                         lvitem.iSubItem = IND_SUBITEMID;
  424.                         cstrText.Format("%d", lID);
  425.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  426.                         VERIFY(pPropsList->SetItem(&lvitem));
  427.  
  428.                         hRes = pProp->get_Name(&bstrVal);
  429.                         ASSERT(SUCCEEDED(hRes));
  430.                         lvitem.iSubItem = IND_SUBITEMNAME;
  431.                         cstrText = bstrVal;
  432.                         ::SysFreeString(bstrVal);
  433.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  434.                         VERIFY(pPropsList->SetItem(&lvitem));
  435.  
  436.                         hRes = pProp->get_ReadOnly(&iVal);
  437.                         lvitem.iSubItem = IND_SUBITEMREADONLY;
  438.                         lvitem.pszText = bVal ? "r-" : "rw";
  439.                         VERIFY(pPropsList->SetItem(&lvitem));
  440.  
  441.                         hRes = pProp->get_Type(&iVal);
  442.                         lvitem.iSubItem = IND_SUBITEMTYPE;
  443.                         cstrText = VartypeToText(iVal);
  444.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  445.                         VERIFY(pPropsList->SetItem(&lvitem));
  446.  
  447.                         pvarVal = new COleVariant();
  448.                         hRes = pProp->get_Value(0, pvarVal);
  449.                         lvitem.iSubItem = IND_SUBITEMVALUE;
  450.                         cstrText = VariantToText(pvarVal, IDS_SOURCE);
  451.                         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  452.                         VERIFY(pPropsList->SetItem(&lvitem));
  453.  
  454.                         VERIFY(index == m_arrVal.Add(pvarVal));
  455.                         VERIFY(pPropsList->SetItemData(index, (DWORD)pProp));
  456.                         index++;
  457.                     }
  458.                     else
  459.                         pProp->Release();
  460.                 }
  461.             }
  462.         }
  463.     }
  464.  
  465.     return TRUE;  // return TRUE unless you set the focus to a control
  466.                   // EXCEPTION: OCX Property Pages should return FALSE
  467. }
  468.  
  469. void CPropDialog::OnModify() 
  470. {
  471.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  472.     if (pPropsList != NULL)
  473.     {
  474.         int iSelItem = pPropsList->GetNextItem(-1, LVNI_SELECTED);        
  475.         if (iSelItem >= 0)
  476.         {
  477. //            Property *pProp = (Property *)pPropsList->GetItemData(iSelItem);
  478.             COleVariant *pvarVal = (COleVariant *)m_arrVal.GetAt(iSelItem);
  479.             if (pvarVal != NULL)
  480.             {
  481.                 CString cstrName = pPropsList->GetItemText(iSelItem, IND_SUBITEMNAME);
  482.                 CString cstrType = pPropsList->GetItemText(iSelItem, IND_SUBITEMTYPE);
  483.  
  484.                 CPropModify dlgModify(pvarVal, cstrName, cstrType, this);
  485.                 if (dlgModify.DoModal() == IDOK)
  486.                 {
  487.                     CString cstrText = VariantToText(&(dlgModify.m_varVal), IDS_MODIFIED);
  488.                     VERIFY(SUCCEEDED(::VariantCopyInd(pvarVal, dlgModify.m_varVal)));
  489.                     LV_ITEM            lvitem;
  490.                     lvitem.mask = LVIF_TEXT;
  491.                     lvitem.iItem = iSelItem;
  492.                     lvitem.iSubItem = IND_SUBITEMVALUE;
  493.                     lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  494.  
  495.                     VERIFY(pPropsList->SetItem(&lvitem));
  496.                     pPropsList->Update(iSelItem);
  497.                 }
  498.             }
  499.         }
  500.     
  501.     }
  502. }
  503.  
  504. void CPropDialog::OnCancel() 
  505. {
  506.     // TODO: Add extra cleanup here
  507.     
  508.     CDialog::OnCancel();
  509. }
  510.  
  511. void CPropDialog::OnOK() 
  512. {
  513.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  514.     if (pPropsList != NULL)
  515.     {
  516.         ASSERT(::IsWindow(pPropsList->GetSafeHwnd()));
  517.         Property *pProp = NULL;
  518.         int iCount = pPropsList->GetItemCount();
  519.         for (int iItem = 0; iItem < iCount; iItem++)
  520.         {
  521.             COleVariant *pvar = (COleVariant *)m_arrVal.GetAt(iItem);
  522.             pProp = (Property *)pPropsList->GetItemData(iItem);
  523.             if (pProp == NULL)
  524.             {
  525.                 CString cstrName = pPropsList->GetItemText(iItem, IND_SUBITEMNAME);
  526.                 BSTR bstrName = cstrName.AllocSysString();
  527.  
  528.                 COleVariant varReadOnly;
  529.                 CString cstrReadOnly = pPropsList->GetItemText(iItem, IND_SUBITEMREADONLY);
  530.                 TextToVariant(cstrReadOnly, &varReadOnly, VT_BOOL);
  531.  
  532.                 COleVariant varMissing;
  533.                 varMissing.vt = VT_ERROR;
  534.                 varMissing.scode = DISP_E_PARAMNOTFOUND;
  535.  
  536.                 HRESULT hRes = m_pProps->Add(bstrName,
  537.                                              pvar,
  538.                                              varReadOnly,
  539.                                              &varMissing,
  540.                                              &pProp);
  541.                 ::SysFreeString(bstrName);
  542.                 if (SUCCEEDED(hRes))
  543.                     pProp->Release();
  544.                 else
  545.                 {
  546.                     CString cstrError;
  547.                     cstrError.Format(IDS_CANNOTADDPROPERTY, cstrName);                    
  548.                     AfxMessageBox(cstrError);
  549.                 }
  550.             }
  551.             else
  552.                 pProp->put_Value(0,pvar);
  553.         }
  554.     }
  555.     else
  556.         ASSERT(FALSE);
  557.     CDialog::OnOK();
  558. }
  559.  
  560. BOOL CPropDialog::DestroyWindow() 
  561. {
  562.     CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  563.     if (pPropsList != NULL)
  564.     {
  565.         ASSERT(::IsWindow(pPropsList->GetSafeHwnd()));
  566.         Property *pProp = NULL;
  567.         COleVariant *pvarVal;
  568.         int iCount = pPropsList->GetItemCount();
  569.         for (int iItem = 0; iItem < iCount; iItem++)
  570.         {
  571.             pProp = (Property *)pPropsList->GetItemData(iItem);
  572.             if (pProp != NULL)
  573.                 pProp->Release();
  574.             pvarVal = (COleVariant *)m_arrVal.GetAt(iItem);
  575.             if (pvarVal != NULL)
  576.                 delete pvarVal;
  577.         }
  578.     }
  579.     else
  580.         ASSERT(FALSE);
  581.     
  582.     return CDialog::DestroyWindow();
  583. }
  584.  
  585. void CPropDialog::OnAdd() 
  586. {
  587.     CAddProperty dlgAdd;
  588.     if (dlgAdd.DoModal())
  589.     {
  590.         CListCtrl *pPropsList = (CListCtrl *)GetDlgItem(IDC_PROPERTYLIST);
  591.  
  592.         int iCount = pPropsList->GetItemCount();
  593.         LV_ITEM            lvitem;
  594.         lvitem.mask = LVIF_TEXT;
  595.         lvitem.iItem = iCount;
  596.  
  597.         lvitem.iSubItem = IND_SUBITEMINDEX;
  598.         CString cstrText = "?";
  599.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  600.         int index = pPropsList->InsertItem(&lvitem);
  601.         ASSERT(index >= 0);
  602.  
  603.         lvitem.iSubItem = IND_SUBITEMID;
  604.         cstrText = "?";
  605.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  606.         VERIFY(pPropsList->SetItem(&lvitem));
  607.  
  608.         lvitem.iSubItem = IND_SUBITEMNAME;
  609.         cstrText = dlgAdd.m_cstrName;
  610.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  611.         VERIFY(pPropsList->SetItem(&lvitem));
  612.  
  613.         lvitem.iSubItem = IND_SUBITEMREADONLY;
  614.         lvitem.pszText = dlgAdd.m_bReadOnly ? "r-" : "rw";
  615.         VERIFY(pPropsList->SetItem(&lvitem));
  616.  
  617.         lvitem.iSubItem = IND_SUBITEMTYPE;
  618.         cstrText = dlgAdd.m_cstrType;
  619.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  620.         VERIFY(pPropsList->SetItem(&lvitem));
  621.  
  622.         COleVariant *pvarVal = new COleVariant();
  623.         pvarVal->vt = TextToVartype(cstrText);
  624.         lvitem.iSubItem = IND_SUBITEMVALUE;
  625.         cstrText = VariantToText(pvarVal, IDS_SOURCE);
  626.         lvitem.pszText = (LPTSTR)(LPCTSTR)cstrText;
  627.         VERIFY(pPropsList->SetItem(&lvitem));
  628.         VERIFY(index == m_arrVal.Add(pvarVal));
  629.     }
  630. }
  631.