![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mapiapp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / mapi|
Return to mapiapp.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / mapi |
1.1 root 1: /* QuickCase:W KNB Version 1.00 */
2: #include "MAPIAPP.h"
3: #include <string.h>
4: #include <stdio.h>
5: #include "mapi.h"
6: #define MAIN 1
7: #include "mapinit.h"
8:
9:
10: HANDLE hLibrary;
11: LHANDLE hMAPISession;
12:
13: MapiMessage mmMapiMessage;
14:
15: ULONG nMessageSize = 0x000004000;
16: lpMapiMessage FAR *lppMessage;
17: lpMapiMessage lpMessage;
18: char szSeedMessageID[512];
19: char szMessageID[512];
20: char szSubject[512];
21: char szNoteText[4096];
22:
23: LPSTR lpszSeedMessageID = &szSeedMessageID[0];
24: LPSTR lpszMessageID = &szMessageID[0];
25:
26: LPSTR pszSubject = &szSubject[0];
27: LPSTR pszNoteText = &szNoteText[0];
28: LPSTR pszDateReceived = "1991/03/23 12:00";
29: MapiRecipDesc rdOriginator = { 0L,MAPI_ORIG,(LPSTR)"ONE",NULL};
30:
31: int iFindFirst= TRUE;
32:
33: void InitMessage(lpMapiMessage pmmMessage)
34: {
35: pmmMessage->ulReserved = 0L;
36: pmmMessage->lpszSubject =pszSubject;
37: pmmMessage->lpszNoteText =pszNoteText;
38: pmmMessage->lpszMessageType = NULL;
39: pmmMessage->lpszDateReceived = pszDateReceived;
40: pmmMessage->flFlags = MAPI_UNREAD;
41: pmmMessage->lpOriginator = &rdOriginator;
42: pmmMessage->nRecipCount = 0L;
43: pmmMessage->lpRecips = NULL;
44: pmmMessage->nFileCount = 0L;
45: pmmMessage->lpFiles = NULL;
46: }
47:
48: /****************************************************************************
49:
50: FUNCTION: OutOfMemory(void)
51:
52: PURPOSE: Displays warning message
53:
54: ****************************************************************************/
55: void OutOfMemory(void)
56: {
57: MessageBox(
58: GetFocus(),
59: "Out of Memory",
60: NULL,
61: MB_ICONHAND | MB_SYSTEMMODAL);
62: return;
63: }
64:
65: void mycpystr(char * npszStrg, LPSTR lpszStrg)
66: {
67: if (lpszStrg != NULL)
68: strcpy(npszStrg, lpszStrg);
69: else
70: *npszStrg = '\0';
71: }
72:
73:
74: /************************************************************************/
75: /* */
76: /* Windows 3.0 Main Program Body */
77: /* */
78: /* The following routine is the Windows Main Program. The Main Program */
79: /* is executed when a program is selected from the Windows Control */
80: /* Panel or File Manager. The WinMain routine registers and creates */
81: /* the program's main window and initializes global objects. The */
82: /* WinMain routine also includes the applications message dispatch */
83: /* loop. Every window message destined for the main window or any */
84: /* subordinate windows is obtained, possibly translated, and */
85: /* dispatched to a window or dialog processing function. The dispatch */
86: /* loop is exited when a WM_QUIT message is obtained. Before exiting */
87: /* the WinMain routine should destroy any objects created and free */
88: /* memory and other resources. */
89: /* */
90: /************************************************************************/
91:
92: int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
93: {
94: /***********************************************************************/
95: /* HANDLE hInstance; handle for this instance */
96: /* HANDLE hPrevInstance; handle for possible previous instances */
97: /* LPSTR lpszCmdLine; long pointer to exec command line */
98: /* int nCmdShow; Show code for main window display */
99: /***********************************************************************/
100:
101: MSG msg; /* MSG structure to store your messages */
102: int nRc; /* return value from Register Classes */
103: long nWndunits; /* window units for size and location */
104: int nWndx; /* the x axis multiplier */
105: int nWndy; /* the y axis multiplier */
106: int nX; /* the resulting starting point (x, y) */
107: int nY;
108: int nWidth; /* the resulting width and height for this */
109: int nHeight; /* window */
110:
111: strcpy(szAppName, "MAPIAPP");
112: hInst = hInstance;
113: if(!hPrevInstance)
114: {
115: /* register window classes if first instance of application */
116: if ((nRc = nCwRegisterClasses()) == -1)
117: {
118: /* registering one of the windows failed */
119: LoadString(hInst, IDS_ERR_REGISTER_CLASS, szString, sizeof(szString));
120: MessageBox(NULL, szString, NULL, MB_ICONEXCLAMATION);
121: return nRc;
122: }
123: }
124:
125: /* Create a device independant size and location */
126: nWndunits = GetDialogBaseUnits();
127: nWndx = LOWORD(nWndunits);
128: nWndy = HIWORD(nWndunits);
129: nX = ((60 * nWndx) / 4);
130: nY = ((60 * nWndy) / 8);
131: nWidth = ((197 * nWndx) / 4);
132: nHeight = ((138 * nWndy) / 8);
133:
134: /* create application's Main window */
135: hWndMain = CreateWindow(
136: szAppName, /* Window class name */
137: "MAPI Sample App", /* Window's title */
138: WS_CAPTION | /* Title and Min/Max */
139: WS_SYSMENU | /* Add system menu box */
140: WS_MINIMIZEBOX | /* Add minimize box */
141: WS_MAXIMIZEBOX | /* Add maximize box */
142: WS_BORDER | /* thin frame */
143: WS_CLIPCHILDREN | /* don't draw in child windows areas */
144: WS_OVERLAPPED,
145: nX, nY, /* X, Y */
146: nWidth, nHeight, /* Width, Height of window */
147: NULL, /* Parent window's handle */
148: NULL, /* Default to Class Menu */
149: hInst, /* Instance of window */
150: NULL); /* Create struct for WM_CREATE */
151:
152:
153: if (InitMAPI() != 0)
154: return ERR_LOAD_LIB;
155:
156: InitMessage(&mmMapiMessage);
157:
158: if(hWndMain == NULL)
159: {
160: LoadString(hInst, IDS_ERR_CREATE_WINDOW, szString, sizeof(szString));
161: MessageBox(NULL, szString, NULL, MB_ICONEXCLAMATION);
162: return IDS_ERR_CREATE_WINDOW;
163: }
164:
165: EnableMenuItem(GetMenu(hWndMain), IDM_A_LOGOFF, MF_DISABLED | MF_GRAYED);
166: EnableMenuItem(GetMenu(hWndMain), IDM_S_MAIL, MF_DISABLED | MF_GRAYED);
167: EnableMenuItem(GetMenu(hWndMain), IDM_S_DOCUMENT, MF_DISABLED | MF_GRAYED);
168: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDFIRST, MF_DISABLED | MF_GRAYED);
169: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDNEXT, MF_DISABLED | MF_GRAYED);
170: EnableMenuItem(GetMenu(hWndMain), IDM_M_READ, MF_DISABLED | MF_GRAYED);
171: EnableMenuItem(GetMenu(hWndMain), IDM_M_DELETE, MF_DISABLED | MF_GRAYED);
172:
173: ShowWindow(hWndMain, nCmdShow); /* display main window */
174:
175: while(GetMessage(&msg, NULL, 0, 0)) /* Until WM_QUIT message */
176: {
177: TranslateMessage(&msg);
178: DispatchMessage(&msg);
179: }
180:
181: DeInitMAPI();
182: /* Do clean up before exiting from the application */
183: CwUnRegisterClasses();
184: return msg.wParam;
185: } /* End of WinMain */
186: /************************************************************************/
187: /* */
188: /* Main Window Procedure */
189: /* */
190: /* This procedure provides service routines for the Windows events */
191: /* (messages) that Windows sends to the window, as well as the user */
192: /* initiated events (messages) that are generated when the user selects */
193: /* the action bar and pulldown menu controls or the corresponding */
194: /* keyboard accelerators. */
195: /* */
196: /* The SWITCH statement shown below distributes the window messages to */
197: /* the respective message service routines, which are set apart by the */
198: /* CASE statements. The window procedures must provide an appropriate */
199: /* service routine for its end user initiated messages, as well as the */
200: /* general Windows messages (ie. WM_CLOSE message). If a message is */
201: /* sent to this procedure for which there is no programmed CASE clause */
202: /* (i.e., no service routine), the message is defaulted to the */
203: /* DefWindowProc function, where it is handled by Windows */
204: /* */
205: /* For the end-user initiated messages, this procedure is concerned */
206: /* principally with the WM_COMMAND message. The menu control ID (or the */
207: /* corresponding accelerator ID) is communicated to this procedure in */
208: /* the first message parameter (wParam). The window procedure provides */
209: /* a major CASE statement for the WM_COMMAND message and a subordinate */
210: /* SWITCH statement to provide CASE clauses for the message service */
211: /* routines for the various menu item's, identified by their ID values. */
212: /* */
213: /* The message service routines for the individual menu items are the */
214: /* main work points in the program. These service routines contain the */
215: /* units of work performed when the end user select one of the menu */
216: /* controls. The required application response to a menu control is */
217: /* programmed in its associated CASE clause. The service routines may */
218: /* contain subroutine calls to separately compiled and libraried */
219: /* routines, in-line calls to subroutines to be embodied in this source */
220: /* code module, or program statements entered directly in the CASE */
221: /* clauses. Program control is switched to the appropriate service */
222: /* routine when Windows recognizes the end user event and sends a WM_COMMAND */
223: /* message to the window procedure. The service routine provides the */
224: /* appropriate application-specific response to the end user initiated */
225: /* event, then breaks to return control to the WinMain() routine which */
226: /* continues to service the message queue of the window(s). */
227: /* */
228: /************************************************************************/
229:
230: LONG FAR PASCAL WndProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam)
231: {
232: HMENU hMenu=0; /* handle for the menu */
233: HBITMAP hBitmap=0; /* handle for bitmaps */
234: HDC hDC; /* handle for the display device */
235: PAINTSTRUCT ps; /* holds PAINT information */
236: int nRc=0; /* return code */
237: FLAGS flFlag = 0L;
238: ULONG ulResult;
239: char szBuf[32*1024]; // Waste of stack space, but this is only a demo.
240: char szTmp[32*1024]; // Waste of stack space, but this is only a demo.
241:
242: switch (Message) {
243: case WM_COMMAND:
244: /* The Windows messages for action bar and pulldown menu items */
245: /* are processed here. */
246: /* The WM_COMMAND message contains the message ID in its first */
247: /* parameter (wParam). This routine is programmed to SWITCH on */
248: /* the #define values generated by CASE:W for the menu items */
249: /* in the application's header (*.H) file. The ID values have */
250: /* the format, IDM_itemname. The service routines for the */
251: /* various menu items follow the CASE statements up to the */
252: /* generated BREAK statements. */
253: switch (LOWORD(wParam)) {
254: case IDM_A_LOGON:
255: /* Place User Code to respond to the */
256: /* Menu Item Named "Log&In" here. */
257: flFlag =MAPI_NEW_SESSION | MAPI_LOGON_UI;
258: ulResult = (*lpfnMAPILogon)(hWnd, NULL, NULL, flFlag, 0L, (LPLHANDLE)&hMAPISession);
259: if (ulResult == 0L) {
260: EnableMenuItem(GetMenu(hWndMain), IDM_A_LOGOFF, MF_ENABLED);
261: EnableMenuItem(GetMenu(hWndMain), IDM_S_MAIL, MF_ENABLED);
262: EnableMenuItem(GetMenu(hWndMain), IDM_S_DOCUMENT, MF_ENABLED);
263: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDFIRST, MF_ENABLED);
264: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDNEXT, MF_ENABLED);
265: }
266: break;
267:
268: case IDM_A_LOGOFF:
269: /* Place User Code to respond to the */
270: /* Menu Item Named "Log&Off" here. */
271: ulResult = (*lpfnMAPILogoff)(hMAPISession, hWnd, 0L, 0L);
272: if (ulResult == 0L) {
273: EnableMenuItem(GetMenu(hWndMain), IDM_A_LOGOFF, MF_DISABLED | MF_GRAYED);
274: EnableMenuItem(GetMenu(hWndMain), IDM_S_MAIL, MF_DISABLED | MF_GRAYED);
275: EnableMenuItem(GetMenu(hWndMain), IDM_S_DOCUMENT, MF_DISABLED | MF_GRAYED);
276: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDFIRST, MF_DISABLED | MF_GRAYED);
277: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDNEXT, MF_DISABLED | MF_GRAYED);
278: EnableMenuItem(GetMenu(hWndMain), IDM_M_READ, MF_DISABLED | MF_GRAYED);
279: EnableMenuItem(GetMenu(hWndMain), IDM_M_DELETE, MF_DISABLED | MF_GRAYED);
280: }
281: break;
282:
283: case IDM_S_MAIL:
284: /* Place User Code to respond to the */
285: /* Menu Item Named "&Mail" here. */
286: flFlag =MAPI_DIALOG;
287: ulResult = (*lpfnMAPISendMail)(hMAPISession, hWnd, &mmMapiMessage, flFlag, 0L);
288: break;
289:
290: case IDM_S_DOCUMENT:
291: /* Place User Code to respond to the */
292: /* Menu Item Named "&Document" here. */
293: ulResult = (*lpfnMAPISendDocuments)(hWnd, ";", "C:\\CONFIG.SYS", "CONFIG.SYS", 0L);
294: break;
295:
296: case IDM_M_FINDFIRST:
297: iFindFirst=TRUE;
298: case IDM_M_FINDNEXT:
299: /* Place User Code to respond to the */
300: /* Menu Item Named "&Find Next" here. */
301: if (iFindFirst) {
302: *lpszSeedMessageID = '\0';
303: iFindFirst = FALSE;
304: }
305: else {
306: strcpy(lpszSeedMessageID,lpszMessageID);
307: }
308: ulResult = (*lpfnMAPIFindNext)(hMAPISession, hWnd, NULL, lpszSeedMessageID, flFlag, 0L, lpszMessageID);
309: if (ulResult == 0L) {
310: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDNEXT, MF_ENABLED);
311: EnableMenuItem(GetMenu(hWndMain), IDM_M_READ, MF_ENABLED);
312: EnableMenuItem(GetMenu(hWndMain), IDM_M_DELETE, MF_ENABLED);
313: }
314: else {
315: EnableMenuItem(GetMenu(hWndMain), IDM_M_FINDNEXT, MF_DISABLED | MF_GRAYED);
316: EnableMenuItem(GetMenu(hWndMain), IDM_M_READ, MF_DISABLED | MF_GRAYED);
317: EnableMenuItem(GetMenu(hWndMain), IDM_M_DELETE, MF_DISABLED | MF_GRAYED);
318: }
319: break;
320:
321: case IDM_M_READ:
322: /* Place User Code to respond to the */
323: /* Menu Item Named "&Read" here. */
324:
325: lppMessage= (lpMapiMessage FAR *) &lpMessage;
326: ulResult = (*lpfnMAPIReadMail)(hMAPISession, hWnd, lpszMessageID, flFlag, 0L, lppMessage);
327: if (ulResult == 0L) {
328: mycpystr(szTmp,lpMessage->lpOriginator->lpszName);
329: sprintf(szBuf,"From: %s\n",szTmp);
330: mycpystr(szTmp,lpMessage->lpRecips[0].lpszName);
331: sprintf(szBuf,"%sTo: %s\n",szBuf,szTmp);
332: mycpystr(szTmp,lpMessage->lpszDateReceived);
333: sprintf(szBuf,"%sDate: %s\n",szBuf,szTmp);
334: mycpystr(szTmp,lpMessage->lpszSubject);
335: sprintf(szBuf,"%sSubject: %s\n\n",szBuf,szTmp);
336: mycpystr(szTmp,lpMessage->lpszNoteText);
337: sprintf(szBuf,"%s%s",szBuf,szTmp);
338:
339: MessageBox(hWnd,szBuf,"Message",MB_OK);
340:
341: ulResult = lpfnMAPIFreeBuffer((LPVOID)lpMessage);
342: }
343: break;
344:
345: case IDM_M_DELETE:
346: /* Place User Code to respond to the */
347: /* Menu Item Named "&Delete" here. */
348:
349: ulResult = (*lpfnMAPIDeleteMail)(hMAPISession, hWnd, lpszMessageID, flFlag, 0l);
350: if (ulResult == 0L) {
351: EnableMenuItem(GetMenu(hWndMain), IDM_M_READ, MF_DISABLED | MF_GRAYED);
352: EnableMenuItem(GetMenu(hWndMain), IDM_M_DELETE, MF_DISABLED | MF_GRAYED);
353: }
354: break;
355:
356: default:
357: return DefWindowProc(hWnd, Message, wParam, lParam);
358: }
359: if (ulResult != 0L) { /** oops **/
360: sprintf(szBuf,"Error Returned = %lu",ulResult);
361: MessageBox(hWnd,szBuf,"FAILED",MB_OK);
362: }
363: else {
364: sprintf(szBuf,"Good Job");
365: MessageBox(hWnd,szBuf,"SUCCESS",MB_OK);
366: }
367: break; /* End of WM_COMMAND */
368:
369: case WM_CREATE:
370: /* The WM_CREATE message is sent once to a window when the */
371: /* window is created. The window procedure for the new window */
372: /* receives this message after the window is created, but */
373: /* before the window becomes visible. */
374: /* */
375: /* Parameters: */
376: /* */
377: /* lParam - Points to a CREATESTRUCT structure with */
378: /* the following form: */
379: /* */
380: /* typedef struct */
381: /* { */
382: /* LPSTR lpCreateParams; */
383: /* HANDLE hInst; */
384: /* HANDLE hMenu; */
385: /* HWND hwndParent; */
386: /* int cy; */
387: /* int cx; */
388: /* int y; */
389: /* int x; */
390: /* LONG style; */
391: /* LPSTR lpszName; */
392: /* LPSTR lpszClass; */
393: /* DWORD dwExStyle; */
394: /* } CREATESTRUCT; */
395:
396:
397:
398: break; /* End of WM_CREATE */
399:
400: case WM_MOVE: /* code for moving the window */
401: break;
402:
403: case WM_SIZE: /* code for sizing client area */
404: /* wParam contains a code indicating the requested sizing */
405: /* lParam contains the new height and width of the client area */
406: break; /* End of WM_SIZE */
407:
408: case WM_PAINT: /* code for the window's client area */
409: /* Obtain a handle to the device context */
410: /* BeginPaint will sends WM_ERASEBKGND if appropriate */
411: memset(&ps, 0x00, sizeof(PAINTSTRUCT));
412: hDC = BeginPaint(hWnd, &ps);
413:
414: /* Included in case the background is not a pure color */
415: SetBkMode(hDC, TRANSPARENT);
416:
417: /* Application should draw on the client window using */
418: /* the GDI graphics and text functions. 'ps' the PAINTSTRUCT */
419: /* returned by BeginPaint contains a rectangle to the */
420: /* area that must be repainted. */
421:
422: /* Inform Windows painting is complete */
423: EndPaint(hWnd, &ps);
424: break; /* End of WM_PAINT */
425:
426: case WM_CLOSE: /* close the window */
427: /* Destroy child windows, modeless dialogs, then, this window */
428: DestroyWindow(hWnd);
429: if (hWnd == hWndMain)
430: PostQuitMessage(0); /* Quit the application */
431: break;
432:
433: default:
434: /* For any message for which you don't specifically provide a */
435: /* service routine, you should return the message to Windows */
436: /* for default message processing. */
437: return DefWindowProc(hWnd, Message, wParam, lParam);
438: }
439: return 0L;
440: } /* End of WndProc */
441:
442: /************************************************************************/
443: /* */
444: /* nCwRegisterClasses Function */
445: /* */
446: /* The following function registers all the classes of all the windows */
447: /* associated with this application. The function returns an error code */
448: /* if unsuccessful, otherwise it returns 0. */
449: /* */
450: /************************************************************************/
451:
452: int nCwRegisterClasses(void)
453: {
454: WNDCLASS wndclass; /* struct to define a window class */
455: memset(&wndclass, 0x00, sizeof(WNDCLASS));
456:
457:
458: /* load WNDCLASS with window's characteristics */
459: wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_BYTEALIGNWINDOW;
460: wndclass.lpfnWndProc = WndProc;
461: /* Extra storage for Class and Window objects */
462: wndclass.cbClsExtra = 0;
463: wndclass.cbWndExtra = 0;
464: wndclass.hInstance = hInst;
465: wndclass.hIcon = LoadIcon(hInst, "MAPIAPP");
466: wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
467: /* Create brush for erasing background */
468: wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
469: wndclass.lpszMenuName = szAppName; /* Menu Name is App Name */
470: wndclass.lpszClassName = szAppName; /* Class Name is App Name */
471: if(!RegisterClass(&wndclass))
472: return -1;
473:
474:
475: return(0);
476: } /* End of nCwRegisterClasses */
477:
478: /************************************************************************/
479: /* CwUnRegisterClasses Function */
480: /* */
481: /* Deletes any refrences to windows resources created for this */
482: /* application, frees memory, deletes instance, handles and does */
483: /* clean up prior to exiting the window */
484: /* */
485: /************************************************************************/
486:
487: void CwUnRegisterClasses(void)
488: {
489: WNDCLASS wndclass; /* struct to define a window class */
490: memset(&wndclass, 0x00, sizeof(WNDCLASS));
491:
492: UnregisterClass(szAppName, hInst);
493: } /* End of CwUnRegisterClasses */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.