![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to busy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui|
Return to busy.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * BUSY.C
3: *
4: * Implements the OleUIBusy function which invokes the "Server Busy"
5: * dialog.
6: *
7: * Copyright (c)1992 Microsoft Corporation, All Right Reserved
8: */
9:
10: #define STRICT 1
11: #include "ole2ui.h"
12: #include "common.h"
13: #include "utility.h"
14: #include "busy.h"
15: #include <ctype.h> // for tolower() and toupper()
16:
17: #ifndef WIN32
18: #include <toolhelp.h>
19: #endif
20:
21:
22: /*
23: * OleUIBusy
24: *
25: * Purpose:
26: * Invokes the standard OLE "Server Busy" dialog box which
27: * notifies the user that the server application is not receiving
28: * messages. The dialog then asks the user to either cancel
29: * the operation, switch to the task which is blocked, or continue
30: * waiting.
31: *
32: * Parameters:
33: * lpBZ LPOLEUIBUSY pointing to the in-out structure
34: * for this dialog.
35: *
36: * Return Value:
37: * OLEUI_BZERR_HTASKINVALID : Error
38: * OLEUI_BZ_SWITCHTOSELECTED : Success, user selected "switch to"
39: * OLEUI_BZ_RETRYSELECTED : Success, user selected "retry"
40: * OLEUI_CANCEL : Success, user selected "cancel"
41: */
42:
43: STDAPI_(UINT) OleUIBusy(LPOLEUIBUSY lpOBZ)
44: {
45: UINT uRet = 0;
46: HGLOBAL hMemDlg=NULL;
47:
48: #if defined( NT_BUG )
49:
50: uRet=UStandardValidation((LPOLEUISTANDARD)lpOBZ, sizeof(OLEUIBUSY)
51: , &hMemDlg);
52:
53: // Error out if the standard validation failed
54: if (OLEUI_SUCCESS!=uRet)
55: return uRet;
56:
57: #if !defined( WIN32 )
58: // Validate HTASK
59: if (!IsTask(lpOBZ->hTask))
60: uRet = OLEUI_BZERR_HTASKINVALID;
61: #endif
62:
63: // Error out if our secondary validation failed
64: if (OLEUI_ERR_STANDARDMIN <= uRet)
65: {
66: if (NULL!=hMemDlg)
67: FreeResource(hMemDlg);
68:
69: return uRet;
70: }
71:
72: // Invoke the dialog.
73: uRet=UStandardInvocation(BusyDialogProc, (LPOLEUISTANDARD)lpOBZ,
74: hMemDlg, MAKEINTRESOURCE(IDD_BUSY));
75: #endif
76:
77: return uRet;
78: }
79:
80:
81: /*
82: * BusyDialogProc
83: *
84: * Purpose:
85: * Implements the OLE Busy dialog as invoked through the OleUIBusy function.
86: *
87: * Parameters:
88: * Standard
89: *
90: * Return Value:
91: * Standard
92: *
93: */
94:
95: BOOL CALLBACK EXPORT BusyDialogProc(HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
96: {
97: LPBUSY lpBZ;
98: UINT uRet = 0;
99:
100: //Declare Win16/Win32 compatible WM_COMMAND parameters.
101: COMMANDPARAMS(wID, wCode, hWndMsg);
102:
103: //This will fail under WM_INITDIALOG, where we allocate it.
104: lpBZ=(LPBUSY)LpvStandardEntry(hDlg, iMsg, wParam, lParam, &uRet);
105:
106: //If the hook processed the message, we're done.
107: if (0!=uRet)
108: return (BOOL)uRet;
109:
110: //Process the temination message
111: if (iMsg==uMsgEndDialog)
112: {
113: BusyCleanup(hDlg);
114: StandardCleanup(lpBZ, hDlg);
115: EndDialog(hDlg, wParam);
116: return TRUE;
117: }
118:
119: // Process our special "close" message. If we get this message,
120: // this means that the call got unblocked, so we need to
121: // return OLEUI_BZ_CALLUNBLOCKED to our calling app.
122: if (iMsg == uMsgCloseBusyDlg)
123: {
124: SendMessage(hDlg, uMsgEndDialog, OLEUI_BZ_CALLUNBLOCKED, 0L);
125: return TRUE;
126: }
127:
128: switch (iMsg)
129: {
130: case WM_INITDIALOG:
131: FBusyInit(hDlg, wParam, lParam);
132: return TRUE;
133:
134: case WM_COMMAND:
135: switch (wID)
136: {
137: case IDBZ_SWITCHTO:
138:
139: // If user selects "Switch To...", switch activation
140: // directly to the window which is causing the problem.
141: if (IsWindow(lpBZ->hWndBlocked))
142: MakeWindowActive(lpBZ->hWndBlocked);
143: else
144: StartTaskManager(); // Fail safe: Start Task Manager
145:
146: // If this is the app not responding case, then we want
147: // to bring down the dialog when "SwitchTo" is selected.
148: // If the app is busy (RetryRejectedCall situation) then
149: // we do NOT want to bring down the dialog. this is
150: // the OLE2.0 user model design.
151: if (lpBZ->dwFlags & BZ_NOTRESPONDINGDIALOG)
152: SendMessage(hDlg, uMsgEndDialog, OLEUI_BZ_SWITCHTOSELECTED, 0L);
153: break;
154:
155: case IDBZ_RETRY:
156: SendMessage(hDlg, uMsgEndDialog, OLEUI_BZ_RETRYSELECTED, 0L);
157: break;
158:
159: case IDCANCEL:
160: SendMessage(hDlg, uMsgEndDialog, OLEUI_CANCEL, 0L);
161: break;
162: }
163: break;
164: }
165: return FALSE;
166: }
167:
168:
169: /*
170: * FBusyInit
171: *
172: * Purpose:
173: * WM_INITIDIALOG handler for the Busy dialog box.
174: *
175: * Parameters:
176: * hDlg HWND of the dialog
177: * wParam WPARAM of the message
178: * lParam LPARAM of the message
179: *
180: * Return Value:
181: * BOOL Value to return for WM_INITDIALOG.
182: */
183:
184: BOOL FBusyInit(HWND hDlg, WPARAM wParam, LPARAM lParam)
185: {
186: LPBUSY lpBZ;
187: LPOLEUIBUSY lpOBZ;
188: HFONT hFont;
189: LPSTR lpTaskName;
190: LPSTR lpWindowName;
191: HICON hIcon;
192:
193: lpBZ=(LPBUSY)LpvStandardInit(hDlg, sizeof(OLEUIBUSY), TRUE, &hFont);
194:
195: // PvStandardInit sent a termination to us already.
196: if (NULL==lpBZ)
197: return FALSE;
198:
199: // Our original structure is in lParam
200: lpOBZ = (LPOLEUIBUSY)lParam;
201:
202: // Copy it to our instance of the structure (in lpBZ)
203: lpBZ->lpOBZ=lpOBZ;
204:
205: //Copy other information from lpOBZ that we might modify.
206: lpBZ->dwFlags = lpOBZ->dwFlags;
207:
208: // Set default information
209: lpBZ->hWndBlocked = NULL;
210:
211: // Insert HWND of our dialog into the address pointed to by
212: // lphWndDialog. This can be used by the app who called
213: // OleUIBusy to bring down the dialog with uMsgCloseBusyDialog
214: if (lpOBZ->lphWndDialog &&
215: !IsBadWritePtr((VOID FAR *)lpOBZ->lphWndDialog, sizeof(HWND)))
216: {
217: *lpOBZ->lphWndDialog = hDlg;
218: }
219:
220: // Update text in text box --
221: // GetTaskInfo will return two pointers, one to the task name
222: // (file name) and one to the window name. We need to call
223: // IMallocMemFree on these when we're done with them. We also
224: // get the HWND which is blocked in this call
225: //
226: // In the case where this call fails, a default message should already
227: // be present in the dialog template, so no action is needed
228:
229: if (GetTaskInfo(hDlg, lpOBZ->hTask, &lpTaskName, &lpWindowName, &lpBZ->hWndBlocked))
230: {
231: // Build string to present to user, place in IDBZ_MESSAGE1 control
232: BuildBusyDialogString(hDlg, lpBZ->dwFlags, IDBZ_MESSAGE1, lpTaskName, lpWindowName);
233: IMallocMemFree(lpTaskName);
234: IMallocMemFree(lpWindowName);
235: }
236:
237: // Update icon with the system "exclamation" icon
238: hIcon = LoadIcon(NULL, IDI_EXCLAMATION);
239: SendDlgItemMessage(hDlg, IDBZ_ICON, STM_SETICON, (WPARAM)hIcon, 0L);
240:
241: // Disable/Enable controls
242: if ((lpBZ->dwFlags & BZ_DISABLECANCELBUTTON) ||
243: (lpBZ->dwFlags & BZ_NOTRESPONDINGDIALOG)) // Disable cancel for "not responding" dialog
244: EnableWindow(GetDlgItem(hDlg, IDCANCEL), FALSE);
245:
246: if (lpBZ->dwFlags & BZ_DISABLESWITCHTOBUTTON)
247: EnableWindow(GetDlgItem(hDlg, IDBZ_SWITCHTO), FALSE);
248:
249: if (lpBZ->dwFlags & BZ_DISABLERETRYBUTTON)
250: EnableWindow(GetDlgItem(hDlg, IDBZ_RETRY), FALSE);
251:
252: // Call the hook with lCustData in lParam
253: UStandardHook((LPVOID)lpBZ, hDlg, WM_INITDIALOG, wParam, lpOBZ->lCustData);
254:
255: // Update caption if lpszCaption was specified
256: if (lpBZ->lpOBZ->lpszCaption && !IsBadReadPtr(lpBZ->lpOBZ->lpszCaption, 1)
257: && lpBZ->lpOBZ->lpszCaption[0] != '\0')
258: SetWindowText(hDlg, (LPSTR)lpBZ->lpOBZ->lpszCaption);
259:
260: return TRUE;
261: }
262:
263:
264: /*
265: * BuildBusyDialogString
266: *
267: * Purpose:
268: * Builds the string that will be displayed in the dialog from the
269: * task name and window name parameters.
270: *
271: * Parameters:
272: * hDlg HWND of the dialog
273: * dwFlags DWORD containing flags passed into dialog
274: * iControl Control ID to place the text string
275: * lpTaskName LPSTR pointing to name of task (e.g. C:\TEST\TEST.EXE)
276: * lpWindowName LPSTR for name of window
277: *
278: * Caveats:
279: * The caller of this function MUST de-allocate the lpTaskName and
280: * lpWindowName pointers itself with IMallocMemFree.
281: *
282: * Return Value:
283: * void
284: */
285:
286: void BuildBusyDialogString(HWND hDlg, DWORD dwFlags, int iControl, LPSTR lpTaskName, LPSTR lpWindowName)
287: {
288: LPSTR pszT, psz1, psz2, psz3;
289: UINT cch;
290: LPSTR pszDot, pszSlash;
291: UINT uiStringNum;
292:
293: /*
294: * We need scratch memory for loading the stringtable string,
295: * the task name, and constructing the final string. We therefore
296: * allocate three buffers as large as the maximum message
297: * length (512) plus the object type, guaranteeing that we have enough
298: * in all cases.
299: */
300: cch=512;
301:
302: // Use OLE-supplied allocation
303: if ((pszT = IMallocMemAlloc((DWORD)(3*cch))) == NULL)
304: return;
305:
306: psz1=pszT;
307: psz2=psz1+cch;
308: psz3=psz2+cch;
309:
310: // Parse base name out of path name, use psz2 for the task
311: // name to display
312:
313: _fstrcpy(psz2, lpTaskName);
314: pszDot = _fstrrchr(psz2, '.');
315: if (pszDot != NULL)
316: *pszDot = '\0'; // Null terminate at the DOT
317:
318: pszSlash = _fstrrchr(psz2, '\\'); // Find last backslash in path
319: if (pszSlash != NULL)
320: psz2 = pszSlash + 1; // Nuke everything up to this point
321:
322: #ifdef LOWERCASE_NAME
323: // Compile this with /DLOWERCASE_NAME if you want the lower-case
324: // module name to be displayed in the dialog rather than the
325: // all-caps name.
326: {
327: int i,l;
328:
329: // Now, lowercase all letters except first one
330: l = _fstrlen(psz2);
331: for(i=0;i<l;i++)
332: psz2[i] = tolower(psz2[i]);
333:
334: psz2[0] = toupper(psz2[0]);
335: }
336: #endif
337:
338: // Check size of lpWindowName. We can reasonably fit about 80
339: // characters into the text control, so truncate more than 80 chars
340: if (_fstrlen(lpWindowName) > 80)
341: lpWindowName[80] = '\0';
342:
343: // Load the format string out of stringtable, choose a different
344: // string depending on what flags are passed in to the dialog
345: if (dwFlags & BZ_NOTRESPONDINGDIALOG)
346: uiStringNum = IDS_BZRESULTTEXTNOTRESPONDING;
347: else
348: uiStringNum = IDS_BZRESULTTEXTBUSY;
349:
350: if (LoadString(ghInst, uiStringNum, psz1, cch) == 0)
351: return;
352:
353: // Build the string. The format string looks like this:
354: // "This action cannot be completed because the '%s' application
355: // (%s) is [busy | not responding]. Choose \"Switch To\" to activate '%s' and
356: // correct the problem."
357:
358: wsprintf(psz3, psz1, (LPSTR)psz2, (LPSTR)lpWindowName, (LPSTR)psz2);
359: SetDlgItemText(hDlg, iControl, (LPSTR)psz3);
360: IMallocMemFree(pszT);
361:
362: return;
363: }
364:
365:
366:
367: /*
368: * BusyCleanup
369: *
370: * Purpose:
371: * Performs busy-specific cleanup before termination.
372: *
373: * Parameters:
374: * hDlg HWND of the dialog box so we can access controls.
375: *
376: * Return Value:
377: * None
378: */
379: void BusyCleanup(HWND hDlg)
380: {
381: return;
382: }
383:
384:
385:
386: /*
387: * GetTaskInfo()
388: *
389: * Purpose: Gets information about the specified task and places the
390: * module name, window name and top-level HWND for the task in the specified
391: * pointers
392: *
393: * NOTE: The two string pointers allocated in this routine are
394: * the responsibility of the CALLER to de-allocate.
395: *
396: * Parameters:
397: * hWnd HWND who called this function
398: * htask HTASK which we want to find out more info about
399: * lplpszTaskName Location that the module name is returned
400: * lplpszWindowName Location where the window name is returned
401: *
402: */
403:
404: BOOL GetTaskInfo(HWND hWnd, HTASK htask, LPSTR FAR* lplpszTaskName, LPSTR FAR*lplpszWindowName, HWND FAR*lphWnd)
405: {
406: BOOL fRet = FALSE;
407: #if !defined( WIN32 )
408: TASKENTRY te;
409: #endif
410: HWND hwndNext;
411: LPSTR lpszTN = NULL;
412: LPSTR lpszWN = NULL;
413: HWND hwndFind = NULL;
414:
415: // Clear out return values in case of error
416: *lplpszTaskName = NULL;
417: *lplpszWindowName = NULL;
418:
419: #if !defined( WIN32 )
420: te.dwSize = sizeof(TASKENTRY);
421: if (TaskFindHandle(&te, htask))
422: #endif
423: {
424: // Now, enumerate top-level windows in system
425: hwndNext = GetWindow(hWnd, GW_HWNDFIRST);
426: while (hwndNext)
427: {
428: // See if we can find a non-owned top level window whose
429: // hInstance matches the one we just got passed. If we find one,
430: // we can be fairly certain that this is the top-level window for
431: // the task which is blocked.
432: //
433: // REVIEW: Will this filter hold true for InProcServer DLL-created
434: // windows?
435: //
436: if ((hwndNext != hWnd) &&
437: #if !defined( WIN32 )
438: (GetWindowWord(hwndNext, GWW_HINSTANCE) == (WORD)te.hInst) &&
439: #else
440: (GetWindowThreadProcessId(hwndNext,NULL) == htask) &&
441: #endif
442: (IsWindowVisible(hwndNext)) &&
443: !GetWindow(hwndNext, GW_OWNER))
444: {
445: // We found our window! Alloc space for new strings
446: if ((lpszTN = IMallocMemAlloc(OLEUI_CCHPATHMAX)) == NULL)
447: return TRUE; // continue task window enumeration
448:
449: if ((lpszWN = IMallocMemAlloc(OLEUI_CCHPATHMAX)) == NULL)
450: return TRUE; // continue task window enumeration
451:
452: // We found the window we were looking for, copy info to
453: // local vars
454: GetWindowText(hwndNext, lpszWN, OLEUI_CCHPATHMAX);
455: #if !defined( WIN32 )
456: lstrcpyn(lpszTN, te.szModule, OLEUI_CCHPATHMAX);
457: #else
458: /* WIN32 NOTE: we are not able to get a module name
459: ** given a thread process id on WIN32. the best we
460: ** can do is use the window title as the module/app
461: ** name.
462: */
463: lstrcpyn(lpszTN, lpszWN, OLEUI_CCHPATHMAX);
464: #endif
465: hwndFind = hwndNext;
466:
467: fRet = TRUE;
468: goto OKDone;
469: }
470:
471: hwndNext = GetWindow(hwndNext, GW_HWNDNEXT);
472: }
473: }
474:
475: OKDone:
476:
477: // OK, everything was successful. Set string pointers to point to
478: // our data.
479:
480: *lplpszTaskName = lpszTN;
481: *lplpszWindowName = lpszWN;
482: *lphWnd = hwndFind;
483:
484: return fRet;
485: }
486:
487:
488: /*
489: * IMallocMemAlloc()
490: *
491: * Purpose: Allocates dwSize bytes of memory using the OLE-supplied
492: * memory allocation.
493: *
494: * Parameters:
495: * dwSize Size of memory requested
496: *
497: * Returns:
498: * void FAR * Pointer to new memory, or NULL if failed
499: *
500: */
501:
502: void FAR * IMallocMemAlloc(DWORD dwSize)
503: {
504: LPMALLOC pIMalloc;
505: LPSTR pszT;
506:
507: // Use OLE-supplied allocation
508: if (CoGetMalloc(MEMCTX_TASK, &pIMalloc) != NOERROR)
509: return NULL;
510:
511: pszT=(LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, dwSize);
512: pIMalloc->lpVtbl->Release(pIMalloc);
513: return pszT;
514: }
515:
516:
517: /*
518: * IMallocMemFree()
519: *
520: * Purpose: Frees memory allocated with IMallocMemAlloc()
521: *
522: * Parameters:
523: * ptr Pointer to memory to free
524: *
525: * Returns:
526: * SCODE Return code from CoGetMalloc
527: */
528:
529: SCODE IMallocMemFree(void FAR *ptr)
530: {
531: SCODE sc;
532: LPMALLOC pIMalloc;
533:
534: sc = GetScode(CoGetMalloc(MEMCTX_TASK, &pIMalloc));
535: if (SUCCEEDED(sc))
536: {
537: pIMalloc->lpVtbl->Free(pIMalloc, ptr);
538: pIMalloc->lpVtbl->Release(pIMalloc);
539: }
540: return sc;
541:
542: }
543:
544:
545: /*
546: * StartTaskManager()
547: *
548: * Purpose: Starts Task Manager. Used to bring up task manager to
549: * assist in switching to a given blocked task.
550: *
551: */
552:
553: StartTaskManager()
554: {
555: WinExec("taskman.exe", SW_SHOW);
556: return TRUE;
557: }
558:
559:
560:
561: /*
562: * MakeWindowActive()
563: *
564: * Purpose: Makes specified window the active window.
565: *
566: */
567:
568: void MakeWindowActive(HWND hWndSwitchTo)
569: {
570: // Move the new window to the top of the Z-order
571: SetWindowPos(hWndSwitchTo, HWND_TOP, 0, 0, 0, 0,
572: SWP_NOSIZE | SWP_NOMOVE);
573:
574: // If it's iconic, we need to restore it.
575: if (IsIconic(hWndSwitchTo))
576: ShowWindow(hWndSwitchTo, SW_RESTORE);
577: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.