home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / sdk / mapi / win16 / dev / tablevu / tblview.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-11  |  116.8 KB  |  4,262 lines
  1. /*
  2.  -  T B L V I E W . C P P
  3.  -  Copyright (C) 1995 Microsoft Corporation
  4.  -
  5.  *  Purpose:
  6.  *      Contains the implementation of a generic IMAPITable viewer.
  7.  *      This viewer is contained in a DLL and is accessed by the user
  8.  *      throught a single entry point: ViewMapiTable(LPMAPITABLE FAR *, HWND).
  9.  *      The UI is presented through 3 main dialogs: CTblDlg, CSortDlg,
  10.  *      and CResDlg.  These are MFC 2.0 based dialog classes.
  11.  *
  12.  */
  13.  
  14.  
  15. #ifdef WIN32
  16. #ifdef _WIN95
  17. #define _INC_OLE
  18. #endif
  19. #define INC_OLE2
  20. #define INC_RPC
  21. #endif
  22.  
  23. #include <afxwin.h>     
  24. #include <windowsx.h>
  25. #include <stdio.h>
  26. #include <string.h>
  27.  
  28. #ifdef WIN16
  29. #include <compobj.h>
  30. #endif
  31.  
  32. #ifdef WIN32
  33. #include <objbase.h>
  34. #include <objerror.h>
  35. #ifdef _WIN95
  36. #include <ole2.h>
  37. #endif
  38. #endif
  39.  
  40.  
  41. #include <mapiwin.h>
  42. #include <mapix.h>
  43. #include <strtbl.h>
  44. #include <misctool.h>
  45. #include <pvalloc.h>
  46. #include <tventry.h>
  47. #include <limits.h>
  48. #include "resource.h"
  49. #include "tblview.h"
  50.  
  51.  
  52. /* Global Objects */
  53. CWnd        *pStatusWnd;
  54. CWnd        *pLogWnd;
  55. HRESULT     hError          = 0;
  56. ULONG       ulNumResTypes   = 0;        // determine number of restriction types
  57.  
  58. /*
  59.  -  ViewMapiTable
  60.  -
  61.  *  Purpose:
  62.  *      Main entry point for table viewer.
  63.  *
  64.  *  Parameters:
  65.  *      lpTable         - Pointer to an IMAPITable
  66.  *
  67.  *  Returns:
  68.  *      void.
  69.  *
  70.  */
  71.  
  72. extern "C"
  73. BOOL ViewMapiTable(LPMAPITABLE FAR *lppMAPITable, HWND hWnd)
  74. {
  75.     CTblDlg     tblDlg(*lppMAPITable, hWnd);
  76.     return (tblDlg.DoModal() == IDOK);
  77. }
  78.  
  79.  
  80. /* CTblDlg implementation */
  81.  
  82. BEGIN_MESSAGE_MAP(CTblDlg, CModalDialog)
  83.     ON_LBN_SELCHANGE(IDC_DISPLAYVALUE, OnSelDisplayValue)
  84.     ON_COMMAND(IDC_SETBOOKMARK,        OnSetBookmark)
  85.     ON_COMMAND(IDC_FORCESORT,          OnForceSort)
  86.     ON_COMMAND(IDC_FORCERES,           OnForceRestriction)
  87.     ON_COMMAND(IDC_GETSTATUS,          OnGetStatus)
  88.     ON_COMMAND(IDC_QUERYPOS,           OnQueryPosition)
  89.     ON_COMMAND(IDC_QUERYSORTORDER,     OnQuerySortOrder)
  90.     ON_COMMAND(IDC_GETROWCOUNT,        OnGetRowCount)
  91.     ON_COMMAND(IDC_GETLASTERROR,       OnGetLastError)
  92.     ON_COMMAND(IDC_ABORT,              OnAbort)
  93.     ON_COMMAND(IDC_FIND,               OnFind)
  94.     ON_COMMAND(IDC_FREEBOOKMARK,       OnFreeBookmark)
  95.     ON_COMMAND(IDC_RESTRICTION,        OnRestriction)
  96.     ON_COMMAND(IDC_SEEK,               OnSeek)
  97.     ON_COMMAND(IDC_SETCOLUMNS,         OnSetColumns)
  98.     ON_COMMAND(IDC_SORTORDER,          OnSortOrder)
  99.     ON_COMMAND(IDC_CLOSE,              OnClose)
  100.     ON_COMMAND(IDC_CLEARSTATUS,        OnClearStatus)
  101.     ON_COMMAND(IDC_CLEARMAPILOG,       OnClearMapiLog)
  102. END_MESSAGE_MAP()
  103.  
  104.  
  105. /*
  106.  -  CTblDlg::
  107.  -  CTblDlg
  108.  -
  109.  *  Purpose:
  110.  *      Constructor for main dialog class.
  111.  *
  112.  */
  113.  
  114. CTblDlg::CTblDlg(LPMAPITABLE lpTbl, HWND hWnd)
  115.     : CModalDialog(IDD_TBLDLG, FromHandle(hWnd))
  116. {
  117.     m_lpTable           = lpTbl;
  118.     m_lpSort            = NULL;
  119.     m_lpRes             = NULL;
  120.     m_cRows             = 0;
  121.     m_ulptDisplay       = PR_DISPLAY_NAME;
  122.     m_BookMarks.cValues = 0;
  123. }
  124.  
  125. /*------------------------------------*/
  126. /* Message Handlers for CTblDlg class */
  127. /*------------------------------------*/
  128.  
  129. /*
  130.  -  CTblDlg::
  131.  -  OnInitDialog
  132.  -
  133.  *  Purpose:
  134.  *      Constructor for main dialog class.
  135.  *
  136.  */
  137.  
  138. BOOL CTblDlg::OnInitDialog()
  139. {
  140.     pStatusWnd = GetDlgItem(IDC_STATUS);
  141.     pLogWnd = GetDlgItem(IDC_MAPILOG);
  142.  
  143.     RenderTable();
  144.  
  145.     GetDlgItem(IDC_DISPLAYVALUE)->SetFocus();
  146.     SendDlgItemMessage(IDC_DISPLAYVALUE, LB_SETCURSEL, 0, 0L);
  147.  
  148.     OnSelDisplayValue();
  149.  
  150.     SendDlgItemMessage(IDC_MAPILOG, LB_SETHORIZONTALEXTENT,
  151.             (WPARAM)VALUES_LB_HOR_SIZE, 0);
  152.  
  153.     return TRUE;
  154. }
  155.  
  156.  
  157. /*
  158.  -  CTblDlg::
  159.  -  OnSelDisplayValue
  160.  -
  161.  *  Purpose:
  162.  *      Displays the table contents in the right pane based upon the
  163.  *      current row in the left pane.
  164.  *
  165.  */
  166.  
  167. void CTblDlg::OnSelDisplayValue()
  168. {
  169.     DWORD       idxCurSel;
  170.     SCODE       sc;
  171.     LPSRowSet   lpRow = NULL;
  172.     LONG        cRows = 0;
  173.     char        szBuff[256];
  174.     char        szBuffer[256];
  175.  
  176.     idxCurSel = SendDlgItemMessage(IDC_DISPLAYVALUE, LB_GETCURSEL, 0, 0L);
  177.  
  178.     if(idxCurSel == LB_ERR)
  179.     {
  180.         SendDlgItemMessage(IDC_DISPLAYVALUE, LB_RESETCONTENT, 0, 0L);
  181.         SendDlgItemMessage(IDC_ROWVALUES, LB_RESETCONTENT, 0, 0L);
  182.         return;
  183.     }
  184.  
  185.     /*  Check for being at the end of the table, if so display a warning,
  186.         and return to the beginning of the table. */
  187.     if( idxCurSel >= m_cRows )
  188.     {
  189.         SetStatus("End of table reached", (SCODE)0);
  190.         MessageBox( "You are at the end of the table.", "Warning",MB_OK | MB_ICONINFORMATION);
  191.         wsprintf(szBuff, " %s", "End of table");
  192.         SendDlgItemMessage(IDC_ROWVALUES,LB_RESETCONTENT, 0, 0L);
  193.         lstrcpy(szBuffer,"No row values available");
  194.         SendDlgItemMessage(IDC_ROWVALUES,LB_ADDSTRING, 0, (LPARAM)szBuffer);
  195.         return;
  196.     }
  197.  
  198.     if( FAILED(sc = GetScode(hError = m_lpTable->SeekRow(BOOKMARK_BEGINNING, idxCurSel, &cRows))) )
  199.         SetStatus("SeekRow failed", sc);
  200.  
  201.     UpdateRow(m_lpTable);
  202. }
  203.  
  204.  
  205. /*
  206.  -  CTblDlg
  207.  -  OnSetBookmark
  208.  -
  209.  *  Purpose:
  210.  *      Sets the requested bookmark.  Adds the bookmark the internal list
  211.  *      of bookmarks.
  212.  *
  213.  */
  214.  
  215. void CTblDlg::OnSetBookmark()
  216. {
  217.     DWORD       idxCurSel;
  218.     SCODE       sc;
  219.     LPSRowSet   lpRow;
  220.     LONG        cRows;
  221.     BOOKMARK    bk;
  222.     ULONG       idx;
  223.  
  224.     /* Get index of current row and Seek to there in the table */
  225.     idxCurSel = SendDlgItemMessage(IDC_DISPLAYVALUE, LB_GETCURSEL, 0, 0L);
  226.  
  227.     if( FAILED(sc = GetScode(hError = m_lpTable->SeekRow(BOOKMARK_BEGINNING, idxCurSel, &cRows))) )
  228.         SetStatus("SeekRow", sc);
  229.  
  230.     /* Create the Bookmark */
  231.     if( FAILED(sc = GetScode(hError = m_lpTable->CreateBookmark(&bk))) )
  232.         SetStatus("CreateBookmark failed", sc);
  233.  
  234.     /* QueryRow and get PropValue of Display Value field */
  235.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryRows(1, TBL_NOADVANCE, &lpRow))) )
  236.         SetStatus("QueryRows failed", sc);
  237.  
  238.     for(idx = 0; idx < lpRow->aRow[0].cValues; idx++)
  239.         if(lpRow->aRow[0].lpProps[idx].ulPropTag == m_ulptDisplay)
  240.             break;
  241.  
  242.     /* Add new Bookmark to list */
  243.     AddBookmark(&m_BookMarks, bk, &lpRow->aRow[0].lpProps[idx]);
  244.  
  245.     FreeRowSet(lpRow);
  246. }
  247.  
  248.  
  249. /*
  250.  -  CTblDlg
  251.  -  OnForceSort
  252.  -
  253.  *  Purpose:
  254.  *      Sorts the table based upom the requested sort criteria.
  255.  *
  256.  */
  257.  
  258. void CTblDlg::OnForceSort()
  259. {
  260.     SCODE   sc;
  261.     ULONG   ulCount = 0;
  262.  
  263.     if(m_lpSort)
  264.     {
  265.         if( FAILED(sc = GetScode(hError = m_lpTable->SortTable(m_lpSort, 0))) )
  266.         {
  267.             SetStatus("SortTable failed", sc);
  268.             return;
  269.         }
  270.  
  271.         if( FAILED(sc = GetScode(hError = m_lpTable->GetRowCount(TBL_NOWAIT, &ulCount))) )
  272.         {
  273.             SetStatus("SortTable failed", sc);
  274.             return;
  275.         }
  276.  
  277.         if( ulCount != m_cRows )
  278.         {
  279.             SetStatus("Sort has not completed", sc);
  280.             return;
  281.         }
  282.  
  283.         RenderTable();
  284.     }
  285. }
  286.  
  287.  
  288. /*
  289.  -  CTblDlg
  290.  -  OnForceRestriction
  291.  -
  292.  *  Purpose:
  293.  *      Restricts the table based upon the requested restrictions.
  294.  *
  295.  */
  296.  
  297. void CTblDlg::OnForceRestriction()
  298. {
  299.     SCODE   sc;
  300.  
  301.     /* Perform restriction */
  302.     if( FAILED(sc = GetScode(hError = m_lpTable->Restrict(m_lpRes, 0))) )
  303.         SetStatus("Restrict failed", sc);
  304.  
  305.     // NYI
  306.     /* LogRestriction(m_lpRes, pLogWnd->m_hWnd); */
  307.  
  308.     if( FAILED(sc = GetScode(hError = m_lpTable->GetRowCount(0, &m_cRows))) )
  309.         SetStatus("GetRowCount failed", sc);
  310.  
  311.     RenderTable();
  312. }
  313.  
  314.  
  315. /*
  316.  -  CTblDlg
  317.  -  OnGetStatus
  318.  -
  319.  *  Purpose:
  320.  *      Gets the current table status and type and places them in the logging
  321.  *      window.
  322.  *
  323.  */
  324.  
  325. void CTblDlg::OnGetStatus()
  326. {
  327.     ULONG       ulTableStatus;
  328.     ULONG       ulTableType;
  329.     char        szStatus[64];
  330.     char        szType[64];
  331.     char        szBuff[256];
  332.     SCODE       sc;
  333.  
  334.     if( FAILED(sc = GetScode(hError = m_lpTable->GetStatus(&ulTableStatus, &ulTableType))) )
  335.     {
  336.         SetStatus("GetStatus failed", sc);
  337.         return;
  338.     }
  339.     else
  340.     {
  341.         wsprintf( szStatus, "%s%s%s%s%s%s%s%s",
  342.                 ((ulTableStatus == TBLSTAT_COMPLETE)         ? "TBLSTAT_COMPLETE "       : ""),
  343.                 ((ulTableStatus == TBLSTAT_QCHANGED)         ? "TBLSTAT_QCHANGED "       : ""),
  344.                 ((ulTableStatus == TBLSTAT_SORTING)          ? "TBLSTAT_SORTING "        : ""),
  345.                 ((ulTableStatus == TBLSTAT_SORT_ERROR)       ? "TBLSTAT_SORT_ERROR "     : ""),
  346.                 ((ulTableStatus == TBLSTAT_SETTING_COLS)     ? "TBLSTAT_SETTING_COLS "   : ""),
  347.                 ((ulTableStatus == TBLSTAT_SETCOL_ERROR)     ? "TBLSTAT_SETCOL_ERROR "   : ""),
  348.                 ((ulTableStatus == TBLSTAT_RESTRICTING)      ? "TBLSTAT_RESTRICTING "    : ""),
  349.                 ((ulTableStatus == TBLSTAT_RESTRICT_ERROR)   ? "TBLSTAT_RESTRICT_ERROR " : ""));
  350.         wsprintf( szType, "%s%s%s",
  351.                 ((ulTableType == TBLTYPE_SNAPSHOT)           ? "TBLTYPE_SNAPSHOT "       : ""),
  352.                 ((ulTableType == TBLTYPE_KEYSET)             ? "TBLTYPE_KEYSET "         : ""),
  353.                 ((ulTableType == TBLTYPE_DYNAMIC)            ? "TBLTYPE_DYNAMIC "        : ""));
  354.  
  355.         wsprintf( szBuff, "TBLSTAT: %s(%lu)  TBLTYPE: %s(%lu)", szStatus,
  356.                   ulTableStatus, szType, ulTableType );
  357.         pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szBuff );
  358.     }
  359. }
  360.  
  361.  
  362. /*
  363.  -  CTblDlg
  364.  -  OnClearStatus
  365.  -
  366.  *  Purpose:
  367.  *      Clears the status window.
  368.  *
  369.  */
  370.  
  371. void CTblDlg::OnClearStatus()
  372. {
  373.     pStatusWnd->SetWindowText("");
  374. }
  375.  
  376.  
  377. /*
  378.  -  CTblDlg
  379.  -  OnClearMapiLog
  380.  -
  381.  *  Purpose:
  382.  *      Clears the logging window.
  383.  *
  384.  */
  385.  
  386. void CTblDlg::OnClearMapiLog()
  387. {
  388.     LONG        j, nSc;
  389.  
  390.     nSc = SendDlgItemMessage( IDC_MAPILOG, LB_GETCOUNT, 0, 0L);
  391.  
  392.     if( nSc == LB_ERR )
  393.         return;
  394.  
  395.     for( j=nSc; j>=0; j-- )
  396.         SendDlgItemMessage(IDC_MAPILOG, LB_DELETESTRING, (WPARAM)j, 0L);
  397. }
  398.  
  399.  
  400. /*
  401.  -  CTblDlg
  402.  -  OnQueryPosition
  403.  -
  404.  *  Purpose:
  405.  *      Retrieves the current position in the table and updates the control.
  406.  *
  407.  */
  408.  
  409. void CTblDlg::OnQueryPosition()
  410. {
  411.     SCODE       sc;
  412.     ULONG       ulRow, ulNum, ulDenom;
  413.     char        szBuff[256];
  414.  
  415.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryPosition(&ulRow, &ulNum, &ulDenom))) )
  416.         SetStatus("QueryPosition failed", sc);
  417.  
  418.     if(&ulRow == (ULONG *)0xFFFFFFF)
  419.         MessageBox("QueryPosition returned *lpulRow = 0xFFFFFFFF", "Return values", MB_OK | MB_ICONINFORMATION);
  420.  
  421.     else
  422.     {
  423.         wsprintf(szBuff, "QueryPosition return values:\
  424.                           \n     ulRow (Current row 0 based): %lu\
  425.                           \n     ulNum (Numerator for fractional position): %lu\
  426.                           \n     ulDenom (Denominator for fractional position): %lu", ulRow, ulNum, ulDenom);
  427.         MessageBox(szBuff, "Return values", MB_OK | MB_ICONINFORMATION);
  428.  
  429.         strcpy(szBuff,"QueryPosition return values");
  430.         pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szBuff);
  431.  
  432.         wsprintf(szBuff,"     lpulRow (Current row 0 based): %lu", ulRow);
  433.         pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szBuff);
  434.  
  435.         wsprintf(szBuff,"     lpulNum (Numerator for fractional position): %lu", ulNum);
  436.         pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szBuff);
  437.  
  438.         wsprintf(szBuff,"     lpulDenom (Denominator for fractional position): %lu", ulDenom);
  439.         pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szBuff);
  440.     }
  441.  
  442. }
  443.  
  444.  
  445. /*
  446.  -  CTblDlg
  447.  -  OnQuerySortOrder
  448.  -
  449.  *  Purpose:
  450.  *      Retrieves the current sort order.
  451.  *
  452.  */
  453.  
  454. void CTblDlg::OnQuerySortOrder()
  455. {
  456.     SCODE           sc;
  457.     LPSSortOrderSet lpSortCriteria;
  458.     LPSSortOrder    lpso = NULL;
  459.     ULONG           idx;
  460.     char            szBuff[128];
  461.     char            szPropTag[128];
  462.     char            szSO[512];
  463.     char            szSOtemp[128];
  464.  
  465.     if( FAILED(sc = GetScode(hError = m_lpTable->QuerySortOrder(&lpSortCriteria))) )
  466.         SetStatus("QuerySortOrder failed", sc);
  467.     else
  468.     {
  469.         if(lpSortCriteria)
  470.         {
  471.             strcpy(szSO,"Current Sort Order");
  472.             pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szSO );
  473.             for(idx = 0; idx < lpSortCriteria->cSorts; idx++)
  474.             {
  475.                 lpso = (LPSSortOrder)PvAlloc(sizeof(SSortOrder));
  476.                 *lpso = lpSortCriteria->aSort[idx];
  477.                 GetString("PropTags", lpso->ulPropTag, szPropTag);
  478.  
  479.                 if(lpso->ulOrder == TABLE_SORT_ASCEND)
  480.                     wsprintf(szBuff, "   A %s", szPropTag);
  481.                 else
  482.                     wsprintf(szBuff, "   D %s", szPropTag);
  483.  
  484.                 pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szBuff);
  485.                 wsprintf(szSOtemp, "\n   %s", szBuff);
  486.                 strcat(szSO, szSOtemp);
  487.  
  488.                 PvFree(lpso);
  489.             }
  490.             MessageBox(szSO, "Return value", MB_OK | MB_ICONINFORMATION);
  491.             strcpy(szBuff,"End of Sort Order");
  492.             pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM)szBuff );
  493.  
  494.             MAPIFreeBuffer(lpSortCriteria);
  495.         }
  496.  
  497.         else
  498.             MessageBox("NULL was returned, the Sort Order could not be determined",
  499.                        "Return value", MB_OK | MB_ICONINFORMATION);
  500.     }
  501.  
  502. }
  503.  
  504.  
  505. /*
  506.  -  CTblDlg
  507.  -  OnGetLastError
  508.  -
  509.  *  Purpose:
  510.  *      Retrieves the last MAPI error.
  511.  *
  512.  */
  513.  
  514. void CTblDlg::OnGetLastError()
  515. {
  516.     LPMAPIERROR lpMAPIError     = NULL;
  517.     char        szBuff[256];
  518.  
  519.     m_lpTable->GetLastError(hError, 0, &lpMAPIError);
  520.                 
  521.     if(lpMAPIError)
  522.     {
  523.         wsprintf(szBuff,"lpObj->GetLastError()  ulLowLevelError == %lu,ulVersion == %lu lpszMessage == %s, lpszComponent == %s, ulContext == %lu",
  524.                 lpMAPIError->ulLowLevelError,
  525.                 lpMAPIError->ulVersion,
  526.                 ((lpMAPIError->lpszError == NULL)     ? "NULL" : lpMAPIError->lpszError),
  527.                 ((lpMAPIError->lpszComponent == NULL) ? "NULL" : lpMAPIError->lpszComponent),
  528.                 lpMAPIError->ulContext);
  529.  
  530.         MessageBox(szBuff, "Warning",MB_OK | MB_ICONINFORMATION);
  531.         pStatusWnd->SetWindowText(lpMAPIError->lpszError);
  532.         MAPIFreeBuffer(lpMAPIError);
  533.     }
  534.     else
  535.         MessageBox("No errors returned from GetLastError().", "Warning", MB_OK | MB_ICONINFORMATION);
  536. }
  537.  
  538.  
  539. /*
  540.  -  CTblDlg
  541.  -  OnGetRowCount
  542.  -
  543.  *  Purpose:
  544.  *      Retrieves the row count.
  545.  *
  546.  */
  547.  
  548. void CTblDlg::OnGetRowCount()
  549. {
  550.     SCODE       sc;
  551.     ULONG       ulRowCount;
  552.     char        szBuff[256];
  553.  
  554.     if( FAILED(sc = GetScode(hError = m_lpTable->GetRowCount(0, &ulRowCount))) )
  555.         SetStatus("GetRowCount failed", sc);
  556.     else
  557.     {
  558.         wsprintf(szBuff,"GetRowCount returned %lu row(s).", ulRowCount);
  559.         MessageBox(szBuff, "Return value", MB_OK | MB_ICONINFORMATION);
  560.         pStatusWnd->SetWindowText(szBuff);
  561.     }
  562. }
  563.  
  564.  
  565. /*
  566.  -  CTblDlg
  567.  -  OnAbort
  568.  -
  569.  *  Purpose:
  570.  *      This function aborts asynchronous operations.
  571.  *
  572.  */
  573.  
  574. void CTblDlg::OnAbort()
  575. {
  576.     SCODE       sc;
  577.  
  578.     if( FAILED(sc = GetScode(hError = m_lpTable->Abort())) )
  579.         SetStatus("Abort failed", sc);
  580. }
  581.  
  582.  
  583. /*
  584.  -  CTblDlg
  585.  -  OnFind
  586.  -
  587.  *  Purpose:
  588.  *      This function seeks to the next row in the table that contains a
  589.  *      property matching the specified criteria.
  590.  *
  591.  */
  592.  
  593. void CTblDlg::OnFind()
  594. {
  595.     SCODE       sc;
  596.     ULONG       ulRow, ulNum, ulDenom;
  597.     LPSRowSet   lpRow = NULL;
  598.     CFindDlg    dlgFind(m_lpTable, &m_BookMarks);
  599.  
  600.     if(dlgFind.DoModal() == IDOK)
  601.     {
  602.         if( FAILED(sc = GetScode(hError = m_lpTable->QueryPosition(&ulRow, &ulNum, &ulDenom))) )
  603.             SetStatus("QueryPosition failed", sc);
  604.  
  605.         SendDlgItemMessage(IDC_DISPLAYVALUE, LB_SETCURSEL, (WPARAM)ulRow, 0L);
  606.         GetDlgItem(IDC_DISPLAYVALUE)->SetFocus();
  607.  
  608.         UpdateRow(m_lpTable);
  609.     }
  610. }
  611.  
  612.  
  613. /*
  614.  -  CTblDlg
  615.  -  OnFreeBookmark
  616.  -
  617.  *  Purpose:
  618.  *      Free the requested bookmarks.
  619.  *
  620.  */
  621.  
  622. void CTblDlg::OnFreeBookmark()
  623. {
  624.     CFreeBkDlg  dlgFreeBk(m_lpTable, &m_BookMarks);
  625.     dlgFreeBk.DoModal();
  626. }
  627.  
  628.  
  629. /*
  630.  -  CTblDlg
  631.  -  OnRestriction
  632.  -
  633.  *  Purpose:
  634.  *      Brings up the Restriction dialog assigns the restriction variable
  635.  *
  636.  */
  637.  
  638. void CTblDlg::OnRestriction()
  639. {
  640.     SCODE           sc;
  641.     LPSRestriction  lpRes;
  642.     LPSPropTagArray lpCurColumns;
  643.  
  644.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryColumns(TBL_ALL_COLUMNS, &lpCurColumns))) )
  645.         SetStatus("QueryColumns failed", sc);
  646.  
  647.     lpRes = (LPSRestriction)PvAlloc(sizeof(SRestriction));
  648.  
  649.     CResDlg         dlgRes(lpCurColumns, lpRes);
  650.  
  651.     if(dlgRes.DoModal() == IDOK)
  652.     {
  653.         FreeRestriction(m_lpRes);
  654.         PvFree(m_lpRes);
  655.         m_lpRes = lpRes;
  656.     }
  657.     else
  658.         PvFree(lpRes);
  659.  
  660.     MAPIFreeBuffer(lpCurColumns);
  661. }
  662.  
  663.  
  664. /*
  665.  -  CTblDlg
  666.  -  OnSeek
  667.  -
  668.  *  Purpose:
  669.  *      Seeks the specified row(s) or fractional position.
  670.  *
  671.  */
  672.  
  673. void CTblDlg::OnSeek()
  674. {
  675.     SCODE       sc;
  676.     ULONG       ulRow, ulNum, ulDenom;
  677.     LPSRowSet   lpRow = NULL;
  678.     CSeekDlg    dlgSeek(m_lpTable, &m_BookMarks);
  679.     char        szBuffer[256];
  680.  
  681.     if(dlgSeek.DoModal() == IDOK)
  682.     {
  683.         if( FAILED(sc = GetScode(hError = m_lpTable->QueryPosition(&ulRow, &ulNum, &ulDenom))) )
  684.             SetStatus("QueryPosition failed", sc);
  685.  
  686.         /*  End of table was reached, bring up a warning dialog and place focus
  687.             on the END OF TABLE entry */
  688.         if(ulNum == ulDenom)
  689.         {
  690.             SetStatus("End of table reached", (SCODE)0);
  691.             MessageBox( "You are at the end of the table.", "Warning",MB_OK | MB_ICONINFORMATION);
  692.             SendDlgItemMessage(IDC_DISPLAYVALUE, LB_SETCURSEL, (WPARAM)m_cRows, 0L);
  693.             SendDlgItemMessage(IDC_ROWVALUES,LB_RESETCONTENT, 0, 0L);
  694.             lstrcpy(szBuffer,"No row values available");
  695.             SendDlgItemMessage(IDC_ROWVALUES,LB_ADDSTRING, 0, (LPARAM)szBuffer);
  696.             return;
  697.         }
  698.  
  699.         SendDlgItemMessage(IDC_DISPLAYVALUE, LB_SETCURSEL, (WPARAM)ulRow, 0L);
  700.         GetDlgItem(IDC_DISPLAYVALUE)->SetFocus();
  701.  
  702.         UpdateRow(m_lpTable);
  703.     }
  704. }
  705.  
  706.  
  707. /*
  708.  -  CTblDlg
  709.  -  OnSetColumns
  710.  -
  711.  *  Purpose:
  712.  *      Changes the columns currently in view.
  713.  *
  714.  */
  715.  
  716. void CTblDlg::OnSetColumns()
  717. {
  718.     CSetColDlg  dlgSetCol(m_lpTable);
  719.  
  720.     dlgSetCol.DoModal();
  721.  
  722.     RenderTable();
  723.  
  724.     UpdateRow(m_lpTable);
  725. }
  726.  
  727.  
  728. /*
  729.  -  CTblDlg
  730.  -  OnSortOrder
  731.  -
  732.  *  Purpose:
  733.  *      Brings up the sort dialog and assigns the sort criteria.
  734.  *
  735.  */
  736.  
  737. void CTblDlg::OnSortOrder()
  738. {
  739.     LPSSortOrderSet lpSort;
  740.     CSortDlg        dlgSort(m_lpTable, &lpSort);
  741.  
  742.     if(dlgSort.DoModal() == IDOK)
  743.     {
  744.         PvFree(m_lpSort);
  745.         m_lpSort = lpSort;
  746.     }
  747. }
  748.  
  749.  
  750. /*
  751.  -  CTblDlg
  752.  -  OnClose
  753.  -
  754.  *  Purpose:
  755.  *      Closes the Table viewere and frees memory previously allocated.
  756.  *
  757.  */
  758.  
  759. void CTblDlg::OnClose()
  760. {
  761.     PvFree(m_lpSort);
  762.     FreeRestriction(m_lpRes);
  763.     PvFree(m_lpRes);
  764.     EndDialog(IDOK);
  765. }
  766.  
  767.  
  768. /*
  769.  -  CTblDLg::
  770.  -  UpdateRow
  771.  -
  772.  *  Purpose:
  773.  *      Update the current row and free the allocated memory
  774.  *
  775.  */
  776.  
  777. void CTblDlg::UpdateRow(LPMAPITABLE lpTable)
  778. {
  779.     SCODE       sc;
  780.     LPSRowSet   lpRow = NULL;
  781.  
  782.     if( FAILED(sc = GetScode(hError = lpTable->QueryRows(1, TBL_NOADVANCE, &lpRow))) )
  783.         SetStatus("QueryRows failed", sc);
  784.  
  785.     CTblDlg::RenderRow(lpRow->aRow[0].cValues, lpRow->aRow[0].lpProps);
  786.  
  787.     FreeRowSet(lpRow);
  788. }
  789.  
  790.  
  791. /*
  792.  -  CTblDlg::
  793.  -  RenderRow
  794.  -
  795.  *  Purpose:
  796.  *      Updates the current row in the right pane(row values).
  797.  *
  798.  */
  799.  
  800. void CTblDlg::RenderRow(ULONG cValues, LPSPropValue lpProps)
  801. {
  802.     ULONG   idx;
  803.     INT     rgTabStops[2];
  804.     char    szBuffer[1024];
  805.     char    szID[50];
  806.     char    szData[512];
  807.     char    szType[32];
  808.  
  809.     /* Clear the ListBox, Set its size, and set its TabStops */
  810.     SendDlgItemMessage(IDC_ROWVALUES, LB_RESETCONTENT, 0, 0);
  811.  
  812.     SendDlgItemMessage(IDC_ROWVALUES, LB_SETHORIZONTALEXTENT,
  813.             (WPARAM)VALUES_LB_HOR_SIZE, 0);
  814.  
  815.     rgTabStops[0] = VALUES_LB_TAB1;
  816.     rgTabStops[1] = VALUES_LB_TAB2;
  817.  
  818.     SendDlgItemMessage(IDC_ROWVALUES, LB_SETTABSTOPS,
  819.             (WPARAM)2, (LPARAM)rgTabStops);
  820.  
  821.     /* Populate the ListBox with the data for this row */
  822.     for(idx = 0; idx < cValues; idx++)
  823.     {
  824.         szID[0]     = '\0';
  825.         szData[0]   = '\0';
  826.         szType[0]   = '\0';
  827.         szBuffer[0] = '\0';
  828.  
  829.         if(GetString("PropIDs", PROP_ID(lpProps[idx].ulPropTag), szID))
  830.         {
  831.             lstrcat(szBuffer, szID );
  832.             lstrcat(szBuffer, "\t");
  833.         }
  834.         else
  835.         {
  836.             wsprintf(szBuffer,"%#08X\t", PROP_ID(lpProps[idx].ulPropTag));
  837.         }
  838.  
  839.         if(GetString("PropType", PROP_TYPE(lpProps[idx].ulPropTag), szType))
  840.         {
  841.             lstrcat(szBuffer, szType);
  842.             lstrcat(szBuffer, "\t");
  843.         }
  844.         else
  845.         {
  846.             wsprintf(szType, "%#08X\t", PROP_TYPE(lpProps[idx].ulPropTag));
  847.             lstrcat(szBuffer, szType);
  848.         }
  849.  
  850.         SzGetPropValue(szData, (LPSPropValue)&lpProps[idx]);
  851.         lstrcat(szBuffer, szData);
  852.  
  853.         SendDlgItemMessage(IDC_ROWVALUES, LB_ADDSTRING, 0, (LPARAM)szBuffer);
  854.     }
  855.  
  856.     SendDlgItemMessage(IDC_ROWVALUES, LB_SETCURSEL, (WPARAM)-1, 0);
  857. }
  858.  
  859.  
  860. /*
  861.  -  CTblDlg::
  862.  -  RenderTable
  863.  -
  864.  *  Purpose:
  865.  *      Updates the current rows in the left pane(Display values).
  866.  *
  867.  */
  868.  
  869. void CTblDlg::RenderTable()
  870. {
  871.     SCODE       sc          = S_OK;
  872.     LONG        cRows       = 0;
  873.     LPSRowSet   lpRows      = NULL;
  874.     ULONG       idx, idxDN;
  875.     char        szBuff[512];
  876.     char        szBuffer[256];
  877.     char        szErrorBuff[200];
  878.     char        szDummy[50];
  879.  
  880.     ULONG       ulSize      = LONG_MAX;
  881.  
  882.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryRows(ulSize, TBL_NOADVANCE, &lpRows))) )
  883.     {
  884.         SetStatus("QueryRows failed", sc);
  885.         wsprintf(szErrorBuff,"CTblDlg::RenderTable(),  lpTable->QueryRows(0x%X,TBL_NOADVANCE,&lpRows) SC: %s",ulSize,
  886.                      GetString( "MAPIErrors", sc, szDummy) );
  887.         MessageBox(szErrorBuff,"Error", MB_ICONSTOP | MB_OK);
  888.         return;
  889.     }
  890.  
  891.     if( FAILED(sc = GetScode(hError = m_lpTable->SeekRow(BOOKMARK_BEGINNING, 0, &cRows))) )
  892.     {
  893.         SetStatus("SeekRow failed", sc);
  894.         wsprintf(szErrorBuff,"CTblDlg::RenderTable(), lpTable->SeekRow(BOOKMARK_BEGINNING, 0, &cRows)) SC: %s",
  895.                      GetString( "MAPIErrors", sc, szDummy) );
  896.         MessageBox(szErrorBuff,"Error", MB_ICONSTOP | MB_OK);
  897.         return;
  898.     }
  899.     
  900.     ASSERT(lpRows);
  901.  
  902.     m_cRows = lpRows->cRows;
  903.     if(!m_cRows)
  904.     {
  905.         SendDlgItemMessage(IDC_DISPLAYVALUE, LB_RESETCONTENT, 0, 0L);
  906.         SendDlgItemMessage(IDC_ROWVALUES, LB_RESETCONTENT, 0, 0L);
  907.         FreeRowSet(lpRows);
  908.         return;
  909.     }
  910.  
  911.     FreeRowSet(lpRows);
  912.  
  913.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryRows(ulSize, TBL_NOADVANCE, &lpRows))) )
  914.         SetStatus("QueryRows failed", sc);
  915.  
  916.     if(lpRows->cRows != m_cRows)
  917.         m_cRows = lpRows->cRows;
  918.  
  919.     /* Look for m_ulptDisplay.  If found, remember its index in the
  920.        PropArray, else display UI and ask user for the property they want
  921.        to display in the left pane. */
  922.     for(idx = 0; idx < lpRows->aRow[0].cValues; idx++)
  923.     {
  924.         if(lpRows->aRow[0].lpProps[idx].ulPropTag == m_ulptDisplay)
  925.             break;
  926.     }
  927.  
  928.     if(idx < lpRows->aRow[0].cValues)
  929.     {
  930.         idxDN = idx;
  931.     }
  932.     else
  933.     {
  934.         MessageBox("Click OK to select a Display Property.",
  935.                     "Warning", MB_OK | MB_ICONINFORMATION);
  936.  
  937.         CPickPropDlg dlgPickProp(&lpRows->aRow[0], &idxDN);
  938.         dlgPickProp.DoModal();
  939.     }
  940.  
  941.     /* Keep PropTag of Display Value property */
  942.     m_ulptDisplay = lpRows->aRow[0].lpProps[idxDN].ulPropTag;
  943.  
  944.     /* Reset then populate Table listbox with Display Values */
  945.     SendDlgItemMessage(IDC_DISPLAYVALUE, LB_RESETCONTENT, 0, 0L);
  946.  
  947.     for(idx = 0; idx < m_cRows; idx++)
  948.     {
  949.         SzGetPropValue(szBuff, &lpRows->aRow[idx].lpProps[idxDN]);
  950.         SendDlgItemMessage(IDC_DISPLAYVALUE, LB_ADDSTRING, 0, (LPARAM)szBuff);
  951.     }
  952.  
  953.     lstrcpy(szBuffer,"END OF TABLE");
  954.     SendDlgItemMessage(IDC_DISPLAYVALUE, LB_ADDSTRING, 0, (LPARAM)szBuffer);
  955.     SendDlgItemMessage(IDC_DISPLAYVALUE, LB_SETCURSEL, 0, 0L);
  956.  
  957.     FreeRowSet(lpRows);
  958. }
  959.  
  960.  
  961. /*
  962.  -  SetStatus(Overloaded)
  963.  -
  964.  *  Purpose:
  965.  *      Displays a status message in the status window at bottom of dialog.
  966.  *
  967.  */
  968.  
  969. void SetStatus(LPSTR szMsg, SCODE sc)
  970. {
  971.     char    szError[80];
  972.     char    szBuff[80];
  973.  
  974.     GetString("MAPIErrors", sc, szError);
  975.     wsprintf(szBuff, "%s: %s", szMsg, szError);
  976.     pStatusWnd->SetWindowText(szBuff);
  977.     pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM) szBuff);
  978. }
  979.  
  980.  
  981. #ifdef WIN16
  982. /*
  983.  -  SetStatus(Overloaded)
  984.  -
  985.  *  Purpose:
  986.  *      Displays a status message in the status window at bottom of dialog.
  987.  *
  988.  */
  989.  
  990. void SetStatus(LPSTR szMsg, HRESULT hr)
  991. {
  992.     SetStatus(szMsg, GetScode(hr));
  993. }
  994. #endif   
  995.  
  996. /*-----------------------------*/
  997. /* CSetColDlg Message Handlers */
  998. /*-----------------------------*/
  999.  
  1000. BEGIN_MESSAGE_MAP(CSetColDlg, CModalDialog)
  1001.     ON_COMMAND(IDC_ADD,         OnAdd)
  1002.     ON_COMMAND(IDC_REMOVE,      OnRemove)
  1003.     ON_COMMAND(IDC_REMOVEALL,   OnRemoveAll)
  1004.     ON_COMMAND(IDC_ADDHEX,      OnAddHexValue)
  1005.     ON_COMMAND(IDC_ALLMAPITAGS, OnAllMAPITags)
  1006.     ON_COMMAND(IDC_SET,         OnSet)
  1007.     ON_COMMAND(IDOK,            OnClose)
  1008.     ON_COMMAND(IDCANCEL,        OnCancel)
  1009. END_MESSAGE_MAP()
  1010.  
  1011.  
  1012. /*
  1013.  -  CSetColDlg::
  1014.  -  OnInitDialog
  1015.  -
  1016.  *  Purpose:
  1017.  *      Constructor for main dialog class.
  1018.  *
  1019.  */
  1020.  
  1021. BOOL CSetColDlg::OnInitDialog()
  1022. {
  1023.     SCODE           sc;
  1024.     ULONG           idx;
  1025.     char            szBuff[256];
  1026.     LPSPropTagArray lpAllColumns;
  1027.     LPSPropTagArray lpCurColumns;
  1028.  
  1029.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryColumns(TBL_ALL_COLUMNS, &lpAllColumns))) )
  1030.         SetStatus("QueryColumns failed", sc);
  1031.  
  1032.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryColumns(0, &lpCurColumns))) )
  1033.         SetStatus("QueryColumns failed", sc);
  1034.  
  1035.     for(idx = 0; idx < lpAllColumns->cValues; idx++)
  1036.     {
  1037.         GetString("PropTags", lpAllColumns->aulPropTag[idx], szBuff);
  1038.         SendDlgItemMessage(IDC_ALLCOL, LB_ADDSTRING, 0, (LPARAM)szBuff);
  1039.     }
  1040.  
  1041.     for(idx = 0; idx < lpCurColumns->cValues; idx++)
  1042.     {
  1043.         GetString("PropTags", lpCurColumns->aulPropTag[idx], szBuff);
  1044.         SendDlgItemMessage(IDC_CURCOL, LB_ADDSTRING, 0, (LPARAM)szBuff);
  1045.     }
  1046.  
  1047.     MAPIFreeBuffer(lpAllColumns);
  1048.     MAPIFreeBuffer(lpCurColumns);
  1049.  
  1050.     return TRUE;
  1051. }
  1052.  
  1053.  
  1054. /*
  1055.  -  CSetColDlg
  1056.  -  OnAdd
  1057.  -
  1058.  *  Purpose:
  1059.  *      Adds the requested columns for a SetColumns call.
  1060.  *
  1061.  */
  1062.  
  1063. void CSetColDlg::OnAdd()
  1064. {
  1065.     DWORD       idx;
  1066.     INT         *lpItems;
  1067.     LONG        nSc;
  1068.     char        szPropTag[128];
  1069.     char        szBuff[128];
  1070.  
  1071.     nSc = SendDlgItemMessage( IDC_ALLCOL, LB_GETSELCOUNT, 0, 0L);
  1072.     lpItems = (INT *)PvAlloc(sizeof(int)*nSc);
  1073.     idx = SendDlgItemMessage(IDC_ALLCOL, LB_GETSELITEMS, (WPARAM)nSc, (LPARAM)lpItems );
  1074.  
  1075.     if( idx == LB_ERR )
  1076.     {
  1077.         wsprintf(szBuff, "An error occured when adding a PropTag");
  1078.         pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM) szBuff);
  1079.  
  1080.         PvFree(lpItems);
  1081.         return;
  1082.     }
  1083.  
  1084.     for( nSc=0; nSc<idx; nSc++ )
  1085.     {
  1086.         SendDlgItemMessage(IDC_ALLCOL, LB_GETTEXT, lpItems[nSc], (LPARAM)szPropTag);
  1087.         SendDlgItemMessage(IDC_CURCOL, LB_ADDSTRING, 0, (LPARAM)szPropTag);
  1088.     }
  1089.     PvFree(lpItems);
  1090.     wsprintf(szBuff, "All PropTag(s) were added to SetColumns");
  1091.     pLogWnd->SendMessage(LB_ADDSTRING, 0, (LPARAM) szBuff);
  1092. }
  1093.  
  1094.  
  1095. /*
  1096.  -  CSetColDlg
  1097.  -  OnRemove
  1098.  -
  1099.  *  Purpose:
  1100.  *      Removes the requested columns for a SetColumns call.
  1101.  *
  1102.  */
  1103.  
  1104. void CSetColDlg::OnRemove()
  1105. {
  1106.     DWORD       idx;
  1107.     INT         *lpItems;
  1108.     LONG        nSc;
  1109.  
  1110.     nSc = SendDlgItemMessage( IDC_CURCOL, LB_GETSELCOUNT, 0, 0L);
  1111.     if( nSc == 0)
  1112.         return;
  1113.  
  1114.     lpItems = (INT *)PvAlloc(sizeof(int)*nSc);
  1115.     idx = SendDlgItemMessage(IDC_CURCOL, LB_GETSELITEMS, (WPARAM)nSc, (LPARAM)lpItems );
  1116.  
  1117.     if( idx == LB_ERR )
  1118.     {
  1119.         PvFree(lpItems);
  1120.         return;
  1121.     }
  1122.  
  1123.     while(nSc-- > 0)
  1124.         SendDlgItemMessage(IDC_CURCOL, LB_DELETESTRING, (WPARAM)lpItems[nSc], 0L);
  1125.  
  1126.     PvFree(lpItems);
  1127. }
  1128.  
  1129.  
  1130. /*
  1131.  -  CSetColDlg
  1132.  -  OnRemove
  1133.  -
  1134.  *  Purpose:
  1135.  *      Removes all columns for a SetColumns call.
  1136.  *
  1137.  */
  1138.  
  1139. void CSetColDlg::OnRemoveAll()
  1140. {
  1141.     SendDlgItemMessage(IDC_CURCOL, LB_RESETCONTENT, (WPARAM)0, 0L);
  1142. }
  1143.  
  1144.  
  1145. /*
  1146.  -  CSetColDlg
  1147.  -  OnRemove
  1148.  -
  1149.  *  Purpose:
  1150.  *      Takes the requested columns and updates the table.
  1151.  *
  1152.  */
  1153.  
  1154. void CSetColDlg::OnSet()
  1155. {
  1156.     SCODE           sc;
  1157.     DWORD           idx, cPropTags;
  1158.     char            szPropTag[128];
  1159.     ULONG *         lpulTag;
  1160.     LPSPropTagArray lpspta;
  1161.     char            *szEnd      = NULL;    
  1162.  
  1163.     cPropTags = SendDlgItemMessage(IDC_CURCOL, LB_GETCOUNT, 0, 0L);
  1164.  
  1165.     lpspta = (LPSPropTagArray)PvAlloc(sizeof(SPropTagArray) + cPropTags * sizeof(ULONG));
  1166.  
  1167.     lpspta->cValues = cPropTags;
  1168.  
  1169.     lpulTag = &lpspta->aulPropTag[0];
  1170.  
  1171.     for(idx=0; idx<cPropTags; idx++)
  1172.     {
  1173.         SendDlgItemMessage(IDC_CURCOL, LB_GETTEXT, (WPARAM)idx, (LPARAM)szPropTag);
  1174.         if(!GetID("PropTags", szPropTag, (LONG *)lpulTag))
  1175.         #ifdef WIN16
  1176.             *lpulTag = strtoul(szPropTag,&szEnd,16);
  1177.         #else
  1178.             sscanf(szPropTag, "0x%lX", lpulTag);
  1179.         #endif
  1180.         lpulTag++;
  1181.     }
  1182.  
  1183.  
  1184.     if( FAILED(sc = GetScode(hError = m_lpTable->SetColumns(lpspta, 0))) )
  1185.         SetStatus("SetColumns failed", sc);
  1186.  
  1187.     PvFree(lpspta);
  1188. }
  1189.  
  1190.  
  1191. /*
  1192.  -  CSetColDlg::
  1193.  -  OnAddHexValue()
  1194.  *
  1195.  *  Purpose:
  1196.  *      Select a hex value for the PROP ID and adjust the
  1197.  *      proptag listbox and the prop data accordingly
  1198.  *
  1199.  *  Parameters:
  1200.  *      None
  1201.  *
  1202.  *  Returns:
  1203.  *      Nothing
  1204.  *
  1205.  */
  1206.  
  1207. void CSetColDlg::OnAddHexValue()
  1208. {
  1209.     char    szBuffer[512];
  1210.     ULONG   ulIDVal     = 0;
  1211.     LONG    len         = -1;
  1212.  
  1213.     // get value out of the edit control
  1214.     *(WORD *)szBuffer = sizeof(szBuffer) -1;    // first char has buffer length
  1215.  
  1216.     len  = SendDlgItemMessage(IDC_HEXVALUE, EM_GETLINE, 0, (LPARAM)(void *)szBuffer);
  1217.  
  1218.     szBuffer[len] = '\0';        // null terminate our buffer
  1219.  
  1220.     if( ! AsciiToHex(len, szBuffer, &ulIDVal ) )
  1221.  
  1222.     {
  1223.         MessageBox("AsciiToHex conversion failed", "Error", MB_OK | MB_ICONEXCLAMATION );
  1224.         return;
  1225.     }
  1226.  
  1227.     if( !GetString("PropIDs", ulIDVal, szBuffer) )
  1228.     {
  1229.         wsprintf(szBuffer, "0x%X",ulIDVal);
  1230.         SendDlgItemMessage(IDC_CURCOL, LB_ADDSTRING, 0, (LPARAM)szBuffer);
  1231.     }
  1232.     else
  1233.         SendDlgItemMessage(IDC_CURCOL, LB_ADDSTRING, 0, (LPARAM)szBuffer);
  1234.  
  1235.     strcpy(szBuffer,"");
  1236.     SendDlgItemMessage(IDC_HEXVALUE, WM_SETTEXT, 0, (LPARAM)szBuffer);
  1237. }
  1238.  
  1239.  
  1240. /*
  1241.  -  CSetColDlg
  1242.  -  OnAddMAPITags
  1243.  -
  1244.  *  Purpose
  1245.  *      Adds all MAPI PropTags to the  list.
  1246.  *
  1247.  */
  1248.  
  1249. void CSetColDlg::OnAllMAPITags()
  1250. {
  1251.     ULONG       idx;
  1252.     ULONG       ulRowCount;
  1253.     char        szBuffer[64];
  1254.  
  1255.     //Reset content of listbox
  1256.     SendDlgItemMessage(IDC_ALLCOL, LB_RESETCONTENT, 0, (LPARAM)0);
  1257.  
  1258.     // ADD DATA TO LISTBOX OF PROP IDS
  1259.     szBuffer[0] = '\0' ;
  1260.     // this (UNKNOWN PROPID) is always in the 0th place in listbox
  1261.     SendDlgItemMessage(IDC_ALLCOL, LB_ADDSTRING, 0, (LPARAM)(void *)"AN UNKNOWN PROPID");
  1262.  
  1263.     ulRowCount = GetRowCount("PropIDs");
  1264.     for( idx = 0; idx < ulRowCount ; idx++ )
  1265.     {
  1266.         GetRowString("PropIDs",idx,szBuffer);
  1267.         SendDlgItemMessage(IDC_ALLCOL, LB_ADDSTRING, 0, (LPARAM)szBuffer);
  1268.     }
  1269. }
  1270.  
  1271.  
  1272. /*
  1273.  -  CSetColDlg
  1274.  -  OnClose
  1275.  -
  1276.  *  Purpose
  1277.  *      Closes the SetColumns dialog.
  1278.  *
  1279.  */
  1280.  
  1281. void CSetColDlg::OnClose()
  1282. {
  1283.     if( SendDlgItemMessage(IDC_CURCOL, LB_GETCOUNT, 0, 0L) == 0)
  1284.         MessageBox("You must select at least 1 property.",
  1285.                    "Warning", MB_OK | MB_ICONINFORMATION);
  1286.     else
  1287.         EndDialog(IDOK);
  1288. }
  1289.  
  1290.  
  1291. /*
  1292.  -  CSetColDlg
  1293.  -  OnCancel
  1294.  -
  1295.  *  Purpose
  1296.  *      Cancels the SetColumns dialog.
  1297.  *
  1298.  */
  1299.  
  1300. void CSetColDlg::OnCancel()
  1301. {
  1302.     EndDialog(IDCANCEL);
  1303. }
  1304.  
  1305.  
  1306. /*-------------------------------*/
  1307. /* CPickPropDlg Message Handlers */
  1308. /*-------------------------------*/
  1309.  
  1310. BEGIN_MESSAGE_MAP(CPickPropDlg, CModalDialog)
  1311. END_MESSAGE_MAP()
  1312.  
  1313.  
  1314. /*
  1315.  -  CPickPropDlg::
  1316.  -  OnInitDialog
  1317.  -
  1318.  *  Purpose:
  1319.  *      Constructor for main dialog class.
  1320.  *
  1321.  */
  1322.  
  1323. BOOL CPickPropDlg::OnInitDialog()
  1324. {
  1325.     ULONG   idx;
  1326.     char    szPropTag[256];
  1327.  
  1328.     for(idx = 0; idx < m_lpRow->cValues; idx++)
  1329.     {
  1330.         GetString("PropTags", m_lpRow->lpProps[idx].ulPropTag, szPropTag);
  1331.         SendDlgItemMessage(IDC_PICKPROP, LB_ADDSTRING, 0, (LPARAM)szPropTag);
  1332.     }
  1333.  
  1334.     return TRUE;
  1335. }
  1336.  
  1337. /*
  1338.  -  CPickPropDlg
  1339.  -  OnOK
  1340.  -
  1341.  *  Purpose:
  1342.  *      Retrieves the currently selected property for display values
  1343.  *
  1344.  */
  1345.  
  1346. void CPickPropDlg::OnOK()
  1347. {
  1348.     *m_lpdwIndex = SendDlgItemMessage(IDC_PICKPROP, LB_GETCURSEL, 0, 0L);
  1349.     EndDialog(IDOK);
  1350. }
  1351.  
  1352.  
  1353. /*-----------------------------*/
  1354. /* CFreeBkDlg Message Handlers */
  1355. /*-----------------------------*/
  1356.  
  1357. BEGIN_MESSAGE_MAP(CFreeBkDlg, CModalDialog)
  1358.     ON_COMMAND(IDC_FREE,    OnFree)
  1359.     ON_COMMAND(IDC_FREEALL, OnFreeAll)
  1360.     ON_COMMAND(IDC_CLOSE,   OnClose)
  1361. END_MESSAGE_MAP()
  1362.  
  1363.  
  1364. /*
  1365.  -  CFreeBkDlg::
  1366.  -  OnInitDialog
  1367.  -
  1368.  *  Purpose:
  1369.  *      Constructor for main dialog class.
  1370.  *
  1371.  */
  1372.  
  1373. BOOL CFreeBkDlg::OnInitDialog()
  1374. {
  1375.     ULONG   idx;
  1376.     char    szBuff[512];
  1377.  
  1378.     if(!m_lpBkList->cValues)
  1379.     {
  1380.         GetDlgItem(IDC_FREE)->EnableWindow(FALSE);
  1381.         GetDlgItem(IDC_FREEALL)->EnableWindow(FALSE);
  1382.         return TRUE;
  1383.     }
  1384.  
  1385.     for(idx = 0; idx < m_lpBkList->cValues; idx++)
  1386.     {
  1387.         SzGetPropValue(szBuff, m_lpBkList->bkList[idx].lpProp);
  1388.         SendDlgItemMessage(IDC_BKVALUES, LB_ADDSTRING, 0, (LPARAM)szBuff);
  1389.     }
  1390.  
  1391.     return TRUE;
  1392. }
  1393.  
  1394.  
  1395. /*
  1396.  -  CFreeBkDlg::
  1397.  -  OnFree
  1398.  -
  1399.  *  Purpose:
  1400.  *      Frees the requested bookmarks.
  1401.  *
  1402.  */
  1403.  
  1404. void CFreeBkDlg::OnFree()
  1405. {
  1406.     DWORD       cLeft = 0;
  1407.     INT         *lpItems;
  1408.     LONG        nSc;
  1409.     SCODE       sc;
  1410.  
  1411.     nSc = SendDlgItemMessage( IDC_BKVALUES, LB_GETSELCOUNT, 0, 0L);
  1412.     lpItems = (INT *)PvAlloc(sizeof(int)*nSc);
  1413.     if( SendDlgItemMessage(IDC_BKVALUES, LB_GETSELITEMS, (WPARAM)nSc, (LPARAM)lpItems ) == LB_ERR )
  1414.     {
  1415.         PvFree(lpItems);
  1416.         return;
  1417.     }
  1418.  
  1419.     while(nSc-- > 0)
  1420.     {
  1421.         cLeft = SendDlgItemMessage(IDC_BKVALUES, LB_DELETESTRING, (WPARAM)lpItems[nSc], 0L);
  1422.         if( FAILED(sc = GetScode(hError = m_lpTable->FreeBookmark(m_lpBkList->bkList[nSc].bk))) )
  1423.             SetStatus("FreeBookmark failed", sc);
  1424.         RemoveBookmark(m_lpBkList, nSc);
  1425.     }
  1426.     PvFree(lpItems);
  1427.  
  1428.     if(!cLeft)
  1429.     {
  1430.         GetDlgItem(IDC_FREE)->EnableWindow(FALSE);
  1431.         GetDlgItem(IDC_FREEALL)->EnableWindow(FALSE);
  1432.     }
  1433. }
  1434.  
  1435.  
  1436. /*
  1437.  -  CFreeBkDlg::
  1438.  -  OnFreeAll
  1439.  -
  1440.  *  Purpose:
  1441.  *      Frees all of the bookmarks.
  1442.  *
  1443.  */
  1444.  
  1445. void CFreeBkDlg::OnFreeAll()
  1446. {
  1447.     SCODE   sc;
  1448.     DWORD   idx;
  1449.     DWORD   cBks;
  1450.  
  1451.     cBks = m_lpBkList->cValues;
  1452.  
  1453.     for(idx = cBks; idx > 0; idx--)
  1454.     {
  1455.         if( FAILED(sc = GetScode(hError = m_lpTable->FreeBookmark(m_lpBkList->bkList[idx-1].bk))) )
  1456.             SetStatus("FreeBookmark failed", sc);
  1457.         RemoveBookmark(m_lpBkList, idx-1);
  1458.     }
  1459.  
  1460.     SendDlgItemMessage(IDC_BKVALUES, LB_RESETCONTENT, 0, 0L);
  1461.  
  1462.     GetDlgItem(IDC_FREE)->EnableWindow(FALSE);
  1463.     GetDlgItem(IDC_FREEALL)->EnableWindow(FALSE);
  1464. }
  1465.  
  1466.  
  1467. /*
  1468.  -  CFreeBkDlg::
  1469.  -  OnClose
  1470.  -
  1471.  *  Purpose:
  1472.  *      Closes the FreeBookmark dialog.
  1473.  *
  1474.  */
  1475.  
  1476. void CFreeBkDlg::OnClose()
  1477. {
  1478.     EndDialog(IDOK);
  1479. }
  1480.  
  1481.  
  1482. /*-----------------------------*/
  1483. /* CSortDlg Message Handlers */
  1484. /*-----------------------------*/
  1485.  
  1486. BEGIN_MESSAGE_MAP(CSortDlg, CModalDialog)
  1487.     ON_COMMAND(IDC_ADDA,        OnAdd)
  1488.     ON_COMMAND(IDC_ADDD,        OnAddDesc)
  1489.     ON_COMMAND(IDC_REMOVESORT,  OnRemove)
  1490.     ON_COMMAND(IDC_REMOVEALL,   OnRemoveAll)
  1491.     ON_COMMAND(IDC_ADDHEXA,     OnAddHexValueA)
  1492.     ON_COMMAND(IDC_ADDHEXD,     OnAddHexValueD)    
  1493.     ON_COMMAND(IDC_ALLMAPITAGS, OnAllMAPITags)    
  1494. END_MESSAGE_MAP()
  1495.  
  1496.  
  1497. /*
  1498.  -  CSortDlg::
  1499.  -  OnInitDialog
  1500.  -
  1501.  *  Purpose:
  1502.  *      Constructor for main dialog class.
  1503.  *
  1504.  */
  1505.  
  1506. BOOL CSortDlg::OnInitDialog()
  1507. {
  1508.     SCODE           sc;
  1509.     ULONG           idx;
  1510.     DWORD           dwIndex;
  1511.     LPSSortOrder    lpso = NULL;
  1512.     LPSSortOrderSet lpCurSort = NULL;
  1513.     LPSPropTagArray lpAllColumns = NULL;
  1514.     char            szBuff[128];
  1515.     char            szPropTag[128];
  1516.  
  1517.     fDesc = FALSE;
  1518.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryColumns(TBL_ALL_COLUMNS, &lpAllColumns))) )
  1519.         SetStatus("QueryColumns",sc);
  1520.  
  1521.     for(idx = 0; idx < lpAllColumns->cValues; idx++)
  1522.     {
  1523.         GetString("PropTags", lpAllColumns->aulPropTag[idx], szPropTag);
  1524.         SendDlgItemMessage(IDC_COLUMN, LB_ADDSTRING, 0, (LPARAM)szPropTag);
  1525.     }
  1526.  
  1527.     if( FAILED(sc = GetScode(hError = m_lpTable->QuerySortOrder(&lpCurSort))) )
  1528.     {
  1529.         SetStatus("QuerySortOrder failed", sc);
  1530.         goto exit;
  1531.     }
  1532.  
  1533.     for(idx = 0; idx < lpCurSort->cSorts; idx++)
  1534.     {
  1535.         lpso = (LPSSortOrder)PvAlloc(sizeof(SSortOrder));
  1536.  
  1537.         *lpso = lpCurSort->aSort[idx];
  1538.  
  1539.         GetString("PropTags", lpso->ulPropTag, szPropTag);
  1540.  
  1541.         if(lpso->ulOrder == TABLE_SORT_ASCEND)
  1542.             wsprintf(szBuff, "A %s", szPropTag);
  1543.         else
  1544.             wsprintf(szBuff, "D %s", szPropTag);
  1545.  
  1546.         dwIndex = SendDlgItemMessage(IDC_SORT, LB_ADDSTRING, 0, (LPARAM)szBuff);
  1547.  
  1548.         SendDlgItemMessage(IDC_SORT, LB_SETITEMDATA, (WPARAM)dwIndex, (LPARAM)lpso);
  1549.     }
  1550.  
  1551.     MAPIFreeBuffer(lpCurSort);
  1552.  
  1553. exit:
  1554.     MAPIFreeBuffer(lpAllColumns);
  1555.  
  1556.     return TRUE;
  1557. }
  1558.  
  1559.  
  1560. /*
  1561.  -  CSortDlg
  1562.  -  OnAdd
  1563.  -
  1564.  *  Purpose:
  1565.  *      Adds an ascending sort order criteria.
  1566.  *
  1567.  */
  1568.  
  1569. void CSortDlg::OnAdd()
  1570. {
  1571.     DWORD           dwIndex;
  1572.     char            szBuff[128];
  1573.     char            szPropTag[128];
  1574.     LPSSortOrder    lpso;
  1575.  
  1576.     dwIndex = SendDlgItemMessage(IDC_COLUMN, LB_GETCURSEL, 0, 0L);
  1577.  
  1578.     if(dwIndex == LB_ERR)
  1579.         return;
  1580.  
  1581.     SendDlgItemMessage(IDC_COLUMN, LB_GETTEXT,
  1582.             (WPARAM)dwIndex, (LPARAM)szPropTag);
  1583.  
  1584.     lpso = (LPSSortOrder)PvAlloc(sizeof(SSortOrder));
  1585.  
  1586.     if(fDesc)
  1587.     {
  1588.         if(!GetID("PropTags", szPropTag, (LONG *)&lpso->ulPropTag))
  1589.             lpso->ulPropTag = strtoul(szPropTag, NULL ,0);
  1590.         lpso->ulOrder   = TABLE_SORT_DESCEND;
  1591.  
  1592.         wsprintf(szBuff, "D %s", szPropTag);
  1593.         fDesc = FALSE;
  1594.     }
  1595.  
  1596.     else
  1597.     {
  1598.         if(!GetID("PropTags", szPropTag, (LONG *)&lpso->ulPropTag))
  1599.             lpso->ulPropTag = strtoul(szPropTag, NULL ,0);
  1600.         lpso->ulOrder   = TABLE_SORT_ASCEND;
  1601.  
  1602.         wsprintf(szBuff, "A %s", szPropTag);
  1603.     }
  1604.  
  1605.     dwIndex = SendDlgItemMessage(IDC_SORT, LB_ADDSTRING, 0, (LPARAM)szBuff);
  1606.  
  1607.     SendDlgItemMessage(IDC_SORT, LB_SETITEMDATA, (WPARAM)dwIndex, (LPARAM)lpso);
  1608. }
  1609.  
  1610. /*
  1611.  -  CSortDlg
  1612.  -  OnAddDesc
  1613.  -
  1614.  *  Purpose:
  1615.  *      Adds an ascending sort order criteria.
  1616.  *
  1617.  */
  1618.  
  1619. void CSortDlg::OnAddDesc()
  1620. {
  1621.     fDesc = TRUE;
  1622.     OnAdd();
  1623. }
  1624.  
  1625.  
  1626. /*
  1627.  -  CSortDlg
  1628.  -  OnRemove
  1629.  -
  1630.  *  Purpose:
  1631.  *      Removes a sort order.
  1632.  *
  1633.  */
  1634.  
  1635. void CSortDlg::OnRemove()
  1636. {
  1637.     DWORD           dwIndex;
  1638.     LPSSortOrder    lpso;
  1639.  
  1640.     dwIndex = SendDlgItemMessage(IDC_SORT, LB_GETCURSEL, 0, 0L);
  1641.  
  1642.     if(dwIndex == LB_ERR)
  1643.         return;
  1644.  
  1645.     lpso = (LPSSortOrder)SendDlgItemMessage(IDC_SORT,
  1646.             LB_GETITEMDATA, (WPARAM)dwIndex, 0L);
  1647.  
  1648.     PvFree(lpso);
  1649.  
  1650.     SendDlgItemMessage(IDC_SORT, LB_DELETESTRING, (WPARAM)dwIndex, 0L);
  1651. }
  1652.  
  1653.  
  1654. /*
  1655.  -  CSortDlg
  1656.  -  OnRemoveAll
  1657.  -
  1658.  *  Purpose:
  1659.  *      Removes all sort orders.
  1660.  *
  1661.  */
  1662.  
  1663. void CSortDlg::OnRemoveAll()
  1664. {
  1665.     LPSSortOrder    lpso;
  1666.     DWORD           idx;
  1667.     DWORD           cSorts;
  1668.  
  1669.     cSorts = SendDlgItemMessage(IDC_SORT, LB_GETCOUNT, 0, 0L);
  1670.  
  1671.     for(idx = 0; idx < cSorts; idx++)
  1672.     {
  1673.         lpso = (LPSSortOrder)SendDlgItemMessage(IDC_SORT,
  1674.                 LB_GETITEMDATA, (WPARAM)idx, 0L);
  1675.  
  1676.         PvFree(lpso);
  1677.     }
  1678.  
  1679.     SendDlgItemMessage(IDC_SORT, LB_RESETCONTENT, 0, 0L);
  1680. }
  1681.  
  1682.  
  1683. /*
  1684.  -  CSortDlg::
  1685.  -  OnAddHexValueA()
  1686.  *
  1687.  *  Purpose:
  1688.  *      Select a hex value for the PROP ID and adjust the
  1689.  *      proptag listbox and the prop data accordingly.  Order is Ascending
  1690.  *
  1691.  *  Parameters:
  1692.  *      None
  1693.  *
  1694.  *  Returns:
  1695.  *      Nothing
  1696.  *
  1697.  */
  1698.               
  1699. void CSortDlg::OnAddHexValueA()
  1700. {
  1701.     char            szBuffer[512];
  1702.     ULONG           ulIDVal     = 0;
  1703.     LONG            len         = -1;
  1704.     DWORD           dwIndex;
  1705.     char            szBuff[128];
  1706.     char            szPropTag[128];
  1707.     LPSSortOrder    lpso;
  1708.  
  1709.     // get value out of the edit control
  1710.     *(WORD *)szBuffer = sizeof(szBuffer) -1;    // first char has buffer length
  1711.  
  1712.     len  = SendDlgItemMessage(IDC_HEXVALUE, EM_GETLINE, 0, (LPARAM)(void *)szBuffer);
  1713.  
  1714.     szBuffer[len] = '\0';        // null terminate our buffer
  1715.  
  1716.     if( ! AsciiToHex(len, szBuffer, &ulIDVal ) )
  1717.  
  1718.     {
  1719.         MessageBox("AsciiToHex conversion failed", "Error", MB_OK | MB_ICONEXCLAMATION );
  1720.         return;
  1721.     }
  1722.  
  1723.     lpso = (LPSSortOrder)PvAlloc(sizeof(SSortOrder));
  1724.  
  1725.     if(fDesc)
  1726.     {
  1727.         if( GetString("PropIDs", ulIDVal, szBuffer) )
  1728.             GetID("PropTags", szPropTag, (LONG *)&lpso->ulPropTag);
  1729.         else
  1730.         {
  1731.             lpso->ulPropTag = ulIDVal;
  1732.             wsprintf(szPropTag, "0x%X",ulIDVal);
  1733.         }                        
  1734.                         
  1735.         lpso->ulOrder   = TABLE_SORT_DESCEND;
  1736.  
  1737.         wsprintf(szBuff, "D %s", szPropTag);
  1738.         fDesc = FALSE;
  1739.     }
  1740.  
  1741.     else
  1742.     {
  1743.         if( GetString("PropIDs", ulIDVal, szBuffer) )
  1744.             GetID("PropTags", szPropTag, (LONG *)&lpso->ulPropTag);
  1745.         else
  1746.         {
  1747.             lpso->ulPropTag = ulIDVal;
  1748.             wsprintf(szPropTag, "0x%X",ulIDVal);
  1749.         }                        
  1750.  
  1751.         lpso->ulOrder   = TABLE_SORT_ASCEND;
  1752.  
  1753.         wsprintf(szBuff, "A %s", szPropTag);
  1754.     }
  1755.  
  1756.     dwIndex = SendDlgItemMessage(IDC_SORT, LB_ADDSTRING, 0, (LPARAM)szBuff);
  1757.  
  1758.     SendDlgItemMessage(IDC_SORT, LB_SETITEMDATA, (WPARAM)dwIndex, (LPARAM)lpso);
  1759.  
  1760.     strcpy(szBuff,"");
  1761.     SendDlgItemMessage(IDC_HEXVALUE, WM_SETTEXT, 0, (LPARAM)szBuff); 
  1762. }
  1763.  
  1764.  
  1765. /*
  1766.  -  CSortDlg
  1767.  -  OnAddHexValueD
  1768.  -
  1769.  *  Purpose:
  1770.  *      Adds an ascending sort order criteria.
  1771.  *
  1772.  */
  1773.  
  1774. void CSortDlg::OnAddHexValueD()
  1775. {
  1776.     fDesc = TRUE;
  1777.     OnAddHexValueA();
  1778. }
  1779.  
  1780.  
  1781. /*
  1782.  -  CSetColDlg
  1783.  -  OnAddMAPITags
  1784.  -
  1785.  *  Purpose
  1786.  *      Adds all MAPI PropTags to the  list.
  1787.  *
  1788.  */
  1789.  
  1790. void CSortDlg::OnAllMAPITags()
  1791. {
  1792.     ULONG       idx;
  1793.     ULONG       ulRowCount;
  1794.     char        szBuffer[64];
  1795.  
  1796.     //Reset content of listbox
  1797.     SendDlgItemMessage(IDC_COLUMN, LB_RESETCONTENT, 0, (LPARAM)0);
  1798.  
  1799.     // ADD DATA TO LISTBOX OF PROP IDS
  1800.     szBuffer[0] = '\0' ;
  1801.     // this (UNKNOWN PROPID) is always in the 0th place in listbox
  1802.     SendDlgItemMessage(IDC_COLUMN, LB_ADDSTRING, 0, (LPARAM)(void *)"AN UNKNOWN PROPID");
  1803.  
  1804.     ulRowCount = GetRowCount("PropIDs");
  1805.     for( idx = 0; idx < ulRowCount ; idx++ )
  1806.     {
  1807.         GetRowString("PropIDs",idx,szBuffer);
  1808.         SendDlgItemMessage(IDC_COLUMN, LB_ADDSTRING, 0, (LPARAM)szBuffer);
  1809.     }
  1810. }
  1811.  
  1812.  
  1813. /*
  1814.  -  CSortDlg
  1815.  -  OnOK
  1816.  -
  1817.  *  Purpose:
  1818.  *      Exits the Sort dialog and assigns all the sort orders to
  1819.  *      be used when sort is executed(forced).
  1820.  *
  1821.  */
  1822.  
  1823. void CSortDlg::OnOK()
  1824. {
  1825.     LPSSortOrder    lpso;
  1826.     LPSSortOrderSet lpsos = NULL;
  1827.     DWORD           idx;
  1828.     DWORD           cSorts;
  1829.  
  1830.     cSorts = SendDlgItemMessage(IDC_SORT, LB_GETCOUNT, 0, 0L);
  1831.  
  1832.     lpsos = (LPSSortOrderSet)PvAlloc(sizeof(SSortOrderSet) + cSorts * sizeof(SSortOrder));
  1833.     lpsos->cSorts = cSorts;
  1834.     lpsos->cCategories = 0;
  1835.     lpsos->cExpanded = 0;
  1836.  
  1837.     for(idx = 0; idx < cSorts; idx++)
  1838.     {
  1839.         lpso = (LPSSortOrder)SendDlgItemMessage(IDC_SORT,
  1840.                 LB_GETITEMDATA, (WPARAM)idx, 0L);
  1841.  
  1842.         lpsos->aSort[idx] = *lpso;
  1843.  
  1844.         PvFree(lpso);
  1845.     }
  1846.  
  1847.     SendDlgItemMessage(IDC_SORT, LB_RESETCONTENT, 0, 0L);
  1848.  
  1849.     *m_lppSort = lpsos;
  1850.  
  1851.     EndDialog(IDOK);
  1852. }
  1853.  
  1854.  
  1855. /*
  1856.  -  CSortDlg
  1857.  -  OnCancel
  1858.  -
  1859.  *  Purpose:
  1860.  *      Cancels the sort dialog.
  1861.  *
  1862.  */
  1863.  
  1864. void CSortDlg::OnCancel()
  1865. {
  1866.     LPSSortOrder    lpso;
  1867.     DWORD           idx;
  1868.     DWORD           cSorts;
  1869.  
  1870.     cSorts = SendDlgItemMessage(IDC_SORT, LB_GETCOUNT, 0, 0L);
  1871.  
  1872.     for(idx = 0; idx < cSorts; idx++)
  1873.     {
  1874.         lpso = (LPSSortOrder)SendDlgItemMessage(IDC_SORT,
  1875.                 LB_GETITEMDATA, (WPARAM)idx, 0L);
  1876.  
  1877.         PvFree(lpso);
  1878.     }
  1879.  
  1880.     SendDlgItemMessage(IDC_SORT, LB_RESETCONTENT, 0, 0L);
  1881.  
  1882.     *m_lppSort = NULL;
  1883.  
  1884.     EndDialog(IDCANCEL);
  1885. }
  1886.  
  1887.  
  1888.  
  1889. /*-----------------------------*/
  1890. /* CSeekDlg Message Handlers   */
  1891. /*-----------------------------*/
  1892.  
  1893. BEGIN_MESSAGE_MAP(CSeekDlg, CModalDialog)
  1894.     ON_COMMAND(IDC_SEEKROW,       OnTypeSeekRow)
  1895.     ON_COMMAND(IDC_SEEKROWAPPROX, OnTypeSeekRowApprox)
  1896.     ON_COMMAND(IDC_BEGINNING,     OnBkBeginning)
  1897.     ON_COMMAND(IDC_CURRENT,       OnBkCurrent)
  1898.     ON_COMMAND(IDC_END,           OnBkEnd)
  1899.     ON_COMMAND(IDC_USER,          OnBkUser)
  1900. END_MESSAGE_MAP()
  1901.  
  1902.  
  1903. /*
  1904.  -  CSeekDlg::
  1905.  -  OnInitDialog
  1906.  -
  1907.  *  Purpose:
  1908.  *      Constructor for main dialog class.
  1909.  *
  1910.  */
  1911.  
  1912. BOOL CSeekDlg::OnInitDialog()
  1913. {
  1914.     ULONG   idx;
  1915.     char    szBuff[512];
  1916.  
  1917.     CheckDlgButton(IDC_SEEKROW, TRUE);
  1918.     CheckDlgButton(IDC_BEGINNING, TRUE);
  1919.  
  1920.     m_fSeek = TRUE;
  1921.     m_nBk = 0;
  1922.  
  1923.     if(!m_lpBkList->cValues)
  1924.     {
  1925.         GetDlgItem(IDC_USER)->EnableWindow(FALSE);
  1926.     }
  1927.     else
  1928.     {
  1929.         for(idx = 0; idx < m_lpBkList->cValues; idx++)
  1930.         {
  1931.             SzGetPropValue(szBuff, m_lpBkList->bkList[idx].lpProp);
  1932.  
  1933.             SendDlgItemMessage(IDC_BKSEEK, LB_ADDSTRING, 0, (LPARAM)szBuff);
  1934.         }
  1935.     }
  1936.  
  1937.     GetDlgItem(IDC_ROWCOUNT)->SetFocus();
  1938.  
  1939.     return TRUE;
  1940. }
  1941.  
  1942.  
  1943. /*
  1944.  -  CSeekDlg
  1945.  -  OnTypeSeekRow
  1946.  -
  1947.  *  Purpose:
  1948.  *      Changes the view in the SeekRow/SeekRowApprox dialog.  This view is for
  1949.  *      SeekRow().
  1950.  *
  1951.  */
  1952.  
  1953. void CSeekDlg::OnTypeSeekRow()
  1954. {
  1955.     GetDlgItem(IDT_NUMERATOR)->EnableWindow(FALSE);
  1956.     GetDlgItem(IDC_NUMERATOR)->EnableWindow(FALSE);
  1957.     GetDlgItem(IDT_DENOMINATOR)->EnableWindow(FALSE);
  1958.     GetDlgItem(IDC_DENOMINATOR)->EnableWindow(FALSE);
  1959.     GetDlgItem(IDT_ROWCOUNT)->EnableWindow(TRUE);
  1960.     GetDlgItem(IDC_ROWCOUNT)->EnableWindow(TRUE);
  1961.  
  1962.     m_fSeek = TRUE;
  1963. }
  1964.  
  1965.  
  1966. /*
  1967.  -  CSeekDlg
  1968.  -  OnTypeSeekRowApprox
  1969.  -
  1970.  *  Purpose:
  1971.  *      Changes the view in the SeekRow/SeekRowApprox dialog.  This view is for
  1972.  *      SeekRowApprox().
  1973.  *
  1974.  */
  1975.  
  1976. void CSeekDlg::OnTypeSeekRowApprox()
  1977. {
  1978.     GetDlgItem(IDT_NUMERATOR)->EnableWindow(TRUE);
  1979.     GetDlgItem(IDC_NUMERATOR)->EnableWindow(TRUE);
  1980.     GetDlgItem(IDT_DENOMINATOR)->EnableWindow(TRUE);
  1981.     GetDlgItem(IDC_DENOMINATOR)->EnableWindow(TRUE);
  1982.     GetDlgItem(IDT_ROWCOUNT)->EnableWindow(FALSE);
  1983.     GetDlgItem(IDC_ROWCOUNT)->EnableWindow(FALSE);
  1984.  
  1985.     m_fSeek = FALSE;
  1986. }
  1987.  
  1988.  
  1989. /*
  1990.  -  CSeekDlg
  1991.  -  OnBkBeginning
  1992.  -
  1993.  *  Purpose:
  1994.  *      Sets the Beginning bookmark.
  1995.  *
  1996.  */
  1997.  
  1998. void CSeekDlg::OnBkBeginning()
  1999. {
  2000.     m_nBk = 0;
  2001. }
  2002.  
  2003.  
  2004. /*
  2005.  -  CSeekDlg
  2006.  -  OnBkCurrent
  2007.  -
  2008.  *  Purpose:
  2009.  *      Sets the Current bookmark.
  2010.  *
  2011.  */
  2012.  
  2013. void CSeekDlg::OnBkCurrent()
  2014. {
  2015.     m_nBk = 1;
  2016. }
  2017.  
  2018.  
  2019. /*
  2020.  -  CSeekDlg
  2021.  -  OnBkEnd
  2022.  -
  2023.  *  Purpose:
  2024.  *      Sets the End bookmark.
  2025.  *
  2026.  */
  2027.  
  2028. void CSeekDlg::OnBkEnd()
  2029. {
  2030.     m_nBk = 2;
  2031. }
  2032.  
  2033.  
  2034. /*
  2035.  -  CSeekDlg
  2036.  -  OnBkUser
  2037.  -
  2038.  *  Purpose:
  2039.  *      Sets the user bookmark.
  2040.  *
  2041.  */
  2042.  
  2043. void CSeekDlg::OnBkUser()
  2044. {
  2045.     m_nBk = 3;
  2046. }
  2047.  
  2048.  
  2049. /*
  2050.  -  CSeekDlg
  2051.  -  OnOK
  2052.  -
  2053.  *  Purpose:
  2054.  *      Executes the SeekRow or SeekRowApprox command and closes the dialog.
  2055.  *
  2056.  */
  2057.  
  2058. void CSeekDlg::OnOK()
  2059. {
  2060.     SCODE       sc;
  2061.     BOOL        fSeek = FALSE;
  2062.     LONG        lRowCount;
  2063.     LONG        lRowsSeeked;
  2064.     ULONG       ulNum;
  2065.     ULONG       ulDenom;
  2066.     DWORD       dwIndex;
  2067.     BOOKMARK    bk;
  2068.  
  2069.     if(m_fSeek)
  2070.     {
  2071.         lRowCount = (LONG)(int)GetDlgItemInt(IDC_ROWCOUNT);
  2072.     }
  2073.     else
  2074.     {
  2075.         ulNum   = (ULONG)GetDlgItemInt(IDC_NUMERATOR, NULL, FALSE);
  2076.         ulDenom = (ULONG)GetDlgItemInt(IDC_DENOMINATOR, NULL, FALSE);
  2077.     }
  2078.  
  2079.     if(m_fSeek)
  2080.     {
  2081.         switch(m_nBk)
  2082.         {
  2083.         case 0:
  2084.             bk = BOOKMARK_BEGINNING;
  2085.             break;
  2086.  
  2087.         case 1:
  2088.             bk = BOOKMARK_CURRENT;
  2089.             break;
  2090.  
  2091.         case 2:
  2092.             bk = BOOKMARK_END;
  2093.             break;
  2094.  
  2095.         case 3:
  2096.             dwIndex = SendDlgItemMessage(IDC_BKSEEK, LB_GETCURSEL, 0, 0L);
  2097.  
  2098.             bk = m_lpBkList->bkList[dwIndex].bk;
  2099.             break;
  2100.         }
  2101.     }
  2102.  
  2103.     if(m_fSeek)
  2104.     {
  2105.         if( FAILED(sc = GetScode(hError = m_lpTable->SeekRow(bk, lRowCount, &lRowsSeeked))) )
  2106.             SetStatus("SeekRow failed", sc);
  2107.  
  2108.         if( lRowCount != lRowsSeeked )
  2109.             SetStatus("lRowCount != lRowSeeked beginning or end of table reached", (SCODE)0);
  2110.     }
  2111.     else
  2112.     {
  2113.         if( FAILED(sc = GetScode(hError = m_lpTable->SeekRowApprox(ulNum, ulDenom))) )
  2114.             SetStatus("SeekRowApprox failed", sc);
  2115.     }
  2116.  
  2117.     EndDialog(IDOK);
  2118. }
  2119.  
  2120.  
  2121. /*
  2122.  -  CSeekDlg
  2123.  -  OnCancel
  2124.  -
  2125.  *  Purpose:
  2126.  *      Cancels the SeekRow/SeekRowApprox dialgo
  2127.  *
  2128.  */
  2129.  
  2130. void CSeekDlg::OnCancel()
  2131. {
  2132.     EndDialog(IDCANCEL);
  2133. }
  2134.  
  2135.  
  2136.  
  2137. /*-----------------------------*/
  2138. /* CFindDlg Message Handlers   */
  2139. /*-----------------------------*/
  2140.  
  2141. BEGIN_MESSAGE_MAP(CFindDlg, CModalDialog)
  2142.     ON_COMMAND(IDC_BUILDRES,    OnBuildRes)
  2143.     ON_COMMAND(IDC_FORWARD,     OnDirForward)
  2144.     ON_COMMAND(IDC_BACKWARD,    OnDirBackward)
  2145.     ON_COMMAND(IDC_INVALID,     OnDirInvalid)
  2146.     ON_COMMAND(IDC_BEGINNING,   OnBkBeginning)
  2147.     ON_COMMAND(IDC_CURRENT,     OnBkCurrent)
  2148.     ON_COMMAND(IDC_END,         OnBkEnd)
  2149.     ON_COMMAND(IDC_USER,        OnBkUser)
  2150. END_MESSAGE_MAP()
  2151.  
  2152.  
  2153. /*
  2154.  -  CFindDlg::
  2155.  -  OnInitDialog
  2156.  -
  2157.  *  Purpose:
  2158.  *      Constructor for main dialog class.
  2159.  *
  2160.  */
  2161.  
  2162. BOOL CFindDlg::OnInitDialog()
  2163. {
  2164.     ULONG   idx;
  2165.     char    szBuff[512];
  2166.  
  2167.     CheckDlgButton(IDC_FORWARD, TRUE);
  2168.     CheckDlgButton(IDC_BEGINNING, TRUE);
  2169.  
  2170.     m_nBk = 0;
  2171.     m_ulFlags = 0;
  2172.  
  2173.     if(!m_lpBkList->cValues)
  2174.     {
  2175.         GetDlgItem(IDC_USER)->EnableWindow(FALSE);
  2176.     }
  2177.     else
  2178.     {
  2179.         for(idx = 0; idx < m_lpBkList->cValues; idx++)
  2180.         {
  2181.             SzGetPropValue(szBuff, m_lpBkList->bkList[idx].lpProp);
  2182.  
  2183.             SendDlgItemMessage(IDC_BKSEEK, LB_ADDSTRING, 0, (LPARAM)szBuff);
  2184.         }
  2185.     }
  2186.  
  2187.     GetDlgItem(IDC_FORWARD)->SetFocus();
  2188.  
  2189.     return TRUE;
  2190. }
  2191.  
  2192.  
  2193. /*
  2194.  -  CFindDlg
  2195.  -  OnBuildRes
  2196.  -
  2197.  *  Purpose:
  2198.  *      Brings up the Restriction dialog from the Find dialog and assigns
  2199.  *      the restriction to be executed when the Find is executed.
  2200.  *
  2201.  */
  2202.  
  2203. void CFindDlg::OnBuildRes()
  2204. {
  2205.     SCODE           sc;
  2206.     LPSRestriction  lpRes;
  2207.     LPSPropTagArray lpCurColumns;
  2208.  
  2209.     if( FAILED(sc = GetScode(hError = m_lpTable->QueryColumns(0, &lpCurColumns))) )
  2210.         SetStatus("QueryColumns failed", sc);
  2211.  
  2212.     lpRes = (LPSRestriction)PvAlloc(sizeof(SRestriction));
  2213.  
  2214.     CResDlg         dlgBuildRes(lpCurColumns, lpRes);
  2215.  
  2216.     if(dlgBuildRes.DoModal() == IDOK)
  2217.     {
  2218.         FreeRestriction(m_lpFindRes);
  2219.         PvFree(m_lpFindRes);
  2220.         m_lpFindRes = lpRes;
  2221.     }
  2222.     else
  2223.         PvFree(lpRes);
  2224.  
  2225.     MAPIFreeBuffer(lpCurColumns);
  2226. }
  2227.  
  2228.  
  2229. /*
  2230.  -  CFindDlg
  2231.  -  OnDirForward
  2232.  -
  2233.  *  Purpose:
  2234.  *      Sets the direction to Forward for FindRow()
  2235.  *
  2236.  */
  2237.  
  2238. void CFindDlg::OnDirForward()
  2239. {
  2240.     m_ulFlags = 0;
  2241. }
  2242.  
  2243.  
  2244. /*
  2245.  -  CFindDlg
  2246.  -  OnDirForward
  2247.  -
  2248.  *  Purpose:
  2249.  *      Sets the direction to Backward for FindRow()
  2250.  *
  2251.  */
  2252.  
  2253. void CFindDlg::OnDirBackward()
  2254. {
  2255.     m_ulFlags = DIR_BACKWARD;
  2256. }
  2257.  
  2258.  
  2259. /*
  2260.  -  CFindDlg
  2261.  -  OnDirForward
  2262.  -
  2263.  *  Purpose:
  2264.  *      Sets the direction to be invalid for FindRow()*
  2265.  */
  2266.  
  2267. void CFindDlg::OnDirInvalid()
  2268. {
  2269.     m_ulFlags = 42;
  2270. }
  2271.  
  2272.  
  2273. /*
  2274.  -  CSeekDlg
  2275.  -  OnBkBeginning
  2276.  -
  2277.  *  Purpose:
  2278.  *      Sets the Beginning bookmark.
  2279.  *
  2280.  */
  2281.  
  2282. void CFindDlg::OnBkBeginning()
  2283. {
  2284.     m_nBk = 0;
  2285. }
  2286.  
  2287.  
  2288. /*
  2289.  -  CSeekDlg
  2290.  -  OnBkBeginning
  2291.  -
  2292.  *  Purpose:
  2293.  *      Sets the Current bookmark.
  2294.  *
  2295.  */
  2296.  
  2297. void CFindDlg::OnBkCurrent()
  2298. {
  2299.     m_nBk = 1;
  2300. }
  2301.  
  2302.  
  2303. /*
  2304.  -  CSeekDlg
  2305.  -  OnBkBeginning
  2306.  -
  2307.  *  Purpose:
  2308.  *      Sets the End bookmark.
  2309.  *
  2310.  */
  2311.  
  2312. void CFindDlg::OnBkEnd()
  2313. {
  2314.     m_nBk = 2;
  2315. }
  2316.  
  2317.  
  2318. /*
  2319.  -  CSeekDlg
  2320.  -  OnBkBeginning
  2321.  -
  2322.  *  Purpose:
  2323.  *      Sets the user bookmark.
  2324.  *
  2325.  */
  2326.  
  2327. void CFindDlg::OnBkUser()
  2328. {
  2329.     m_nBk = 3;
  2330. }
  2331.  
  2332.  
  2333. void CFindDlg::OnOK()
  2334. {
  2335.     SCODE       sc;
  2336.     DWORD       dwIndex;
  2337.     BOOKMARK    bk;
  2338.  
  2339.     switch(m_nBk)
  2340.     {
  2341.     case 0:
  2342.         bk = BOOKMARK_BEGINNING;
  2343.         break;
  2344.  
  2345.     case 1:
  2346.         bk = BOOKMARK_CURRENT;
  2347.         break;
  2348.  
  2349.     case 2:
  2350.         bk = BOOKMARK_END;
  2351.         break;
  2352.  
  2353.     case 3:
  2354.         dwIndex = SendDlgItemMessage(IDC_BKSEEK, LB_GETCURSEL, 0, 0L);
  2355.  
  2356.         bk = m_lpBkList->bkList[dwIndex].bk;
  2357.         break;
  2358.     }
  2359.  
  2360.     if( FAILED(sc = GetScode(hError = m_lpTable->FindRow(m_lpFindRes, bk, m_ulFlags))) )
  2361.         SetStatus("FindRow failed", sc);
  2362.  
  2363.     PvFree(m_lpFindRes);
  2364.  
  2365.     EndDialog(IDOK);
  2366. }
  2367.  
  2368.  
  2369. void CFindDlg::OnCancel()
  2370. {
  2371.     PvFree(m_lpFindRes);
  2372.     EndDialog(IDCANCEL);
  2373. }
  2374.  
  2375.  
  2376.  
  2377. /*---------------------------------*/
  2378. /* CRestriction Message Handlers   */
  2379. /*---------------------------------*/
  2380.  
  2381. BEGIN_MESSAGE_MAP(CAcceptRestrictionDlg, CModalDialog)
  2382.     ON_COMMAND(IDMODIFY,    OnModify)
  2383. END_MESSAGE_MAP()
  2384.  
  2385. void CAcceptRestrictionDlg::OnModify()
  2386. {
  2387.     EndDialog(IDCANCEL);
  2388. }
  2389.  
  2390. /********************************************************************/
  2391. /*
  2392.  -  CAcceptRestrictionDlg::
  2393.  -  OnInitDialog
  2394.  -
  2395.  *  Purpose:
  2396.  *
  2397.  */
  2398. /********************************************************************/
  2399.  
  2400. BOOL CAcceptRestrictionDlg::OnInitDialog()
  2401. {
  2402.     int             rgTabStops[12];
  2403.     DWORD           dwReturn        = 0;      
  2404.         
  2405.     SendDlgItemMessage(IDC_ACCEPTRES,LB_RESETCONTENT,0,0);
  2406.  
  2407.     rgTabStops[0] = 20;
  2408.     rgTabStops[1] = 30;
  2409.     rgTabStops[2] = 40;
  2410.     rgTabStops[3] = 50;
  2411.     rgTabStops[4] = 60;
  2412.     rgTabStops[5] = 70;
  2413.     rgTabStops[6] = 80;
  2414.     rgTabStops[7] = 90;
  2415.     rgTabStops[8] = 100;
  2416.     rgTabStops[9] = 110;
  2417.     rgTabStops[10]= 120;
  2418.  
  2419.     dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_SETTABSTOPS,
  2420.                     (WPARAM) 11,(LPARAM)rgTabStops );
  2421.  
  2422.     DisplayRestriction(m_prest);
  2423.  
  2424.     return TRUE;    
  2425. }
  2426.  
  2427. /*******************************************************************/
  2428. /*
  2429.  -  CAcceptRestrictionDlg::
  2430.  -  DisplayRestriction
  2431.  *
  2432.  *  Purpose:
  2433.  *
  2434.  *  Parameters:
  2435.  *
  2436.  *  Returns:
  2437.  *
  2438.  */
  2439. /*******************************************************************/
  2440.  
  2441. void CAcceptRestrictionDlg::DisplayRestriction(LPSRestriction lpRes)
  2442. {
  2443.     DWORD           dwReturn        = 0;      
  2444.     char            szBuff1[256];
  2445.     char            szBuff2[256];
  2446.     char            szBuff3[256];
  2447.     char            szBuffer[1024];
  2448.     ULONG           i = 0;
  2449.     static  ULONG   cTabs = 0;
  2450.     static  char    szTabs[11][22] = {"",
  2451.                      "\t",
  2452.                      "\t\t",
  2453.                      "\t\t\t",
  2454.                      "\t\t\t\t",
  2455.                      "\t\t\t\t\t",
  2456.                      "\t\t\t\t\t\t",
  2457.                      "\t\t\t\t\t\t\t",
  2458.                      "\t\t\t\t\t\t\t\t",
  2459.                      "\t\t\t\t\t\t\t\t\t",
  2460.                      "\t\t\t\t\t\t\t\t\t\t"};
  2461.  
  2462.     if(!lpRes)
  2463.     {
  2464.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)(char *)"lpRestriction == NULL"); 
  2465.         return;
  2466.     }        
  2467.  
  2468.     switch(lpRes->rt)
  2469.     {
  2470.     case RES_CONTENT:       
  2471.         wsprintf(szBuffer,"%sSContentRestriction:", szTabs[cTabs]);
  2472.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2473.         GetString("FuzzyLevel", lpRes->res.resContent.ulFuzzyLevel, szBuff1);
  2474.         wsprintf(szBuffer,"%sFuzzy Level: %s", szTabs[cTabs+1], szBuff1);
  2475.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2476.         GetString("PropTags", lpRes->res.resContent.ulPropTag, szBuff1);
  2477.         wsprintf(szBuffer,"%s%s contains %s", szTabs[cTabs+1], szBuff1,
  2478.             SzGetPropValue(szBuff2, lpRes->res.resContent.lpProp));
  2479.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2480.         break;
  2481.  
  2482.     case RES_PROPERTY:
  2483.         wsprintf(szBuffer,"%sSPropertyRestriction:", szTabs[cTabs]);
  2484.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2485.         GetString("PropTags", lpRes->res.resProperty.ulPropTag, szBuff1);
  2486.         GetString("RelOp", lpRes->res.resProperty.relop, szBuff2);
  2487.         wsprintf(szBuffer,"%s%s %s %s", szTabs[cTabs+1], szBuff1, szBuff2,
  2488.             SzGetPropValue(szBuff3, lpRes->res.resProperty.lpProp));
  2489.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2490.         break;
  2491.  
  2492.     case RES_COMPAREPROPS:
  2493.         wsprintf(szBuffer,"%sSComparePropsRestriction:", szTabs[cTabs]);
  2494.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2495.         GetString("PropTags", lpRes->res.resCompareProps.ulPropTag1, szBuff1);
  2496.         GetString("RelOp", lpRes->res.resCompareProps.relop, szBuff2);
  2497.         GetString("PropTags", lpRes->res.resCompareProps.ulPropTag2, szBuff3);              
  2498.         wsprintf(szBuffer,"%s%s %s %s", szTabs[cTabs+1], szBuff1, szBuff2, szBuff3);
  2499.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2500.         break;
  2501.  
  2502.     case RES_BITMASK:
  2503.         wsprintf(szBuffer,"%sSBitMaskRestriction:", szTabs[cTabs]);
  2504.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2505.         GetString("PropTags", lpRes->res.resBitMask.ulPropTag, szBuff1);
  2506.         GetString("Bmr", lpRes->res.resBitMask.relBMR, szBuff2);        
  2507.         wsprintf(szBuffer,"%s(%s & 0x%08lX) %s", szTabs[cTabs+1], szBuff1,
  2508.                  lpRes->res.resBitMask.ulMask, szBuff2);
  2509.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2510.         break;
  2511.  
  2512.     case RES_SIZE:
  2513.         wsprintf(szBuffer,"%sSSizeRestriction:", szTabs[cTabs]);
  2514.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2515.         GetString("PropTags", lpRes->res.resSize.ulPropTag, szBuff1);
  2516.         GetString("RelOp", lpRes->res.resSize.relop, szBuff2);
  2517.         wsprintf(szBuffer,"%ssizeof(%s) %s %lu", szTabs[cTabs+1], szBuff1, szBuff2, 
  2518.                  lpRes->res.resSize.cb);
  2519.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2520.         break;
  2521.  
  2522.     case RES_EXIST:
  2523.         wsprintf(szBuffer,"%sSExistRestriction:", szTabs[cTabs]);
  2524.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2525.         GetString("PropTags", lpRes->res.resExist.ulPropTag, szBuff1); 
  2526.         wsprintf(szBuffer,"%s%s Exists", szTabs[cTabs+1], szBuff1);
  2527.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2528.         break;
  2529.  
  2530.     case RES_SUBRESTRICTION:
  2531.         wsprintf(szBuffer,"%sSSubRestriction:", szTabs[cTabs]);
  2532.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2533.         wsprintf(szBuffer,"%s ulSubObject: %s", szTabs[cTabs+1],
  2534.             (lpRes->res.resSub.ulSubObject == PR_MESSAGE_ATTACHMENTS) 
  2535.                         ? "PR_MESSAGE_ATTACHMENTS" :
  2536.                           "PR_MESSAGE_RECIPIENTS"     );
  2537.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2538.         cTabs++;
  2539.         DisplayRestriction(lpRes->res.resSub.lpRes);
  2540.         cTabs--;
  2541.         break;
  2542.  
  2543.     case RES_NOT:
  2544.         wsprintf(szBuffer,"%sNot:", szTabs[cTabs]);
  2545.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2546.         cTabs++;
  2547.         DisplayRestriction(lpRes->res.resNot.lpRes);
  2548.         cTabs--;
  2549.         break;
  2550.  
  2551.     case RES_AND:
  2552.         wsprintf(szBuffer,"%sAnd:", szTabs[cTabs]);
  2553.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2554.         cTabs++;
  2555.         for(i = 0; i < lpRes->res.resAnd.cRes; i++)
  2556.         {
  2557.             DisplayRestriction(&lpRes->res.resAnd.lpRes[i]);
  2558.         }
  2559.         cTabs--;
  2560.         break;
  2561.  
  2562.     case RES_OR:
  2563.         wsprintf(szBuffer,"%sOr:", szTabs[cTabs]);
  2564.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2565.         cTabs++;
  2566.         for(i = 0; i < lpRes->res.resOr.cRes; i++)
  2567.         {
  2568.             DisplayRestriction(&lpRes->res.resOr.lpRes[i]);
  2569.         }
  2570.         cTabs--;
  2571.         break;
  2572.  
  2573.     case RES_COMMENT:
  2574.         wsprintf(szBuffer,"%sSCommentRestriction:", szTabs[cTabs]);
  2575.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2576.         wsprintf(szBuffer,"%s cValues: %lu, lpPropValue: 0x%08X", szTabs[cTabs+1],
  2577.             lpRes->res.resComment.cValues,
  2578.             lpRes->res.resComment.lpProp);
  2579.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2580.         cTabs++;
  2581.         DisplayRestriction(lpRes->res.resComment.lpRes);
  2582.         cTabs--;
  2583.         break;
  2584.  
  2585.     default:
  2586.         wsprintf(szBuffer,"%sUNKNOWN RES TYPE lpRes->rt == %lu",szTabs[cTabs] , lpRes->rt);
  2587.         dwReturn = SendDlgItemMessage(IDC_ACCEPTRES,LB_ADDSTRING,0,(LPARAM)szBuffer);   
  2588.         break;
  2589.     }
  2590.     return;
  2591. }
  2592.  
  2593. /*******************************************************************/
  2594. /*
  2595.  -  CAcceptRestrictionDlg::
  2596.  -  ~CAcceptRestrictionDlg
  2597.  -
  2598.  *  Purpose:
  2599.  *      Destructor for class CAcceptRestrictionDlg. Releases and Frees memory
  2600.  *      allocated in this class
  2601.  *
  2602.  */
  2603. /*******************************************************************/
  2604.  
  2605. CAcceptRestrictionDlg::~CAcceptRestrictionDlg()
  2606. {
  2607.  
  2608. } 
  2609.  
  2610.  
  2611.  
  2612. ////////////////////////////////////////////////////
  2613.  
  2614.  
  2615.  
  2616. /*-----------------------------*/
  2617. /* CResDlg Message Handlers    */
  2618. /*-----------------------------*/
  2619.  
  2620. BEGIN_MESSAGE_MAP(CResDlg, CModalDialog)
  2621.     ON_COMMAND(IDC_AND,      OnAnd)
  2622.     ON_COMMAND(IDC_OR,       OnOr)
  2623.     ON_COMMAND(IDC_SUBRES1,  OnSubRes1)
  2624.     ON_COMMAND(IDC_SUBRES2,  OnSubRes2)
  2625.     ON_COMMAND(IDC_SUBRES3,  OnSubRes3)
  2626.     ON_CBN_SELCHANGE(IDC_RESTYPE1, OnResType1)
  2627.     ON_CBN_SELCHANGE(IDC_RESTYPE2, OnResType2)
  2628.     ON_CBN_SELCHANGE(IDC_RESTYPE3, OnResType3)
  2629. END_MESSAGE_MAP()
  2630.  
  2631. /*
  2632.  -  CResDlg::
  2633.  -  CResDlg
  2634.  *
  2635.  *  Purpose:
  2636.  *      Constructor for the CResDlg class.
  2637.  */
  2638.  
  2639. CResDlg::CResDlg(LPSPropTagArray lpspta, LPSRestriction lpr, CWnd* lpParent)
  2640.         : CModalDialog(IDD_RESDLG, lpParent)
  2641. {
  2642.     m_lpCurColumns = lpspta;
  2643.     m_lpRes        = lpr;
  2644.  
  2645.     m_lpSubRes = (LPSRestriction)PvAlloc(3 * sizeof(SRestriction));
  2646. }
  2647.  
  2648.  
  2649. /*
  2650.  -  CResDlg::
  2651.  -  OnInitDialog
  2652.  -
  2653.  *  Purpose:
  2654.  *      Constructor for main dialog class.
  2655.  *
  2656.  */
  2657.  
  2658. BOOL CResDlg::OnInitDialog()
  2659. {
  2660.     ULONG   idx;
  2661.     char    szBuff[512];
  2662.     char    szBuffer[256];
  2663.     ULONG   ulNum;
  2664.  
  2665.     CheckDlgButton(IDC_AND, TRUE);
  2666.  
  2667.     ulNumResTypes = GetRowCount("RestrictionType");
  2668.  
  2669.     for(idx = 0; idx < ulNumResTypes; idx++)
  2670.     {
  2671.         GetRowString("RestrictionType",idx,szBuffer);
  2672.         SendDlgItemMessage(IDC_RESTYPE1, CB_ADDSTRING, 0,
  2673.                 (LPARAM)szBuffer);
  2674.         SendDlgItemMessage(IDC_RESTYPE2, CB_ADDSTRING, 0,
  2675.                 (LPARAM)szBuffer);
  2676.         SendDlgItemMessage(IDC_RESTYPE3, CB_ADDSTRING, 0,
  2677.                 (LPARAM)szBuffer);
  2678.     }
  2679.  
  2680.     SendDlgItemMessage(IDC_RESTYPE1, CB_ADDSTRING, 0,
  2681.                 (LPARAM)(char *)"None");
  2682.     SendDlgItemMessage(IDC_RESTYPE2, CB_ADDSTRING, 0,
  2683.                 (LPARAM)(char *)"None");
  2684.     SendDlgItemMessage(IDC_RESTYPE3, CB_ADDSTRING, 0,
  2685.                 (LPARAM)(char *)"None");
  2686.  
  2687.     SendDlgItemMessage(IDC_RESTYPE1, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  2688.     SendDlgItemMessage(IDC_RESTYPE2, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  2689.     SendDlgItemMessage(IDC_RESTYPE3, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  2690.  
  2691.     for(idx = 0; idx < m_lpCurColumns->cValues; idx++)
  2692.     {
  2693.         GetString("PropTags", m_lpCurColumns->aulPropTag[idx], szBuff);
  2694.  
  2695.         SendDlgItemMessage(IDC_PROPTAG1, CB_ADDSTRING, 0, (LPARAM)szBuff);
  2696.         SendDlgItemMessage(IDC_PROPTAG2, CB_ADDSTRING, 0, (LPARAM)szBuff);
  2697.         SendDlgItemMessage(IDC_PROPTAG3, CB_ADDSTRING, 0, (LPARAM)szBuff);
  2698.     }
  2699.  
  2700.     ulNum = GetRowCount("RelOp");
  2701.  
  2702.     for(idx = 0; idx < ulNum; idx++)
  2703.     {
  2704.         GetRowString("RelOp",idx,szBuffer);
  2705.   
  2706.         SendDlgItemMessage(IDC_RELATIONSHIP1, CB_ADDSTRING, 0,
  2707.                 (LPARAM)szBuffer);
  2708.         SendDlgItemMessage(IDC_RELATIONSHIP2, CB_ADDSTRING, 0,
  2709.                 (LPARAM)szBuffer);
  2710.         SendDlgItemMessage(IDC_RELATIONSHIP3, CB_ADDSTRING, 0,
  2711.                 (LPARAM)szBuffer);
  2712.     }
  2713.  
  2714.     /* Hide everything until the Restriction Type is chosen
  2715.        Restriction 1 */
  2716.     GetDlgItem(IDT_PROPTAG1)->ShowWindow(FALSE);
  2717.     GetDlgItem(IDC_PROPTAG1)->ShowWindow(FALSE);
  2718.     GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2719.     GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(FALSE);
  2720.     GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(FALSE);
  2721.     GetDlgItem(IDT_VALUE1)->ShowWindow(FALSE);
  2722.     GetDlgItem(IDC_VALUE1)->ShowWindow(FALSE);
  2723.     GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2724.  
  2725.     /* Restriction 2 */
  2726.     GetDlgItem(IDT_PROPTAG2)->ShowWindow(FALSE);
  2727.     GetDlgItem(IDC_PROPTAG2)->ShowWindow(FALSE);
  2728.     GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  2729.     GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(FALSE);
  2730.     GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(FALSE);
  2731.     GetDlgItem(IDT_VALUE2)->ShowWindow(FALSE);
  2732.     GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  2733.     GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  2734.  
  2735.     /* Restriction 3 */
  2736.     GetDlgItem(IDT_PROPTAG3)->ShowWindow(FALSE);
  2737.     GetDlgItem(IDC_PROPTAG3)->ShowWindow(FALSE);
  2738.     GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  2739.     GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(FALSE);
  2740.     GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(FALSE);
  2741.     GetDlgItem(IDT_VALUE3)->ShowWindow(FALSE);
  2742.     GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  2743.  
  2744.     m_fComb = 0;
  2745.     m_nResType1 = (int) ulNumResTypes;
  2746.     m_nResType2 = (int) ulNumResTypes;
  2747.     m_nResType3 = (int) ulNumResTypes;
  2748.  
  2749.     GetDlgItem(IDC_AND)->SetFocus();
  2750.  
  2751.     return TRUE;
  2752. }
  2753.  
  2754.  
  2755. /*
  2756.  -  CResDlg
  2757.  -  OnAnd
  2758.  -
  2759.  *  Purpose:
  2760.  *      Sets the AND restriction flag.
  2761.  *
  2762.  */
  2763.  
  2764. void CResDlg::OnAnd()
  2765. {
  2766.     m_fComb = 0;
  2767. }
  2768.  
  2769.  
  2770. /*
  2771.  -  CResDlg
  2772.  -  OnOr
  2773.  -
  2774.  *  Purpose:
  2775.  *      Sets the OR restriction flag.
  2776.  *
  2777.  */
  2778.  
  2779. void CResDlg::OnOr()
  2780. {
  2781.     m_fComb = 1;
  2782. }
  2783.  
  2784. /*
  2785.  -  CResDlg
  2786.  -  OnResType1
  2787.  -
  2788.  *  Purpose:
  2789.  *      Changes the view of the restriction based on the type for
  2790.  *      Restriction 1.
  2791.  *
  2792.  */
  2793.  
  2794. void CResDlg::OnResType1()
  2795. {
  2796.     INT     idx;
  2797.     LONG    nNewResType;
  2798.     char    szBuff[128];
  2799.     char    szBuffer[256];
  2800.     ULONG   ulNum   = 0;
  2801.  
  2802.     nNewResType = SendDlgItemMessage(IDC_RESTYPE1, CB_GETCURSEL, 0, 0L);
  2803.  
  2804.     if(nNewResType == m_nResType1)
  2805.         return;
  2806.  
  2807.     switch(nNewResType)
  2808.     {
  2809.     case RES_AND:
  2810.     case RES_OR:
  2811.     case RES_NOT:
  2812.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(FALSE);
  2813.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(FALSE);
  2814.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2815.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(FALSE);
  2816.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(FALSE);
  2817.         GetDlgItem(IDT_VALUE1)->ShowWindow(FALSE);
  2818.         GetDlgItem(IDC_VALUE1)->ShowWindow(FALSE);
  2819.         GetDlgItem(IDC_SUBRES1)->EnableWindow(TRUE);
  2820.         break;
  2821.  
  2822.     case RES_CONTENT:
  2823.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(TRUE);
  2824.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(TRUE);
  2825.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2826.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(TRUE);
  2827.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(TRUE);
  2828.         GetDlgItem(IDT_VALUE1)->ShowWindow(TRUE);
  2829.         GetDlgItem(IDC_VALUE1)->ShowWindow(TRUE);
  2830.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  2831.         
  2832.         GetDlgItem(IDT_VALUE1)->SetWindowText("Value:");
  2833.         GetDlgItem(IDT_PROPTAG1)->SetWindowText("PropTag:");
  2834.         GetDlgItem(IDT_RELATIONSHIP1)->SetWindowText("Fuzzy Level:");
  2835.  
  2836.         // update RELATIONSHIP
  2837.         SendDlgItemMessage(IDC_RELATIONSHIP1, CB_RESETCONTENT, 0, 0L);
  2838.         ulNum = GetRowCount("FuzzyLevel");
  2839.  
  2840.         for(idx = 0; idx < ulNum; idx++)
  2841.         {
  2842.             GetRowString("FuzzyLevel",idx,szBuffer);
  2843.             SendDlgItemMessage(IDC_RELATIONSHIP1, CB_ADDSTRING, 0,
  2844.                     (LPARAM)szBuffer);
  2845.         }
  2846.  
  2847.         break;
  2848.  
  2849.     case RES_PROPERTY:
  2850.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(TRUE);
  2851.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(TRUE);
  2852.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2853.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(TRUE);
  2854.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(TRUE);
  2855.         GetDlgItem(IDT_VALUE1)->ShowWindow(TRUE);
  2856.         GetDlgItem(IDC_VALUE1)->ShowWindow(TRUE);
  2857.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  2858.         
  2859.         GetDlgItem(IDT_VALUE1)->SetWindowText("Value:");
  2860.         GetDlgItem(IDT_PROPTAG1)->SetWindowText("PropTag:");
  2861.         GetDlgItem(IDT_RELATIONSHIP1)->SetWindowText("Relationship:");
  2862.  
  2863.         // update RELATIONSHIP
  2864.         SendDlgItemMessage(IDC_RELATIONSHIP1, CB_RESETCONTENT, 0, 0L);
  2865.         ulNum = GetRowCount("RelOp");
  2866.         for(idx = 0; idx < ulNum; idx++)
  2867.         {
  2868.             GetRowString("RelOp",idx,szBuffer);
  2869.             SendDlgItemMessage(IDC_RELATIONSHIP1, CB_ADDSTRING, 0,
  2870.                     (LPARAM)szBuffer);
  2871.         }
  2872.         break;
  2873.  
  2874.     case RES_COMPAREPROPS:
  2875.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(TRUE);
  2876.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(TRUE);
  2877.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(TRUE);
  2878.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(TRUE);
  2879.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(TRUE);
  2880.         GetDlgItem(IDT_VALUE1)->ShowWindow(TRUE);
  2881.         GetDlgItem(IDC_VALUE1)->ShowWindow(FALSE);
  2882.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  2883.         
  2884.         GetDlgItem(IDT_PROPTAG1)->SetWindowText("PropTag1:");
  2885.         GetDlgItem(IDT_VALUE1)->SetWindowText("PropTag2:");
  2886.         GetDlgItem(IDT_RELATIONSHIP1)->SetWindowText("Relationship:");
  2887.  
  2888.         // update RELATIONSHIP
  2889.         SendDlgItemMessage(IDC_RELATIONSHIP1, CB_RESETCONTENT, 0, 0L);
  2890.         ulNum = GetRowCount("RelOp");
  2891.         for(idx = 0; idx < ulNum; idx++)
  2892.         {
  2893.             GetRowString("RelOp",idx,szBuffer);
  2894.             SendDlgItemMessage(IDC_RELATIONSHIP1, CB_ADDSTRING, 0,
  2895.                     (LPARAM)szBuffer);
  2896.         }
  2897.  
  2898.         // update second PROPS
  2899.         SendDlgItemMessage(IDC_PROPTAG12, CB_RESETCONTENT, 0, (LPARAM)szBuff);
  2900.         for(idx = 0; idx < m_lpCurColumns->cValues; idx++)
  2901.         {
  2902.             GetString("PropTags", m_lpCurColumns->aulPropTag[idx], szBuff);
  2903.             SendDlgItemMessage(IDC_PROPTAG12, CB_ADDSTRING, 0, (LPARAM)szBuff);
  2904.         }
  2905.         break;
  2906.  
  2907.     case RES_BITMASK:
  2908.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(TRUE);
  2909.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(TRUE);
  2910.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2911.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(TRUE);
  2912.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(TRUE);
  2913.         GetDlgItem(IDT_VALUE1)->ShowWindow(TRUE);
  2914.         GetDlgItem(IDC_VALUE1)->ShowWindow(TRUE);
  2915.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  2916.  
  2917.         GetDlgItem(IDT_VALUE1)->SetWindowText("Mask: ex. 0x00000678");
  2918.         GetDlgItem(IDT_PROPTAG1)->SetWindowText("PropTag:");
  2919.         GetDlgItem(IDT_RELATIONSHIP1)->SetWindowText("Relationship:");
  2920.  
  2921.         // update RELATIONSHIP
  2922.         SendDlgItemMessage(IDC_RELATIONSHIP1, CB_RESETCONTENT, 0, 0L);
  2923.         ulNum = GetRowCount("Bmr");
  2924.         for(idx = 0; idx < ulNum; idx++)
  2925.         {
  2926.             GetRowString("Bmr",idx,szBuffer);
  2927.             SendDlgItemMessage(IDC_RELATIONSHIP1, CB_ADDSTRING, 0,
  2928.                     (LPARAM)szBuffer);
  2929.         }
  2930.         break;
  2931.  
  2932.     case RES_SUBRESTRICTION:
  2933.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(FALSE);
  2934.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(FALSE);
  2935.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(TRUE);
  2936.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(FALSE);
  2937.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(FALSE);
  2938.         GetDlgItem(IDT_VALUE1)->ShowWindow(TRUE);
  2939.         GetDlgItem(IDC_VALUE1)->ShowWindow(FALSE);
  2940.         GetDlgItem(IDC_SUBRES1)->EnableWindow(TRUE);
  2941.  
  2942.         GetDlgItem(IDT_VALUE1)->SetWindowText("ulSubObj:");
  2943.  
  2944.         // DIFFERENT SPECIAL PROPERTIES
  2945.         SendDlgItemMessage(IDC_PROPTAG12, CB_RESETCONTENT, 0, 0L);
  2946.         SendDlgItemMessage(IDC_PROPTAG12, CB_ADDSTRING,    0, (LPARAM)(char *)"PR_MESSAGE_ATTACHMENTS");
  2947.         SendDlgItemMessage(IDC_PROPTAG12, CB_ADDSTRING,    0, (LPARAM)(char *)"PR_MESSAGE_RECIPIENTS");
  2948.  
  2949.         break;
  2950.  
  2951.     case RES_SIZE:
  2952.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(TRUE);
  2953.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(TRUE);
  2954.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2955.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(TRUE);
  2956.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(TRUE);
  2957.         GetDlgItem(IDT_VALUE1)->ShowWindow(TRUE);
  2958.         GetDlgItem(IDC_VALUE1)->ShowWindow(TRUE);
  2959.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2960.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  2961.  
  2962.         GetDlgItem(IDT_PROPTAG1)->SetWindowText("PropTag:");
  2963.         GetDlgItem(IDT_RELATIONSHIP1)->SetWindowText("Relationship:");
  2964.         GetDlgItem(IDT_VALUE1)->SetWindowText("cb:");
  2965.  
  2966.         // update RELATIONSHIP
  2967.         SendDlgItemMessage(IDC_RELATIONSHIP1, CB_RESETCONTENT, 0, 0L);
  2968.         ulNum = GetRowCount("RelOp");
  2969.         for(idx = 0; idx < ulNum; idx++)
  2970.         {
  2971.             GetRowString("RelOp",idx,szBuffer);
  2972.             SendDlgItemMessage(IDC_RELATIONSHIP1, CB_ADDSTRING, 0,
  2973.                     (LPARAM)szBuffer);
  2974.         }
  2975.  
  2976.         break;
  2977.  
  2978.     case RES_EXIST:
  2979.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(TRUE);
  2980.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(TRUE);
  2981.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2982.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(FALSE);
  2983.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(FALSE);
  2984.         GetDlgItem(IDT_VALUE1)->ShowWindow(FALSE);
  2985.         GetDlgItem(IDC_VALUE1)->ShowWindow(FALSE);
  2986.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2987.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  2988.  
  2989.         GetDlgItem(IDT_PROPTAG1)->SetWindowText("PropTag:");
  2990.         break;
  2991.  
  2992.     case RES_COMMENT:
  2993.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(FALSE);
  2994.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(FALSE);
  2995.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  2996.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(FALSE);
  2997.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(FALSE);
  2998.         GetDlgItem(IDT_VALUE1)->ShowWindow(TRUE);
  2999.         GetDlgItem(IDC_VALUE1)->ShowWindow(TRUE);
  3000.         GetDlgItem(IDC_SUBRES1)->EnableWindow(TRUE);
  3001.  
  3002.         GetDlgItem(IDT_VALUE1)->SetWindowText("cValues:");
  3003.  
  3004.         break;
  3005.  
  3006.     
  3007.     default:
  3008.         GetDlgItem(IDT_PROPTAG1)->ShowWindow(FALSE);
  3009.         GetDlgItem(IDC_PROPTAG1)->ShowWindow(FALSE);
  3010.         GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  3011.         GetDlgItem(IDT_RELATIONSHIP1)->ShowWindow(FALSE);
  3012.         GetDlgItem(IDC_RELATIONSHIP1)->ShowWindow(FALSE);
  3013.         GetDlgItem(IDT_VALUE1)->ShowWindow(FALSE);
  3014.         GetDlgItem(IDC_VALUE1)->ShowWindow(FALSE);
  3015.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  3016.     }
  3017.  
  3018.     m_nResType1 = (int)nNewResType;
  3019. }
  3020.  
  3021.  
  3022. /*
  3023.  -  CResDlg
  3024.  -  OnResType2
  3025.  -
  3026.  *  Purpose:
  3027.  *      Changes the view of the restriction based on the type for
  3028.  *      Restriction 2.
  3029.  *
  3030.  */
  3031.  
  3032. void CResDlg::OnResType2()
  3033. {
  3034.     INT     idx;
  3035.     LONG    nNewResType;
  3036.     char    szBuff[128];
  3037.     char    szBuffer[256];
  3038.     ULONG   ulNum   = 0;
  3039.  
  3040.     nNewResType = SendDlgItemMessage(IDC_RESTYPE2, CB_GETCURSEL, 0, 0L);
  3041.  
  3042.     if(nNewResType == m_nResType2)
  3043.         return;
  3044.  
  3045.     switch(nNewResType)
  3046.     {
  3047.     case RES_AND:
  3048.     case RES_OR:
  3049.     case RES_NOT:
  3050.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(FALSE);
  3051.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(FALSE);
  3052.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3053.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(FALSE);
  3054.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(FALSE);
  3055.         GetDlgItem(IDT_VALUE2)->ShowWindow(FALSE);
  3056.         GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  3057.         GetDlgItem(IDC_SUBRES2)->EnableWindow(TRUE);
  3058.         break;
  3059.  
  3060.     case RES_CONTENT:
  3061.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(TRUE);
  3062.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(TRUE);
  3063.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3064.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(TRUE);
  3065.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(TRUE);
  3066.         GetDlgItem(IDT_VALUE2)->ShowWindow(TRUE);
  3067.         GetDlgItem(IDC_VALUE2)->ShowWindow(TRUE);
  3068.  
  3069.         GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3070.         GetDlgItem(IDT_VALUE2)->SetWindowText("Value:");
  3071.         GetDlgItem(IDT_PROPTAG2)->SetWindowText("PropTag:");
  3072.         GetDlgItem(IDT_RELATIONSHIP2)->SetWindowText("Fuzzy Level:");
  3073.  
  3074.         // update RELATIONSHIP
  3075.         SendDlgItemMessage(IDC_RELATIONSHIP2, CB_RESETCONTENT, 0, 0L);
  3076.         ulNum = GetRowCount("FuzzyLevel");
  3077.         for(idx = 0; idx < ulNum; idx++)
  3078.         {
  3079.             GetRowString("FuzzyLevel",idx,szBuffer);
  3080.             SendDlgItemMessage(IDC_RELATIONSHIP2, CB_ADDSTRING, 0,
  3081.                     (LPARAM)szBuffer);
  3082.         }
  3083.         break;
  3084.  
  3085.     case RES_PROPERTY:
  3086.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(TRUE);
  3087.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(TRUE);
  3088.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3089.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(TRUE);
  3090.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(TRUE);
  3091.         GetDlgItem(IDT_VALUE2)->ShowWindow(TRUE);
  3092.         GetDlgItem(IDC_VALUE2)->ShowWindow(TRUE);
  3093.  
  3094.         GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3095.         GetDlgItem(IDT_VALUE2)->SetWindowText("Value:");
  3096.         GetDlgItem(IDT_PROPTAG2)->SetWindowText("PropTag:");
  3097.         GetDlgItem(IDT_RELATIONSHIP2)->SetWindowText("Relationship:");
  3098.  
  3099.         // update RELATIONSHIP
  3100.         SendDlgItemMessage(IDC_RELATIONSHIP2, CB_RESETCONTENT, 0, 0L);
  3101.         ulNum = GetRowCount("RelOp");
  3102.         for(idx = 0; idx < ulNum; idx++)
  3103.         {
  3104.             GetRowString("RelOp",idx,szBuffer);
  3105.             SendDlgItemMessage(IDC_RELATIONSHIP2, CB_ADDSTRING, 0,
  3106.                     (LPARAM)szBuffer);
  3107.         }
  3108.  
  3109.         break;
  3110.  
  3111.     case RES_COMPAREPROPS:
  3112.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(TRUE);
  3113.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(TRUE);
  3114.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(TRUE);
  3115.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(TRUE);
  3116.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(TRUE);
  3117.         GetDlgItem(IDT_VALUE2)->ShowWindow(TRUE);
  3118.         GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  3119.  
  3120.         GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3121.         GetDlgItem(IDT_PROPTAG2)->SetWindowText("PropTag1:");
  3122.         GetDlgItem(IDT_VALUE2)->SetWindowText("PropTag2:");
  3123.         GetDlgItem(IDT_RELATIONSHIP2)->SetWindowText("Relationship:");
  3124.  
  3125.         // update RELATIONSHIP
  3126.         SendDlgItemMessage(IDC_RELATIONSHIP2, CB_RESETCONTENT, 0, 0L);
  3127.         ulNum = GetRowCount("RelOp");
  3128.         for(idx = 0; idx < ulNum; idx++)
  3129.         {
  3130.             GetRowString("RelOp",idx,szBuffer);
  3131.             SendDlgItemMessage(IDC_RELATIONSHIP2, CB_ADDSTRING, 0,
  3132.                     (LPARAM)szBuffer);
  3133.         }
  3134.  
  3135.         // update 2nd PROPS
  3136.         SendDlgItemMessage(IDC_PROPTAG22, CB_RESETCONTENT, 0, (LPARAM)szBuff);
  3137.         for(idx = 0; idx < m_lpCurColumns->cValues; idx++)
  3138.         {
  3139.             GetString("PropTags", m_lpCurColumns->aulPropTag[idx], szBuff);
  3140.             SendDlgItemMessage(IDC_PROPTAG22, CB_ADDSTRING, 0, (LPARAM)szBuff);
  3141.         }
  3142.         break;
  3143.  
  3144.     case RES_BITMASK:
  3145.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(TRUE);
  3146.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(TRUE);
  3147.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3148.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(TRUE);
  3149.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(TRUE);
  3150.         GetDlgItem(IDT_VALUE2)->ShowWindow(TRUE);
  3151.         GetDlgItem(IDC_VALUE2)->ShowWindow(TRUE);
  3152.  
  3153.         GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3154.         GetDlgItem(IDT_VALUE2)->SetWindowText("Mask: ex. 0x00000678");
  3155.         GetDlgItem(IDT_PROPTAG2)->SetWindowText("PropTag:");
  3156.         GetDlgItem(IDT_RELATIONSHIP2)->SetWindowText("Relationship:");
  3157.  
  3158.  
  3159.         // update RELATIONSHIP
  3160.         SendDlgItemMessage(IDC_RELATIONSHIP2, CB_RESETCONTENT, 0, 0L);
  3161.         ulNum = GetRowCount("Bmr");
  3162.         for(idx = 0; idx < ulNum; idx++)
  3163.         {
  3164.             GetRowString("Bmr",idx,szBuffer);
  3165.             SendDlgItemMessage(IDC_RELATIONSHIP2, CB_ADDSTRING, 0,
  3166.                     (LPARAM)szBuffer);
  3167.         }
  3168.  
  3169.         break;
  3170.  
  3171.     case RES_SUBRESTRICTION:
  3172.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(FALSE);
  3173.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(FALSE);
  3174.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(TRUE);
  3175.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(FALSE);
  3176.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(FALSE);
  3177.         GetDlgItem(IDT_VALUE2)->ShowWindow(TRUE);
  3178.         GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  3179.         GetDlgItem(IDC_SUBRES2)->EnableWindow(TRUE);
  3180.  
  3181.         GetDlgItem(IDT_VALUE2)->SetWindowText("ulSubObj:");
  3182.  
  3183.         // DIFFERENT SPECIAL PROPERTIES
  3184.         SendDlgItemMessage(IDC_PROPTAG22, CB_RESETCONTENT, 0, 0L);
  3185.         SendDlgItemMessage(IDC_PROPTAG22, CB_ADDSTRING,    0, (LPARAM)(char *)"PR_MESSAGE_ATTACHMENTS");
  3186.         SendDlgItemMessage(IDC_PROPTAG22, CB_ADDSTRING,    0, (LPARAM)(char *)"PR_MESSAGE_RECIPIENTS");
  3187.                 
  3188.         break;
  3189.  
  3190.     case RES_SIZE:
  3191.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(TRUE);
  3192.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(TRUE);
  3193.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3194.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(TRUE);
  3195.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(TRUE);
  3196.         GetDlgItem(IDT_VALUE2)->ShowWindow(TRUE);
  3197.         GetDlgItem(IDC_VALUE2)->ShowWindow(TRUE);
  3198.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3199.         GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3200.  
  3201.         GetDlgItem(IDT_PROPTAG2)->SetWindowText("PropTag:");
  3202.         GetDlgItem(IDT_RELATIONSHIP2)->SetWindowText("Relationship:");
  3203.         GetDlgItem(IDT_VALUE2)->SetWindowText("cb:");
  3204.  
  3205.         // update RELATIONSHIP
  3206.         SendDlgItemMessage(IDC_RELATIONSHIP2, CB_RESETCONTENT, 0, 0L);
  3207.         ulNum = GetRowCount("RelOp");
  3208.         for(idx = 0; idx < ulNum; idx++)
  3209.         {
  3210.             GetRowString("RelOp",idx,szBuffer);
  3211.             SendDlgItemMessage(IDC_RELATIONSHIP2, CB_ADDSTRING, 0,
  3212.                     (LPARAM)szBuffer);
  3213.         }
  3214.  
  3215.         break;
  3216.  
  3217.     case RES_EXIST:
  3218.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(TRUE);
  3219.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(TRUE);
  3220.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3221.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(FALSE);
  3222.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(FALSE);
  3223.         GetDlgItem(IDT_VALUE2)->ShowWindow(FALSE);
  3224.         GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  3225.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3226.         GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3227.  
  3228.         GetDlgItem(IDT_PROPTAG2)->SetWindowText("PropTag:");
  3229.         break;
  3230.  
  3231.  
  3232.     case RES_COMMENT:
  3233.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(FALSE);
  3234.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(FALSE);
  3235.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3236.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(FALSE);
  3237.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(FALSE);
  3238.         GetDlgItem(IDT_VALUE2)->ShowWindow(TRUE);
  3239.         GetDlgItem(IDC_VALUE2)->ShowWindow(TRUE);
  3240.         GetDlgItem(IDC_SUBRES2)->EnableWindow(TRUE);
  3241.  
  3242.         GetDlgItem(IDT_VALUE2)->SetWindowText("cValues:");
  3243.  
  3244.         break;
  3245.  
  3246.  
  3247.  
  3248.     default:
  3249.         GetDlgItem(IDT_PROPTAG2)->ShowWindow(FALSE);
  3250.         GetDlgItem(IDC_PROPTAG2)->ShowWindow(FALSE);
  3251.         GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3252.         GetDlgItem(IDT_RELATIONSHIP2)->ShowWindow(FALSE);
  3253.         GetDlgItem(IDC_RELATIONSHIP2)->ShowWindow(FALSE);
  3254.         GetDlgItem(IDT_VALUE2)->ShowWindow(FALSE);
  3255.         GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  3256.         GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  3257.         GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  3258.   
  3259.     }
  3260.  
  3261.     m_nResType2 = (int)nNewResType;
  3262. }
  3263.  
  3264.  
  3265. /*
  3266.  -  CResDlg
  3267.  -  OnResType3
  3268.  -
  3269.  *  Purpose:
  3270.  *      Changes the view of the restriction based on the type for
  3271.  *      Restriction 3.
  3272.  *
  3273.  */
  3274.  
  3275. void CResDlg::OnResType3()
  3276. {
  3277.     INT     idx;
  3278.     LONG    nNewResType;
  3279.     char    szBuff[128];
  3280.     char    szBuffer[256];
  3281.     ULONG   ulNum   = 0;
  3282.  
  3283.     nNewResType = SendDlgItemMessage(IDC_RESTYPE3, CB_GETCURSEL, 0, 0L);
  3284.  
  3285.     if(nNewResType == m_nResType3)
  3286.         return;
  3287.  
  3288.     switch(nNewResType)
  3289.     {
  3290.     case RES_AND:
  3291.     case RES_OR:
  3292.     case RES_NOT:
  3293.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(FALSE);
  3294.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(FALSE);
  3295.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3296.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(FALSE);
  3297.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(FALSE);
  3298.         GetDlgItem(IDT_VALUE3)->ShowWindow(FALSE);
  3299.         GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  3300.         GetDlgItem(IDC_SUBRES3)->EnableWindow(TRUE);
  3301.         break;
  3302.  
  3303.     case RES_CONTENT:
  3304.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(TRUE);
  3305.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(TRUE);
  3306.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3307.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(TRUE);
  3308.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(TRUE);
  3309.         GetDlgItem(IDT_VALUE3)->ShowWindow(TRUE);
  3310.         GetDlgItem(IDC_VALUE3)->ShowWindow(TRUE);
  3311.  
  3312.         GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3313.         GetDlgItem(IDT_VALUE3)->SetWindowText("Value:");
  3314.         GetDlgItem(IDT_PROPTAG3)->SetWindowText("PropTag:");
  3315.         GetDlgItem(IDT_RELATIONSHIP3)->SetWindowText("Fuzzy Level:");
  3316.  
  3317.         // update RELATIONSHIP
  3318.         SendDlgItemMessage(IDC_RELATIONSHIP3, CB_RESETCONTENT, 0, 0L);
  3319.         ulNum = GetRowCount("FuzzyLevel");
  3320.         for(idx = 0; idx < ulNum; idx++)
  3321.         {
  3322.             GetRowString("FuzzyLevel",idx,szBuffer);
  3323.             SendDlgItemMessage(IDC_RELATIONSHIP3, CB_ADDSTRING, 0,
  3324.                     (LPARAM)szBuffer);
  3325.         }
  3326.  
  3327.         break;
  3328.  
  3329.     case RES_PROPERTY:
  3330.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(TRUE);
  3331.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(TRUE);
  3332.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3333.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(TRUE);
  3334.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(TRUE);
  3335.         GetDlgItem(IDT_VALUE3)->ShowWindow(TRUE);
  3336.         GetDlgItem(IDC_VALUE3)->ShowWindow(TRUE);
  3337.  
  3338.         GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3339.         GetDlgItem(IDT_VALUE3)->SetWindowText("Value:");
  3340.         GetDlgItem(IDT_PROPTAG3)->SetWindowText("PropTag:");
  3341.         GetDlgItem(IDT_RELATIONSHIP3)->SetWindowText("Relationship:");
  3342.  
  3343.         // update RELATIONSHIP
  3344.         SendDlgItemMessage(IDC_RELATIONSHIP3, CB_RESETCONTENT, 0, 0L);
  3345.         ulNum = GetRowCount("RelOp");
  3346.         for(idx = 0; idx < ulNum; idx++)
  3347.         {
  3348.             GetRowString("RelOp",idx,szBuffer);
  3349.             SendDlgItemMessage(IDC_RELATIONSHIP3, CB_ADDSTRING, 0,
  3350.                     (LPARAM)szBuffer);
  3351.         }
  3352.  
  3353.         break;
  3354.  
  3355.     case RES_COMPAREPROPS:
  3356.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(TRUE);
  3357.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(TRUE);
  3358.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(TRUE);
  3359.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(TRUE);
  3360.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(TRUE);
  3361.         GetDlgItem(IDT_VALUE3)->ShowWindow(TRUE);
  3362.         GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  3363.  
  3364.         GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3365.         GetDlgItem(IDT_PROPTAG3)->SetWindowText("PropTag1:");
  3366.         GetDlgItem(IDT_VALUE3)->SetWindowText("PropTag2:");
  3367.         GetDlgItem(IDT_RELATIONSHIP3)->SetWindowText("Relationship:");
  3368.  
  3369.         // update RELATIONSHIP
  3370.         SendDlgItemMessage(IDC_RELATIONSHIP3, CB_RESETCONTENT, 0, 0L);
  3371.         ulNum = GetRowCount("RelOp");
  3372.         for(idx = 0; idx < ulNum; idx++)
  3373.         {
  3374.             GetRowString("RelOp",idx,szBuffer);
  3375.             SendDlgItemMessage(IDC_RELATIONSHIP3, CB_ADDSTRING, 0,
  3376.                     (LPARAM)szBuffer);
  3377.         }
  3378.  
  3379.         // update 2nd PROPS
  3380.         SendDlgItemMessage(IDC_PROPTAG32, CB_RESETCONTENT, 0, (LPARAM)szBuff);
  3381.         for(idx = 0; idx < m_lpCurColumns->cValues; idx++)
  3382.         {
  3383.             GetString("PropTags", m_lpCurColumns->aulPropTag[idx], szBuff);
  3384.             SendDlgItemMessage(IDC_PROPTAG32, CB_ADDSTRING, 0, (LPARAM)szBuff);
  3385.         }
  3386.         break;
  3387.  
  3388.     case RES_BITMASK:
  3389.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(TRUE);
  3390.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(TRUE);
  3391.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3392.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(TRUE);
  3393.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(TRUE);
  3394.         GetDlgItem(IDT_VALUE3)->ShowWindow(TRUE);
  3395.         GetDlgItem(IDC_VALUE3)->ShowWindow(TRUE);
  3396.  
  3397.         GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3398.         GetDlgItem(IDT_VALUE3)->SetWindowText("Mask: ex. 0x00000678");
  3399.         GetDlgItem(IDT_PROPTAG3)->SetWindowText("PropTag:");
  3400.         GetDlgItem(IDT_RELATIONSHIP3)->SetWindowText("Relationship:");
  3401.  
  3402.         // update RELATIONSHIP
  3403.         SendDlgItemMessage(IDC_RELATIONSHIP3, CB_RESETCONTENT, 0, 0L);
  3404.         ulNum = GetRowCount("Bmr");
  3405.         for(idx = 0; idx < ulNum; idx++)
  3406.         {
  3407.             GetRowString("Bmr",idx,szBuffer);
  3408.             SendDlgItemMessage(IDC_RELATIONSHIP3, CB_ADDSTRING, 0,
  3409.                     (LPARAM)szBuffer);
  3410.         }
  3411.  
  3412.         break;
  3413.  
  3414.     case RES_SUBRESTRICTION:
  3415.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(FALSE);
  3416.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(FALSE);
  3417.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(TRUE);
  3418.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(FALSE);
  3419.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(FALSE);
  3420.         GetDlgItem(IDT_VALUE3)->ShowWindow(TRUE);
  3421.         GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  3422.         GetDlgItem(IDC_SUBRES3)->EnableWindow(TRUE);
  3423.         
  3424.         GetDlgItem(IDT_VALUE3)->SetWindowText("ulSubObj:");
  3425.  
  3426.         // DIFFERENT SPECIAL PROPERTIES
  3427.         SendDlgItemMessage(IDC_PROPTAG32, CB_RESETCONTENT, 0, 0L);
  3428.         SendDlgItemMessage(IDC_PROPTAG32, CB_ADDSTRING,    0, (LPARAM)(char *)"PR_MESSAGE_ATTACHMENTS");
  3429.         SendDlgItemMessage(IDC_PROPTAG32, CB_ADDSTRING,    0, (LPARAM)(char *)"PR_MESSAGE_RECIPIENTS");
  3430.         
  3431.         break;
  3432.  
  3433.     case RES_SIZE:
  3434.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(TRUE);
  3435.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(TRUE);
  3436.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3437.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(TRUE);
  3438.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(TRUE);
  3439.         GetDlgItem(IDT_VALUE3)->ShowWindow(TRUE);
  3440.         GetDlgItem(IDC_VALUE3)->ShowWindow(TRUE);
  3441.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3442.         GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3443.  
  3444.         GetDlgItem(IDT_PROPTAG3)->SetWindowText("PropTag:");
  3445.         GetDlgItem(IDT_RELATIONSHIP3)->SetWindowText("Relationship:");
  3446.         GetDlgItem(IDT_VALUE3)->SetWindowText("cb:");
  3447.  
  3448.         // update RELATIONSHIP
  3449.         SendDlgItemMessage(IDC_RELATIONSHIP3, CB_RESETCONTENT, 0, 0L);
  3450.         ulNum = GetRowCount("RelOp");
  3451.         for(idx = 0; idx < ulNum; idx++)
  3452.         {
  3453.             GetRowString("RelOp",idx,szBuffer);
  3454.             SendDlgItemMessage(IDC_RELATIONSHIP3, CB_ADDSTRING, 0,
  3455.                     (LPARAM)szBuffer);
  3456.         }
  3457.         break;
  3458.  
  3459.     case RES_EXIST:
  3460.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(TRUE);
  3461.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(TRUE);
  3462.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3463.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(FALSE);
  3464.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(FALSE);
  3465.         GetDlgItem(IDT_VALUE3)->ShowWindow(FALSE);
  3466.         GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  3467.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3468.         GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3469.  
  3470.         GetDlgItem(IDT_PROPTAG3)->SetWindowText("PropTag:");
  3471.         
  3472.         break;
  3473.  
  3474.     case RES_COMMENT:
  3475.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(FALSE);
  3476.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(FALSE);
  3477.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3478.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(FALSE);
  3479.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(FALSE);
  3480.         GetDlgItem(IDT_VALUE3)->ShowWindow(TRUE);
  3481.         GetDlgItem(IDC_VALUE3)->ShowWindow(TRUE);
  3482.         GetDlgItem(IDC_SUBRES3)->EnableWindow(TRUE);
  3483.  
  3484.         GetDlgItem(IDT_VALUE2)->SetWindowText("cValues:");
  3485.         break;
  3486.  
  3487.  
  3488.     default:
  3489.         GetDlgItem(IDT_PROPTAG3)->ShowWindow(FALSE);
  3490.         GetDlgItem(IDC_PROPTAG3)->ShowWindow(FALSE);
  3491.         GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3492.         GetDlgItem(IDT_RELATIONSHIP3)->ShowWindow(FALSE);
  3493.         GetDlgItem(IDC_RELATIONSHIP3)->ShowWindow(FALSE);
  3494.         GetDlgItem(IDT_VALUE3)->ShowWindow(FALSE);
  3495.         GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  3496.         GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  3497.         GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3498.     }
  3499.  
  3500.     m_nResType3 = (int)nNewResType;
  3501. }
  3502.  
  3503.  
  3504.  
  3505. /*
  3506.  -  CResDlg
  3507.  -  OnSubRes1
  3508.  -
  3509.  *  Purpose:
  3510.  *      Creates a sub-Restriction for Restriction 1.
  3511.  *
  3512.  */
  3513.  
  3514. void CResDlg::OnSubRes1()
  3515. {
  3516.     LPSRestriction  lpRes;
  3517.     ULONG           rt;
  3518.  
  3519.     rt = SendDlgItemMessage(IDC_RESTYPE1, CB_GETCURSEL, 0, 0L);
  3520.  
  3521.     if(rt == RES_NOT)
  3522.     {
  3523.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3524.  
  3525.         m_lpSubRes[0].rt = RES_NOT;
  3526.         m_lpSubRes[0].res.resNot.lpRes = lpRes;
  3527.     }
  3528.     else if(rt == RES_SUBRESTRICTION)
  3529.     {
  3530.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3531.  
  3532.         m_lpSubRes[0].rt = RES_SUBRESTRICTION;
  3533.         m_lpSubRes[0].res.resSub.lpRes = lpRes;
  3534.     }
  3535.     else if(rt == RES_COMMENT)
  3536.     {
  3537.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3538.  
  3539.         m_lpSubRes[0].rt = RES_COMMENT;
  3540.         m_lpSubRes[0].res.resComment.lpRes = lpRes;
  3541.     }
  3542.     else
  3543.     {
  3544.         lpRes = &m_lpSubRes[0];
  3545.     }
  3546.  
  3547.     CResDlg dlgSubRes1(m_lpCurColumns, lpRes);
  3548.     dlgSubRes1.SetWindowText("Sub Restriction");
  3549.  
  3550.     if(dlgSubRes1.DoModal() != IDOK) 
  3551.     {
  3552.         if(rt == RES_NOT)
  3553.         {
  3554.             m_lpSubRes[0].res.resNot.lpRes = NULL;
  3555.             SendDlgItemMessage(IDC_RESTYPE1, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3556.             GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  3557.         }
  3558.         else if(rt ==  RES_SUBRESTRICTION )
  3559.         { 
  3560.             m_lpSubRes[0].res.resSub.lpRes = NULL;
  3561.             SendDlgItemMessage(IDC_RESTYPE1, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3562.             GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  3563.             
  3564.             GetDlgItem(IDT_VALUE1)->ShowWindow(FALSE);
  3565.             GetDlgItem(IDC_PROPTAG12)->ShowWindow(FALSE);
  3566.         }
  3567.         else if(rt ==  RES_COMMENT )
  3568.         {
  3569.             m_lpSubRes[0].res.resComment.lpRes = NULL;
  3570.             SendDlgItemMessage(IDC_RESTYPE1, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3571.             GetDlgItem(IDC_SUBRES1)->EnableWindow(FALSE);
  3572.          
  3573.             GetDlgItem(IDT_VALUE1)->ShowWindow(FALSE);
  3574.             GetDlgItem(IDC_VALUE1)->ShowWindow(FALSE);
  3575.         }        
  3576.     }
  3577. }
  3578.  
  3579.  
  3580. /*
  3581.  -  CResDlg
  3582.  -  OnSubRes2
  3583.  -
  3584.  *  Purpose:
  3585.  *      Creates a sub-Restriction for Restriction 2.
  3586.  *
  3587.  */
  3588.  
  3589. void CResDlg::OnSubRes2()
  3590. {
  3591.     LPSRestriction  lpRes;
  3592.     ULONG           rt;
  3593.  
  3594.     rt = SendDlgItemMessage(IDC_RESTYPE2, CB_GETCURSEL, 0, 0L);
  3595.  
  3596.     if(rt == RES_NOT)
  3597.     {
  3598.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3599.  
  3600.         m_lpSubRes[1].rt = RES_NOT;
  3601.         m_lpSubRes[1].res.resNot.lpRes = lpRes;
  3602.     }
  3603.     else if(rt == RES_SUBRESTRICTION)
  3604.     {
  3605.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3606.  
  3607.         m_lpSubRes[1].rt = RES_SUBRESTRICTION;
  3608.         m_lpSubRes[1].res.resSub.lpRes = lpRes;
  3609.     }
  3610.     else if(rt == RES_COMMENT)
  3611.     {
  3612.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3613.  
  3614.         m_lpSubRes[1].rt = RES_COMMENT;
  3615.         m_lpSubRes[1].res.resComment.lpRes = lpRes;
  3616.     }
  3617.     else
  3618.     {
  3619.         lpRes = &m_lpSubRes[1];
  3620.     }
  3621.  
  3622.     CResDlg dlgSubRes2(m_lpCurColumns, lpRes);
  3623.     dlgSubRes2.SetWindowText("Sub Restriction");
  3624.  
  3625.     if(dlgSubRes2.DoModal() != IDOK) 
  3626.     {
  3627.         if(rt == RES_NOT)
  3628.         {
  3629.             m_lpSubRes[1].res.resNot.lpRes = NULL;
  3630.             SendDlgItemMessage(IDC_RESTYPE2, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3631.             GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3632.  
  3633.         }
  3634.         else if(rt ==  RES_SUBRESTRICTION )
  3635.         { 
  3636.             m_lpSubRes[1].res.resSub.lpRes = NULL;
  3637.             SendDlgItemMessage(IDC_RESTYPE2, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3638.             GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3639.             GetDlgItem(IDT_VALUE2)->ShowWindow(FALSE);
  3640.             GetDlgItem(IDC_PROPTAG22)->ShowWindow(FALSE);
  3641.         }
  3642.         else if(rt ==  RES_COMMENT )
  3643.         {
  3644.             m_lpSubRes[1].res.resComment.lpRes = NULL;
  3645.             SendDlgItemMessage(IDC_RESTYPE2, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3646.             GetDlgItem(IDC_SUBRES2)->EnableWindow(FALSE);
  3647.  
  3648.             GetDlgItem(IDT_VALUE2)->ShowWindow(FALSE);
  3649.             GetDlgItem(IDC_VALUE2)->ShowWindow(FALSE);
  3650.         }        
  3651.     }
  3652. }
  3653.  
  3654.  
  3655. /*
  3656.  -  CResDlg
  3657.  -  OnSubRes3
  3658.  -
  3659.  *  Purpose:
  3660.  *      Creates a sub-Restriction for Restriction 3.
  3661.  *
  3662.  */
  3663.  
  3664. void CResDlg::OnSubRes3()
  3665. {
  3666.     LPSRestriction  lpRes;
  3667.     ULONG           rt;
  3668.  
  3669.     rt = SendDlgItemMessage(IDC_RESTYPE3, CB_GETCURSEL, 0, 0L);
  3670.  
  3671.     if(rt == RES_NOT)
  3672.     {
  3673.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3674.  
  3675.         m_lpSubRes[2].rt = RES_NOT;
  3676.         m_lpSubRes[2].res.resNot.lpRes = lpRes;
  3677.     }
  3678.     else if(rt == RES_SUBRESTRICTION)
  3679.     {
  3680.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3681.  
  3682.         m_lpSubRes[2].rt = RES_SUBRESTRICTION;
  3683.         m_lpSubRes[2].res.resSub.lpRes = lpRes;
  3684.     }
  3685.     else if(rt == RES_COMMENT)
  3686.     {
  3687.         lpRes = (LPSRestriction)PvAllocMore(sizeof(SRestriction), m_lpSubRes);
  3688.  
  3689.         m_lpSubRes[2].rt = RES_COMMENT;
  3690.         m_lpSubRes[2].res.resComment.lpRes = lpRes;
  3691.     }
  3692.     else
  3693.     {
  3694.         lpRes = &m_lpSubRes[2];
  3695.     }
  3696.  
  3697.     CResDlg dlgSubRes3(m_lpCurColumns, lpRes);
  3698.     dlgSubRes3.SetWindowText("Sub Restriction");
  3699.  
  3700.  
  3701.     if(dlgSubRes3.DoModal() != IDOK) 
  3702.     {
  3703.         if(rt == RES_NOT)
  3704.         {
  3705.             m_lpSubRes[2].res.resNot.lpRes = NULL;
  3706.             SendDlgItemMessage(IDC_RESTYPE3, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3707.             GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3708.  
  3709.         }
  3710.         else if(rt ==  RES_SUBRESTRICTION )
  3711.         { 
  3712.             m_lpSubRes[2].res.resSub.lpRes = NULL;
  3713.             SendDlgItemMessage(IDC_RESTYPE3, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3714.             GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3715.  
  3716.             GetDlgItem(IDT_VALUE3)->ShowWindow(FALSE);
  3717.             GetDlgItem(IDC_PROPTAG32)->ShowWindow(FALSE);
  3718.  
  3719.         }                         
  3720.         else if(rt ==  RES_COMMENT )
  3721.         {
  3722.             m_lpSubRes[2].res.resComment.lpRes = NULL;
  3723.             SendDlgItemMessage(IDC_RESTYPE3, CB_SETCURSEL, (WPARAM) ulNumResTypes, 0L);
  3724.             GetDlgItem(IDC_SUBRES3)->EnableWindow(FALSE);
  3725.  
  3726.             GetDlgItem(IDT_VALUE3)->ShowWindow(FALSE);
  3727.             GetDlgItem(IDC_VALUE3)->ShowWindow(FALSE);
  3728.         }        
  3729.     }
  3730. }
  3731.  
  3732.  
  3733. /*
  3734.  -  CResDlg
  3735.  -  OnOK
  3736.  -
  3737.  *  Purpose:
  3738.  *      Collects the restiction and sub-restriction information and does
  3739.  *      the appropriate assignments.  This function performs the assignments
  3740.  *      for all three restrictions.
  3741.  *
  3742.  */
  3743.  
  3744. void CResDlg::OnOK()
  3745. {
  3746.     ULONG           cRes = 1;
  3747.     char            szBuff[1024];
  3748.     char            *szEnd      = NULL;
  3749.     LPSPropValue    lpProp;
  3750.     ULONG           idx;
  3751.     BOOL            fTrans;
  3752.     LONG            lSelection   = 0;
  3753.     ULONG           i = 0;
  3754.  
  3755.     m_lpRes->rt = m_fComb;
  3756.     m_lpRes->res.resAnd.cRes = 0;
  3757.     m_lpRes->res.resAnd.lpRes = m_lpSubRes;
  3758.  
  3759.     /* Collect values from Restriction 1 group */
  3760.     switch(m_lpSubRes[0].rt = SendDlgItemMessage(IDC_RESTYPE1,
  3761.             CB_GETCURSEL, 0, 0L))
  3762.     {
  3763.     case RES_AND:
  3764.     case RES_OR:
  3765.     case RES_NOT:
  3766.         m_lpRes[0].res.resAnd.cRes++;
  3767.         break;
  3768.  
  3769.     case RES_CONTENT:
  3770.         idx = SendDlgItemMessage(IDC_PROPTAG1, CB_GETCURSEL, 0, 0L);
  3771.         m_lpSubRes[0].res.resContent.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3772.  
  3773.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP1, CB_GETCURSEL, 0, 0L);
  3774.         m_lpSubRes[0].res.resContent.ulFuzzyLevel = GetRowID("FuzzyLevel",lSelection);
  3775.         
  3776.         SendDlgItemMessage(IDC_VALUE1, WM_GETTEXT, sizeof(szBuff),
  3777.                 (LPARAM)szBuff);
  3778.         lpProp = (LPSPropValue)PvAllocMore(sizeof(SPropValue),
  3779.                 (LPVOID)m_lpSubRes);
  3780.  
  3781.         MakePropValue(lpProp, PROP_TAG(PT_TSTRING, 0x0000), szBuff, m_lpSubRes);
  3782.  
  3783.         m_lpSubRes[0].res.resContent.lpProp = lpProp;
  3784.         m_lpRes[0].res.resAnd.cRes++;
  3785.         break;
  3786.  
  3787.     case RES_PROPERTY:
  3788.         idx = SendDlgItemMessage(IDC_PROPTAG1, CB_GETCURSEL, 0, 0L);
  3789.         m_lpSubRes[0].res.resProperty.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3790.  
  3791.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP1, CB_GETCURSEL, 0, 0L);
  3792.         m_lpSubRes[0].res.resProperty.relop  = GetRowID("RelOp",lSelection);
  3793.         
  3794.         SendDlgItemMessage(IDC_VALUE1, WM_GETTEXT, sizeof(szBuff),
  3795.                 (LPARAM)szBuff);
  3796.  
  3797.         lpProp = (LPSPropValue)PvAllocMore(sizeof(SPropValue),
  3798.                 (LPVOID)m_lpSubRes);
  3799.  
  3800.         MakePropValue(lpProp,m_lpCurColumns->aulPropTag[idx] , szBuff, m_lpSubRes);
  3801.         
  3802.         m_lpSubRes[0].res.resProperty.lpProp = lpProp;
  3803.         m_lpRes[0].res.resAnd.cRes++;
  3804.         break;
  3805.  
  3806.     case RES_COMPAREPROPS:
  3807.         idx = SendDlgItemMessage(IDC_PROPTAG1, CB_GETCURSEL, 0, 0L);
  3808.         m_lpSubRes[0].res.resCompareProps.ulPropTag1 = m_lpCurColumns->aulPropTag[idx];
  3809.  
  3810.         idx = SendDlgItemMessage(IDC_PROPTAG12, CB_GETCURSEL, 0, 0L);
  3811.         m_lpSubRes[0].res.resCompareProps.ulPropTag2 = m_lpCurColumns->aulPropTag[idx];
  3812.  
  3813.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP1, CB_GETCURSEL, 0, 0L);
  3814.         m_lpSubRes[0].res.resCompareProps.relop  = GetRowID("RelOp",lSelection);
  3815.  
  3816.         m_lpRes[0].res.resAnd.cRes++;
  3817.         break;
  3818.  
  3819.     case RES_BITMASK:
  3820.         idx = SendDlgItemMessage(IDC_PROPTAG1, CB_GETCURSEL, 0, 0L);
  3821.         m_lpSubRes[0].res.resBitMask.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3822.  
  3823.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP1, CB_GETCURSEL, 0, 0L);
  3824.         m_lpSubRes[0].res.resBitMask.relBMR  = GetRowID("Bmr",lSelection);
  3825.  
  3826.         m_lpSubRes[0].res.resBitMask.relBMR = SendDlgItemMessage(IDC_RELATIONSHIP1,
  3827.                 CB_GETCURSEL, 0, 0L);
  3828.  
  3829.         SendDlgItemMessage(IDC_VALUE1, WM_GETTEXT, sizeof(szBuff),
  3830.                 (LPARAM)szBuff);
  3831.  
  3832.         m_lpSubRes[0].res.resBitMask.ulMask = strtoul(szBuff,&szEnd,16);
  3833.         
  3834.         m_lpRes[0].res.resAnd.cRes++;
  3835.         break;
  3836.  
  3837.     case RES_SIZE:
  3838.     
  3839.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP1, CB_GETCURSEL, 0, 0L);
  3840.         m_lpSubRes[0].res.resSize.relop  = GetRowID("RelOp",lSelection);
  3841.     
  3842.         idx = SendDlgItemMessage(IDC_PROPTAG1, CB_GETCURSEL, 0, 0L);
  3843.         m_lpSubRes[0].res.resSize.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3844.  
  3845.         m_lpSubRes[0].res.resSize.cb = (ULONG)GetDlgItemInt(IDC_VALUE1, &fTrans , FALSE );
  3846.  
  3847.         m_lpRes[0].res.resAnd.cRes++;
  3848.         break;
  3849.  
  3850.     case RES_EXIST:
  3851.         idx = SendDlgItemMessage(IDC_PROPTAG1, CB_GETCURSEL, 0, 0L);
  3852.         m_lpSubRes[0].res.resExist.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3853.  
  3854.         m_lpRes[0].res.resAnd.cRes++;
  3855.         break;
  3856.  
  3857.     case RES_SUBRESTRICTION:
  3858.         idx = SendDlgItemMessage(IDC_PROPTAG12, CB_GETCURSEL, 0, 0L);
  3859.         if( idx == 1 ) 
  3860.             m_lpSubRes[0].res.resSub.ulSubObject = PR_MESSAGE_RECIPIENTS;
  3861.         else
  3862.             m_lpSubRes[0].res.resSub.ulSubObject = PR_MESSAGE_ATTACHMENTS;
  3863.  
  3864.         m_lpRes[0].res.resAnd.cRes++;
  3865.         break;
  3866.  
  3867.     case RES_COMMENT:
  3868.         m_lpSubRes[0].res.resComment.cValues = (ULONG)GetDlgItemInt(IDC_VALUE1, &fTrans , FALSE );
  3869.  
  3870.         lpProp = (LPSPropValue)PvAllocMore( m_lpSubRes[0].res.resComment.cValues * sizeof(SPropValue),
  3871.                 (LPVOID)m_lpSubRes);
  3872.  
  3873.         for( i = 0 ; i < m_lpSubRes[0].res.resComment.cValues ; i++)
  3874.             MakePropValue( &(lpProp[i]),PR_SUBJECT, "TEST STRING", m_lpSubRes);
  3875.  
  3876.         m_lpSubRes[0].res.resComment.lpProp = lpProp;
  3877.         m_lpRes[0].res.resAnd.cRes++;
  3878.         break;
  3879.  
  3880.     default:
  3881.         break;
  3882.     }
  3883.  
  3884.     /* Collect values from Restriction 2 group */
  3885.     switch(m_lpSubRes[1].rt = SendDlgItemMessage(IDC_RESTYPE2,
  3886.             CB_GETCURSEL, 0, 0L))
  3887.     {
  3888.     case RES_AND:
  3889.     case RES_OR:
  3890.     case RES_NOT:
  3891.         m_lpRes[0].res.resAnd.cRes++;
  3892.         break;
  3893.  
  3894.     case RES_CONTENT:
  3895.         idx = SendDlgItemMessage(IDC_PROPTAG2, CB_GETCURSEL, 0, 0L);
  3896.         m_lpSubRes[1].res.resContent.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3897.  
  3898.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP2, CB_GETCURSEL, 0, 0L);
  3899.         m_lpSubRes[1].res.resContent.ulFuzzyLevel = GetRowID("FuzzyLevel",lSelection);
  3900.  
  3901.         SendDlgItemMessage(IDC_VALUE2, WM_GETTEXT, sizeof(szBuff),
  3902.                 (LPARAM)szBuff);
  3903.         lpProp = (LPSPropValue)PvAllocMore(sizeof(SPropValue),
  3904.                 (LPVOID)m_lpSubRes);
  3905.  
  3906.         MakePropValue(lpProp, PROP_TAG(PT_TSTRING, 0x0000), szBuff, m_lpSubRes);
  3907.  
  3908.         m_lpSubRes[1].res.resContent.lpProp = lpProp;
  3909.         m_lpRes[0].res.resAnd.cRes++;
  3910.         break;
  3911.  
  3912.     case RES_PROPERTY:
  3913.         idx = SendDlgItemMessage(IDC_PROPTAG2, CB_GETCURSEL, 0, 0L);
  3914.         m_lpSubRes[1].res.resProperty.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3915.  
  3916.  
  3917.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP2, CB_GETCURSEL, 0, 0L);
  3918.         m_lpSubRes[1].res.resProperty.relop  = GetRowID("RelOp",lSelection);
  3919.  
  3920.         SendDlgItemMessage(IDC_VALUE2, WM_GETTEXT, sizeof(szBuff),
  3921.                 (LPARAM)szBuff);
  3922.         lpProp = (LPSPropValue)PvAllocMore(sizeof(SPropValue),
  3923.                 (LPVOID)m_lpSubRes);
  3924.  
  3925.         MakePropValue(lpProp,m_lpCurColumns->aulPropTag[idx] , szBuff, m_lpSubRes);
  3926.  
  3927.         m_lpSubRes[1].res.resProperty.lpProp = lpProp;
  3928.         m_lpRes[0].res.resAnd.cRes++;
  3929.         break;
  3930.  
  3931.     case RES_COMPAREPROPS:
  3932.         idx = SendDlgItemMessage(IDC_PROPTAG2, CB_GETCURSEL, 0, 0L);
  3933.         m_lpSubRes[1].res.resCompareProps.ulPropTag1 = m_lpCurColumns->aulPropTag[idx];
  3934.  
  3935.         idx = SendDlgItemMessage(IDC_PROPTAG22, CB_GETCURSEL, 0, 0L);
  3936.         m_lpSubRes[1].res.resCompareProps.ulPropTag2 = m_lpCurColumns->aulPropTag[idx];
  3937.  
  3938.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP2, CB_GETCURSEL, 0, 0L);
  3939.         m_lpSubRes[1].res.resCompareProps.relop  = GetRowID("RelOp",lSelection);
  3940.  
  3941.         m_lpRes[0].res.resAnd.cRes++;
  3942.         break;
  3943.  
  3944.     case RES_BITMASK:
  3945.         idx = SendDlgItemMessage(IDC_PROPTAG2, CB_GETCURSEL, 0, 0L);
  3946.         m_lpSubRes[1].res.resBitMask.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3947.  
  3948.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP2, CB_GETCURSEL, 0, 0L);
  3949.         m_lpSubRes[1].res.resBitMask.relBMR  = GetRowID("Bmr",lSelection);
  3950.  
  3951.         SendDlgItemMessage(IDC_VALUE2, WM_GETTEXT, sizeof(szBuff),
  3952.                 (LPARAM)szBuff);
  3953.  
  3954.         m_lpSubRes[1].res.resBitMask.ulMask = strtoul(szBuff,&szEnd,16);
  3955.  
  3956.         m_lpRes[0].res.resAnd.cRes++;
  3957.         break;
  3958.  
  3959.     case RES_SIZE:
  3960.  
  3961.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP2, CB_GETCURSEL, 0, 0L);
  3962.         m_lpSubRes[1].res.resSize.relop  = GetRowID("RelOp",lSelection);
  3963.  
  3964.         idx = SendDlgItemMessage(IDC_PROPTAG2, CB_GETCURSEL, 0, 0L);
  3965.         m_lpSubRes[1].res.resSize.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3966.  
  3967.         m_lpSubRes[1].res.resSize.cb = (ULONG)GetDlgItemInt(IDC_VALUE2, &fTrans , FALSE );
  3968.  
  3969.         m_lpRes[0].res.resAnd.cRes++;
  3970.         break;
  3971.  
  3972.     case RES_EXIST:
  3973.         idx = SendDlgItemMessage(IDC_PROPTAG2, CB_GETCURSEL, 0, 0L);
  3974.         m_lpSubRes[1].res.resExist.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  3975.  
  3976.         m_lpRes[0].res.resAnd.cRes++;
  3977.         break;
  3978.  
  3979.     case RES_SUBRESTRICTION:
  3980.         idx = SendDlgItemMessage(IDC_PROPTAG22, CB_GETCURSEL, 0, 0L);
  3981.         if( idx == 1 ) 
  3982.             m_lpSubRes[1].res.resSub.ulSubObject = PR_MESSAGE_RECIPIENTS;
  3983.         else
  3984.             m_lpSubRes[1].res.resSub.ulSubObject = PR_MESSAGE_ATTACHMENTS;
  3985.  
  3986.         m_lpRes[0].res.resAnd.cRes++;
  3987.         break;
  3988.  
  3989.     case RES_COMMENT:
  3990.         m_lpSubRes[1].res.resComment.cValues = (ULONG)GetDlgItemInt(IDC_VALUE2, &fTrans , FALSE );
  3991.  
  3992.         lpProp = (LPSPropValue)PvAllocMore( m_lpSubRes[1].res.resComment.cValues * sizeof(SPropValue),
  3993.                 (LPVOID)m_lpSubRes);
  3994.  
  3995.         for( i = 0 ; i < m_lpSubRes[1].res.resComment.cValues ; i++)
  3996.             MakePropValue( &(lpProp[i]),PR_SUBJECT, "TEST STRING", m_lpSubRes);
  3997.  
  3998.         m_lpSubRes[1].res.resComment.lpProp = lpProp;
  3999.         m_lpRes[0].res.resAnd.cRes++;
  4000.         break;
  4001.  
  4002.     default:
  4003.         break;
  4004.     }
  4005.  
  4006.     /* Collect values from Restriction 3 group */
  4007.     switch(m_lpSubRes[2].rt = SendDlgItemMessage(IDC_RESTYPE3,
  4008.             CB_GETCURSEL, 0, 0L))
  4009.     {
  4010.     case RES_AND:
  4011.     case RES_OR:
  4012.     case RES_NOT:
  4013.         m_lpRes[0].res.resAnd.cRes++;
  4014.         break;
  4015.  
  4016.     case RES_CONTENT:
  4017.         idx = SendDlgItemMessage(IDC_PROPTAG3, CB_GETCURSEL, 0, 0L);
  4018.         m_lpSubRes[2].res.resContent.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  4019.  
  4020.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP3, CB_GETCURSEL, 0, 0L);
  4021.         m_lpSubRes[2].res.resContent.ulFuzzyLevel = GetRowID("FuzzyLevel",lSelection);
  4022.  
  4023.         SendDlgItemMessage(IDC_VALUE3, WM_GETTEXT, sizeof(szBuff),
  4024.                 (LPARAM)szBuff);
  4025.         lpProp = (LPSPropValue)PvAllocMore(sizeof(SPropValue),
  4026.                 (LPVOID)m_lpSubRes);
  4027.  
  4028.         MakePropValue(lpProp, PROP_TAG(PT_TSTRING, 0x0000), szBuff, m_lpSubRes);
  4029.  
  4030.         m_lpSubRes[2].res.resContent.lpProp = lpProp;
  4031.         m_lpRes[0].res.resAnd.cRes++;
  4032.         break;
  4033.  
  4034.     case RES_PROPERTY:
  4035.         idx = SendDlgItemMessage(IDC_PROPTAG3, CB_GETCURSEL, 0, 0L);
  4036.         m_lpSubRes[2].res.resProperty.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  4037.  
  4038.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP3, CB_GETCURSEL, 0, 0L);
  4039.         m_lpSubRes[2].res.resProperty.relop  = GetRowID("RelOp",lSelection);
  4040.  
  4041.         SendDlgItemMessage(IDC_VALUE3, WM_GETTEXT, sizeof(szBuff),
  4042.                 (LPARAM)szBuff);
  4043.         lpProp = (LPSPropValue)PvAllocMore(sizeof(SPropValue),
  4044.                 (LPVOID)m_lpSubRes);
  4045.  
  4046.         MakePropValue(lpProp,m_lpCurColumns->aulPropTag[idx] , szBuff, m_lpSubRes);
  4047.  
  4048.         m_lpSubRes[2].res.resProperty.lpProp = lpProp;
  4049.         m_lpRes[0].res.resAnd.cRes++;
  4050.         break;
  4051.  
  4052.     case RES_COMPAREPROPS:
  4053.         idx = SendDlgItemMessage(IDC_PROPTAG3, CB_GETCURSEL, 0, 0L);
  4054.         m_lpSubRes[2].res.resCompareProps.ulPropTag1 = m_lpCurColumns->aulPropTag[idx];
  4055.  
  4056.         idx = SendDlgItemMessage(IDC_PROPTAG32, CB_GETCURSEL, 0, 0L);
  4057.         m_lpSubRes[2].res.resCompareProps.ulPropTag2 = m_lpCurColumns->aulPropTag[idx];
  4058.  
  4059.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP3, CB_GETCURSEL, 0, 0L);
  4060.         m_lpSubRes[2].res.resCompareProps.relop  = GetRowID("RelOp",lSelection);
  4061.  
  4062.         m_lpRes[0].res.resAnd.cRes++;
  4063.         break;
  4064.  
  4065.     case RES_BITMASK:
  4066.         idx = SendDlgItemMessage(IDC_PROPTAG3, CB_GETCURSEL, 0, 0L);
  4067.         m_lpSubRes[2].res.resBitMask.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  4068.  
  4069.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP3, CB_GETCURSEL, 0, 0L);
  4070.         m_lpSubRes[2].res.resBitMask.relBMR  = GetRowID("Bmr",lSelection);
  4071.  
  4072.         SendDlgItemMessage(IDC_VALUE3, WM_GETTEXT, sizeof(szBuff),
  4073.                 (LPARAM)szBuff);
  4074.  
  4075.         m_lpSubRes[2].res.resBitMask.ulMask = strtoul(szBuff,&szEnd,16);
  4076.  
  4077.         m_lpRes[0].res.resAnd.cRes++;
  4078.         break;
  4079.  
  4080.     case RES_SIZE:
  4081.         lSelection = SendDlgItemMessage(IDC_RELATIONSHIP3, CB_GETCURSEL, 0, 0L);
  4082.         m_lpSubRes[2].res.resSize.relop  = GetRowID("RelOp",lSelection);
  4083.  
  4084.         idx = SendDlgItemMessage(IDC_PROPTAG3, CB_GETCURSEL, 0, 0L);
  4085.         m_lpSubRes[2].res.resSize.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  4086.  
  4087.         m_lpSubRes[2].res.resSize.cb = (ULONG)GetDlgItemInt(IDC_VALUE3, &fTrans , FALSE );
  4088.  
  4089.         m_lpRes[0].res.resAnd.cRes++;
  4090.         break;
  4091.  
  4092.     case RES_EXIST:
  4093.         idx = SendDlgItemMessage(IDC_PROPTAG3, CB_GETCURSEL, 0, 0L);
  4094.         m_lpSubRes[2].res.resExist.ulPropTag = m_lpCurColumns->aulPropTag[idx];
  4095.  
  4096.         m_lpRes[0].res.resAnd.cRes++;
  4097.         break;
  4098.  
  4099.     case RES_SUBRESTRICTION:
  4100.         idx = SendDlgItemMessage(IDC_PROPTAG32, CB_GETCURSEL, 0, 0L);
  4101.         if( idx == 1 ) 
  4102.             m_lpSubRes[2].res.resSub.ulSubObject = PR_MESSAGE_RECIPIENTS;
  4103.         else
  4104.             m_lpSubRes[2].res.resSub.ulSubObject = PR_MESSAGE_ATTACHMENTS;
  4105.        
  4106.         m_lpRes[0].res.resAnd.cRes++;
  4107.         break;
  4108.  
  4109.     case RES_COMMENT:
  4110.         m_lpSubRes[2].res.resComment.cValues = (ULONG)GetDlgItemInt(IDC_VALUE3, &fTrans , FALSE );
  4111.  
  4112.         lpProp = (LPSPropValue)PvAllocMore( m_lpSubRes[2].res.resComment.cValues * sizeof(SPropValue),
  4113.                 (LPVOID)m_lpSubRes);
  4114.  
  4115.         for( i = 0 ; i < m_lpSubRes[2].res.resComment.cValues ; i++)
  4116.             MakePropValue( &(lpProp[i]),PR_SUBJECT, "TEST STRING", m_lpSubRes);
  4117.  
  4118.         m_lpSubRes[2].res.resComment.lpProp = lpProp;
  4119.         m_lpRes[0].res.resAnd.cRes++;
  4120.         break;
  4121.  
  4122.     default:
  4123.         break;
  4124.     }
  4125.  
  4126.     // display restriction
  4127.     CAcceptRestrictionDlg Res(this);
  4128.     
  4129.     Res.m_prest = m_lpRes;
  4130.     if(Res.DoModal() == IDOK)
  4131.         EndDialog(IDOK);        
  4132. }
  4133.  
  4134.  
  4135. void CResDlg::OnCancel()
  4136. {
  4137.     PvFree(m_lpSubRes);
  4138.     EndDialog(IDCANCEL);
  4139. }
  4140.  
  4141.  
  4142. /*-------------------------*/
  4143. /* Misc. Support Functions */
  4144. /*-------------------------*/
  4145.  
  4146. /*
  4147.  -  AddBookmark
  4148.  -
  4149.  *  Purpose:
  4150.  *      Adds a bookmark to the internal list.
  4151.  *
  4152.  */
  4153.  
  4154. void AddBookmark(LPBKLIST lpBkList, BOOKMARK bk, LPSPropValue lpProp)
  4155. {
  4156.     LPSPropValue    lpNewProp;
  4157.  
  4158.     ASSERT(lpBkList->cValues < BKLIST_MAX);
  4159.  
  4160.     /* We associate a PropValue with a bookmark for display */
  4161.     /* purposes.  We need to make a copy of this PropValue. */
  4162.     lpNewProp = (LPSPropValue)PvAlloc(sizeof(SPropValue));
  4163.  
  4164.     CopyPropValue(lpNewProp, lpProp, lpNewProp);
  4165.  
  4166.     /* New bookmarks go in at bottom of list */
  4167.     lpBkList->bkList[lpBkList->cValues].bk = bk;
  4168.     lpBkList->bkList[lpBkList->cValues++].lpProp = lpNewProp;
  4169. }
  4170.  
  4171.  
  4172. /*
  4173.  -  RemoveBookmark
  4174.  -
  4175.  *  Purpose:
  4176.  *      Removes a bookmark from the internal list.
  4177.  *
  4178.  */
  4179.  
  4180. void RemoveBookmark(LPBKLIST lpBkList, DWORD idxBk)
  4181. {
  4182.     DWORD   idx;
  4183.  
  4184.     ASSERT(lpBkList->cValues);
  4185.     ASSERT(idxBk < lpBkList->cValues);
  4186.  
  4187.     /* Free the PropValue associated with this bookmark */
  4188.      PvFree(lpBkList->bkList[idxBk].lpProp);
  4189.  
  4190.     /* Decrement the current count of bookmarks */
  4191.     lpBkList->cValues--;
  4192.  
  4193.     /* Shift remaining values up one */
  4194.     for(idx = idxBk; idx < lpBkList->cValues; idx++)
  4195.     {
  4196.         lpBkList->bkList[idx].bk = lpBkList->bkList[idx+1].bk;
  4197.         lpBkList->bkList[idx].lpProp = lpBkList->bkList[idx+1].lpProp;
  4198.     }
  4199. }
  4200.  
  4201.  
  4202. /*
  4203.  -  FreeRestriction
  4204.  -
  4205.  *  Purpose:
  4206.  *      Free the memory of a restriciton.
  4207.  */
  4208. void FreeRestriction(LPSRestriction lpRes)
  4209. {
  4210.     ULONG   idx;
  4211.  
  4212.     if(!lpRes)
  4213.         return;
  4214.  
  4215.     if(lpRes->rt == RES_AND || lpRes->rt == RES_OR)
  4216.     {
  4217.         for(idx = 0; idx < lpRes->res.resAnd.cRes; idx++)
  4218.         {
  4219.             if(lpRes->res.resAnd.lpRes[idx].rt ==  RES_AND ||
  4220.                lpRes->res.resAnd.lpRes[idx].rt == RES_OR)
  4221.                 FreeRestriction(&lpRes->res.resAnd.lpRes[idx]);
  4222.  
  4223.             if(lpRes->res.resAnd.lpRes[idx].rt == RES_NOT)
  4224.                 FreeRestriction(lpRes->res.resAnd.lpRes[idx].res.resNot.lpRes);
  4225.         }
  4226.  
  4227.         PvFree(lpRes->res.resAnd.lpRes);
  4228.     }
  4229. }
  4230.  
  4231.  
  4232.  
  4233. /*--------------------*/
  4234. /* Library Init stuff */
  4235. /*--------------------*/
  4236.  
  4237. class CTblViewDLL : public CWinApp
  4238. {
  4239. public:
  4240.     virtual BOOL InitInstance();
  4241.     virtual BOOL ExitInstance();
  4242.  
  4243.     CTblViewDLL(const char *pszAppName)
  4244.             : CWinApp(pszAppName)
  4245.         {
  4246.         }
  4247. };
  4248.  
  4249. BOOL CTblViewDLL::InitInstance()
  4250. {
  4251.     SetDialogBkColor();
  4252.     return TRUE;
  4253. }
  4254.  
  4255.  
  4256. BOOL CTblViewDLL::ExitInstance()
  4257. {
  4258.     return TRUE;
  4259. }
  4260.  
  4261. CTblViewDLL  vtDLL("tblvu32.dll");
  4262.