![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to insobj.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 insobj.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * INSOBJ.C
3: *
4: * Implements the OleUIInsertObject function which invokes the complete
5: * Insert Object dialog. Makes use of the OleChangeIcon function in
6: * ICON.C.
7: *
8: * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
9: */
10:
11: #define STRICT 1
12: #include "ole2ui.h"
13: #include <commdlg.h>
14: #include <memory.h>
15: #include <direct.h>
16: #include <malloc.h>
17: #include <dos.h>
18: #include "common.h"
19: #include "utility.h"
20: #include "icon.h"
21: #include "insobj.h"
22: #include "resimage.h"
23: #include "iconbox.h"
24: #include "geticon.h"
25:
26: #define IS_FILENAME_DELIM(c) ( (c) == '\\' || (c) == '/' || (c) == ':' )
27:
28: /*
29: * OleUIInsertObject
30: *
31: * Purpose:
32: * Invokes the standard OLE Insert Object dialog box allowing the
33: * user to select an object source and classname as well as the option
34: * to display the object as itself or as an icon.
35: *
36: * Parameters:
37: * lpIO LPOLEUIINSERTOBJECT pointing to the in-out structure
38: * for this dialog.
39: *
40: * Return Value:
41: * UINT OLEUI_SUCCESS or OLEUI_OK if all is well, otherwise
42: * an error value.
43: */
44:
45: STDAPI_(UINT) OleUIInsertObject(LPOLEUIINSERTOBJECT lpIO)
46: {
47: UINT uRet;
48: HGLOBAL hMemDlg=NULL;
49: HRESULT hrErr;
50:
51: uRet=UStandardValidation((LPOLEUISTANDARD)lpIO, sizeof(OLEUIINSERTOBJECT)
52: , &hMemDlg);
53:
54: if (OLEUI_SUCCESS!=uRet)
55: return uRet;
56:
57: //Now we can do Insert Object specific validation.
58:
59:
60: // NULL is NOT valid for lpszFile
61: if ( (NULL == lpIO->lpszFile)
62: || (IsBadReadPtr(lpIO->lpszFile, lpIO->cchFile))
63: || (IsBadWritePtr(lpIO->lpszFile, lpIO->cchFile)) )
64: uRet=OLEUI_IOERR_LPSZFILEINVALID;
65:
66: if (NULL != lpIO->lpszFile
67: && (lpIO->cchFile <= 0 || lpIO->cchFile > OLEUI_CCHPATHMAX))
68: uRet=OLEUI_IOERR_CCHFILEINVALID;
69:
70: if (0!=lpIO->cClsidExclude)
71: {
72: if (NULL!=lpIO->lpClsidExclude && IsBadReadPtr(lpIO->lpClsidExclude
73: , lpIO->cClsidExclude*sizeof(CLSID)))
74: uRet=OLEUI_IOERR_LPCLSIDEXCLUDEINVALID;
75: }
76:
77: //If we have flags to create any object, validate necessary data.
78: if (lpIO->dwFlags & (IOF_CREATENEWOBJECT | IOF_CREATEFILEOBJECT | IOF_CREATELINKOBJECT))
79: {
80: if (NULL!=lpIO->lpFormatEtc
81: && IsBadReadPtr(lpIO->lpFormatEtc, sizeof(FORMATETC)))
82: uRet=OLEUI_IOERR_LPFORMATETCINVALID;
83:
84: if (NULL!=lpIO->ppvObj && IsBadWritePtr(lpIO->ppvObj, sizeof(LPVOID)))
85: uRet=OLEUI_IOERR_PPVOBJINVALID;
86:
87: if (NULL!=lpIO->lpIOleClientSite
88: && IsBadReadPtr(lpIO->lpIOleClientSite->lpVtbl, sizeof(IOleClientSiteVtbl)))
89: uRet=OLEUI_IOERR_LPIOLECLIENTSITEINVALID;
90:
91: if (NULL!=lpIO->lpIStorage
92: && IsBadReadPtr(lpIO->lpIStorage->lpVtbl, sizeof(IStorageVtbl)))
93: uRet=OLEUI_IOERR_LPISTORAGEINVALID;
94: }
95:
96: if (OLEUI_ERR_STANDARDMIN <= uRet)
97: {
98: if (NULL!=hMemDlg)
99: FreeResource(hMemDlg);
100:
101: return uRet;
102: }
103:
104: //Now that we've validated everything, we can invoke the dialog.
105: uRet=UStandardInvocation(InsertObjectDialogProc, (LPOLEUISTANDARD)lpIO
106: , hMemDlg, MAKEINTRESOURCE(IDD_INSERTOBJECT));
107:
108:
109: //Stop here if we cancelled or had an error.
110: if (OLEUI_SUCCESS !=uRet && OLEUI_OK!=uRet)
111: return uRet;
112:
113:
114: /*
115: * If any of the flags specify that we're to create objects on return
116: * from this dialog, then do so. If we encounter an error in this
117: * processing, we return OLEUI_IOERR_SCODEHASERROR. Since the
118: * three select flags are mutually exclusive, we don't have to
119: * if...else here, just if each case (keeps things cleaner that way).
120: */
121:
122: lpIO->sc=S_OK;
123:
124: //Check if Create New was selected and we have IOF_CREATENEWOBJECT
125: if ((lpIO->dwFlags & IOF_SELECTCREATENEW) && (lpIO->dwFlags & IOF_CREATENEWOBJECT))
126: {
127: hrErr=OleCreate(&lpIO->clsid, &lpIO->iid, lpIO->oleRender
128: , lpIO->lpFormatEtc, lpIO->lpIOleClientSite, lpIO->lpIStorage
129: , lpIO->ppvObj);
130: lpIO->sc = GetScode(hrErr);
131: }
132:
133: //Try Create From File
134: if ((lpIO->dwFlags & IOF_SELECTCREATEFROMFILE))
135: {
136: if (!(lpIO->dwFlags & IOF_CHECKLINK) && (lpIO->dwFlags & IOF_CREATEFILEOBJECT))
137: {
138: hrErr=OleCreateFromFile(&CLSID_NULL, lpIO->lpszFile, &lpIO->iid
139: , lpIO->oleRender, lpIO->lpFormatEtc, lpIO->lpIOleClientSite
140: , lpIO->lpIStorage, lpIO->ppvObj);
141: lpIO->sc = GetScode(hrErr);
142: }
143:
144: if ((lpIO->dwFlags & IOF_CHECKLINK) && (lpIO->dwFlags & IOF_CREATELINKOBJECT))
145: {
146: hrErr=OleCreateLinkToFile(lpIO->lpszFile, &lpIO->iid
147: , lpIO->oleRender, lpIO->lpFormatEtc, lpIO->lpIOleClientSite
148: , lpIO->lpIStorage, lpIO->ppvObj);
149: lpIO->sc = GetScode(hrErr);
150: }
151: }
152:
153: //If we tried but failed a create option, then return the appropriate error
154: if (S_OK!=lpIO->sc)
155: uRet=OLEUI_IOERR_SCODEHASERROR;
156:
157: return uRet;
158: }
159:
160:
161:
162:
163:
164: /*
165: * InsertObjectDialogProc
166: *
167: * Purpose:
168: * Implements the OLE Insert Object dialog as invoked through the
169: * OleUIInsertObject function.
170: */
171:
172: BOOL CALLBACK EXPORT InsertObjectDialogProc(HWND hDlg, UINT iMsg
173: , WPARAM wParam, LPARAM lParam)
174: {
175: LPOLEUIINSERTOBJECT lpOIO;
176: LPINSERTOBJECT lpIO;
177: OLEUICHANGEICON ci;
178: UINT i;
179: BOOL fCheck=FALSE;
180: UINT uRet=0;
181:
182: //Declare Win16/Win32 compatible WM_COMMAND parameters.
183: COMMANDPARAMS(wID, wCode, hWndMsg);
184:
185: //This will fail under WM_INITDIALOG, where we allocate it.
186: lpIO=(LPINSERTOBJECT)LpvStandardEntry(hDlg, iMsg, wParam, lParam, &uRet);
187:
188: //If the hook processed the message, we're done.
189: if (0!=uRet)
190: return (BOOL)uRet;
191:
192: //Process help message from Change Icon
193: if (iMsg==uMsgHelp)
194: {
195: PostMessage(lpIO->lpOIO->hWndOwner, uMsgHelp, wParam, lParam);
196: return FALSE;
197: }
198:
199: //Process the temination message
200: if (iMsg==uMsgEndDialog)
201: {
202: InsertObjectCleanup(hDlg);
203: StandardCleanup(lpIO, hDlg);
204: EndDialog(hDlg, wParam);
205: return TRUE;
206: }
207:
208: switch (iMsg)
209: {
210: case WM_INITDIALOG:
211: return FInsertObjectInit(hDlg, wParam, lParam);
212:
213: case WM_COMMAND:
214: switch (wID)
215: {
216: case ID_IO_CREATENEW:
217: FToggleObjectSource(hDlg, lpIO, IOF_SELECTCREATENEW);
218: break;
219:
220: case ID_IO_CREATEFROMFILE:
221: FToggleObjectSource(hDlg, lpIO, IOF_SELECTCREATEFROMFILE);
222: break;
223:
224: case ID_IO_LINKFILE:
225: fCheck=IsDlgButtonChecked(hDlg, wID);
226:
227: if (fCheck)
228: lpIO->dwFlags |=IOF_CHECKLINK;
229: else
230: lpIO->dwFlags &=~IOF_CHECKLINK;
231:
232: //Results change here, so be sure to update it.
233: SetInsertObjectResults(hDlg, lpIO);
234: UpdateClassIcon(hDlg, lpIO, NULL);
235: break;
236:
237: case ID_IO_OBJECTTYPELIST:
238: switch (wCode)
239: {
240: case LBN_SELCHANGE:
241: UpdateClassIcon(hDlg, lpIO, hWndMsg);
242: SetInsertObjectResults(hDlg, lpIO);
243: break;
244:
245: case LBN_DBLCLK:
246: //Same as pressing OK.
247: SendCommand(hDlg, IDOK, BN_CLICKED, hWndMsg);
248: break;
249: }
250: break;
251:
252:
253: case ID_IO_FILEDISPLAY:
254: //If there are characters, enable OK and Display As Icon
255: if (EN_CHANGE==wCode)
256: {
257: lpIO->fFileDirty = TRUE;
258: lpIO->fFileValid = FALSE;
259:
260: lpIO->fFileSelected=
261: (0L!=SendMessage(hWndMsg, EM_LINELENGTH, 0, 0L));
262: EnableWindow(GetDlgItem(hDlg, ID_IO_LINKFILE), lpIO->fFileSelected);
263: EnableWindow(GetDlgItem(hDlg, ID_IO_DISPLAYASICON), lpIO->fFileSelected);
264: EnableWindow(GetDlgItem(hDlg, ID_IO_CHANGEICON), lpIO->fFileSelected);
265: EnableWindow(GetDlgItem(hDlg, IDOK), lpIO->fFileSelected);
266: }
267:
268: if (EN_KILLFOCUS==wCode && NULL!=lpIO)
269: {
270: if (FValidateInsertFile(hDlg,FALSE,&lpIO->nErrCode)) {
271: lpIO->fFileDirty = FALSE;
272: lpIO->fFileValid = TRUE;
273: UpdateClassIcon(hDlg, lpIO, NULL);
274: UpdateClassType(hDlg, lpIO, TRUE);
275: } else {
276: lpIO->fFileDirty = FALSE;
277: lpIO->fFileValid = FALSE;
278: UpdateClassType(hDlg, lpIO, FALSE);
279: }
280: }
281: break;
282:
283:
284: case ID_IO_DISPLAYASICON:
285: fCheck=IsDlgButtonChecked(hDlg, wID);
286: EnableWindow(GetDlgItem(hDlg, ID_IO_CHANGEICON), fCheck);
287:
288: if (fCheck)
289: lpIO->dwFlags |=IOF_CHECKDISPLAYASICON;
290: else
291: lpIO->dwFlags &=~IOF_CHECKDISPLAYASICON;
292:
293: //Update the internal flag based on this checking
294: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
295: lpIO->fAsIconNew=fCheck;
296: else
297: lpIO->fAsIconFile=fCheck;
298:
299: //Re-read the class icon on Display checked
300: if (fCheck)
301: {
302: if (lpIO->dwFlags & IOF_SELECTCREATEFROMFILE)
303: {
304: if (FValidateInsertFile(hDlg, TRUE,&lpIO->nErrCode))
305: {
306: lpIO->fFileDirty = FALSE;
307: lpIO->fFileValid = TRUE;
308: UpdateClassIcon(hDlg, lpIO,
309: GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST));
310:
311: UpdateClassType(hDlg, lpIO, TRUE);
312: }
313:
314: else
315: {
316: HWND hWndEC;
317:
318: lpIO->fAsIconFile= FALSE;
319: lpIO->fFileDirty = FALSE;
320: lpIO->fFileValid = FALSE;
321: SendDlgItemMessage(hDlg, ID_IO_ICONDISPLAY, IBXM_IMAGESET, 0, 0L);
322: UpdateClassType(hDlg, lpIO, FALSE);
323:
324: lpIO->dwFlags &=~IOF_CHECKDISPLAYASICON;
325: CheckDlgButton(hDlg, ID_IO_DISPLAYASICON, 0);
326:
327: hWndEC = GetDlgItem(hDlg, ID_IO_FILEDISPLAY);
328: SetFocus(hWndEC);
329: SendMessage(hWndEC, EM_SETSEL, 0, MAKELPARAM(0, (WORD)-1));
330: return TRUE;
331: }
332: }
333: else
334: UpdateClassIcon(hDlg, lpIO,
335: GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST));
336: }
337:
338:
339: //Results change here, so be sure to update it.
340: SetInsertObjectResults(hDlg, lpIO);
341:
342:
343: /*
344: * Show or hide controls as appropriate. Do the icon
345: * display last because it will take some time to repaint.
346: * If we do it first then the dialog looks too sluggish.
347: */
348: i=(fCheck) ? SW_SHOWNORMAL : SW_HIDE;
349: StandardShowDlgItem(hDlg, ID_IO_CHANGEICON, i);
350: StandardShowDlgItem(hDlg, ID_IO_ICONDISPLAY, i);
351:
352: break;
353:
354:
355: case ID_IO_CHANGEICON:
356: {
357:
358: LPMALLOC pIMalloc;
359: HWND hList;
360: LPSTR pszString, pszCLSID;
361:
362: int iCurSel;
363:
364: // if we're in SELECTCREATEFROMFILE mode, then we need to Validate
365: // the contents of the edit control first.
366:
367: if (lpIO->dwFlags & IOF_SELECTCREATEFROMFILE)
368: {
369: if ( lpIO->fFileDirty
370: && !FValidateInsertFile(hDlg, TRUE, &lpIO->nErrCode) )
371: {
372: HWND hWndEC;
373:
374: lpIO->fFileDirty = TRUE;
375: hWndEC = GetDlgItem(hDlg, ID_IO_FILEDISPLAY);
376: SetFocus(hWndEC);
377: SendMessage(hWndEC, EM_SETSEL, 0, MAKELPARAM(0, (WORD)-1));
378: return TRUE;
379: }
380: else
381: lpIO->fFileDirty = FALSE;
382: }
383:
384:
385:
386: //Initialize the structure for the hook.
387: _fmemset((LPOLEUICHANGEICON)&ci, 0, sizeof(ci));
388:
389: ci.hMetaPict=(HGLOBAL)SendDlgItemMessage(hDlg
390: , ID_IO_ICONDISPLAY, IBXM_IMAGEGET, 0, 0L);
391:
392: ci.cbStruct =sizeof(ci);
393: ci.hWndOwner=hDlg;
394: ci.dwFlags =CIF_SELECTCURRENT;
395:
396: if (lpIO->dwFlags & IOF_SHOWHELP)
397: ci.dwFlags |= CIF_SHOWHELP;
398:
399:
400:
401:
402: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
403: {
404: // Initialize clsid...
405: if (NOERROR != CoGetMalloc(MEMCTX_TASK, &pIMalloc))
406: return FALSE;
407:
408: pszString = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHKEYMAX + OLEUI_CCHCLSIDSTRING);
409:
410:
411: hList = GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST);
412: iCurSel = (int)SendMessage(hList, LB_GETCURSEL, 0, 0L);
413: SendMessage(hList, LB_GETTEXT, iCurSel, (LONG)pszString);
414:
415: pszCLSID = PointerToNthField(pszString, 2, '\t');
416:
417: CLSIDFromString((LPSTR)pszCLSID, (LPCLSID)&(ci.clsid));
418:
419: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszString);
420: pIMalloc->lpVtbl->Release(pIMalloc);
421: }
422: else // IOF_SELECTCREATEFROMFILE
423: {
424:
425: char szFileName[OLEUI_CCHPATHMAX];
426:
427: GetDlgItemText(hDlg, ID_IO_FILEDISPLAY, (LPSTR)szFileName, OLEUI_CCHPATHMAX);
428:
429: if (NOERROR != GetClassFile((LPSTR)szFileName, (LPCLSID)&(ci.clsid)))
430: {
431: LPSTR lpszExtension;
432: int istrlen;
433:
434: istrlen = lstrlen(szFileName);
435:
436: lpszExtension = (LPSTR)szFileName + istrlen -1;
437:
438: while ( (lpszExtension > szFileName) &&
439: (*lpszExtension != '.') )
440: lpszExtension--;
441:
442: GetAssociatedExecutable(lpszExtension, (LPSTR)ci.szIconExe);
443: ci.cchIconExe = lstrlen(ci.szIconExe);
444: ci.dwFlags |= CIF_USEICONEXE;
445:
446: }
447: }
448:
449:
450: //Let the hook in to customize Change Icon if desired.
451: uRet=UStandardHook(lpIO, hDlg, uMsgChangeIcon
452: , 0, (LONG)(LPSTR)&ci);
453:
454: if (0==uRet)
455: uRet=(UINT)(OLEUI_OK==OleUIChangeIcon(&ci));
456:
457: //Update the display and itemdata if necessary.
458: if (0!=uRet)
459: {
460:
461: /*
462: * OleUIChangeIcon will have already freed our
463: * current hMetaPict that we passed in when OK is
464: * pressed in that dialog. So we use 0L as lParam
465: * here so the IconBox doesn't try to free the
466: * metafilepict again.
467: */
468: SendDlgItemMessage(hDlg, ID_IO_ICONDISPLAY, IBXM_IMAGESET
469: , (WPARAM)ci.hMetaPict, 0L);
470:
471: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
472: SendMessage(hList, LB_SETITEMDATA, iCurSel, MAKELPARAM(ci.hMetaPict, 0));
473: }
474: }
475: break;
476:
477:
478: case ID_IO_FILE:
479: {
480: /*
481: * To allow the hook to customize the browse dialog, we
482: * send OLEUI_MSG_BROWSE. If the hook returns FALSE
483: * we use the default, otherwise we trust that it retrieved
484: * a filename for us. This mechanism prevents hooks from
485: * trapping ID_IO_BROWSE to customize the dialog and from
486: * trying to figure out what we do after we have the name.
487: */
488:
489: char szTemp[OLEUI_CCHPATHMAX];
490: char szInitialDir[OLEUI_CCHPATHMAX];
491: DWORD dwOfnFlags;
492: int nChars;
493: BOOL fUseInitialDir = FALSE;
494:
495:
496: nChars = GetDlgItemText(hDlg, ID_IO_FILEDISPLAY, (LPSTR)szTemp, OLEUI_CCHPATHMAX);
497:
498: if (FValidateInsertFile(hDlg, FALSE, &lpIO->nErrCode))
499: {
500:
501: int istrlen;
502:
503: GetFileTitle((LPSTR)szTemp, lpIO->szFile, OLEUI_CCHPATHMAX);
504:
505: istrlen = lstrlen(lpIO->szFile);
506:
507: lstrcpyn((LPSTR)szInitialDir, szTemp, nChars - istrlen);
508: fUseInitialDir = TRUE;
509:
510: }
511: else // file name isn't valid...lop off end of szTemp to get a
512: // valid directory
513: {
514: #if defined( WIN32 )
515: char szBuffer[OLEUI_CCHPATHMAX];
516: DWORD Attribs;
517:
518: lstrcpyn(szBuffer, szTemp, sizeof(szBuffer)-1);
519: szBuffer[sizeof(szBuffer)-1] = '\0';
520:
521: if ('\\' == szBuffer[nChars-1])
522: szBuffer[nChars-1] = '\0';
523:
524: Attribs = GetFileAttributes(szBuffer);
525: if (Attribs != 0xffffffff &&
526: (Attribs & FILE_ATTRIBUTE_DIRECTORY) )
527: {
528: lstrcpy(szInitialDir, (LPSTR)szBuffer);
529: fUseInitialDir = TRUE;
530: }
531: #else
532: static char szBuffer[OLEUI_CCHPATHMAX];
533: static int attrib ;
534:
535: lstrcpyn(szBuffer, szTemp, sizeof(szBuffer)-1);
536: szBuffer[sizeof(szBuffer)-1] = '\0';
537:
538: if ('\\' == szBuffer[nChars-1])
539: szBuffer[nChars-1] = '\0';
540:
541: AnsiToOem(szBuffer, szBuffer);
542: if(0 == _dos_getfileattr(szBuffer, &attrib))
543: {
544: lstrcpy(szInitialDir, (LPSTR)szBuffer);
545: fUseInitialDir = TRUE;
546: }
547: #endif
548: *lpIO->szFile = '\0';
549: }
550:
551: uRet=UStandardHook(lpIO, hDlg, uMsgBrowse
552: , OLEUI_CCHPATHMAX, (LPARAM)(LPSTR)lpIO->szFile);
553:
554: dwOfnFlags = OFN_FILEMUSTEXIST;
555:
556: // dont show the help button: easiest fix for #4567, since there is no hook proc
557: // if (lpIO->lpOIO->dwFlags & IOF_SHOWHELP)
558: // dwOfnFlags |= OFN_SHOWHELP;
559:
560: if (0==uRet)
561: uRet=(UINT)Browse(hDlg,
562: lpIO->szFile,
563: fUseInitialDir ? (LPSTR)szInitialDir : NULL,
564: OLEUI_CCHPATHMAX,
565: IDS_FILTERS,
566: dwOfnFlags);
567:
568: //Only update if the file changed.
569: if (0!=uRet && 0!=lstrcmpi(szTemp, lpIO->szFile))
570: {
571: SetDlgItemText(hDlg, ID_IO_FILEDISPLAY, lpIO->szFile);
572: lpIO->fFileSelected=TRUE;
573:
574: if (FValidateInsertFile(hDlg, TRUE, &lpIO->nErrCode))
575: {
576: lpIO->fFileDirty = FALSE;
577: lpIO->fFileValid = TRUE;
578: UpdateClassIcon(hDlg, lpIO, NULL);
579: UpdateClassType(hDlg, lpIO, TRUE);
580: }
581: else // filename is invalid - set focus back to ec
582: {
583: HWND hWnd;
584:
585: lpIO->fFileDirty = FALSE;
586: lpIO->fFileValid = FALSE;
587: hWnd = GetDlgItem(hDlg, ID_IO_FILEDISPLAY);
588: SetFocus(hWnd);
589: SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(0, (WORD)-1));
590: }
591:
592: //Once we have a file, Display As Icon is always enabled
593: EnableWindow(GetDlgItem(hDlg, ID_IO_DISPLAYASICON), TRUE);
594:
595: //As well as OK
596: EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
597:
598: }
599: }
600: break;
601:
602:
603: case IDOK:
604: {
605: HWND hListBox;
606: WORD iCurSel;
607: char szBuffer[OLEUI_CCHKEYMAX + OLEUI_CCHCLSIDSTRING];
608: LPSTR lpszCLSID;
609:
610: if ((HWND)(LOWORD(lParam)) != GetFocus())
611: SetFocus((HWND)(LOWORD(lParam)));
612:
613:
614:
615: // If the file name is clean (already validated), or
616: // if Create New is selected, then we can skip this part.
617:
618: if ( (lpIO->dwFlags & IOF_SELECTCREATEFROMFILE)
619: && (TRUE == lpIO->fFileDirty) )
620: {
621:
622: if (FValidateInsertFile(hDlg, TRUE, &lpIO->nErrCode))
623: {
624: lpIO->fFileDirty = FALSE;
625: lpIO->fFileValid = TRUE;
626: UpdateClassIcon(hDlg, lpIO, NULL);
627: UpdateClassType(hDlg, lpIO, TRUE);
628: }
629: else // filename is invalid - set focus back to ec
630: {
631: HWND hWnd;
632:
633: lpIO->fFileDirty = FALSE;
634: lpIO->fFileValid = FALSE;
635: hWnd = GetDlgItem(hDlg, ID_IO_FILEDISPLAY);
636: SetFocus(hWnd);
637: SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(0, (WORD)-1));
638: UpdateClassType(hDlg, lpIO, FALSE);
639: }
640:
641: return TRUE; // eat this message
642: }
643: else if ( (lpIO->dwFlags & IOF_SELECTCREATEFROMFILE)
644: && (FALSE == lpIO->fFileValid) )
645: {
646: // filename is invalid - set focus back to ec
647: HWND hWnd;
648: char szFile[OLEUI_CCHPATHMAX];
649:
650: if (0!=GetDlgItemText(hDlg, ID_IO_FILEDISPLAY,
651: szFile, sizeof(szFile)))
652: {
653: OpenFileError(hDlg, lpIO->nErrCode, szFile);
654: }
655: lpIO->fFileDirty = FALSE;
656: lpIO->fFileValid = FALSE;
657: hWnd = GetDlgItem(hDlg, ID_IO_FILEDISPLAY);
658: SetFocus(hWnd);
659: SendMessage(hWnd, EM_SETSEL, 0, MAKELPARAM(0, (WORD)-1));
660: UpdateClassType(hDlg, lpIO, FALSE);
661: return TRUE; // eat this message
662: }
663:
664: //Copy the necessary information back to the original struct
665: lpOIO=lpIO->lpOIO;
666: lpOIO->dwFlags=lpIO->dwFlags;
667:
668: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
669: {
670: hListBox=GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST);
671: iCurSel=(WORD)SendMessage(hListBox, LB_GETCURSEL, 0, 0);
672:
673: if (lpIO->dwFlags & IOF_CHECKDISPLAYASICON)
674: {
675: lpOIO->hMetaPict=(HGLOBAL)SendMessage(hListBox,
676: LB_GETITEMDATA, iCurSel, 0L);
677:
678: /*
679: * Set the item data to 0 here so that the cleanup
680: * code doesn't delete the metafile.
681: */
682: SendMessage(hListBox, LB_SETITEMDATA, iCurSel, 0L);
683: }
684: else
685: lpOIO->hMetaPict = (HGLOBAL)NULL;
686:
687: SendMessage(hListBox, LB_GETTEXT, iCurSel
688: , (LPARAM)(LPSTR)szBuffer);
689:
690: lpszCLSID=PointerToNthField((LPSTR)szBuffer, 2, '\t');
691: CLSIDFromString(lpszCLSID, &lpOIO->clsid);
692:
693: }
694: else // IOF_SELECTCREATEFROMFILE
695: {
696: if (lpIO->dwFlags & IOF_CHECKDISPLAYASICON)
697: {
698: // get metafile here
699: lpOIO->hMetaPict = (HGLOBAL)SendDlgItemMessage(hDlg,
700: ID_IO_ICONDISPLAY,
701: IBXM_IMAGEGET,
702: 0, 0L);
703:
704:
705: }
706: else
707: lpOIO->hMetaPict = (HGLOBAL)NULL;
708:
709: }
710:
711: GetDlgItemText(hDlg, ID_IO_FILEDISPLAY,
712: lpIO->szFile, lpOIO->cchFile);
713:
714: lstrcpyn(lpOIO->lpszFile, lpIO->szFile, lpOIO->cchFile);
715:
716: SendMessage(hDlg, uMsgEndDialog, OLEUI_OK, 0L);
717: }
718: break;
719:
720: case IDCANCEL:
721: SendMessage(hDlg, uMsgEndDialog, OLEUI_CANCEL, 0L);
722: break;
723:
724: case ID_OLEUIHELP:
725: PostMessage(lpIO->lpOIO->hWndOwner, uMsgHelp
726: , (WPARAM)hDlg, MAKELPARAM(IDD_INSERTOBJECT, 0));
727: break;
728: }
729: break;
730: }
731:
732: return FALSE;
733: }
734:
735:
736:
737:
738: /*
739: * FInsertObjectInit
740: *
741: * Purpose:
742: * WM_INITIDIALOG handler for the Insert Object dialog box.
743: *
744: * Parameters:
745: * hDlg HWND of the dialog
746: * wParam WPARAM of the message
747: * lParam LPARAM of the message
748: *
749: * Return Value:
750: * BOOL Value to return for WM_INITDIALOG.
751: */
752:
753: BOOL FInsertObjectInit(HWND hDlg, WPARAM wParam, LPARAM lParam)
754: {
755: LPOLEUIINSERTOBJECT lpOIO;
756: LPINSERTOBJECT lpIO;
757: RECT rc;
758: DWORD dw;
759: HFONT hFont;
760: HWND hList;
761: UINT u;
762: BOOL fCheck;
763: char *pch;
764:
765: //1. Copy the structure at lParam into our instance memory.
766: lpIO=(LPINSERTOBJECT)LpvStandardInit(hDlg, sizeof(INSERTOBJECT), TRUE, &hFont);
767:
768: //PvStandardInit send a termination to us already.
769: if (NULL==lpIO)
770: return FALSE;
771:
772: lpOIO=(LPOLEUIINSERTOBJECT)lParam;
773:
774: //2. Save the original pointer and copy necessary information.
775: lpIO->lpOIO =lpOIO;
776: lpIO->dwFlags=lpOIO->dwFlags;
777: lpIO->clsid =lpOIO->clsid;
778:
779: if ( (lpOIO->lpszFile) && ('\0' != *lpOIO->lpszFile) )
780: lstrcpyn((LPSTR)lpIO->szFile, lpOIO->lpszFile, OLEUI_CCHPATHMAX);
781: else
782: *(lpIO->szFile) = '\0';
783:
784: lpIO->hMetaPictFile = (HGLOBAL)NULL;
785:
786: //3. If we got a font, send it to the necessary controls.
787: if (NULL!=hFont)
788: {
789: SendDlgItemMessage(hDlg, ID_IO_RESULTTEXT, WM_SETFONT, (WPARAM)hFont, 0L);
790: SendDlgItemMessage(hDlg, ID_IO_FILETYPE, WM_SETFONT, (WPARAM)hFont, 0L);
791: }
792:
793:
794: //4. Fill the Object Type listbox with entries from the reg DB.
795: hList=GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST);
796: UFillClassList(hList, lpOIO->cClsidExclude, lpOIO->lpClsidExclude
797: , (BOOL)(lpOIO->dwFlags & IOF_VERIFYSERVERSEXIST));
798:
799: //Set the tab width in the list to push all the tabs off the side.
800: GetClientRect(hList, &rc);
801: dw=GetDialogBaseUnits();
802: rc.right =(8*rc.right)/LOWORD(dw); //Convert pixels to 2x dlg units.
803: SendMessage(hList, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)&rc.right);
804:
805:
806: //5. Initilize the file name display to cwd if we don't have any name.
807: if ('\0' == *(lpIO->szFile))
808: {
809: pch=_getcwd(NULL, OLEUI_CCHPATHMAX);
810: if (*(pch+lstrlen(pch)-1) != '\\')
811: lstrcat(pch, "\\"); // put slash on end of cwd
812: SetDlgItemText(hDlg, ID_IO_FILEDISPLAY, pch);
813: lpIO->fFileDirty = TRUE; // cwd is not a valid filename
814: #ifndef __TURBOC__
815: free(pch);
816: #endif
817: }
818: else
819: {
820: SetDlgItemText(hDlg, ID_IO_FILEDISPLAY, lpIO->szFile);
821:
822: if (FValidateInsertFile(hDlg, FALSE, &lpIO->nErrCode))
823: lpIO->fFileDirty = FALSE;
824: else
825: lpIO->fFileDirty = TRUE;
826: }
827:
828:
829: //6. Initialize the selected type radiobutton.
830: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
831: {
832: StandardShowDlgItem(hDlg, ID_IO_FILETEXT, SW_HIDE);
833: StandardShowDlgItem(hDlg, ID_IO_FILETYPE, SW_HIDE);
834: StandardShowDlgItem(hDlg, ID_IO_FILEDISPLAY, SW_HIDE);
835: StandardShowDlgItem(hDlg, ID_IO_FILE, SW_HIDE);
836: StandardShowDlgItem(hDlg, ID_IO_LINKFILE, SW_HIDE);
837:
838: CheckRadioButton(hDlg, ID_IO_CREATENEW, ID_IO_CREATEFROMFILE, ID_IO_CREATENEW);
839:
840: lpIO->fAsIconNew=(0L!=(lpIO->dwFlags & IOF_CHECKDISPLAYASICON));
841: SetFocus(hList);
842: }
843: else
844: {
845: /*
846: * Use pszType as the initial File. If there's no initial
847: * file then we have to remove any check from Display As
848: * Icon. We also check Link if so indicated for this option.
849: */
850: StandardShowDlgItem(hDlg, ID_IO_OBJECTTYPELIST, SW_HIDE);
851: StandardShowDlgItem(hDlg, ID_IO_OBJECTTYPETEXT, SW_HIDE);
852:
853: // Don't preselect display as icon if the filename isn't valid
854: if (TRUE == lpIO->fFileDirty)
855: lpIO->dwFlags &= ~(IOF_CHECKDISPLAYASICON);
856:
857: if (IOF_DISABLELINK & lpIO->dwFlags)
858: StandardShowDlgItem(hDlg, ID_IO_LINKFILE, SW_HIDE);
859: else
860: {
861: CheckDlgButton(hDlg, ID_IO_LINKFILE
862: , (BOOL)(0L!=(lpIO->dwFlags & IOF_CHECKLINK)));
863: }
864:
865: CheckRadioButton(hDlg, ID_IO_CREATENEW, ID_IO_CREATEFROMFILE, ID_IO_CREATEFROMFILE);
866:
867: lpIO->fAsIconFile=(0L!=(lpIO->dwFlags & IOF_CHECKDISPLAYASICON));
868: SetFocus(GetDlgItem(hDlg, ID_IO_FILEDISPLAY));
869: }
870:
871:
872: //7. Initialize the Display as Icon state
873: fCheck=(BOOL)(lpIO->dwFlags & IOF_CHECKDISPLAYASICON);
874: u=fCheck ? SW_SHOWNORMAL : SW_HIDE;
875:
876: StandardShowDlgItem(hDlg, ID_IO_CHANGEICON, u);
877: StandardShowDlgItem(hDlg, ID_IO_ICONDISPLAY, u);
878:
879: CheckDlgButton(hDlg, ID_IO_DISPLAYASICON, fCheck);
880:
881:
882: //8. Show or hide the help button
883: if (!(lpIO->dwFlags & IOF_SHOWHELP))
884: StandardShowDlgItem(hDlg, ID_OLEUIHELP, SW_HIDE);
885:
886:
887: //9. Initialize the result display
888: UpdateClassIcon(hDlg, lpIO, GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST));
889: SetInsertObjectResults(hDlg, lpIO);
890:
891: //10. Change the caption
892: if (NULL!=lpOIO->lpszCaption)
893: SetWindowText(hDlg, lpOIO->lpszCaption);
894:
895:
896: //All Done: call the hook with lCustData
897: UStandardHook(lpIO, hDlg, WM_INITDIALOG, wParam, lpOIO->lCustData);
898:
899: /*
900: * We either set focus to the listbox or the edit control. In either
901: * case we don't want Windows to do any SetFocus, so we return FALSE.
902: */
903: return FALSE;
904: }
905:
906:
907:
908:
909:
910:
911: /*
912: * UFillClassList
913: *
914: * Purpose:
915: * Enumerates available OLE object classes from the registration
916: * database and fills a listbox with those names.
917: *
918: * Note that this function removes any prior contents of the listbox.
919: *
920: * Parameters:
921: * hList HWND to the listbox to fill.
922: * cIDEx UINT number of CLSIDs to exclude in lpIDEx
923: * lpIDEx LPCLSID to CLSIDs to leave out of the listbox.
924: * fVerify BOOL indicating if we are to validate existence of
925: * servers before putting them in the list.
926: *
927: * Return Value:
928: * UINT Number of strings added to the listbox, -1 on failure.
929: */
930:
931: UINT UFillClassList(HWND hList, UINT cIDEx, LPCLSID lpIDEx, BOOL fVerify)
932: {
933: DWORD dw;
934: UINT cStrings=0;
935: UINT i;
936: UINT cch;
937: HKEY hKey;
938: LONG lRet;
939: HFILE hFile;
940: OFSTRUCT of;
941: BOOL fExclude;
942: LPMALLOC pIMalloc;
943: LPSTR pszExec;
944: LPSTR pszClass;
945: LPSTR pszKey;
946: LPSTR pszID;
947: CLSID clsid;
948:
949: //Get some work buffers
950: if (NOERROR!=CoGetMalloc(MEMCTX_TASK, &pIMalloc))
951: return (UINT)-1;
952:
953: pszExec=(LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHKEYMAX*4);
954:
955: if (NULL==pszExec)
956: {
957: pIMalloc->lpVtbl->Release(pIMalloc);
958: return (UINT)-1;
959: }
960:
961: pszClass=pszExec+OLEUI_CCHKEYMAX;
962: pszKey=pszClass+OLEUI_CCHKEYMAX;
963: pszID=pszKey+OLEUI_CCHKEYMAX;
964:
965: //Open up the root key.
966: lRet=RegOpenKey(HKEY_CLASSES_ROOT, NULL, &hKey);
967:
968: if ((LONG)ERROR_SUCCESS!=lRet)
969: {
970: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszExec);
971: pIMalloc->lpVtbl->Release(pIMalloc);
972: return (UINT)-1;
973: }
974:
975: //Clean out the existing strings.
976: SendMessage(hList, LB_RESETCONTENT, 0, 0L);
977:
978: cStrings=0;
979:
980: while (TRUE)
981: {
982: lRet=RegEnumKey(hKey, cStrings++, pszClass, OLEUI_CCHKEYMAX);
983:
984: if ((LONG)ERROR_SUCCESS!=lRet)
985: break;
986:
987: //Cheat on lstrcat by using lstrcpy after this string, saving time
988: cch=lstrlen(pszClass);
989:
990: //Check for a \protocol\StdFileEditing\server entry.
991: lstrcpy(pszClass+cch, "\\protocol\\StdFileEditing\\server");
992:
993: dw=OLEUI_CCHKEYMAX;
994: lRet=RegQueryValue(hKey, pszClass, pszKey, &dw);
995:
996: if ((LONG)ERROR_SUCCESS==lRet)
997: {
998: /*
999: * Check if the EXE actually exists. By default we don't do this
1000: * to bring up the dialog faster. If an application wants to be
1001: * stringent, they can provide IOF_VERIFYSERVERSEXIST.
1002: */
1003:
1004: hFile = !HFILE_ERROR;
1005:
1006: if (fVerify)
1007: hFile=OpenFile(pszKey, &of, OF_EXIST);
1008:
1009: if (HFILE_ERROR!=hFile)
1010: {
1011: dw=OLEUI_CCHKEYMAX;
1012: *(pszClass+cch)=0; // set back to rootkey
1013: // Get full user type name
1014: lRet=RegQueryValue(hKey, pszClass, pszKey, &dw);
1015:
1016: if ((LONG)ERROR_SUCCESS!=lRet)
1017: continue; // error getting type name--skip this class
1018:
1019: //Tell the code below to get the string for us.
1020: pszID=NULL;
1021: }
1022: }
1023: else
1024: {
1025: /*
1026: * No \protocol\StdFileEditing\server entry. Look to see if
1027: * there's an Insertable entry. If there is, then use the
1028: * Clsid to look at CLSID\clsid\LocalServer and \InprocServer
1029: */
1030:
1031: lstrcpy(pszClass+cch, "\\Insertable");
1032:
1033: dw=OLEUI_CCHKEYMAX;
1034: lRet=RegQueryValue(hKey, pszClass, pszKey, &dw);
1035:
1036: if ((LONG)ERROR_SUCCESS!=lRet)
1037: continue; // Insertable NOT found--skip this class
1038:
1039: //Get memory for pszID
1040: pszID=pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHKEYMAX);
1041:
1042: if (NULL==pszID)
1043: continue;
1044:
1045: *(pszClass+cch)=0; // set back to rootkey
1046: lstrcat(pszClass+cch, "\\CLSID");
1047:
1048: dw=OLEUI_CCHKEYMAX;
1049: lRet=RegQueryValue(hKey, pszClass, pszID, &dw);
1050:
1051: if ((LONG)ERROR_SUCCESS!=lRet)
1052: continue; // CLSID subkey not found
1053:
1054: lstrcpy(pszExec, "CLSID\\");
1055: lstrcat(pszExec, pszID);
1056:
1057: //CLSID\ is 6, dw contains pszID length.
1058: cch=6+(UINT)dw;
1059:
1060: lstrcpy(pszExec+cch, "\\LocalServer");
1061: dw=OLEUI_CCHKEYMAX;
1062: lRet=RegQueryValue(hKey, pszExec, pszKey, &dw);
1063:
1064: if ((LONG)ERROR_SUCCESS!=lRet)
1065: {
1066: //Try InprocServer
1067: lstrcpy(pszExec+cch, "\\InProcServer");
1068: dw=OLEUI_CCHKEYMAX;
1069: lRet=RegQueryValue(hKey, pszExec, pszKey, &dw);
1070:
1071: if ((LONG)ERROR_SUCCESS!=lRet)
1072: continue;
1073: }
1074:
1075: if (fVerify)
1076: {
1077: if (HFILE_ERROR==OpenFile(pszKey, &of, OF_EXIST))
1078: continue;
1079: }
1080:
1081: dw=OLEUI_CCHKEYMAX;
1082: lRet=RegQueryValue(hKey, pszExec, pszKey, &dw);
1083: *(pszExec+cch)=0; //Remove \\*Server
1084:
1085: if ((LONG)ERROR_SUCCESS!=lRet)
1086: continue;
1087: }
1088:
1089: //Get CLSID to add to listbox.
1090: if (NULL==pszID)
1091: {
1092: CLSIDFromProgID(pszClass, &clsid);
1093: StringFromCLSID(&clsid, &pszID);
1094: }
1095: else
1096: CLSIDFromString(pszID, &clsid);
1097:
1098: //Check if this CLSID is in the exclusion list.
1099: fExclude=FALSE;
1100:
1101: for (i=0; i < cIDEx; i++)
1102: {
1103: if (IsEqualCLSID(&clsid, (LPCLSID)(lpIDEx+i)))
1104: {
1105: fExclude=TRUE;
1106: break;
1107: }
1108: }
1109:
1110: if (fExclude)
1111: continue;
1112:
1113: //We go through all the conditions, add the string.
1114: lstrcat(pszKey, "\t");
1115: lstrcat(pszKey, pszID);
1116: SendMessage(hList, LB_ADDSTRING, 0, (LPARAM)pszKey);
1117:
1118: //We always allocated this regardless of the path
1119: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszID);
1120: }
1121:
1122:
1123: //Select the first item by default
1124: SendMessage(hList, LB_SETCURSEL, 0, 0L);
1125: RegCloseKey(hKey);
1126:
1127: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszExec);
1128: pIMalloc->lpVtbl->Release(pIMalloc);
1129:
1130: return cStrings;
1131: }
1132:
1133:
1134:
1135:
1136:
1137: /*
1138: * FToggleObjectSource
1139: *
1140: * Purpose:
1141: * Handles enabling, disabling, showing, and flag manipulation when the
1142: * user changes between Create New, Insert File, and Link File in the
1143: * Insert Object dialog.
1144: *
1145: * Parameters:
1146: * hDlg HWND of the dialog
1147: * lpIO LPINSERTOBJECT pointing to the dialog structure
1148: * dwOption DWORD flag indicating the option just selected:
1149: * IOF_SELECTCREATENEW or IOF_SELECTCREATEFROMFILE
1150: *
1151: * Return Value:
1152: * BOOL TRUE if the option was already selected, FALSE otherwise.
1153: */
1154:
1155: BOOL FToggleObjectSource(HWND hDlg, LPINSERTOBJECT lpIO, DWORD dwOption)
1156: {
1157: BOOL fTemp;
1158: UINT uTemp;
1159: DWORD dwTemp;
1160: int i;
1161:
1162: //Skip all of this if we're already selected.
1163: if (lpIO->dwFlags & dwOption)
1164: return TRUE;
1165:
1166:
1167: // if we're switching from "from file" to "create new" and we've got
1168: // an icon for "from file", then we need to save it so that we can
1169: // show it if the user reselects "from file".
1170:
1171: if ( (IOF_SELECTCREATENEW == dwOption) &&
1172: (lpIO->dwFlags & IOF_CHECKDISPLAYASICON) )
1173: lpIO->hMetaPictFile = (HGLOBAL)SendDlgItemMessage(hDlg, ID_IO_ICONDISPLAY, IBXM_IMAGEGET, 0, 0L);
1174:
1175: /*
1176: * 1. Change the Display As Icon checked state to reflect the
1177: * selection for this option, stored in the fAsIcon* flags.
1178: */
1179: fTemp=(IOF_SELECTCREATENEW==dwOption) ? lpIO->fAsIconNew : lpIO->fAsIconFile;
1180:
1181: if (fTemp)
1182: lpIO->dwFlags |=IOF_CHECKDISPLAYASICON;
1183: else
1184: lpIO->dwFlags &=~IOF_CHECKDISPLAYASICON;
1185:
1186: CheckDlgButton(hDlg, ID_IO_DISPLAYASICON
1187: , (BOOL)(0L!=(lpIO->dwFlags & IOF_CHECKDISPLAYASICON)));
1188:
1189: EnableWindow(GetDlgItem(hDlg, ID_IO_CHANGEICON), fTemp);
1190:
1191: /*
1192: * 2. Display Icon: Enabled on Create New or on Create from File if
1193: * there is a selected file.
1194: */
1195: fTemp=(IOF_SELECTCREATENEW==dwOption) ? TRUE : lpIO->fFileSelected;
1196: EnableWindow(GetDlgItem(hDlg, ID_IO_DISPLAYASICON), fTemp);
1197:
1198: //OK and Link follow the same enabling as Display As Icon.
1199: EnableWindow(GetDlgItem(hDlg, IDOK), fTemp);
1200: EnableWindow(GetDlgItem(hDlg, ID_IO_LINKFILE), fTemp);
1201:
1202: //3. Enable Browse... when Create from File is selected.
1203: fTemp=(IOF_SELECTCREATENEW==dwOption);
1204: EnableWindow(GetDlgItem(hDlg, ID_IO_FILE), !fTemp);
1205: EnableWindow(GetDlgItem(hDlg, ID_IO_FILEDISPLAY), !fTemp);
1206:
1207: /*
1208: * 4. Switch between Object Type listbox on Create New and
1209: * file buttons on others.
1210: */
1211: uTemp=(fTemp) ? SW_SHOWNORMAL : SW_HIDE;
1212: StandardShowDlgItem(hDlg, ID_IO_OBJECTTYPELIST, uTemp);
1213: StandardShowDlgItem(hDlg, ID_IO_OBJECTTYPETEXT, uTemp);
1214:
1215: uTemp=(fTemp) ? SW_HIDE : SW_SHOWNORMAL;
1216: StandardShowDlgItem(hDlg, ID_IO_FILETEXT, uTemp);
1217: StandardShowDlgItem(hDlg, ID_IO_FILETYPE, uTemp);
1218: StandardShowDlgItem(hDlg, ID_IO_FILEDISPLAY, uTemp);
1219: StandardShowDlgItem(hDlg, ID_IO_FILE, uTemp);
1220:
1221: //Link is always hidden if IOF_DISABLELINK is set.
1222: if (IOF_DISABLELINK & lpIO->dwFlags)
1223: uTemp=SW_HIDE;
1224:
1225: StandardShowDlgItem(hDlg, ID_IO_LINKFILE, uTemp); //last use of uTemp
1226:
1227:
1228: //5. Clear out existing any flags selection and set the new one
1229: dwTemp=IOF_SELECTCREATENEW | IOF_SELECTCREATEFROMFILE;
1230: lpIO->dwFlags=(lpIO->dwFlags & ~dwTemp) | dwOption;
1231:
1232:
1233: /*
1234: * Show or hide controls as appropriate. Do the icon
1235: * display last because it will take some time to repaint.
1236: * If we do it first then the dialog looks too sluggish.
1237: */
1238:
1239: i=(lpIO->dwFlags & IOF_CHECKDISPLAYASICON) ? SW_SHOWNORMAL : SW_HIDE;
1240: StandardShowDlgItem(hDlg, ID_IO_CHANGEICON, i);
1241: StandardShowDlgItem(hDlg, ID_IO_ICONDISPLAY, i);
1242:
1243:
1244: //6.Change result display
1245: SetInsertObjectResults(hDlg, lpIO);
1246:
1247: /*
1248: * 7. For Create New, twiddle the listbox to think we selected it
1249: * so it updates the icon from the object type.
1250: *
1251: * For Insert or Link file, set the focus to the filename button
1252: * and update the icon if necessary.
1253: */
1254: if (fTemp)
1255: UpdateClassIcon(hDlg, lpIO, GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST));
1256:
1257: else
1258: {
1259: if (lpIO->fAsIconFile && (NULL != lpIO->hMetaPictFile) )
1260: {
1261: SendDlgItemMessage(hDlg, ID_IO_ICONDISPLAY, IBXM_IMAGESET, (WPARAM)lpIO->hMetaPictFile, 0L);
1262: lpIO->hMetaPictFile = 0;
1263: }
1264: else
1265: UpdateClassIcon(hDlg, lpIO, NULL);
1266:
1267: SetFocus(GetDlgItem(hDlg, ID_IO_FILE));
1268: }
1269:
1270: return FALSE;
1271: }
1272:
1273:
1274: /*
1275: * UpdateClassType
1276: *
1277: * Purpose:
1278: * Updates static text control to reflect current file type. Assumes
1279: * a valid filename.
1280: *
1281: * Parameters
1282: * hDlg HWND of the dialog box.
1283: * lpIO LPINSERTOBJECT pointing to the dialog structure
1284: * fSet TRUE to set the text, FALSE to explicitly clear it
1285: *
1286: * Return Value:
1287: * None
1288: */
1289:
1290: void UpdateClassType(HWND hDlg, LPINSERTOBJECT lpIO, BOOL fSet)
1291: {
1292:
1293: CLSID clsid;
1294: char szFileName[OLEUI_CCHPATHMAX];
1295: char szFileType[OLEUI_CCHLABELMAX];
1296:
1297: *szFileType = '\0';
1298:
1299: if (fSet)
1300: {
1301: GetDlgItemText(hDlg, ID_IO_FILEDISPLAY, (LPSTR)szFileName, OLEUI_CCHPATHMAX);
1302:
1303: if (NOERROR == GetClassFile((LPSTR)szFileName, &clsid) )
1304: OleStdGetUserTypeOfClass(&clsid, szFileType, OLEUI_CCHLABELMAX, NULL);
1305:
1306: }
1307:
1308: SetDlgItemText(hDlg, ID_IO_FILETYPE, (LPSTR)szFileType);
1309:
1310: return;
1311: }
1312:
1313:
1314: /*
1315: * UpdateClassIcon
1316: *
1317: * Purpose:
1318: * Handles LBN_SELCHANGE for the Object Type listbox. On a selection
1319: * change, we extract an icon from the server handling the currently
1320: * selected object type using the utility function HIconFromClass.
1321: * Note that we depend on the behavior of FillClassList to stuff the
1322: * object class after a tab in the listbox string that we hide from
1323: * view (see WM_INITDIALOG).
1324: *
1325: * Parameters
1326: * hDlg HWND of the dialog box.
1327: * lpIO LPINSERTOBJECT pointing to the dialog structure
1328: * hList HWND of the Object Type listbox.
1329: *
1330: * Return Value:
1331: * None
1332: */
1333:
1334: void UpdateClassIcon(HWND hDlg, LPINSERTOBJECT lpIO, HWND hList)
1335: {
1336: UINT iSel;
1337: DWORD cb;
1338: LPMALLOC pIMalloc;
1339: LPSTR pszName, pszCLSID, pszTemp;
1340: HGLOBAL hMetaPict;
1341:
1342: LRESULT dwRet;
1343:
1344:
1345: //If Display as Icon is not selected, exit
1346: if (!(lpIO->dwFlags & IOF_CHECKDISPLAYASICON))
1347: return;
1348:
1349: /*
1350: * When we change object type selection, get the new icon for that
1351: * type into our structure and update it in the display. We use the
1352: * class in the listbox when Create New is selected or the association
1353: * with the extension in Create From File.
1354: */
1355:
1356: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
1357: {
1358: iSel=(UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L);
1359:
1360: if (LB_ERR==(int)iSel)
1361: return;
1362:
1363: //Check to see if we've already got the hMetaPict for this item
1364: dwRet=SendMessage(hList, LB_GETITEMDATA, (WPARAM)iSel, 0L);
1365:
1366: hMetaPict=(HGLOBAL)(UINT)dwRet;
1367:
1368: if (hMetaPict)
1369: {
1370: //Yep, we've already got it, so just display it and return.
1371: SendDlgItemMessage(hDlg, ID_IO_ICONDISPLAY, IBXM_IMAGESET, (WPARAM)hMetaPict, 0L);
1372: return;
1373: }
1374:
1375: iSel=(UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L);
1376:
1377: if (LB_ERR==(int)iSel)
1378: return;
1379:
1380: //Allocate a string to hold the entire listbox string
1381: cb=SendMessage(hList, LB_GETTEXTLEN, iSel, 0L);
1382: }
1383: else
1384: cb=OLEUI_CCHPATHMAX;
1385:
1386: if (NOERROR!=CoGetMalloc(MEMCTX_TASK, &pIMalloc))
1387: return;
1388:
1389: pszName=(LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, cb+1);
1390:
1391: if (NULL==pszName)
1392: {
1393: pIMalloc->lpVtbl->Release(pIMalloc);
1394: return;
1395: }
1396:
1397: *pszName=0;
1398:
1399: //Get the clsid we want.
1400: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
1401: {
1402: //Grab the classname string from the list
1403: SendMessage(hList, LB_GETTEXT, iSel, (LONG)pszName);
1404:
1405: //Set pointer to CLSID (string)
1406: pszCLSID=PointerToNthField(pszName, 2, '\t');
1407:
1408: //Null terminate pszName string
1409: pszTemp=AnsiPrev(pszName, pszCLSID);
1410:
1411: *pszTemp='\0';
1412: CLSIDFromString(pszCLSID, &lpIO->clsid);
1413:
1414: hMetaPict = GetIconOfClass(ghInst, &lpIO->clsid, NULL, TRUE);
1415: }
1416:
1417: else
1418: {
1419: //Get the class from the filename
1420: GetDlgItemText(hDlg, ID_IO_FILEDISPLAY, pszName, OLEUI_CCHPATHMAX);
1421:
1422: hMetaPict = GetIconOfFile(ghInst,
1423: pszName,
1424: lpIO->dwFlags & IOF_CHECKLINK ? TRUE : FALSE);
1425: }
1426:
1427:
1428: //Replace the current display with this new one.
1429: SendDlgItemMessage(hDlg, ID_IO_ICONDISPLAY, IBXM_IMAGESET, (WPARAM)hMetaPict, 0L);
1430:
1431: //Enable or disable "Change Icon" button depending on whether
1432: //we've got a valid filename or not.
1433: EnableWindow(GetDlgItem(hDlg, ID_IO_CHANGEICON), hMetaPict ? TRUE : FALSE);
1434:
1435: //Save the hMetaPict so that we won't have to re-create
1436: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
1437: SendMessage(hList, LB_SETITEMDATA, (WPARAM)iSel, MAKELPARAM(hMetaPict,0));
1438:
1439: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszName);
1440: pIMalloc->lpVtbl->Release(pIMalloc);
1441: return;
1442: }
1443:
1444:
1445:
1446:
1447: /*
1448: * SetInsertObjectResults
1449: *
1450: * Purpose:
1451: * Centralizes setting of the Result and icon displays in the Insert Object
1452: * dialog. Handles loading the appropriate string from the module's
1453: * resources and setting the text, displaying the proper result picture,
1454: * and showing the proper icon.
1455: *
1456: * Parameters:
1457: * hDlg HWND of the dialog box so we can access controls.
1458: * lpIO LPINSERTOBJECT in which we assume that the
1459: * current radiobutton and Display as Icon selections
1460: * are set. We use the state of those variables to
1461: * determine which string we use.
1462: *
1463: * Return Value:
1464: * None
1465: */
1466:
1467: void SetInsertObjectResults(HWND hDlg, LPINSERTOBJECT lpIO)
1468: {
1469: LPSTR pszT, psz1, psz2, psz3, psz4, pszTemp;
1470: UINT i, iString1, iString2, iImage, cch;
1471: LPMALLOC pIMalloc;
1472: BOOL fAsIcon;
1473:
1474: /*
1475: * We need scratch memory for loading the stringtable string, loading
1476: * the object type from the listbox, and constructing the final string.
1477: * We therefore allocate three buffers as large as the maximum message
1478: * length (512) plus the object type, guaranteeing that we have enough
1479: * in all cases.
1480: */
1481: i=(UINT)SendDlgItemMessage(hDlg, ID_IO_OBJECTTYPELIST, LB_GETCURSEL, 0, 0L);
1482: cch=512+(UINT)SendDlgItemMessage(hDlg, ID_IO_OBJECTTYPELIST, LB_GETTEXTLEN, i, 0L);
1483:
1484: if (NOERROR!=CoGetMalloc(MEMCTX_TASK, &pIMalloc))
1485: return;
1486:
1487: pszTemp=(LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, (DWORD)(4*cch));
1488:
1489: if (NULL==pszTemp)
1490: {
1491: pIMalloc->lpVtbl->Release(pIMalloc);
1492: return;
1493: }
1494:
1495: psz1=pszTemp;
1496: psz2=psz1+cch;
1497: psz3=psz2+cch;
1498: psz4=psz3+cch;
1499:
1500: fAsIcon=(0L!=(lpIO->dwFlags & IOF_CHECKDISPLAYASICON));
1501:
1502: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
1503: {
1504: iString1 = fAsIcon ? IDS_IORESULTNEWICON : IDS_IORESULTNEW;
1505: iString2 = 0;
1506: iImage = fAsIcon ? RESULTIMAGE_EMBEDICON : RESULTIMAGE_EMBED;
1507: }
1508:
1509: if (lpIO->dwFlags & IOF_SELECTCREATEFROMFILE)
1510: {
1511: //Pay attention to Link checkbox
1512: if (lpIO->dwFlags & IOF_CHECKLINK)
1513: {
1514: iString1 = fAsIcon ? IDS_IORESULTLINKFILEICON1 : IDS_IORESULTLINKFILE1;
1515: iString2 = fAsIcon ? IDS_IORESULTLINKFILEICON2 : IDS_IORESULTLINKFILE2;
1516: iImage =fAsIcon ? RESULTIMAGE_LINKICON : RESULTIMAGE_LINK;
1517: }
1518: else
1519: {
1520: iString1 = IDS_IORESULTFROMFILE1;
1521: iString2 = fAsIcon ? IDS_IORESULTFROMFILEICON2 : IDS_IORESULTFROMFILE2;
1522: iImage =fAsIcon ? RESULTIMAGE_EMBEDICON : RESULTIMAGE_EMBED;
1523: }
1524: }
1525:
1526: //Default is an empty string.
1527: *psz1=0;
1528:
1529: if (0!=LoadString(ghInst, iString1, psz1, cch))
1530: {
1531:
1532: // Load second string, if necessary
1533: if ( (0 != iString2)
1534: && (0 != LoadString(ghInst, iString2, psz4, cch)) )
1535: {
1536: lstrcat(psz1, psz4); // concatenate strings together.
1537: }
1538:
1539:
1540:
1541: //In Create New, do the extra step of inserting the object type string
1542: if (lpIO->dwFlags & IOF_SELECTCREATENEW)
1543: {
1544: SendDlgItemMessage(hDlg, ID_IO_OBJECTTYPELIST, LB_GETTEXT
1545: , i, (LONG)psz2);
1546:
1547: //Null terminate at any tab (before the classname)
1548: pszT=psz2;
1549: while ('\t'!=*pszT && 0!=*pszT)
1550: pszT++;
1551: *pszT=0;
1552:
1553: //Build the string and point psz1 to it.
1554: wsprintf(psz3, psz1, psz2);
1555: psz1=psz3;
1556: }
1557: }
1558:
1559: //If LoadString failed, we simply clear out the results (*psz1=0 above)
1560: SetDlgItemText(hDlg, ID_IO_RESULTTEXT, psz1);
1561:
1562: //Go change the image and Presto! There you have it.
1563: SendDlgItemMessage(hDlg, ID_IO_RESULTIMAGE, RIM_IMAGESET, iImage, 0L);
1564:
1565: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszTemp);
1566: pIMalloc->lpVtbl->Release(pIMalloc);
1567: return;
1568: }
1569:
1570:
1571:
1572: /*
1573: * FValidateInsertFile
1574: *
1575: * Purpose:
1576: * Given a possibly partial pathname from the file edit control,
1577: * attempt to locate the file and if found, store the full path
1578: * in the edit control ID_IO_FILEDISPLAY.
1579: *
1580: * Parameters:
1581: * hDlg HWND of the dialog box.
1582: * fTellUser BOOL TRUE if function should tell user, FALSE if
1583: * function should validate silently.
1584: *
1585: * Return Value:
1586: * BOOL TRUE if the file is acceptable, FALSE otherwise.
1587: */
1588:
1589: BOOL FValidateInsertFile(HWND hDlg, BOOL fTellUser, UINT FAR* lpnErrCode)
1590: {
1591: OFSTRUCT of;
1592: HFILE hFile;
1593: char szFile[OLEUI_CCHPATHMAX];
1594:
1595: *lpnErrCode = 0;
1596: /*
1597: * To validate we attempt OpenFile on the string. If OpenFile
1598: * fails then we display an error. If not, OpenFile will store
1599: * the complete path to that file in the OFSTRUCT which we can
1600: * then stuff in the edit control.
1601: */
1602:
1603: if (0==GetDlgItemText(hDlg, ID_IO_FILEDISPLAY, szFile, sizeof(szFile)))
1604: return FALSE; // #4569 : return FALSE when there is no text in ctl
1605:
1606: hFile=OpenFile(szFile, &of, OF_EXIST);
1607:
1608: // if file is currently open (ie. sharing violation) OleCreateFromFile
1609: // and OleCreateLinkToFile can still succeed; do not consider it an
1610: // error.
1611: if (HFILE_ERROR==hFile && 0x0020/*sharing violation*/!=of.nErrCode)
1612: {
1613: *lpnErrCode = of.nErrCode;
1614: if (fTellUser)
1615: OpenFileError(hDlg, of.nErrCode, szFile);
1616: return FALSE;
1617: }
1618:
1619: //OFSTRUCT contains an OEM name, not ANSI as we need for the edit box.
1620: OemToAnsi(of.szPathName, of.szPathName);
1621: SetDlgItemText(hDlg, ID_IO_FILEDISPLAY, of.szPathName);
1622: return TRUE;
1623: }
1624:
1625:
1626: /*
1627: * InsertObjectCleanup
1628: *
1629: * Purpose:
1630: * Clears cached icon metafiles from those stored in the listbox.
1631: *
1632: * Parameters:
1633: * hDlg HWND of the dialog.
1634: *
1635: * Return Value:
1636: * None
1637: */
1638:
1639: void InsertObjectCleanup(HWND hDlg)
1640: {
1641: HWND hList;
1642: UINT iItems;
1643: HGLOBAL hMetaPict;
1644: LRESULT dwRet;
1645: UINT i;
1646:
1647: hList=GetDlgItem(hDlg, ID_IO_OBJECTTYPELIST);
1648: iItems=(UINT)SendMessage(hList, LB_GETCOUNT, 0, 0L);
1649:
1650: for (i=0; i < iItems; i++)
1651: {
1652: dwRet=SendMessage(hList, LB_GETITEMDATA, (WPARAM)i, 0L);
1653:
1654: //Cast of LRESULT to UINT to HGLOBAL portable to Win32.
1655: hMetaPict=(HGLOBAL)(UINT)dwRet;
1656:
1657: if (hMetaPict)
1658: OleUIMetafilePictIconFree(hMetaPict);
1659: }
1660:
1661: return;
1662: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.