home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / dbmsg / mapi / remote.srv / admdlist.cpp < prev    next >
C/C++ Source or Header  |  1996-04-11  |  53KB  |  1,320 lines
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  File Name 
  4. //      ADMDLIST.CPP
  5. //
  6. //  Description
  7. //
  8. //  Author
  9. //      Irving De la Cruz
  10. //
  11. //  Revision: 1.7
  12. //
  13. // Written for Microsoft Windows Developer Support
  14. // Copyright (c) 1995-1996 Microsoft Corporation. All rights reserved.
  15. //
  16. #include "ADMIN.H"
  17. #include "COMMON.H"
  18.  
  19. extern "C"
  20. {
  21.     HRESULT WINAPI DisplayDistListPropSheets
  22.                         (HWND                       hOwnerWnd,
  23.                          POBJECT_INFO               pObjInfo,
  24.                          BOOL                       fCreate);
  25.     BOOL CALLBACK DLProps1DlgProc
  26.                         (HWND                       hDlg, 
  27.                          UINT                       message, 
  28.                          WPARAM                     wParam, 
  29.                          LPARAM                     lParam);
  30.     BOOL CALLBACK DLProps2DlgProc
  31.                         (HWND                       hDlg, 
  32.                          UINT                       message, 
  33.                          WPARAM                     wParam, 
  34.                          LPARAM                     lParam);
  35.     BOOL CALLBACK DLProps3DlgProc
  36.                         (HWND                       hDlg, 
  37.                          UINT                       message, 
  38.                          WPARAM                     wParam, 
  39.                          LPARAM                     lParam);
  40.     BOOL CALLBACK ModifyListDlgProc
  41.                         (HWND                       hDlg, 
  42.                          UINT                       message, 
  43.                          WPARAM                     wParam, 
  44.                          LPARAM                     lParam);
  45.     BOOL CALLBACK WaitDlgProc
  46.                         (HWND                       hDlg, 
  47.                          UINT                       message, 
  48.                          WPARAM                     wParam, 
  49.                          LPARAM                     lParam);
  50.     void WINAPI AddMembersToPageLV
  51.                         (HWND                       hOwnerWnd,
  52.                          HWND                       hListView,
  53.                          DLM_LIST *                 pMembers);
  54. };
  55.  
  56. ///////////////////////////////////////////////////////////////////////////////
  57. //    GetServerDistLists()
  58. //
  59. //    Parameters
  60. //
  61. //    Purpose
  62. //
  63. //    Return Value
  64. //
  65. HRESULT WINAPI GetServerDistLists (HWND hOwnerWnd)
  66. {
  67.     return DownloadBulkInfo (hOwnerWnd, ghListView, ITEM_SERVER_DIST_LISTS);
  68. }
  69.  
  70. ///////////////////////////////////////////////////////////////////////////////
  71. //    DownloadBulkInfo()
  72. //
  73. //    Parameters
  74. //
  75. //    Purpose
  76. //
  77. //    Return Value
  78. //
  79. HRESULT WINAPI DownloadBulkInfo (HWND hOwnerWnd, HWND hListView, ITEM_TYPE Type)
  80. {
  81.     LV_ITEM lvi = { 0 };
  82.     lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
  83.     int i = 0;
  84.     long lPipeNum;
  85.     TCHAR achPipeName[128];
  86.     LPTSTR szObjAlias;
  87.     HANDLE hPipe;
  88.     DWORD dwBytesRead;
  89.     DWORD * pdwObjID;
  90.     AB_ENTRY_INFO abEntry = { 0 };
  91.     HRESULT hResult = S_OK;
  92.     EnterCriticalSection (&csRemoteServer);
  93.     SendMessage (hOwnerWnd, WM_WINDS_REMOTE_CALL_IN_PROGRESS, hResult, 0);
  94.     ListView_DeleteAllItems (hListView);
  95.     SendMessage (ghStatusBar, SB_SETTEXT, 0, (LPARAM)TEXT("Connecting to the server..."));
  96.     RpcTryExcept
  97.     {
  98.         // Make the remote call to request the server to open a pipe for the download
  99.         switch (Type)
  100.         {
  101.             case ITEM_SERVER_USER_MAILBOXES :
  102.                 hResult = RemoteAdmGetServerMailboxes (&lPipeNum);
  103.                 lvi.iImage = IMG_USER_MAILBOX;
  104.                 pdwObjID = &(abEntry.Info.MB.dwObjID);
  105.                 szObjAlias = abEntry.Info.MB.szMailboxName;
  106.                 break;
  107.             case ITEM_SERVER_DIST_LISTS :
  108.                 hResult = RemoteAdmGetServerDistLists (&lPipeNum);
  109.                 lvi.iImage = IMG_DIST_LIST;
  110.                 pdwObjID = &(abEntry.Info.DL.dwObjID);
  111.                 szObjAlias = abEntry.Info.DL.szDLAlias;
  112.                 break;
  113.             default :
  114.                 ASSERTMSG (FALSE, "Unknown item type");
  115.                 hResult = E_FAIL;
  116.                 break;
  117.         }
  118.         if (!hResult)
  119.         {
  120.             SendMessage (ghStatusBar, SB_SETTEXT, 0, (LPARAM)TEXT("Connection established... Pending pipe connection..."));
  121.             // Construct the download pipe name
  122.             wsprintf (achPipeName, PIPE_NAME_FORMAT, g_szCurrentServer, lPipeNum);
  123.             // Create our endpoint and connect    
  124.             hPipe = CreateFile (achPipeName, 
  125.                                 GENERIC_READ,
  126.                                 0,
  127.                                 NULL,
  128.                                 OPEN_EXISTING,
  129.                                 0,
  130.                                 NULL);
  131.             if (INVALID_HANDLE_VALUE == hPipe)
  132.             {
  133.                 hResult = HRESULT_FROM_WIN32(GetLastError());
  134.             }
  135.         }
  136.     }
  137.     RpcExcept(1)
  138.     {        
  139.         // If we got here is because there was an error while call was made
  140.         // or when it was about to be made.
  141.         hResult = RpcExceptionCode();
  142.         if (RPC_S_SERVER_UNAVAILABLE == hResult)
  143.         {
  144.             hResult = HRESULT_FROM_WIN32(ERROR_HOST_UNREACHABLE);
  145.         }
  146.         else
  147.         {
  148.             hResult = MAKE_HRESULT(1, FACILITY_RPC, hResult);
  149.         }
  150.     }
  151.     RpcEndExcept
  152.     if (!hResult)
  153.     {
  154.         SendMessage (ghStatusBar, SB_SETTEXT, 0, (LPARAM)TEXT("Pipe opened. Downloading server information..."));
  155.         do
  156.         {
  157.             // Read from the pipe
  158.             if (!ReadFile (hPipe, &abEntry, sizeof(AB_ENTRY_INFO), &dwBytesRead, NULL))
  159.             {
  160.                 hResult = HRESULT_FROM_WIN32(GetLastError());
  161.                 if (HRESULT_FROM_WIN32(ERROR_BROKEN_PIPE)   != hResult &&   // For Windows NT
  162.                     HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) != hResult)     // For Windows 95
  163.                 {
  164.                     // There was an error and we can't continue
  165.                     TraceResult ("DownloadBulkInfo: Failed to read from the source", hResult);
  166.                 }
  167.                 else
  168.                 {
  169.                     // If the pipe was broken, it means the server finished writing
  170.                     // to the it, so we are finished reading from it.
  171.                     hResult = S_OK;
  172.                 }
  173.             }
  174.             else
  175.             {   
  176.                 lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
  177.                 lvi.iItem = i;
  178.                 lvi.iSubItem = 0;
  179.                 lvi.pszText = szObjAlias;
  180.                 lvi.lParam = *pdwObjID;
  181.                 lvi.iItem = ListView_InsertItem (hListView, &lvi);
  182.                 
  183.                 switch (Type)
  184.                 {
  185.                     case ITEM_SERVER_USER_MAILBOXES :
  186.                         ListView_SetItemText (hListView, lvi.iItem, 1, abEntry.Info.MB.szFullName);
  187.                         ListView_SetItemText (hListView, lvi.iItem, 2, abEntry.Info.MB.szJobTitle);
  188.                         ListView_SetItemText (hListView, lvi.iItem, 3, abEntry.Info.MB.szOffice);
  189.                         ListView_SetItemText (hListView, lvi.iItem, 4, abEntry.Info.MB.szDepartment);
  190.                         ListView_SetItemText (hListView, lvi.iItem, 5, abEntry.Info.MB.szPhone);
  191.                         ListView_SetItemText (hListView, lvi.iItem, 6, abEntry.Info.MB.szFax);
  192.                         break;
  193.                     case ITEM_SERVER_DIST_LISTS :
  194.                         ListView_SetItemText (hListView, lvi.iItem, 1, abEntry.Info.DL.szDLFullName);
  195.                         break;
  196.                 }
  197.                 i++;
  198.             }
  199.             if (AbortRemoteCall())
  200.             {
  201.                 dwBytesRead = 0; // This will cause the DO-WHILE() loop to terminate
  202.                 hResult = S_OK; // If the user aborted the call, don't return any error.
  203.             }
  204.         } while (dwBytesRead && !hResult);
  205.         CloseHandle (hPipe);
  206.         SendMessage (ghStatusBar, SB_SETTEXT, 0, (LPARAM)TEXT("Connection Closed..."));
  207.     }
  208.     LeaveCriticalSection (&csRemoteServer);
  209.     TraceResult ("DownloadBulkInfo", hResult);
  210.     SendMessage (hOwnerWnd, WM_WINDS_REMOTE_CALL_COMPLETED, hResult, 0);
  211.     return hResult;
  212. }
  213.  
  214. ///////////////////////////////////////////////////////////////////////////////
  215. //    CreateNewDistList()
  216. //
  217. //    Parameters
  218. //      
  219. //    Purpose
  220. //
  221. //    Return Value
  222. //
  223. void WINAPI CreateNewDistList (HWND hOwnerWnd)
  224. {
  225.     DLM_XMIT_LIST Members = { 0 };
  226.     OBJECT_INFO ObjInfo = { 0 };
  227.     ObjInfo.DL.pMembers = &Members;
  228.     ObjInfo.Type = SERVER_DISTRIBUTION_LIST;
  229.     HRESULT hResult = DisplayDistListPropSheets (hOwnerWnd, &ObjInfo, TRUE);
  230.     if (!hResult)
  231.     {
  232.         RpcTryExcept
  233.         {
  234.             hResult = RemoteAdmCreateDistList ((WINDS_RPC_STRING)ObjInfo.DL.szDLAlias,
  235.                                                (WINDS_RPC_STRING)ObjInfo.DL.szDLFullName,
  236.                                                ObjInfo.DL.dwFlags,
  237.                                                (WINDS_RPC_STRING)ObjInfo.DL.szOwnerAlias,
  238.                                                (WINDS_RPC_STRING)ObjInfo.DL.szOwnerName,
  239.                                                ObjInfo.DL.dwOwnerID,
  240.                                                &Members);
  241.         }
  242.         RpcExcept(1)
  243.         {        
  244.             // If we got here is because there was an error while call was made
  245.             // or when it was about to be made.
  246.             hResult = RpcExceptionCode();
  247.             if (RPC_S_SERVER_UNAVAILABLE == hResult)
  248.             {
  249.                 hResult = HRESULT_FROM_WIN32(ERROR_HOST_UNREACHABLE);
  250.             }
  251.             else
  252.             {
  253.                 hResult = MAKE_HRESULT(1, FACILITY_RPC, hResult);
  254.             }
  255.         }
  256.         RpcEndExcept
  257.         FreeDLMList (&Members);
  258.     }
  259.     else
  260.     {
  261.         if (S_FALSE == hResult)
  262.         {
  263.             hResult = S_OK;
  264.         }
  265.     }
  266.     if (hResult)
  267.     {
  268.         ErrorHandler (hOwnerWnd, hResult);
  269.     }
  270. }
  271.  
  272. ///////////////////////////////////////////////////////////////////////////////
  273. //    ShowDistListProps()
  274. //
  275. //    Parameters
  276. //      
  277. //    Purpose
  278. //      
  279. //    Return Value
  280. //      
  281. void WINAPI ShowDistListProps (HWND hOwnerWnd, DWORD dwObjID)
  282. {
  283.     DLM_XMIT_LIST_A Members = { 0 };
  284.     OBJECT_INFO ObjInfo = { 0 };
  285.     ObjInfo.DL.dwObjID = dwObjID;
  286.     ObjInfo.DL.pMembers = &Members;
  287.     ObjInfo.Type = SERVER_DISTRIBUTION_LIST;
  288.  
  289.     HRESULT hResult = S_OK;
  290.     RpcTryExcept
  291.     {
  292.         hResult = RemoteAdmGetDLProps (dwObjID,
  293.                                        (WINDS_RPC_STRING)ObjInfo.DL.szDLAlias,
  294.                                        (WINDS_RPC_STRING)ObjInfo.DL.szDLFullName,
  295.                                        &ObjInfo.DL.dwFlags,
  296.                                        (WINDS_RPC_STRING)ObjInfo.DL.szOwnerAlias,
  297.                                        (WINDS_RPC_STRING)ObjInfo.DL.szOwnerName,
  298.                                        &ObjInfo.DL.dwOwnerID,
  299.                                        (WINDS_RPC_STRING)ObjInfo.DL.szComments,
  300.                                        &Members);
  301.     }
  302.     RpcExcept(1)
  303.     {        
  304.         // If we got here is because there was an error while call was made
  305.         // or when it was about to be made.
  306.         hResult = RpcExceptionCode();
  307.         if (RPC_S_SERVER_UNAVAILABLE == hResult)
  308.         {
  309.             hResult = HRESULT_FROM_WIN32(ERROR_HOST_UNREACHABLE);
  310.         }
  311.         else
  312.         {
  313.             hResult = MAKE_HRESULT(1, FACILITY_RPC, hResult);
  314.         }
  315.     }
  316.     RpcEndExcept
  317.     if (!hResult)
  318.     {   
  319.         hResult = DisplayDistListPropSheets (hOwnerWnd, &ObjInfo, FALSE);
  320.         if (S_OK == hResult)
  321.         {
  322.             RpcTryExcept
  323.             {
  324.                 hResult = RemoteAdmSetDLProps (dwObjID,
  325.                                                (WINDS_RPC_STRING)ObjInfo.DL.szDLAlias,
  326.                                                (WINDS_RPC_STRING)ObjInfo.DL.szDLFullName,
  327.                                                ObjInfo.DL.dwFlags,
  328.                                                (WINDS_RPC_STRING)ObjInfo.DL.szOwnerAlias,
  329.                                                (WINDS_RPC_STRING)ObjInfo.DL.szOwnerName,
  330.                                                ObjInfo.DL.dwOwnerID,
  331.                                                (WINDS_RPC_STRING)ObjInfo.DL.szComments,
  332.                                                &Members);
  333.             }
  334.             RpcExcept(1)
  335.             {        
  336.                 // If we got here is because there was an error while call was made
  337.                 // or when it was about to be made.
  338.                 hResult = RpcExceptionCode();
  339.                 if (RPC_S_SERVER_UNAVAILABLE == hResult)
  340.                 {
  341.                     hResult = HRESULT_FROM_WIN32(ERROR_HOST_UNREACHABLE);
  342.                 }
  343.                 else
  344.                 {
  345.                     hResult = MAKE_HRESULT(1, FACILITY_RPC, hResult);
  346.                 }
  347.             }
  348.             RpcEndExcept
  349.         }
  350.         if (S_FALSE == hResult)
  351.         {
  352.             hResult = S_OK;
  353.         }
  354.         FreeDLMList (&Members);
  355.     }
  356.     if (hResult)
  357.     {
  358.         ErrorHandler (hOwnerWnd, hResult);
  359.     }
  360. }
  361.  
  362. ///////////////////////////////////////////////////////////////////////////////
  363. //    DisplayDistListPropSheets()
  364. //
  365. //    Parameters
  366. //      
  367. //    Purpose
  368. //      
  369. //    Return Value
  370. //      
  371. HRESULT WINAPI DisplayDistListPropSheets (HWND           hOwnerWnd,
  372.                                           POBJECT_INFO   pObjInfo,
  373.                                           BOOL           fCreate)
  374. {
  375.     PROPSHEETHEADER psh = { 0 };
  376.     PROPSHEETPAGE psp[3] = { 0 };
  377.     TCHAR szHeaderTitle[64];
  378.  
  379.     OBJECT_INFO NewObjInfo = *pObjInfo;
  380.  
  381.     psp[0].dwSize      = sizeof(PROPSHEETPAGE);
  382.     psp[0].dwFlags     = PSP_USETITLE;
  383.     psp[0].hInstance   = ghInstance;
  384.     psp[0].pszTemplate = MAKEINTRESOURCE (IDD_DL_PROPS1);
  385.     psp[0].pfnDlgProc  = DLProps1DlgProc;
  386.     psp[0].pszTitle    = TEXT("General");
  387.     psp[0].lParam      = (LPARAM)&NewObjInfo;
  388.     
  389.     psp[1].dwSize      = sizeof(PROPSHEETPAGE);
  390.     psp[1].dwFlags     = PSP_USETITLE;
  391.     psp[1].hInstance   = ghInstance;
  392.     psp[1].pszTemplate = MAKEINTRESOURCE (IDD_DL_PROPS2);
  393.     psp[1].pfnDlgProc  = DLProps2DlgProc;
  394.     psp[1].pszTitle    = TEXT("Members");
  395.     psp[1].lParam      = (LPARAM)&NewObjInfo;
  396.  
  397.     psp[2].dwSize      = sizeof(PROPSHEETPAGE);
  398.     psp[2].dwFlags     = PSP_USETITLE;
  399.     psp[2].hInstance   = ghInstance;
  400.     psp[2].pszTemplate = MAKEINTRESOURCE (IDD_DL_PROPS3);
  401.     psp[2].pfnDlgProc  = DLProps3DlgProc;
  402.     psp[2].pszTitle    = TEXT("Ownership");
  403.     psp[2].lParam      = (LPARAM)&NewObjInfo;
  404.  
  405.     psh.dwSize     = sizeof(PROPSHEETHEADER);
  406.     psh.dwFlags    = PSH_PROPSHEETPAGE | PSH_NOAPPLYNOW;
  407.     psh.hwndParent = hOwnerWnd;
  408.     psh.hInstance  = ghInstance;
  409.     psh.nPages     = sizeof(psp)/sizeof(PROPSHEETPAGE);
  410.     psh.ppsp       = (LPCPROPSHEETPAGE)&psp;
  411.     if (fCreate)
  412.     {
  413.         psh.pszCaption = TEXT("New Distribution List Properties");
  414.         psh.nStartPage = 0;
  415.     }
  416.     else
  417.     {
  418.         wsprintf (szHeaderTitle, TEXT("Distribution List Properties for %s"), pObjInfo->DL.szDLAlias);
  419.         psh.pszCaption = szHeaderTitle;
  420.         psh.nStartPage = 1;
  421.     }
  422.  
  423.     // If the user hit OK and at least one of the properties changed,
  424.     // we must change the properties on the server
  425. ReEnterProperties:
  426.     if (1 == PropertySheet (&psh) &&
  427.         (fCreate || NewObjInfo.dwData ||
  428.         NewObjInfo.DL.dwFlags != pObjInfo->DL.dwFlags ||
  429.         NewObjInfo.DL.dwOwnerID != pObjInfo->DL.dwOwnerID ||
  430.         lstrcmpi (NewObjInfo.DL.szDLFullName, pObjInfo->DL.szDLFullName) ||
  431.         lstrcmpi (NewObjInfo.DL.szDLAlias, pObjInfo->DL.szDLAlias) ||
  432.         lstrcmpi (NewObjInfo.DL.szComments, pObjInfo->DL.szComments)))
  433.     {
  434.         if (fCreate)
  435.         {
  436.             if (!IsObjAliasValid (hOwnerWnd, NewObjInfo.DL.szDLAlias))
  437.             {
  438.                 goto ReEnterProperties;
  439.             }
  440.         }
  441.         if (0 == lstrlen (NewObjInfo.DL.szDLFullName))
  442.         {
  443.             PrivateMessageBox (IDS_MSG_NO_DL_NAME, hOwnerWnd, 0);
  444.             goto ReEnterProperties;
  445.         }
  446.         *pObjInfo = NewObjInfo;
  447.         return S_OK;
  448.     }
  449.     return S_FALSE;
  450. }
  451.  
  452. ///////////////////////////////////////////////////////////////////////////////
  453. //    DLProps1DlgProc()
  454. //
  455. //    Parameters
  456. //      { Refer to Win32 API documentation on dialog procedures }
  457. //
  458. //    Purpose
  459. //      
  460. //    Return Value
  461. //      TRUE if message was handled, FALSE if we don't handle the message
  462. //      
  463. BOOL CALLBACK DLProps1DlgProc (HWND    hDlg, 
  464.                                UINT    message, 
  465.                                WPARAM  wParam, 
  466.                                LPARAM  lParam)
  467. {
  468.     static POBJECT_INFO pObjInfo = NULL;
  469.     static HWND hCtlLabel;
  470.     switch (message)
  471.     {
  472.         case WM_INITDIALOG :
  473.             {
  474.                 // The pointer to the folder object came in the PROPSHEETPAGE
  475.                 // structure. The lParam of this message has a pointer to the
  476.                 // structure used to create this page. Get the OBJECT_INFO
  477.                 // pointer and save it.
  478.                 pObjInfo = (POBJECT_INFO)((PROPSHEETPAGE *)lParam)->lParam;
  479.                 CTL3D_Subclass(g_pctl3d, hDlg, CTL3D_ALL);
  480.                 HWND hCtl = GetDlgItem (hDlg, IDC_OBJECT_ALIAS);
  481.                 SetWindowText (hCtl, pObjInfo->DL.szDLAlias);
  482.                 if (0 == pObjInfo->DL.dwObjID)
  483.                 {
  484.                     EnableWindow (hCtl, TRUE);
  485.                     Edit_LimitText (hCtl, MAX_ALIAS_SIZE);
  486.                     hCtl = GetDlgItem (hDlg, IDC_OBJECT_ALIAS_LABEL);
  487.                     EnableWindow (hCtl, TRUE);
  488.                 }
  489.  
  490.                 hCtl = GetDlgItem (hDlg, IDC_DL_FULLNAME);
  491.                 Edit_LimitText (hCtl, MAX_STRING_SIZE);
  492.                 SetWindowText (hCtl, pObjInfo->DL.szDLFullName);
  493.  
  494.                 hCtlLabel = GetDlgItem (hDlg, IDC_ICON_TITLE);
  495.                 SetWindowText (hCtlLabel, pObjInfo->DL.szDLAlias);
  496.                 SetWindowFont (hCtlLabel, ghBoldFont, TRUE);
  497.  
  498.                 if (OBJECT_DISABLED & pObjInfo->DL.dwFlags)
  499.                 {
  500.                     Button_SetCheck (GetDlgItem (hDlg, IDC_DISABLE), BST_CHECKED);
  501.                 }
  502.                 if (HIDE_IN_DIR & pObjInfo->DL.dwFlags)
  503.                 {
  504.                     Button_SetCheck (GetDlgItem (hDlg, IDC_HIDE), BST_CHECKED);
  505.                 }
  506.  
  507.                 Static_SetIcon (GetDlgItem (hDlg, IDC_PAGE_ICON),
  508.                                 ImageList_GetIcon (g_hIconImgs, ICON_LARGE_ENVEL, ILD_NORMAL));
  509.             }
  510.             return TRUE;
  511.  
  512.         case WM_NOTIFY:
  513.             if (PSN_APPLY == ((LPNMHDR)lParam)->code)
  514.             {
  515.                 if (BST_CHECKED == Button_GetCheck (GetDlgItem (hDlg, IDC_DISABLE)))
  516.                 {
  517.                     pObjInfo->DL.dwFlags |= OBJECT_DISABLED;
  518.                 }
  519.                 else
  520.                 {
  521.                     pObjInfo->DL.dwFlags &= ~OBJECT_DISABLED;
  522.                 }
  523.                 if (BST_CHECKED == Button_GetCheck (GetDlgItem (hDlg, IDC_HIDE)))
  524.                 {
  525.                     pObjInfo->DL.dwFlags |= HIDE_IN_DIR;
  526.                 }
  527.                 else
  528.                 {
  529.                     pObjInfo->DL.dwFlags &= ~HIDE_IN_DIR;
  530.                 }
  531.                 GetWindowText (GetDlgItem (hDlg, IDC_OBJECT_ALIAS),
  532.                                pObjInfo->DL.szDLAlias,
  533.                                MAX_ALIAS_SIZE+1);
  534.                 GetWindowText (GetDlgItem (hDlg, IDC_DL_FULLNAME),
  535.                                pObjInfo->DL.szDLFullName,
  536.                                MAX_STRING_SIZE+1);
  537.                 return PSNRET_NOERROR;
  538.             }
  539.             break;
  540.  
  541.         case WM_COMMAND :
  542.             if (HIWORD(wParam) == EN_CHANGE && LOWORD(wParam) == IDC_OBJECT_ALIAS)
  543.             {
  544.                 GetWindowText ((HWND)lParam, pObjInfo->DL.szDLAlias, MAX_ALIAS_SIZE+1);
  545.                 SetWindowText (hCtlLabel, pObjInfo->DL.szDLAlias);
  546.             }
  547.             break;
  548.     }
  549.     return FALSE;
  550. }
  551.  
  552. ///////////////////////////////////////////////////////////////////////////////
  553. //    DLProps2DlgProc()
  554. //
  555. //    Parameters
  556. //      { Refer to Win32 API documentation on dialog procedures }
  557. //
  558. //    Purpose
  559. //      
  560. //    Return Value
  561. //      TRUE if message was handled, FALSE if we don't handle the message
  562. //      
  563. BOOL CALLBACK DLProps2DlgProc (HWND    hDlg, 
  564.                                UINT    message, 
  565.                                WPARAM  wParam, 
  566.                                LPARAM  lParam)
  567. {
  568.     static POBJECT_INFO pObjInfo = NULL;
  569.     switch (message)
  570.     {   
  571.         case WM_INITDIALOG :
  572.             {
  573.                 // The pointer to the folder object came in the PROPSHEETPAGE
  574.                 // structure. The lParam of this message has a pointer to the
  575.                 // structure used to create this page. Get the OBJECT_INFO
  576.                 // pointer and save it.
  577.                 pObjInfo = (POBJECT_INFO)((PROPSHEETPAGE *)lParam)->lParam;
  578.                 
  579.                 CTL3D_Subclass(g_pctl3d, hDlg, CTL3D_ALL);
  580.                 HWND hCtl = GetDlgItem (hDlg, IDC_ICON_TITLE);
  581.                 SetWindowText (hCtl, pObjInfo->DL.szDLAlias);
  582.                 SetWindowFont (hCtl, ghBoldFont, TRUE);
  583.  
  584.                 hCtl = GetDlgItem (hDlg, IDC_MEMBERS);
  585.                 ListView_SetImageList (hCtl, g_hImages, LVSIL_SMALL);
  586.  
  587.                 RECT rc;
  588.                 GetClientRect (hCtl, &rc);
  589.                 LV_COLUMN lvc;
  590.                 lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  591.                 lvc.fmt = LVCFMT_LEFT;
  592.                 lvc.pszText = TEXT("Full Name");
  593.                 lvc.iSubItem = 0;
  594.                 lvc.cx = 160;
  595.                 ListView_InsertColumn (hCtl, 0, &lvc);
  596.                 lvc.pszText = TEXT("Alias");
  597.                 lvc.iSubItem = 1;
  598.                 lvc.cx = min (110, (rc.right - rc.left - lvc.cx));
  599.                 ListView_InsertColumn (hCtl, 1, &lvc);
  600.  
  601.                 AddMembersToPageLV (hDlg, hCtl, (DLM_LIST *)pObjInfo->DL.pMembers);
  602.  
  603.                 Static_SetIcon (GetDlgItem (hDlg, IDC_PAGE_ICON),
  604.                                 ImageList_GetIcon (g_hIconImgs, ICON_DL_MEMBERS, ILD_NORMAL));
  605.             }
  606.             return TRUE;
  607.  
  608.         case WM_DESTROY :
  609.             ListView_SetImageList (GetDlgItem (hDlg, IDC_MEMBERS), NULL, LVSIL_SMALL);
  610.             break;
  611.  
  612.         case WM_COMMAND :
  613.             if (LOWORD(wParam) == IDC_MODIFY)
  614.             {
  615.                 pObjInfo->pMembers = (DLM_LIST *)pObjInfo->DL.pMembers;
  616.                 if (TRUE == DialogBoxParam (ghInstance,
  617.                                             MAKEINTRESOURCE(IDD_ADDTOLIST),
  618.                                             hDlg,
  619.                                             ModifyListDlgProc,
  620.                                             (LPARAM)pObjInfo))
  621.                 {
  622.                     AddMembersToPageLV (hDlg, GetDlgItem (hDlg, IDC_MEMBERS), (DLM_LIST *)pObjInfo->DL.pMembers);
  623.                 }
  624.             }
  625.             break;
  626.     }
  627.     return FALSE;
  628. }
  629.  
  630. ///////////////////////////////////////////////////////////////////////////////
  631. //    AddMembersToPageLV()
  632. //
  633. //    Parameters
  634. //
  635. //    Purpose
  636. //      
  637. //    Return Value
  638. //      
  639. void WINAPI AddMembersToPageLV (HWND        hOwnerWnd,
  640.                                 HWND        hListView,
  641.                                 DLM_LIST *  pMembers)
  642. {
  643.     ListView_DeleteAllItems (hListView);
  644.     int i = 0;
  645.     LV_ITEM lvi = { 0 };
  646.     lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
  647.     WINDS_AB_OBJTYPE Type;
  648.     DLM_LIST * pNode = pMembers;
  649.     while (pNode && pNode->Info.szMemberAlias[0])
  650.     {
  651.         Type = (WINDS_AB_OBJTYPE)pNode->Info.dwMemberType;
  652.         switch (Type)
  653.         {
  654.             case GATEWAY_RECIPIENT :
  655.             case SERVER_USER_MAILBOX :
  656.                 lvi.iImage = IMG_USER_MAILBOX;
  657.                 break;
  658.             case ITEM_SERVER_DIST_LISTS :
  659.                 lvi.iImage = IMG_DIST_LIST;
  660.                 break;
  661.             case PUBLIC_FOLDER :
  662.                 TraceMessage ("AddMembersToPageLV: Public Folder added - WARNING NYI");
  663.             default :
  664.                 goto NextNode;
  665.         }
  666.         lvi.iItem = i;
  667.         lvi.iSubItem = 0;
  668.         lvi.pszText = (LPSTR)pNode->Info.szMemberName;
  669.         lvi.lParam = pNode->Info.dwMemberID;
  670.         lvi.iItem = ListView_InsertItem (hListView, &lvi);
  671.         ListView_SetItemText (hListView, lvi.iItem, 1, (LPSTR)pNode->Info.szMemberAlias);
  672.         i++;
  673. NextNode:
  674.         pNode = pNode->pNext;
  675.     }
  676. }
  677.  
  678. ///////////////////////////////////////////////////////////////////////////////
  679. //    DLProps3DlgProc()
  680. //
  681. //    Parameters
  682. //      { Refer to Win32 API documentation on dialog procedures }
  683. //
  684. //    Purpose
  685. //      
  686. //    Return Value
  687. //      TRUE if message was handled, FALSE if we don't handle the message
  688. //      
  689. BOOL CALLBACK DLProps3DlgProc (HWND    hDlg, 
  690.                                UINT    message, 
  691.                                WPARAM  wParam, 
  692.                                LPARAM  lParam)
  693. {
  694.     static POBJECT_INFO pObjInfo = NULL;
  695.     switch (message)
  696.     {   
  697.         case WM_INITDIALOG :
  698.             {
  699.                 // The pointer to the folder object came in the PROPSHEETPAGE
  700.                 // structure. The lParam of this message has a pointer to the
  701.                 // structure used to create this page. Get the OBJECT_INFO
  702.                 // pointer and save it.
  703.                 pObjInfo = (POBJECT_INFO)((PROPSHEETPAGE *)lParam)->lParam;
  704.                 CTL3D_Subclass(g_pctl3d, hDlg, CTL3D_ALL);
  705.                 HWND hCtl = GetDlgItem (hDlg, IDC_ICON_TITLE);
  706.                 SetWindowText (hCtl, pObjInfo->DL.szDLAlias);
  707.                 SetWindowFont (hCtl, ghBoldFont, TRUE);
  708.  
  709.                 if (DL_OWNED & pObjInfo->DL.dwFlags)
  710.                 {
  711.                     SetWindowText (GetDlgItem (hDlg, IDC_DL_OWNER), pObjInfo->DL.szOwnerName);
  712.                     hCtl = GetDlgItem (hDlg, IDC_COMMENTS);
  713.                     SetWindowText (hCtl, pObjInfo->DL.szComments);
  714.                     Edit_LimitText (hCtl, sizeof(pObjInfo->DL.szComments)/sizeof(TCHAR) - 1);
  715.                     hCtl = GetDlgItem (hDlg, IDC_OWNED);
  716.                     Button_SetCheck (hCtl, BST_CHECKED);
  717.                     PostMessage (hDlg, WM_COMMAND, MAKEWPARAM(IDC_OWNED, BN_CLICKED), (LPARAM)hCtl);
  718.                 }
  719.                 else
  720.                 {
  721.                     Button_SetCheck (GetDlgItem (hDlg, IDC_NOT_OWNED), BST_CHECKED);
  722.                 }
  723.  
  724.                 Static_SetIcon (GetDlgItem (hDlg, IDC_PAGE_ICON),
  725.                                 ImageList_GetIcon (g_hIconImgs, ICON_DL_OWNER, ILD_NORMAL));
  726.             }
  727.             return TRUE;
  728.  
  729.         case WM_NOTIFY:
  730.             if (PSN_APPLY == ((LPNMHDR)lParam)->code)
  731.             {
  732.                 if (BST_CHECKED == Button_GetCheck (GetDlgItem (hDlg, IDC_OWNED)))
  733.                 {
  734.                     pObjInfo->DL.dwFlags |= DL_OWNED;
  735.                     TCHAR achBuffer[64] = { 0 };
  736.                     GetWindowText (GetDlgItem (hDlg, IDC_DL_OWNER), achBuffer, 64);
  737.                     if (NULL == achBuffer[0])
  738.                     {
  739.                         pObjInfo->DL.dwFlags &= ~DL_OWNED;
  740.                     }
  741.                     else
  742.                     {
  743.                         GetWindowText (GetDlgItem (hDlg, IDC_COMMENTS), pObjInfo->DL.szComments, sizeof(pObjInfo->DL.szComments)/sizeof(TCHAR));
  744.                     }
  745.                 }
  746.                 else
  747.                 {
  748.                     pObjInfo->DL.dwFlags &= ~DL_OWNED;
  749.                 }
  750.                 if (!(DL_OWNED & pObjInfo->DL.dwFlags))
  751.                 {
  752.                     pObjInfo->DL.dwOwnerID = 0;
  753.                     ZeroMemory (pObjInfo->DL.szOwnerAlias, sizeof(pObjInfo->DL.szOwnerAlias));
  754.                     ZeroMemory (pObjInfo->DL.szOwnerName, sizeof(pObjInfo->DL.szOwnerName));
  755.                     ZeroMemory (pObjInfo->DL.szComments, sizeof(pObjInfo->DL.szComments));
  756.                 }
  757.                 return PSNRET_NOERROR;
  758.             }
  759.             break;
  760.  
  761.         case WM_COMMAND :
  762.             switch (LOWORD(wParam))
  763.             {
  764.                 case IDC_OWNED :
  765.                 case IDC_NOT_OWNED :
  766.                     if (HIWORD(wParam) == BN_CLICKED)
  767.                     {
  768.                         SetFocus ((HWND)lParam);
  769.                         BOOL fEnabled = (LOWORD(wParam) == IDC_OWNED ? TRUE : FALSE);
  770.                         HWND hCtl;
  771.                         hCtl = GetDlgItem (hDlg, IDC_DL_OWNER);
  772.                         EnableWindow (hCtl, fEnabled);
  773.                         hCtl = GetDlgItem (hDlg, IDC_OWNER_LABEL);
  774.                         EnableWindow (hCtl, fEnabled);
  775.                         hCtl = GetDlgItem (hDlg, IDC_MODIFY);
  776.                         EnableWindow (hCtl, fEnabled);
  777.                         hCtl = GetDlgItem (hDlg, IDC_COMMENTS_LABEL);
  778.                         EnableWindow (hCtl, fEnabled);
  779.                         hCtl = GetDlgItem (hDlg, IDC_COMMENTS);
  780.                         EnableWindow (hCtl, fEnabled);
  781.                     }
  782.                     break;
  783.  
  784.                 case IDC_MODIFY :
  785.                     if (TRUE == DialogBoxParam (ghInstance,
  786.                                                 MAKEINTRESOURCE(IDD_ONE_MAILBOX),
  787.                                                 hDlg,
  788.                                                 SelectUserDlgProc,
  789.                                                 (LPARAM)pObjInfo))
  790.                     {
  791.                         SetWindowText (GetDlgItem (hDlg, IDC_DL_OWNER), pObjInfo->DL.szOwnerName);
  792.                     }
  793.                     break;
  794.             }
  795.             break;
  796.     }
  797.     return FALSE;
  798. }
  799.  
  800. ///////////////////////////////////////////////////////////////////////////////
  801. //    SelectUserDlgProc()
  802. //
  803. //    Parameters
  804. //      { Refer to Win32 API documentation on dialog procedures }
  805. //
  806. //    Purpose
  807. //      
  808. //    Return Value
  809. //      TRUE if message was handled, FALSE if we don't handle the message
  810. //      
  811. BOOL CALLBACK SelectUserDlgProc (HWND    hDlg, 
  812.                                  UINT    message, 
  813.                                  WPARAM  wParam, 
  814.                                  LPARAM  lParam)
  815. {
  816.     static POBJECT_INFO pObjInfo;
  817.     switch (message)
  818.     {   
  819.         case WM_INITDIALOG :
  820.             {
  821.                 pObjInfo = (POBJECT_INFO)lParam;
  822.                 CTL3D_Subclass(g_pctl3d, hDlg, CTL3D_ALL);
  823.                 HWND hWaitWnd = CreateDialog (ghInstance, MAKEINTRESOURCE(IDD_DIR_DOWNLOAD_WAIT), hDlg, WaitDlgProc);
  824.  
  825.                 long lPipeNum;
  826.                 HANDLE hPipe;
  827.                 DWORD dwBytesRead, dwUserID, dwListUserIndex = 0;
  828.                 if (SERVER_DISTRIBUTION_LIST == pObjInfo->Type)
  829.                 {
  830.                     dwUserID = pObjInfo->DL.dwOwnerID;
  831.                 }
  832.                 else
  833.                 {
  834.                     dwUserID = pObjInfo->MB.dwManagerID;
  835.                 }
  836.                 AB_ENTRY_INFO abEntry = { 0 };
  837.                 HRESULT hResult = S_OK;
  838.                 int nTabStops[1] = { 1000 }; // Off the screen
  839.                 TCHAR achPipeName[64];
  840.                 
  841.                 HWND hListView = GetDlgItem (hDlg, IDC_ALL_USERS);
  842.                 ListView_SetImageList (hListView, g_hImages, LVSIL_SMALL);
  843.                 
  844.                 RECT rc;
  845.                 GetClientRect (hListView, &rc);
  846.                 LV_COLUMN lvc;
  847.                 lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  848.                 lvc.fmt = LVCFMT_LEFT;
  849.                 lvc.pszText = TEXT("Full Name");
  850.                 lvc.iSubItem = 0;
  851.                 lvc.cx = 160;
  852.                 ListView_InsertColumn (hListView, 0, &lvc);
  853.                 lvc.pszText = TEXT("Alias");
  854.                 lvc.iSubItem = 1;
  855.                 lvc.cx = min (110, (rc.right - rc.left - lvc.cx));
  856.                 ListView_InsertColumn (hListView, 1, &lvc);
  857.  
  858.                 int i = 0;
  859.                 LV_ITEM lvi = { 0 };
  860.                 lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
  861.                 lvi.iImage = IMG_USER_MAILBOX;
  862.  
  863.                 RpcTryExcept
  864.                 {
  865.                     hResult = RemoteAdmGetServerMailboxes (&lPipeNum);
  866.                     if (!hResult)
  867.                     {
  868.                         // Construct the download pipe name
  869.                         wsprintf (achPipeName, PIPE_NAME_FORMAT, g_szCurrentServer, lPipeNum);
  870.                         // Create our endpoint and connect    
  871.                         hPipe = CreateFile (achPipeName, 
  872.                                             GENERIC_READ,
  873.                                             0,
  874.                                             NULL,
  875.                                             OPEN_EXISTING,
  876.                                             0,
  877.                                             NULL);
  878.                         if (INVALID_HANDLE_VALUE == hPipe)
  879.                         {
  880.                             hResult = HRESULT_FROM_WIN32(GetLastError());
  881.                         }
  882.                     }
  883.                 }
  884.                 RpcExcept(1)
  885.                 {        
  886.                     // If we got here is because there was an error while call was made
  887.                     // or when it was about to be made.
  888.                     hResult = RpcExceptionCode();
  889.                     if (RPC_S_SERVER_UNAVAILABLE == hResult)
  890.                     {
  891.                         hResult = HRESULT_FROM_WIN32(ERROR_HOST_UNREACHABLE);
  892.                     }
  893.                     else
  894.                     {
  895.                         hResult = MAKE_HRESULT(1, FACILITY_RPC, hResult);
  896.                     }
  897.                 }
  898.                 RpcEndExcept
  899.                 if (!hResult)
  900.                 {
  901.                     
  902.                     do
  903.                     {
  904.                         // Read from the pipe
  905.                         if (!ReadFile (hPipe, &abEntry, sizeof(AB_ENTRY_INFO), &dwBytesRead, NULL))
  906.                         {
  907.                             hResult = HRESULT_FROM_WIN32(GetLastError());
  908.                             if (HRESULT_FROM_WIN32(ERROR_BROKEN_PIPE)   != hResult &&   // For Windows NT
  909.                                 HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) != hResult)     // For Windows 95
  910.                             {
  911.                                 // There was an error and we can't continue
  912.                                 TraceResult ("ModifyListDlgProc: Failed to read from the source", hResult);
  913.                             }
  914.                             else
  915.                             {
  916.                                 // If the pipe was broken, it means the server finished writing
  917.                                 // to the it, so we are finished reading from it.
  918.                                 hResult = S_OK;
  919.                             }
  920.                         }
  921.                         else
  922.                         {
  923.                             lvi.iItem = i;
  924.                             lvi.iSubItem = 0;
  925.                             lvi.pszText = abEntry.Info.MB.szFullName;
  926.                             lvi.lParam = abEntry.Info.MB.dwObjID;
  927.                             lvi.iItem = ListView_InsertItem (hListView, &lvi);
  928.                             ListView_SetItemText (hListView, lvi.iItem, 1, abEntry.Info.MB.szMailboxName);
  929.                             i++;
  930.                             if (abEntry.Info.MB.dwObjID == dwUserID)
  931.                             {
  932.                                 dwListUserIndex = abEntry.Info.MB.dwObjID;
  933.                             }
  934.                         }
  935.                     } while (dwBytesRead && !hResult);
  936.                     CloseHandle (hPipe);
  937.                     if (0 != dwListUserIndex)
  938.                     {
  939.                         ListView_SetItemState (hListView,   
  940.                                                dwListUserIndex,
  941.                                                LVIS_FOCUSED | LVIS_SELECTED,
  942.                                                LVIS_FOCUSED | LVIS_SELECTED);
  943.                     }
  944.                 }
  945.                 DestroyWindow (hWaitWnd);
  946.                 if (hResult)
  947.                 {
  948.                     ErrorHandler (hDlg, hResult);
  949.                     EndDialog (hDlg, -1);
  950.                 }
  951.             }
  952.             return TRUE;
  953.  
  954.         case WM_COMMAND :
  955.             switch (LOWORD(wParam))
  956.             {
  957.                 case IDC_ALL_USERS :
  958.                     if (LBN_DBLCLK == HIWORD(wParam))
  959.                     {
  960.                         PostMessage (hDlg, WM_COMMAND, IDOK, 0);
  961.                     }
  962.                     break;
  963.                 case IDOK :
  964.                     {
  965.                         TCHAR achName[MAX_STRING_SIZE+1], achAlias[MAX_ALIAS_SIZE+1];
  966.                         DWORD dwUserID;
  967.                         HWND hListView= GetDlgItem (hDlg, IDC_ALL_USERS);
  968.                         
  969.                         LV_ITEM lvi = { 0 };
  970.                         lvi.mask = LVIF_PARAM | LVIF_TEXT;
  971.                         lvi.iItem = ListView_GetNextItem (hListView, -1, LVNI_FOCUSED | LVNI_ALL);
  972.                         lvi.iSubItem = 0;
  973.                         lvi.pszText = achName;
  974.                         lvi.cchTextMax = MAX_STRING_SIZE+1;
  975.                         if (ListView_GetItem (hListView, &lvi))
  976.                         {
  977.                             dwUserID = lvi.lParam;
  978.                             lvi.mask = LVIF_TEXT;
  979.                             lvi.iSubItem = 1;
  980.                             lvi.pszText = achAlias;
  981.                             lvi.cchTextMax = MAX_ALIAS_SIZE+1;
  982.                             if (FALSE == ListView_GetItem (hListView, &lvi))
  983.                             {
  984.                                 wParam = IDCANCEL;
  985.                             }
  986.                         }
  987.                         else
  988.                         {
  989.                             wParam = IDCANCEL;
  990.                         }
  991.                         if (IDOK == wParam)
  992.                         {
  993.                             if (SERVER_DISTRIBUTION_LIST == pObjInfo->Type)
  994.                             {
  995.                                 pObjInfo->DL.dwOwnerID = dwUserID;
  996.                             }
  997.                             else
  998.                             {
  999.                                 pObjInfo->MB.dwManagerID = dwUserID;
  1000.                             }
  1001.                             if (SERVER_DISTRIBUTION_LIST == pObjInfo->Type)
  1002.                             {
  1003.                                 lstrcpy (pObjInfo->DL.szOwnerName, achName);
  1004.                             }
  1005.                             else
  1006.                             {
  1007.                                 lstrcpy (pObjInfo->MB.szManagerName, achName);
  1008.                             }
  1009.                             if (SERVER_DISTRIBUTION_LIST == pObjInfo->Type)
  1010.                             {
  1011.                                 lstrcpy (pObjInfo->DL.szOwnerAlias, achAlias);
  1012.                             }
  1013.                             else
  1014.                             {
  1015.                                 lstrcpy (pObjInfo->MB.szManagerAlias, achAlias);
  1016.                             }
  1017.                         }
  1018.                     }
  1019.                     // Fall through
  1020.                 case IDCANCEL :
  1021.                     ListView_SetImageList (GetDlgItem (hDlg, IDC_ALL_USERS), NULL, LVSIL_SMALL);
  1022.                     EndDialog (hDlg, (LOWORD(wParam) == IDOK ? TRUE : FALSE));
  1023.                     return TRUE;
  1024.             }
  1025.     }
  1026.     return FALSE;
  1027. }
  1028.  
  1029. ///////////////////////////////////////////////////////////////////////////////
  1030. //    WaitDlgProc()
  1031. //
  1032. //    Parameters
  1033. //      { Refer to Win32 API documentation on dialog procedures }
  1034. //
  1035. //    Purpose
  1036. //      
  1037. //    Return Value
  1038. //      TRUE if message was handled, FALSE if we don't handle the message
  1039. //      
  1040. BOOL CALLBACK WaitDlgProc (HWND    hDlg, 
  1041.                            UINT    message, 
  1042.                            WPARAM  wParam, 
  1043.                            LPARAM  lParam)
  1044. {
  1045.     if (WM_INITDIALOG == message)
  1046.     {
  1047.         CTL3D_Subclass(g_pctl3d, hDlg, CTL3D_ALL);
  1048.         Static_SetIcon(GetDlgItem (hDlg, IDC_STOPWATCH), GetAnimatedTimerCursor());
  1049.         return TRUE;
  1050.     }
  1051.     return FALSE;
  1052. }
  1053.  
  1054. ///////////////////////////////////////////////////////////////////////////////
  1055. //    ModifyListDlgProc()
  1056. //
  1057. //    Parameters
  1058. //      { Refer to Win32 API documentation on dialog procedures }
  1059. //
  1060. //    Purpose
  1061. //      
  1062. //    Return Value
  1063. //      TRUE if message was handled, FALSE if we don't handle the message
  1064. //      
  1065. BOOL CALLBACK ModifyListDlgProc (HWND    hDlg, 
  1066.                                  UINT    message, 
  1067.                                  WPARAM  wParam, 
  1068.                                  LPARAM  lParam)
  1069. {
  1070.     static POBJECT_INFO pObjInfo;
  1071.     static HWND hAllUsers, hMembers;
  1072.     switch (message)
  1073.     {   
  1074.         case WM_INITDIALOG :
  1075.             {
  1076.                 pObjInfo = (POBJECT_INFO)lParam;
  1077.                 CTL3D_Subclass(g_pctl3d, hDlg, CTL3D_ALL);
  1078.                 HWND hWaitWnd = CreateDialog (ghInstance, MAKEINTRESOURCE(IDD_DIR_DOWNLOAD_WAIT), hDlg, WaitDlgProc);
  1079.  
  1080.                 long lPipeNum;
  1081.                 TCHAR achBuffer[128];
  1082.                 HANDLE hPipe;
  1083.                 DWORD dwBytesRead;
  1084.                 AB_ENTRY_INFO abEntry = { 0 };
  1085.                 HRESULT hResult = S_OK;
  1086.                 int nTabStops[1];
  1087.                 nTabStops[0] = 1000; // Off the screen
  1088.                 
  1089.                 hAllUsers = GetDlgItem (hDlg, IDC_ALL_USERS);
  1090.                 hMembers = GetDlgItem (hDlg, IDC_MEMBERS);
  1091.                 
  1092.                 ListBox_SetTabStops (hAllUsers, sizeof(nTabStops)/sizeof(int), nTabStops);
  1093.                 ListBox_SetTabStops (hMembers, sizeof(nTabStops)/sizeof(int), nTabStops);
  1094.                 RpcTryExcept
  1095.                 {
  1096.                     hResult = RemoteAdmGetGALDirectory (0, &lPipeNum);
  1097.                     if (!hResult)
  1098.                     {
  1099.                         // Construct the download pipe name
  1100.                         wsprintf (achBuffer, PIPE_NAME_FORMAT, g_szCurrentServer, lPipeNum);
  1101.                         // Create our endpoint and connect    
  1102.                         hPipe = CreateFile (achBuffer, 
  1103.                                             GENERIC_READ,
  1104.                                             0,
  1105.                                             NULL,
  1106.                                             OPEN_EXISTING,
  1107.                                             0,
  1108.                                             NULL);
  1109.                         if (INVALID_HANDLE_VALUE == hPipe)
  1110.                         {
  1111.                             hResult = HRESULT_FROM_WIN32(GetLastError());
  1112.                         }
  1113.                     }
  1114.                 }
  1115.                 RpcExcept(1)
  1116.                 {        
  1117.                     // If we got here is because there was an error while call was made
  1118.                     // or when it was about to be made.
  1119.                     hResult = RpcExceptionCode();
  1120.                     if (RPC_S_SERVER_UNAVAILABLE == hResult)
  1121.                     {
  1122.                         hResult = HRESULT_FROM_WIN32(ERROR_HOST_UNREACHABLE);
  1123.                     }
  1124.                     else
  1125.                     {
  1126.                         hResult = MAKE_HRESULT(1, FACILITY_RPC, hResult);
  1127.                     }
  1128.                 }
  1129.                 RpcEndExcept
  1130.                 if (!hResult)
  1131.                 {
  1132.                     do
  1133.                     {
  1134.                         
  1135.                         // Read from the pipe
  1136.                         if (!ReadFile (hPipe, &abEntry, sizeof(AB_ENTRY_INFO), &dwBytesRead, NULL))
  1137.                         {
  1138.                             hResult = HRESULT_FROM_WIN32(GetLastError());
  1139.                             if (HRESULT_FROM_WIN32(ERROR_BROKEN_PIPE)   != hResult &&   // For Windows NT
  1140.                                 HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED) != hResult)     // For Windows 95
  1141.                             {
  1142.                                 // There was an error and we can't continue
  1143.                                 TraceResult ("ModifyListDlgProc: Failed to read from the source", hResult);
  1144.                             }
  1145.                             else
  1146.                             {
  1147.                                 // If the pipe was broken, it means the server finished writing
  1148.                                 // to the it, so we are finished reading from it.
  1149.                                 hResult = S_OK;
  1150.                             }
  1151.                         }
  1152.                         else
  1153.                         {
  1154.                             switch (abEntry.Type)
  1155.                             {
  1156.                                 case GATEWAY_RECIPIENT :
  1157.                                 case SERVER_USER_MAILBOX :
  1158.                                     if (abEntry.Info.MB.dwObjID != pObjInfo->MB.dwObjID)
  1159.                                     {
  1160.                                         wsprintf (achBuffer,
  1161.                                                   TEXT("%s\t%s\t%d\t%d"),
  1162.                                                   abEntry.Info.MB.szFullName,
  1163.                                                   abEntry.Info.MB.szMailboxName,
  1164.                                                   abEntry.Info.MB.dwObjID,
  1165.                                                   abEntry.Type);
  1166.                                         ListBox_AddString (hAllUsers, achBuffer);
  1167.                                     }
  1168.                                     break;
  1169.                                 case SERVER_DISTRIBUTION_LIST :
  1170.                                     if (abEntry.Info.DL.dwObjID != pObjInfo->DL.dwObjID)
  1171.                                     {
  1172.                                         wsprintf (achBuffer,
  1173.                                                   TEXT("%s\t%s\t%d\t%d"),
  1174.                                                   abEntry.Info.DL.szDLFullName,
  1175.                                                   abEntry.Info.DL.szDLAlias,
  1176.                                                   abEntry.Info.DL.dwObjID,
  1177.                                                   abEntry.Type);
  1178.                                         ListBox_AddString (hAllUsers, achBuffer);
  1179.                                     }
  1180.                                     break;
  1181.                             }
  1182.                         }
  1183.                     } while (dwBytesRead && !hResult);
  1184.                     CloseHandle (hPipe);
  1185.                 }
  1186.                 if (!hResult)
  1187.                 {
  1188.                     WINDS_AB_OBJTYPE Type;
  1189.                     DLM_LIST * pNode = pObjInfo->pMembers;
  1190.                     while (pNode && pNode->Info.szMemberAlias[0])
  1191.                     {
  1192.                         Type = (WINDS_AB_OBJTYPE)pNode->Info.dwMemberType;
  1193.                         wsprintf (achBuffer,
  1194.                                   TEXT("%s\t%s\t%d\t%d"),
  1195.                                   pNode->Info.szMemberName,
  1196.                                   pNode->Info.szMemberAlias,
  1197.                                   pNode->Info.dwMemberID,
  1198.                                   pNode->Info.dwMemberType);
  1199.                         ListBox_AddString (hMembers, achBuffer);
  1200.                         pNode = pNode->pNext;
  1201.                     }
  1202.                 }
  1203.                 DestroyWindow (hWaitWnd);
  1204.                 if (hResult)
  1205.                 {
  1206.                     ErrorHandler (hDlg, hResult);
  1207.                     EndDialog (hDlg, -1);
  1208.                 }
  1209.             }
  1210.             return TRUE;
  1211.  
  1212.         case WM_COMMAND :
  1213.             switch (LOWORD(wParam))
  1214.             {
  1215.                 case IDC_REMOVE_ALL :
  1216.                     pObjInfo->dwData = TRUE;
  1217.                     ListBox_ResetContent (hMembers);
  1218.                     break;
  1219.                 
  1220.                 case IDC_MEMBERS :
  1221.                     if (LBN_DBLCLK != HIWORD(wParam))
  1222.                     {
  1223.                         break;
  1224.                     }
  1225.                     // else fall through
  1226.                 case IDC_REMOVE_USER :
  1227.                     {
  1228.                         int nIndex = ListBox_GetCurSel (hMembers);
  1229.                         if (LB_ERR != nIndex)
  1230.                         {
  1231.                             ListBox_DeleteString (hMembers, nIndex);
  1232.                             pObjInfo->dwData = TRUE;
  1233.                         }
  1234.                     }
  1235.                     break;
  1236.  
  1237.                 case IDC_ALL_USERS :
  1238.                     if (LBN_DBLCLK != HIWORD(wParam))
  1239.                     {
  1240.                         break;
  1241.                     }
  1242.                     // else fall through
  1243.                 case IDC_ADD_USER :
  1244.                     {
  1245.                         TCHAR szBuffer[128];
  1246.                         int iUsers = ListBox_GetSelCount (hAllUsers);
  1247.                         if (iUsers == LB_ERR) // Nothins is selected
  1248.                         {
  1249.                             break;
  1250.                         }
  1251.                         int *piList = (int *)HeapAlloc (ghMemHeap, 0, (DWORD)(iUsers * sizeof(int)));
  1252.                         if (NULL == piList) // Low system resources
  1253.                         {
  1254.                             ErrorHandler (hDlg, E_OUTOFMEMORY);
  1255.                             break;
  1256.                         } 
  1257.                         ListBox_GetSelItems (hAllUsers, iUsers, piList);
  1258.  
  1259.                         for (int i=0; i<iUsers; i++)
  1260.                         {
  1261.                             ListBox_GetText (hAllUsers, piList[i], szBuffer);
  1262.                             if (LB_ERR == ListBox_FindStringExact (hMembers, -1, szBuffer))
  1263.                             {
  1264.                                 ListBox_AddString (hMembers, szBuffer);
  1265.                             }
  1266.                             ListBox_SetSel (hMembers, FALSE, i);
  1267.                         }
  1268.                         pObjInfo->dwData = TRUE;
  1269.                         HeapFree (ghMemHeap, 0, piList);
  1270.                     }
  1271.                     break;
  1272.  
  1273.                 case IDOK :
  1274.                     if (pObjInfo->dwData) // Means that something was changed
  1275.                     {
  1276.                         TCHAR achBuffer[128];
  1277.                         DLM_INFO Info = { 0 };
  1278.                         TCHAR * szSubStr;
  1279.                         FreeDLMList ((DLM_LIST*)pObjInfo->DL.pMembers);
  1280.                         DLM_LIST * pMemberList = (DLM_LIST*)pObjInfo->DL.pMembers;
  1281.                         int nCount = ListBox_GetCount (hMembers);
  1282.                         for (int i=0; i<nCount; i++)
  1283.                         {
  1284.                             if (LB_ERR == ListBox_GetText (hMembers, i, achBuffer))
  1285.                             {
  1286.                                 continue;
  1287.                             }
  1288.                             strtok (achBuffer, "\t");
  1289.                             lstrcpy ((LPSTR)Info.szMemberName, achBuffer);
  1290.  
  1291.                             szSubStr = strtok (NULL, "\t");
  1292.                             lstrcpy ((LPSTR)Info.szMemberAlias, szSubStr);
  1293.                             
  1294.                             szSubStr = strtok (NULL, "\t");
  1295.                             Info.dwMemberID = (DWORD)atol (szSubStr);
  1296.  
  1297.                             szSubStr = strtok (NULL, "\t");
  1298.                             Info.dwMemberType = (DWORD)atol (szSubStr);
  1299.  
  1300.                             if (0 == i)
  1301.                             {
  1302.                                 pMemberList->Info = Info;
  1303.                             }
  1304.                             else
  1305.                             {
  1306.                                 InsertNewDLMNode (Info, (DLM_XMIT_LIST *)pMemberList);
  1307.                             }
  1308.                         }
  1309.                     }
  1310.                     // Fall through
  1311.                 case IDCANCEL :
  1312.                     EndDialog (hDlg, (LOWORD(wParam) == IDOK ? TRUE : FALSE));
  1313.                     return TRUE;
  1314.             }
  1315.     }
  1316.     return FALSE;
  1317. }
  1318.  
  1319. // End of file for ADMDLIST.CPP
  1320.