![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to convert.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 convert.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * CONVERT.C
3: *
4: * Implements the OleUIConvert function which invokes the complete
5: * Convert dialog.
6: *
7: * Copyright (c)1992 Microsoft Corporation, All Right Reserved
8: */
9:
10: #define STRICT 1
11: #include "ole2ui.h"
12: #include <stdlib.h>
13: #include "common.h"
14: #include "utility.h"
15: #include "geticon.h"
16: #include "regdb.h"
17: #include "convert.h"
18:
19: #define CF_CLIPBOARDMIN 0xc000
20: #define CF_CLIPBOARDMAX 0xffff
21:
22: #define AUXUSERTYPE_SHORTNAME USERCLASSTYPE_SHORT // short name
23:
24: static char szOLE2DLL[] = "ole2.dll"; // name of OLE 2.0 library
25: static char szVanillaDocIcon[] = "DefIcon";
26:
27: /*
28: * OleUIConvert
29: *
30: * Purpose:
31: * Invokes the standard OLE Change Type dialog box allowing the user
32: * to change the type of the single specified object, or change the
33: * type of all OLE objects of a specified type.
34: *
35: * Parameters:
36: * lpCV LPOLEUICONVERT pointing to the in-out structure
37: * for this dialog.
38: *
39: * Return Value:
40: * UINT One of the following codes, indicating success or error:
41: * OLEUI_SUCCESS Success
42: * OLEUI_ERR_STRUCTSIZE The dwStructSize value is wrong
43: */
44:
45: STDAPI_(UINT) OleUIConvert(LPOLEUICONVERT lpCV)
46: {
47: UINT uRet;
48: HGLOBAL hMemDlg=NULL;
49:
50: uRet=UStandardValidation((LPOLEUISTANDARD)lpCV, sizeof(OLEUICONVERT)
51: , &hMemDlg);
52:
53: if (OLEUI_SUCCESS!=uRet)
54: return uRet;
55:
56: // Validate structure members passed in.
57:
58: if (!IsValidClassID(lpCV->clsid))
59: uRet = OLEUI_CTERR_CLASSIDINVALID;
60:
61: if ( (lpCV->dwFlags & CF_SETCONVERTDEFAULT)
62: && (!IsValidClassID(lpCV->clsidConvertDefault)) )
63: uRet = OLEUI_CTERR_CLASSIDINVALID;
64:
65: if ( (lpCV->dwFlags & CF_SETACTIVATEDEFAULT)
66: && (!IsValidClassID(lpCV->clsidActivateDefault)) )
67: uRet = OLEUI_CTERR_CLASSIDINVALID;
68:
69: if ( (lpCV->dvAspect != DVASPECT_ICON)
70: && (lpCV->dvAspect != DVASPECT_CONTENT) )
71: uRet = OLEUI_CTERR_DVASPECTINVALID;
72:
73: if ( (lpCV->wFormat >= CF_CLIPBOARDMIN)
74: && (lpCV->wFormat <= CF_CLIPBOARDMAX) )
75: {
76: char szTemp[8];
77:
78: if (0 == GetClipboardFormatName(lpCV->wFormat, (LPSTR)szTemp, 8))
79: uRet = OLEUI_CTERR_CBFORMATINVALID;
80: }
81:
82:
83: if ( (NULL != lpCV->lpszUserType)
84: && (IsBadReadPtr(lpCV->lpszUserType, 1)) )
85: uRet = OLEUI_CTERR_STRINGINVALID;
86:
87:
88: if (OLEUI_ERR_STANDARDMIN <= uRet)
89: {
90: if (NULL!=hMemDlg)
91: FreeResource(hMemDlg);
92:
93: return uRet;
94: }
95:
96: //Now that we've validated everything, we can invoke the dialog.
97: uRet=UStandardInvocation(ConvertDialogProc, (LPOLEUISTANDARD)lpCV,
98: hMemDlg, MAKEINTRESOURCE(IDD_CONVERT));
99:
100: return uRet;
101: }
102:
103:
104:
105:
106:
107: /*
108: * ConvertDialogProc
109: *
110: * Purpose:
111: * Implements the OLE Convert dialog as invoked through the
112: * OleUIConvert function.
113: *
114: * Parameters:
115: * Standard
116: *
117: * Return Value:
118: * Standard
119: *
120: */
121:
122: BOOL CALLBACK EXPORT ConvertDialogProc(HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
123: {
124: LPCONVERT lpCV;
125: UINT uRet = 0;
126: OLEUICHANGEICON ci;
127:
128: //Declare Win16/Win32 compatible WM_COMMAND parameters.
129: COMMANDPARAMS(wID, wCode, hWndMsg);
130:
131: //This will fail under WM_INITDIALOG, where we allocate it.
132: lpCV=(LPCONVERT)LpvStandardEntry(hDlg, iMsg, wParam, lParam, (UINT FAR *)&uRet);
133:
134: //If the hook processed the message, we're done.
135: if (0!=uRet)
136: return (BOOL)uRet;
137:
138: //Process the temination message
139: if (iMsg==uMsgEndDialog)
140: {
141: ConvertCleanup(hDlg, lpCV);
142: StandardCleanup(lpCV, hDlg);
143: EndDialog(hDlg, wParam);
144: return TRUE;
145: }
146:
147: // Process help message from Change Icon
148: if (iMsg == uMsgHelp)
149: {
150:
151: PostMessage(lpCV->lpOCV->hWndOwner, uMsgHelp, wParam, lParam);
152: return FALSE;
153:
154: }
155:
156: switch (iMsg)
157: {
158: case WM_INITDIALOG:
159: FConvertInit(hDlg, wParam, lParam);
160: return TRUE;
161:
162: case WM_COMMAND:
163: switch (wID)
164: {
165: case IDCV_ACTIVATELIST:
166: case IDCV_CONVERTLIST:
167: switch (wCode)
168: {
169: case LBN_SELCHANGE:
170:
171: // Change "Results" window to reflect current selection
172: SetConvertResults(hDlg, lpCV);
173:
174: // Update the icon we display, if we are indeed
175: // displaying an icon.
176: if ( (lpCV->dwFlags & CF_SELECTCONVERTTO)
177: && (lpCV->dvAspect == DVASPECT_ICON)
178: && (!lpCV->fCustomIcon) )
179: UpdateCVClassIcon(hDlg, lpCV, hWndMsg);
180:
181: break;
182:
183: case LBN_DBLCLK:
184: //Same as pressing OK.
185: SendCommand(hDlg, IDOK, BN_CLICKED, hWndMsg);
186: break;
187: }
188: break;
189:
190: case IDCV_CONVERTTO:
191: case IDCV_ACTIVATEAS:
192: {
193: HWND hList, hListInvisible;
194: LRESULT lRetVal;
195: BOOL fState;
196:
197: hList = lpCV->hListVisible;
198: hListInvisible = lpCV->hListInvisible;
199:
200:
201: if (IDCV_CONVERTTO == wParam)
202: {
203:
204: // User just click on the button again - it was
205: // already selected.
206: if (lpCV->dwFlags & CF_SELECTCONVERTTO)
207: break;
208:
209:
210: // Turn painting updates off.
211: SendMessage(hDlg, WM_SETREDRAW, FALSE, 0L);
212:
213:
214: // If we're working with a linked object, don't
215: // add the activate list - just the object's
216: // class should appear in the listbox.
217:
218: SwapWindows(hDlg,
219: hList,
220: hListInvisible);
221:
222: lpCV->hListVisible = hListInvisible;
223: lpCV->hListInvisible = hList;
224:
225: EnableWindow(lpCV->hListInvisible, FALSE);
226: EnableWindow(lpCV->hListVisible, TRUE);
227:
228: // Update our flags.
229: lpCV->dwFlags &= ~CF_SELECTACTIVATEAS;
230: lpCV->dwFlags |= CF_SELECTCONVERTTO;
231:
232: }
233: else
234: {
235: if (lpCV->dwFlags & CF_SELECTACTIVATEAS)
236: break;
237:
238: // Turn painting updates off.
239: SendMessage(hDlg, WM_SETREDRAW, FALSE, 0L);
240:
241: SwapWindows(hDlg,
242: hList,
243: hListInvisible);
244:
245: lpCV->hListVisible = hListInvisible;
246: lpCV->hListInvisible = hList;
247:
248: EnableWindow(lpCV->hListInvisible, FALSE);
249: EnableWindow(lpCV->hListVisible, TRUE);
250:
251:
252: // Update our flags.
253: lpCV->dwFlags |= CF_SELECTACTIVATEAS;
254: lpCV->dwFlags &= ~CF_SELECTCONVERTTO;
255: }
256:
257:
258: if (lpCV->dwFlags & CF_SELECTCONVERTTO)
259: lRetVal = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)lpCV->lpszConvertDefault);
260:
261: else
262: lRetVal = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)lpCV->lpszActivateDefault);
263:
264: if (LB_ERR == lRetVal)
265: {
266: char szCurrentObject[40];
267:
268: GetDlgItemText(hDlg, IDCV_OBJECTTYPE, (LPSTR)szCurrentObject, 40);
269: SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)(LPSTR)szCurrentObject);
270: }
271:
272: // Turn updates back on.
273: SendMessage(hDlg, WM_SETREDRAW, TRUE, 0L);
274:
275: InvalidateRect(lpCV->hListVisible, NULL, TRUE);
276: UpdateWindow(lpCV->hListVisible);
277:
278: if ((lpCV->dvAspect & DVASPECT_ICON) && (lpCV->dwFlags & CF_SELECTCONVERTTO))
279: UpdateCVClassIcon(hDlg, lpCV, lpCV->hListVisible);
280:
281: // Hide the icon stuff when Activate is selected...show
282: // it again when Convert is selected.
283:
284: fState = (lpCV->dwFlags & CF_SELECTACTIVATEAS) ? SW_HIDE : SW_SHOW;
285:
286: StandardShowDlgItem(hDlg, IDCV_DISPLAYASICON, fState);
287: StandardShowDlgItem(hDlg, IDCV_CHANGEICON, fState);
288:
289: // Only display the icon if convert is selected AND display
290: // as icon is checked.
291: if ((SW_SHOW == fState) && (DVASPECT_ICON != lpCV->dvAspect))
292: fState = SW_HIDE;
293:
294: StandardShowDlgItem(hDlg, IDCV_ICON, fState);
295: StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, fState);
296: StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, fState);
297:
298: SetConvertResults(hDlg, lpCV);
299:
300: }
301: break;
302:
303:
304: case IDOK:
305: {
306:
307: WORD iCurSel;
308: LPSTR lpszCLSID;
309: char szBuffer[256];
310:
311: // Set OUT parameters
312:
313: //
314: // Set output flags to current ones
315: //
316: lpCV->lpOCV->dwFlags = lpCV->dwFlags;
317:
318:
319: // Update the dvAspect and fObjectsIconChanged members
320: // as appropriate.
321: //
322: if (lpCV->dwFlags & CF_SELECTACTIVATEAS)
323: {
324: // DON'T update aspect if activate as was selected.
325: lpCV->lpOCV->fObjectsIconChanged = FALSE;
326: }
327: else
328: lpCV->lpOCV->dvAspect = lpCV->dvAspect;
329:
330:
331: //
332: // Get the new clsid
333: //
334: iCurSel = (WORD)SendMessage(lpCV->hListVisible, LB_GETCURSEL, 0, 0);
335: SendMessage(lpCV->hListVisible, LB_GETTEXT, iCurSel, (LPARAM)(LPSTR)szBuffer);
336:
337: lpszCLSID = PointerToNthField((LPSTR)szBuffer, 2, '\t');
338:
339: CLSIDFromString(lpszCLSID, (LPCLSID)(&(lpCV->lpOCV->clsidNew)));
340:
341:
342:
343: // Free the hMetaPict we got in.
344: OleUIMetafilePictIconFree(lpCV->lpOCV->hMetaPict);
345:
346: //
347: // Get the hMetaPict (if display as icon is checked)
348: //
349: if (DVASPECT_ICON == lpCV->dvAspect)
350: {
351: HICON hIcon;
352: char szLabel[OLEUI_CCHLABELMAX];
353: int Index;
354:
355:
356: // Create the hMetaPict here from icon, label,
357: // index, and path
358:
359: hIcon = (HICON)SendDlgItemMessage(hDlg, IDCV_ICON, STM_GETICON, 0, 0L);
360:
361: // the combined length of the 2 label lines won't ever be more than
362: // OLEUI_CCHLABELMAX.
363: Index = (int)SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_GETTEXT, OLEUI_CCHLABELMAX, (LPARAM)(LPSTR)szLabel);
364:
365: if (Index < OLEUI_CCHLABELMAX)
366: {
367: LPSTR lpszSecondLine = szLabel + Index;
368:
369:
370: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_GETTEXT,
371: OLEUI_CCHLABELMAX-Index,
372: (LPARAM)(LPSTR)lpszSecondLine);
373: }
374: lpCV->lpOCV->hMetaPict =
375: OleUIMetafilePictFromIconAndLabel(hIcon,
376: (LPSTR)szLabel,
377: lpCV->lpszIconSource,
378: lpCV->IconIndex);
379:
380: }
381: else
382: lpCV->lpOCV->hMetaPict = (HGLOBAL)NULL;
383:
384:
385: //
386: // End the dialog
387: //
388: SendMessage(hDlg, uMsgEndDialog, OLEUI_OK, 0L);
389: }
390: break;
391:
392: case IDCANCEL:
393: SendMessage(hDlg, uMsgEndDialog, OLEUI_CANCEL, 0L);
394: break;
395:
396:
397: case IDCV_HELP:
398: PostMessage(lpCV->lpOCV->hWndOwner,
399: uMsgHelp, (WPARAM)hDlg, MAKELPARAM(IDD_CONVERT, 0));
400: break;
401:
402: case IDCV_DISPLAYASICON:
403: {
404:
405: int i;
406: BOOL fCheck;
407:
408: fCheck=IsDlgButtonChecked(hDlg, wID);
409:
410: if (fCheck)
411: lpCV->dvAspect = DVASPECT_ICON;
412: else
413: lpCV->dvAspect = DVASPECT_CONTENT;
414:
415: if (fCheck && (!lpCV->fCustomIcon))
416: UpdateCVClassIcon(hDlg, lpCV, lpCV->hListVisible);
417:
418: //Show or hide the icon depending on the check state.
419:
420: i=(fCheck) ? SW_SHOWNORMAL : SW_HIDE;
421:
422: StandardShowDlgItem(hDlg, IDCV_CHANGEICON, i);
423: StandardShowDlgItem(hDlg, IDCV_ICON, i);
424: StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, i);
425: StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, i);
426:
427: SetConvertResults(hDlg, lpCV);
428:
429: }
430: break;
431:
432: case IDCV_CHANGEICON:
433: {
434: LPMALLOC pIMalloc;
435: LPSTR pszString, pszCLSID;
436: int iSel;
437: HICON hIcon;
438: char szLabel[OLEUI_CCHLABELMAX];
439: int Index;
440:
441:
442: //Initialize the structure for the hook.
443: _fmemset((LPOLEUICHANGEICON)&ci, 0, sizeof(ci));
444:
445:
446: // Create the hMetaPict here from icon, label,
447: // index, and path
448:
449: hIcon = (HICON)SendDlgItemMessage(hDlg, IDCV_ICON, STM_GETICON, 0, 0L);
450:
451: // the combined length of the 2 label lines won't ever be more than
452: // OLEUI_CCHLABELMAX.
453:
454: Index = (int)SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_GETTEXT, OLEUI_CCHLABELMAX, (LPARAM)(LPSTR)szLabel);
455:
456: if (Index < OLEUI_CCHLABELMAX)
457: {
458: LPSTR lpszSecondLine;
459:
460: lpszSecondLine = szLabel + Index;
461:
462: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_GETTEXT,
463: OLEUI_CCHLABELMAX-Index,
464: (LPARAM)(LPSTR)lpszSecondLine);
465: }
466:
467: ci.hMetaPict =
468: OleUIMetafilePictFromIconAndLabel(hIcon,
469: (LPSTR)szLabel,
470: lpCV->lpszIconSource,
471: lpCV->IconIndex);
472:
473: ci.cbStruct =sizeof(ci);
474: ci.hWndOwner=hDlg;
475: ci.dwFlags = CIF_SELECTCURRENT;
476:
477: // Only show help if we're showing it for this dialog.
478: if (lpCV->dwFlags & CF_SHOWHELPBUTTON)
479: ci.dwFlags |= CIF_SHOWHELP;
480:
481: iSel = (int)SendMessage(lpCV->hListVisible, LB_GETCURSEL, 0, 0L);
482:
483: CoGetMalloc(MEMCTX_TASK, &pIMalloc);
484:
485: pszString = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHLABELMAX + OLEUI_CCHCLSIDSTRING);
486:
487: // Get whole string
488: SendMessage(lpCV->hListVisible, LB_GETTEXT, iSel, (LONG)pszString);
489:
490: // Set pointer to CLSID (string)
491: pszCLSID = PointerToNthField(pszString, 2, '\t');
492:
493: // Get the clsid to pass to change icon.
494: CLSIDFromString((LPSTR)pszCLSID, (LPCLSID)&(ci.clsid));
495:
496: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszString);
497: pIMalloc->lpVtbl->Release(pIMalloc);
498:
499: //Let the hook in to customize Change Icon if desired.
500: uRet=UStandardHook(lpCV, hDlg, uMsgChangeIcon
501: , 0, (LONG)(LPSTR)&ci);
502:
503: if (0==uRet)
504: uRet=(UINT)(OLEUI_OK==OleUIChangeIcon((LPOLEUICHANGEICON)&ci));
505:
506: //Update the display if necessary.
507: if (0!=uRet)
508: {
509: HICON hIcon;
510: char szLabel[OLEUI_CCHLABELMAX];
511: DWORD dwWrapIndex;
512:
513:
514: hIcon = OleUIMetafilePictExtractIcon(ci.hMetaPict);
515:
516: SendDlgItemMessage(hDlg, IDCV_ICON, STM_SETICON, (WPARAM)hIcon, 0L);
517:
518: OleUIMetafilePictExtractIconSource(ci.hMetaPict, lpCV->lpszIconSource, &(lpCV->IconIndex));
519:
520: OleUIMetafilePictExtractLabel(ci.hMetaPict, szLabel, OLEUI_CCHLABELMAX, &dwWrapIndex);
521:
522: if (0 == dwWrapIndex) // no second line
523: {
524: SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_SETTEXT, 0, (LPARAM)(LPSTR)szLabel);
525: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)(LPSTR)"");
526: }
527: else
528: {
529:
530: LPSTR lpszSecondLine;
531:
532: lpszSecondLine = szLabel + dwWrapIndex;
533: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2,
534: WM_SETTEXT, 0, (LPARAM)lpszSecondLine);
535:
536: *lpszSecondLine = '\0';
537: SendDlgItemMessage(hDlg, IDCV_ICONLABEL1,
538: WM_SETTEXT, 0, (LPARAM)(LPSTR)szLabel);
539: }
540:
541:
542: // Update our custom/default flag
543:
544: if (ci.dwFlags & CIF_SELECTDEFAULT)
545: lpCV->fCustomIcon = FALSE; // we're in default mode (icon changes on each LB selchange)
546: else if (ci.dwFlags & CIF_SELECTFROMFILE)
547: lpCV->fCustomIcon = TRUE; // we're in custom mode (icon doesn't change)
548: // no change in fCustomIcon if user selected current
549:
550:
551: lpCV->lpOCV->fObjectsIconChanged = TRUE;
552: }
553: }
554: break;
555:
556: }
557: break;
558: }
559: return FALSE;
560: }
561:
562:
563: /*
564: * FConvertInit
565: *
566: * Purpose:
567: * WM_INITIDIALOG handler for the Convert dialog box.
568: *
569: * Parameters:
570: * hDlg HWND of the dialog
571: * wParam WPARAM of the message
572: * lParam LPARAM of the message
573: *
574: * Return Value:
575: * BOOL Value to return for WM_INITDIALOG.
576: */
577:
578: BOOL FConvertInit(HWND hDlg, WPARAM wParam, LPARAM lParam)
579: {
580: LPCONVERT lpCV;
581: LPOLEUICONVERT lpOCV;
582: LPMALLOC pIMalloc;
583: HFONT hFont; // non-bold version of dialog's font
584: RECT rc;
585: DWORD dw;
586: int cItemsActivate;
587: HKEY hKey;
588: LONG lRet;
589:
590:
591: //Copy the structure at lParam into our instance memory.
592: lpCV=(LPCONVERT)LpvStandardInit(hDlg, sizeof(CONVERT), TRUE, (HFONT FAR *)&hFont);
593:
594: //PvStandardInit send a termination to us already.
595: if (NULL==lpCV)
596: return FALSE;
597:
598: lpOCV=(LPOLEUICONVERT)lParam;
599:
600: lpCV->lpOCV=lpOCV;
601:
602: lpCV->fCustomIcon = FALSE;
603:
604: //Copy other information from lpOCV that we might modify.
605: lpCV->dwFlags = lpOCV->dwFlags;
606: lpCV->clsid = lpOCV->clsid;
607: lpCV->dvAspect = lpOCV->dvAspect;
608: lpCV->hListVisible = GetDlgItem(hDlg, IDCV_ACTIVATELIST);
609: lpCV->hListInvisible = GetDlgItem(hDlg, IDCV_CONVERTLIST);
610: lpCV->lpszCurrentObject = lpOCV->lpszUserType;
611:
612: lpOCV->clsidNew = CLSID_NULL;
613:
614: lpOCV->fObjectsIconChanged = FALSE;
615:
616: //Allocate space for our strings
617: if (NOERROR != CoGetMalloc(MEMCTX_TASK, &pIMalloc))
618: return FALSE;
619:
620: lpCV->lpszConvertDefault = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHLABELMAX);
621: lpCV->lpszActivateDefault = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHLABELMAX);
622: lpCV->lpszIconSource = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHPATHMAX);
623:
624: //If we got a font, send it to the necessary controls.
625: if (NULL!=hFont)
626: {
627: SendDlgItemMessage(hDlg, IDCV_OBJECTTYPE, WM_SETFONT, (WPARAM)hFont, 0L);
628: SendDlgItemMessage(hDlg, IDCV_RESULTTEXT, WM_SETFONT, (WPARAM)hFont, 0L);
629: SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_SETFONT, (WPARAM)hFont, 0L);
630: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETFONT, (WPARAM)hFont, 0L);
631: }
632:
633: //Hide the help button if necessary
634: if (!(lpCV->dwFlags & CF_SHOWHELPBUTTON))
635: StandardShowDlgItem(hDlg, IDCV_HELP, SW_HIDE);
636:
637: //Fill the Object Type listbox with entries from the reg DB.
638: FillClassList(lpOCV->clsid,
639: lpCV->hListVisible,
640: lpCV->hListInvisible,
641: &(lpCV->lpszCurrentObject),
642: lpOCV->fIsLinkedObject,
643: lpOCV->wFormat);
644:
645: // Set the name of the current object.
646: SetDlgItemText(hDlg, IDCV_OBJECTTYPE, (LPSTR)lpCV->lpszCurrentObject);
647:
648: // Disable the "Activate As" button if the Activate list doesn't
649: // have any objects in it.
650:
651: cItemsActivate = (int)SendMessage(lpCV->hListVisible, LB_GETCOUNT, 0, 0L);
652:
653: if (1 >= cItemsActivate)
654: EnableWindow(GetDlgItem(hDlg, IDCV_ACTIVATEAS), FALSE);
655:
656: //Set the tab width in the list to push all the tabs off the side.
657: GetClientRect(lpCV->hListVisible, (LPRECT)&rc);
658: dw=GetDialogBaseUnits();
659: rc.right =(8*rc.right)/LOWORD(dw); //Convert pixels to 2x dlg units.
660: SendMessage(lpCV->hListVisible, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)(&rc.right));
661: SendMessage(lpCV->hListInvisible, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)(&rc.right));
662:
663:
664: // Make sure that either "Convert To" or "Activate As" is selected
665: // and initialize listbox contents and selection accordingly
666: if (lpCV->dwFlags & CF_SELECTACTIVATEAS)
667: {
668: // Don't need to adjust listbox here because FillClassList
669: // initializes to the "Activate As" state.
670: CheckRadioButton(hDlg, IDCV_CONVERTTO, IDCV_ACTIVATEAS, IDCV_ACTIVATEAS);
671:
672: // Hide the icon stuff when Activate is selected...it gets shown
673: // again when Convert is selected.
674:
675: StandardShowDlgItem(hDlg, IDCV_DISPLAYASICON, SW_HIDE);
676: StandardShowDlgItem(hDlg, IDCV_CHANGEICON, SW_HIDE);
677: StandardShowDlgItem(hDlg, IDCV_ICON, SW_HIDE);
678: StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, SW_HIDE);
679: StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, SW_HIDE);
680: }
681: else
682: {
683: // Default case. If user hasn't selected either flag, we will
684: // come here anyway.
685: // swap listboxes.
686:
687: HWND hWndTemp = lpCV->hListVisible;
688:
689:
690: lpCV->dwFlags |= CF_SELECTCONVERTTO; // Make sure flag is set
691: CheckRadioButton(hDlg, IDCV_CONVERTTO, IDCV_ACTIVATEAS, IDCV_CONVERTTO);
692:
693: SwapWindows(hDlg, lpCV->hListVisible, lpCV->hListInvisible);
694:
695: lpCV->hListVisible = lpCV->hListInvisible;
696: lpCV->hListInvisible = hWndTemp;
697:
698: EnableWindow(lpCV->hListInvisible, FALSE);
699: EnableWindow(lpCV->hListVisible, TRUE);
700: }
701:
702:
703:
704: // Initialize Default strings.
705:
706: // Default convert string is easy...just user the user type name from
707: // the clsid we got, or the current object
708: if ( (lpCV->dwFlags & CF_SETCONVERTDEFAULT)
709: && (IsValidClassID(lpCV->lpOCV->clsidConvertDefault)) )
710: {
711: dw = OleStdGetUserTypeOfClass((LPCLSID)(&lpCV->lpOCV->clsidConvertDefault),
712: lpCV->lpszConvertDefault,
713: OLEUI_CCHLABELMAX,
714: NULL);
715:
716: if (0 == dw)
717: lstrcpy((LPSTR)lpCV->lpszConvertDefault, (LPSTR)lpCV->lpszCurrentObject);
718: }
719: else
720: lstrcpy((LPSTR)lpCV->lpszConvertDefault, (LPSTR)lpCV->lpszCurrentObject);
721:
722:
723:
724: // Default activate is a bit trickier. We want to use the user type
725: // name if from the clsid we got (assuming we got one), or the current
726: // object if it fails or we didn't get a clsid. But...if there's a
727: // Treat As entry in the reg db, then we use that instead. So... the
728: // logic boils down to this:
729: //
730: // if ("Treat As" in reg db)
731: // use it;
732: // else
733: // if (CF_SETACTIVATEDEFAULT)
734: // use it;
735: // else
736: // use current object;
737:
738:
739:
740: lRet = RegOpenKey(HKEY_CLASSES_ROOT, "CLSID", (HKEY FAR *)&hKey);
741:
742: if (lRet != ERROR_SUCCESS)
743: goto CheckInputFlag;
744:
745: else
746: {
747: LPSTR lpszCLSID;
748: char szKey[OLEUI_CCHKEYMAX];
749: CLSID clsid;
750: char szValue[OLEUI_CCHKEYMAX];
751:
752: StringFromCLSID(&(lpCV->lpOCV->clsid), &lpszCLSID);
753: lstrcpy(szKey, lpszCLSID);
754: lstrcat(szKey, (LPSTR)"\\TreatAs");
755:
756: dw = OLEUI_CCHKEYMAX;
757: lRet = RegQueryValue(hKey, (LPSTR)szKey, (LPSTR)szValue, (LPDWORD)&dw);
758:
759: if (lRet != ERROR_SUCCESS)
760: {
761:
762: RegCloseKey(hKey);
763: OleStdFreeString(lpszCLSID, NULL);
764: goto CheckInputFlag;
765: }
766: else
767: {
768: CLSIDFromString((LPSTR)szValue, &clsid);
769: if (0 == OleStdGetUserTypeOfClass(&clsid,
770: lpCV->lpszActivateDefault,
771: OLEUI_CCHLABELMAX,
772: NULL))
773: {
774: RegCloseKey(hKey);
775: OleStdFreeString(lpszCLSID, NULL);
776: goto CheckInputFlag;
777: }
778: }
779: RegCloseKey(hKey);
780: OleStdFreeString(lpszCLSID, NULL);
781: goto SelectStringInListbox;
782: }
783:
784:
785: CheckInputFlag:
786: if ( (lpCV->dwFlags & CF_SETACTIVATEDEFAULT)
787: && (IsValidClassID(lpCV->lpOCV->clsidActivateDefault)) )
788: {
789: dw = OleStdGetUserTypeOfClass((LPCLSID)(&lpCV->lpOCV->clsidActivateDefault),
790: lpCV->lpszActivateDefault,
791: OLEUI_CCHLABELMAX,
792: NULL);
793:
794: if (0 == dw)
795: lstrcpy((LPSTR)lpCV->lpszActivateDefault, (LPSTR)lpCV->lpszCurrentObject);
796: }
797: else
798: lstrcpy((LPSTR)(lpCV->lpszActivateDefault), (LPSTR)lpCV->lpszCurrentObject);
799:
800:
801: SelectStringInListbox:
802:
803: if (lpCV->dwFlags & CF_SELECTCONVERTTO)
804: lRet = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)(LPSTR)(lpCV->lpszConvertDefault));
805:
806: else
807: lRet = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)(LPSTR)(lpCV->lpszActivateDefault));
808:
809: if (LB_ERR == lRet)
810: SendMessage(lpCV->hListVisible, LB_SETCURSEL, (WPARAM)0, 0L);
811:
812:
813: // Initialize icon stuff
814: if (DVASPECT_ICON == lpCV->dvAspect )
815: {
816: SendDlgItemMessage(hDlg, IDCV_DISPLAYASICON, BM_SETCHECK, TRUE, 0L);
817:
818: if ((HGLOBAL)NULL != lpOCV->hMetaPict)
819: {
820: char szLabel[OLEUI_CCHLABELMAX];
821: HICON hIcon;
822: DWORD dwWrapIndex;
823:
824:
825: // Set the icon to the icon from the hMetaPict,
826: // set the label to the label from the hMetaPict.
827:
828: if (0 != OleUIMetafilePictExtractLabel(lpOCV->hMetaPict, (LPSTR)szLabel, OLEUI_CCHLABELMAX, &dwWrapIndex))
829: {
830: if (0 == dwWrapIndex) // no second line
831: {
832: SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_SETTEXT, 0, (LPARAM)(LPSTR)szLabel);
833: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)(LPSTR)"");
834: }
835: else
836: {
837:
838: LPSTR lpszSecondLine;
839:
840: lpszSecondLine = szLabel + dwWrapIndex;
841: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2,
842: WM_SETTEXT, 0, (LPARAM)lpszSecondLine);
843:
844: *lpszSecondLine = '\0';
845: SendDlgItemMessage(hDlg, IDCV_ICONLABEL1,
846: WM_SETTEXT, 0, (LPARAM)(LPSTR)szLabel);
847: }
848:
849:
850: }
851:
852: hIcon = OleUIMetafilePictExtractIcon(lpOCV->hMetaPict);
853:
854: if (NULL != hIcon)
855: {
856: SendDlgItemMessage(hDlg, IDCV_ICON, STM_SETICON, (WPARAM)hIcon, 0L);
857: lpCV->fCustomIcon = TRUE;
858: }
859:
860: OleUIMetafilePictExtractIconSource(lpOCV->hMetaPict,
861: (LPSTR)(lpCV->lpszIconSource),
862: &(lpCV->IconIndex));
863:
864: }
865: else
866: UpdateCVClassIcon(hDlg, lpCV, lpCV->hListVisible);
867: }
868: else
869: {
870: // Hide & disable icon stuff
871: StandardShowDlgItem(hDlg, IDCV_ICON, SW_HIDE);
872: StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, SW_HIDE);
873: StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, SW_HIDE);
874: StandardShowDlgItem(hDlg, IDCV_CHANGEICON, SW_HIDE);
875: }
876:
877: // Call the hook with lCustData in lParam
878: UStandardHook((LPVOID)lpCV, hDlg, WM_INITDIALOG, wParam, lpOCV->lCustData);
879:
880: // Update results window
881: SetConvertResults(hDlg, lpCV);
882:
883: // Update caption if lpszCaption was specified
884: if (lpCV->lpOCV->lpszCaption && !IsBadReadPtr(lpCV->lpOCV->lpszCaption, 1)
885: && lpCV->lpOCV->lpszCaption[0] != '\0')
886: SetWindowText(hDlg, (LPSTR)lpCV->lpOCV->lpszCaption);
887:
888: return TRUE;
889: }
890:
891:
892: /*
893: * FillClassList
894: *
895: * Purpose:
896: * Enumerates available OLE object classes from the registration
897: * database that we can convert or activate the specified clsid from.
898: *
899: * Note that this function removes any prior contents of the listbox.
900: *
901: * Parameters:
902: * clsid Class ID for class to find convert classes for
903: * hList HWND to the listbox to fill.
904: * hListActivate HWND to invisible listbox that stores "activate as" list.
905: * lpszClassName LPSTR to put the (hr) class name of the clsid; we
906: * do it here since we've already got the reg db open.
907: * wFormat WORD specifying the format of the original class.
908: *
909: * Return Value:
910: * UINT Number of strings added to the listbox, -1 on failure.
911: */
912:
913: UINT FillClassList(CLSID clsid, HWND hList, HWND hListInvisible, LPSTR FAR *lplpszCurrentClass, BOOL fIsLinkedObject, WORD wFormat)
914: {
915:
916: DWORD dw;
917: UINT cStrings=0;
918: HKEY hKey;
919: LONG lRet;
920: char szFormatKey[OLEUI_CCHKEYMAX];
921: char szClass[OLEUI_CCHKEYMAX];
922: char szFormat[OLEUI_CCHKEYMAX];
923: char szHRClassName[OLEUI_CCHKEYMAX];
924:
925: LPSTR lpszCLSID;
926:
927:
928: //Clean out the existing strings.
929: SendMessage(hList, LB_RESETCONTENT, 0, 0L);
930: SendMessage(hListInvisible, LB_RESETCONTENT, 0, 0L);
931:
932: //Open up the root key.
933: lRet=RegOpenKey(HKEY_CLASSES_ROOT, (LPSTR)"CLSID", (HKEY FAR *)&hKey);
934:
935: if ((LONG)ERROR_SUCCESS!=lRet)
936: return (UINT)-1;
937:
938: if (NULL == *lplpszCurrentClass)
939: {
940: // alloc buffer here...
941:
942: LPMALLOC pIMalloc = NULL;
943: HRESULT hrErr;
944:
945:
946: hrErr = CoGetMalloc(MEMCTX_TASK, &pIMalloc);
947:
948: if (hrErr != NOERROR)
949: {
950: RegCloseKey(hKey);
951: return FALSE;
952: }
953:
954: // Allocate space for lpszCurrentClass
955: *lplpszCurrentClass = (LPSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHKEYMAX);
956:
957: lRet = OleStdGetUserTypeOfClass((REFCLSID)&clsid,
958: *lplpszCurrentClass,
959: OLEUI_CCHLABELMAX,
960: NULL);
961:
962: if (0 ==lRet)
963: {
964: RegCloseKey(hKey);
965: return (UINT)-1;
966: }
967: }
968:
969: // Get the class name of the original class.
970: StringFromCLSID((REFCLSID)&clsid, (LPSTR FAR *)&lpszCLSID);
971:
972:
973: // Here, we step through the entire registration db looking for
974: // class that can read or write the original class' format. We
975: // maintain two lists - an activate list and a convert list. The
976: // activate list is a subset of the convert list - activate == read/write
977: // and convert == read. We swap the listboxes as needed with
978: // SwapWindows, and keep track of which is which in the lpCV structure.
979:
980: // Every item has the following format:
981: //
982: // Class Name\tclsid\0
983:
984:
985: cStrings=0;
986: lRet=RegEnumKey(hKey, cStrings++, (LPSTR)szClass, OLEUI_CCHKEYMAX);
987:
988: while ((LONG)ERROR_SUCCESS==lRet)
989: {
990: // Check for a \Conversion\ReadWriteable\Main entry first - if its
991: // readwriteable, then we don't need to bother checking to see if
992: // its readable.
993:
994: lstrcpy((LPSTR)szFormatKey, (LPSTR)szClass);
995: lstrcat((LPSTR)szFormatKey, (LPSTR)"\\Conversion\\Readwritable\\Main");
996:
997: dw=OLEUI_CCHKEYMAX;
998:
999: lRet=RegQueryValue(hKey, (LPSTR)szFormatKey, (LPSTR)szFormat, (LONG FAR *)&dw);
1000:
1001: if ( (LONG)ERROR_SUCCESS != lRet)
1002: {
1003: // Try \\DataFormats\DefaultFile too
1004:
1005: lstrcpy((LPSTR)szFormatKey, (LPSTR)szClass);
1006: lstrcat((LPSTR)szFormatKey, (LPSTR)"\\DataFormats\\DefaultFile");
1007:
1008: dw=OLEUI_CCHKEYMAX;
1009:
1010: lRet=RegQueryValue(hKey, (LPSTR)szFormatKey, (LPSTR)szFormat, (LONG FAR *)&dw);
1011: }
1012:
1013:
1014: if ( ((LONG)ERROR_SUCCESS==lRet)
1015: && (FormatIncluded((LPSTR)szFormat, wFormat)) )
1016: {
1017:
1018: // Here, we've got a list of formats that this class can read
1019: // and write. We need to see if the original class' format is
1020: // in this list. We do that by looking for wFormat in
1021: // szFormat - if it in there, then we add this class to the
1022: // both lists and continue. If not, then we look at the
1023: // class' readable formats.
1024:
1025:
1026: dw=OLEUI_CCHKEYMAX;
1027: lRet=RegQueryValue(hKey, (LPSTR)szClass, (LPSTR)szHRClassName, (LPDWORD)&dw);
1028:
1029: if ((LONG)ERROR_SUCCESS==lRet)
1030: {
1031:
1032: lstrcat((LPSTR)szHRClassName, (LPSTR)"\t");
1033: lstrcat((LPSTR)szHRClassName, (LPSTR)szClass);
1034:
1035: SendMessage(hList, LB_ADDSTRING, 0, (DWORD)(LPSTR)szHRClassName);
1036:
1037: // add to convert list too.
1038: SendMessage(hListInvisible, LB_ADDSTRING, 0, (DWORD)(LPSTR)szHRClassName);
1039:
1040: }
1041:
1042: }
1043:
1044:
1045: // We either didn't find the readwritable key, or the
1046: // list of readwritable formats didn't include the
1047: // original class format. So, here we'll check to
1048: // see if its in the readable list.
1049:
1050:
1051: // We've got a special case for a linked object here.
1052: // If an object is linked, then the only class that
1053: // should appear in the convert list is the object's
1054: // class. So, here we check to see if the object is
1055: // linked. If it is, then we compare the classes. If
1056: // they aren't the same, then we just go to the next key.
1057:
1058: else if ( (!fIsLinkedObject)
1059: || (lstrcmp((LPSTR)lpszCLSID, (LPSTR)szClass) == 0) )
1060: {
1061:
1062: //Check for a \Conversion\Readable\Main entry
1063: lstrcpy((LPSTR)szFormatKey, (LPSTR)szClass);
1064: lstrcat((LPSTR)szFormatKey, (LPSTR)"\\Conversion\\Readable\\Main");
1065:
1066: dw=OLEUI_CCHKEYMAX;
1067:
1068: // Check to see if this class can read the original class
1069: // format. If it can, add the string to the listbox as
1070: // CONVERT_LIST.
1071:
1072: lRet=RegQueryValue(hKey, (LPSTR)szFormatKey, (LPSTR)szFormat, (LPDWORD)&dw);
1073:
1074: if ( ((LONG)ERROR_SUCCESS==lRet)
1075: && (FormatIncluded((LPSTR)szFormat, wFormat)) )
1076: {
1077:
1078:
1079: dw=OLEUI_CCHKEYMAX;
1080: lRet=RegQueryValue(hKey, (LPSTR)szClass, (LPSTR)szHRClassName, (LPDWORD)&dw);
1081:
1082: if ((LONG)ERROR_SUCCESS==lRet)
1083: {
1084:
1085: lstrcat((LPSTR)szHRClassName, (LPSTR)"\t");
1086: lstrcat((LPSTR)szHRClassName, (LPSTR)szClass);
1087:
1088: SendMessage(hListInvisible, LB_ADDSTRING, 0, (DWORD)(LPSTR)szHRClassName);
1089: } // end if
1090:
1091: } // end if
1092: } // end else
1093:
1094: //Continue with the next key.
1095: lRet=RegEnumKey(hKey, cStrings++, (LPSTR)szClass, OLEUI_CCHKEYMAX);
1096:
1097: } // end while
1098:
1099: // If the original class isn't already in the list, add it.
1100:
1101: lstrcpy((LPSTR)szHRClassName, *lplpszCurrentClass);
1102: lstrcat((LPSTR)szHRClassName, (LPSTR)"\t");
1103: lstrcat((LPSTR)szHRClassName, lpszCLSID);
1104:
1105: lRet = SendMessage(hList, LB_FINDSTRING, (WPARAM)-1, (LPARAM)(LPSTR)szHRClassName);
1106:
1107: // only add it if it's not there already.
1108: if (LB_ERR == lRet)
1109: SendMessage(hList, LB_ADDSTRING, 0, (LPARAM)(LPSTR)szHRClassName);
1110:
1111:
1112: lRet = SendMessage(hListInvisible, LB_FINDSTRING, (WPARAM)-1, (LPARAM)(LPSTR)szHRClassName);
1113:
1114: // only add it if it's not there already.
1115: if (LB_ERR == lRet)
1116: SendMessage(hListInvisible, LB_ADDSTRING, 0, (LPARAM)(LPSTR)szHRClassName);
1117:
1118: // Free the string we got from StringFromCLSID.
1119: // OLE2NOTE: StringFromCLSID uses your IMalloc to alloc a
1120: // string, so you need to be sure to free the string you
1121: // get back, otherwise you'll have leaky memory.
1122:
1123: OleStdFreeString(lpszCLSID, NULL);
1124:
1125: RegCloseKey(hKey);
1126:
1127: return cStrings;
1128: }
1129:
1130:
1131: /*
1132: * FormatIncluded
1133: *
1134: * Purpose:
1135: * Parses the string for format from the word.
1136: *
1137: * Parameters:
1138: * szStringToSearch String to parse
1139: * wFormat format to find
1140: *
1141: * Return Value:
1142: * BOOL TRUE if format is found in string,
1143: * FALSE otherwise.
1144: */
1145: BOOL FormatIncluded(LPSTR szStringToSearch, WORD wFormat)
1146: {
1147:
1148: LPSTR lpToken;
1149: char seps[] = ",";
1150: static char szFormat[255]; // max size of atom (what GetClipboardName returns)
1151:
1152:
1153: if (wFormat < 0xC000) // RegisterClipboardFormat returns values
1154: _itoa(wFormat, szFormat, 10); // between 0xC000 and 0xFFFF.
1155:
1156: else
1157: GetClipboardFormatName(wFormat, szFormat, 255);
1158:
1159:
1160: lpToken = (LPSTR)_fstrtok(szStringToSearch, seps);
1161:
1162: while (lpToken != NULL)
1163: {
1164:
1165: if (0 == lstrcmpi(lpToken, szFormat))
1166: return TRUE;
1167:
1168: else
1169: lpToken = (LPSTR)_fstrtok(NULL, seps);
1170: }
1171:
1172: return FALSE;
1173: }
1174:
1175:
1176:
1177:
1178:
1179:
1180:
1181:
1182:
1183:
1184:
1185: /*
1186: * UpdateCVClassIcon
1187: *
1188: * Purpose:
1189: * Handles LBN_SELCHANGE for the Object Type listbox. On a selection
1190: * change, we extract an icon from the server handling the currently
1191: * selected object type using the utility function HIconFromClass.
1192: * Note that we depend on the behavior of FillClassList to stuff the
1193: * object class after a tab in the listbox string that we hide from
1194: * view (see WM_INITDIALOG).
1195: *
1196: * Parameters
1197: * hDlg HWND of the dialog box.
1198: * lpCV LPCONVERT pointing to the dialog structure
1199: * hList HWND of the Object Type listbox.
1200: *
1201: * Return Value:
1202: * None
1203: */
1204:
1205: void UpdateCVClassIcon(HWND hDlg, LPCONVERT lpCV, HWND hList)
1206: {
1207: UINT iSel;
1208: DWORD cb;
1209: HGLOBAL hMem;
1210: LPSTR pszName, pszCLSID;
1211: CLSID clsid;
1212: HICON hIcon, hOldIcon;
1213: UINT cch, uWrapIndex;
1214: RECT LabelRect;
1215: char szLabel[OLEUI_CCHLABELMAX];
1216: HFONT hFont;
1217: HWND hLabel1;
1218:
1219: /*
1220: * When we change object type selection, get the new icon for that
1221: * type into our structure and update it in the display.
1222: */
1223:
1224: iSel=(UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L);
1225:
1226: if (LB_ERR==(int)iSel)
1227: return;
1228:
1229: //Allocate a string to hold the entire listbox string
1230: cb=SendMessage(hList, LB_GETTEXTLEN, iSel, 0L);
1231:
1232: hMem=GlobalAlloc(GHND, cb+1);
1233:
1234: if (NULL==hMem)
1235: return;
1236:
1237: pszName=GlobalLock(hMem);
1238:
1239: // Get whole string
1240: SendMessage(hList, LB_GETTEXT, iSel, (LONG)pszName);
1241:
1242: // Set pointer to CLSID (string)
1243: pszCLSID = PointerToNthField(pszName, 2, '\t');
1244:
1245: //Create the class ID with this string.
1246: CLSIDFromString((LPSTR)pszCLSID, (LPCLSID)&clsid);
1247:
1248: hIcon = HIconAndSourceFromClass(&clsid, (LPSTR)(lpCV->lpszIconSource), &(lpCV->IconIndex));
1249:
1250: if (NULL == hIcon) // Use Vanilla Document
1251: {
1252: lstrcpy((LPSTR)(lpCV->lpszIconSource), (LPSTR)szOLE2DLL);
1253: lpCV->IconIndex = 0; // 1st icon in OLE2.DLL
1254: hIcon = ExtractIcon(ghInst,
1255: (LPSTR)(lpCV->lpszIconSource),
1256: lpCV->IconIndex);
1257: }
1258:
1259: //Replace the current display with this new one.
1260: hOldIcon = (HICON)SendDlgItemMessage(hDlg, IDCV_ICON, STM_SETICON, (WPARAM)hIcon, 0L);
1261:
1262: // Get the label
1263: if ((cch = OleStdGetAuxUserType(&clsid, AUXUSERTYPE_SHORTNAME,
1264: (LPSTR)szLabel, OLEUI_CCHLABELMAX, NULL)) == 0) {
1265: // If we can't get the AuxUserType2, then try the long name
1266: if ((cch = OleStdGetUserTypeOfClass(&clsid, (LPSTR)szLabel,
1267: OLEUI_CCHKEYMAX, NULL)) == 0) {
1268: // last resort; use "Document" as label
1269: LoadString(ghInst,IDS_DEFICONLABEL,(LPSTR)szLabel,sizeof(szLabel));
1270: cch = lstrlen((LPSTR)szLabel);
1271: }
1272: }
1273:
1274: hLabel1 = GetDlgItem(hDlg, IDCV_ICONLABEL1);
1275:
1276: GetWindowRect(hLabel1, &LabelRect);
1277:
1278: hFont = (HFONT)SendMessage(hLabel1, WM_GETFONT, 0, 0L);
1279:
1280: // Figure out where to split the label
1281: uWrapIndex = OleStdIconLabelTextOut(NULL, hFont, 0, 0, 0, &LabelRect, (LPSTR)szLabel, cch, NULL);
1282:
1283: if (0 == uWrapIndex)
1284: {
1285: SendMessage(hLabel1, WM_SETTEXT, 0, (LPARAM)(LPSTR)szLabel);
1286: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)(LPSTR)"");
1287: }
1288: else
1289: {
1290: char chKeep;
1291: LPSTR lpszSecondLine;
1292:
1293: chKeep = szLabel[uWrapIndex];
1294: szLabel[uWrapIndex] = '\0';
1295:
1296: SendMessage(hLabel1, WM_SETTEXT, 0, (LPARAM)(LPSTR)szLabel);
1297:
1298: szLabel[uWrapIndex] = chKeep;
1299: lpszSecondLine = szLabel + uWrapIndex;
1300:
1301: SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)lpszSecondLine);
1302: }
1303:
1304: // get rid of the old icon
1305: if ((HICON)NULL != hOldIcon)
1306: DestroyIcon(hOldIcon);
1307:
1308: GlobalUnlock(hMem);
1309: GlobalFree(hMem);
1310: return;
1311: }
1312:
1313:
1314:
1315:
1316:
1317:
1318: BOOL IsValidClassID(CLSID cID)
1319: {
1320: if (0 == _fmemcmp(&cID, &CLSID_NULL, sizeof(CLSID))) // if (CLSID_NULL == cID)
1321: return FALSE;
1322: else
1323: return TRUE;
1324: }
1325:
1326:
1327:
1328: /*
1329: * SetConvertResults
1330: *
1331: * Purpose:
1332: * Centralizes setting of the Result display in the Convert
1333: * dialog. Handles loading the appropriate string from the module's
1334: * resources and setting the text, displaying the proper result picture,
1335: * and showing the proper icon.
1336: *
1337: * Parameters:
1338: * hDlg HWND of the dialog box so we can access controls.
1339: * lpCV LPCONVERT in which we assume that the dwFlags is
1340: * set to the appropriate radio button selection, and
1341: * the list box has the appropriate class selected.
1342: *
1343: * Return Value:
1344: * None
1345: */
1346:
1347: void SetConvertResults(HWND hDlg, LPCONVERT lpCV)
1348: {
1349: LPSTR pszT, // temp
1350: lpszOutput, // text sent in SetDlgItemText
1351: lpszDefObj, // string containing default object class
1352: lpszSelObj, // string containing selected object class
1353: lpszString; // stirng we get from loadstring
1354:
1355: UINT i, cch;
1356: HGLOBAL hMem;
1357:
1358: HWND hList; // handle to listbox (so we can just use SendMsg i
1359: // instead of SendDlgItemMsg).
1360:
1361:
1362: hList = lpCV->hListVisible;
1363: /*
1364: * We need scratch memory for loading the stringtable string, loading
1365: * the object type from the listbox, loading the source object
1366: * type, and constructing the final string. We therefore allocate
1367: * four buffers as large as the maximum message length (512) plus
1368: * the object type, guaranteeing that we have enough
1369: * in all cases.
1370: */
1371: i=(UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L);
1372:
1373: cch=512+(UINT)SendMessage(hList, LB_GETTEXTLEN, i, 0L);
1374:
1375: hMem=GlobalAlloc(GHND, (DWORD)(4*cch));
1376:
1377: if (NULL==hMem)
1378: return;
1379:
1380: lpszOutput = (LPSTR)GlobalLock(hMem);
1381: lpszSelObj = lpszOutput + cch;
1382: lpszDefObj = lpszSelObj + cch;
1383: lpszString = lpszDefObj + cch;
1384:
1385: // Get selected object and null terminate human-readable name (1st field).
1386: SendMessage(hList, LB_GETTEXT, i, (LONG)lpszSelObj);
1387:
1388: pszT = PointerToNthField(lpszSelObj, 2, '\t');
1389:
1390: pszT = AnsiPrev(lpszSelObj, pszT);
1391:
1392: *pszT = '\0';
1393:
1394:
1395: // Get default object
1396:
1397: GetDlgItemText(hDlg, IDCV_OBJECTTYPE, lpszDefObj, 512);
1398:
1399:
1400: //Default is an empty string.
1401: *lpszOutput=0;
1402:
1403:
1404: if (lpCV->dwFlags & CF_SELECTCONVERTTO)
1405: {
1406:
1407: if (lpCV->lpOCV->fIsLinkedObject) // working with linked object
1408: LoadString(ghInst, IDS_CVRESULTCONVERTLINK, lpszOutput, cch);
1409:
1410:
1411: else
1412: {
1413: // converting to a new class
1414: if (0 != lstrcmp(lpszDefObj, lpszSelObj))
1415: {
1416: if (0 != LoadString(ghInst, IDS_CVRESULTCONVERTTO, lpszString, cch))
1417: wsprintf(lpszOutput, lpszString, lpszDefObj, lpszSelObj);
1418:
1419: }
1420: else // converting to the same class (no conversion)
1421: {
1422:
1423: if (0 != LoadString(ghInst, IDS_CVRESULTNOCHANGE, lpszString, cch))
1424: wsprintf(lpszOutput, lpszString, lpszDefObj);
1425: }
1426:
1427: }
1428:
1429: if (lpCV->dvAspect == DVASPECT_ICON) // Display as icon is checked
1430: {
1431: if (0 != LoadString(ghInst, IDS_CVRESULTDISPLAYASICON, lpszString, cch))
1432: lstrcat(lpszOutput, lpszString);
1433: }
1434: }
1435:
1436: if (lpCV->dwFlags & CF_SELECTACTIVATEAS)
1437: {
1438:
1439: if (0!=LoadString(ghInst, IDS_CVRESULTACTIVATEAS, lpszString, cch))
1440: wsprintf(lpszOutput, lpszString, lpszDefObj, lpszSelObj);
1441:
1442: // activating as a new class
1443: if (0 != lstrcmp(lpszDefObj, lpszSelObj))
1444: {
1445: if (0!=LoadString(ghInst, IDS_CVRESULTACTIVATEDIFF, lpszString, cch))
1446: lstrcat(lpszOutput, lpszString);
1447: }
1448: else // activating as itself.
1449: {
1450: lstrcat(lpszOutput, ".");
1451: }
1452: }
1453:
1454:
1455: //If LoadString failed, we simply clear out the results (*lpszOutput=0 above)
1456: SetDlgItemText(hDlg, IDCV_RESULTTEXT, lpszOutput);
1457:
1458: GlobalUnlock(hMem);
1459: GlobalFree(hMem);
1460: return;
1461: }
1462:
1463:
1464:
1465:
1466:
1467:
1468: /*
1469: * ConvertCleanup
1470: *
1471: * Purpose:
1472: * Performs convert-specific cleanup before Convert termination.
1473: *
1474: * Parameters:
1475: * hDlg HWND of the dialog box so we can access controls.
1476: *
1477: * Return Value:
1478: * None
1479: */
1480: void ConvertCleanup(HWND hDlg, LPCONVERT lpCV)
1481: {
1482:
1483: LPMALLOC pIMalloc;
1484:
1485:
1486: // Free our strings. Zero out the user type name string
1487: // the the calling app doesn't free to it.
1488:
1489: if (NOERROR != CoGetMalloc(MEMCTX_TASK, &pIMalloc))
1490: {
1491: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpCV->lpszConvertDefault);
1492: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpCV->lpszActivateDefault);
1493: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpCV->lpszIconSource);
1494: pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpCV->lpOCV->lpszUserType);
1495:
1496: lpCV->lpOCV->lpszUserType = NULL;
1497:
1498: pIMalloc->lpVtbl->Release(pIMalloc);
1499: }
1500:
1501: return;
1502: }
1503:
1504:
1505:
1506:
1507:
1508: /*
1509: * SwapWindows
1510: *
1511: * Purpose:
1512: * Moves hWnd1 to hWnd2's position and hWnd2 to hWnd1's position.
1513: * Does NOT change sizes.
1514: *
1515: *
1516: * Parameters:
1517: * hDlg HWND of the dialog box so we can turn redraw off
1518: *
1519: * Return Value:
1520: * None
1521: */
1522: void SwapWindows(HWND hDlg, HWND hWnd1, HWND hWnd2)
1523: {
1524:
1525: RECT Rect1, Rect2;
1526:
1527:
1528: GetWindowRect(hWnd1, &Rect1);
1529: GetWindowRect(hWnd2, &Rect2);
1530:
1531: ScreenToClient(hDlg, (LPPOINT)&Rect1.left);
1532: ScreenToClient(hDlg, (LPPOINT)&Rect1.right);
1533:
1534: ScreenToClient(hDlg, (LPPOINT)&Rect2.left);
1535: ScreenToClient(hDlg, (LPPOINT)&Rect2.right);
1536:
1537: SetWindowPos(hWnd1,
1538: NULL,
1539: Rect2.left,
1540: Rect2.top,
1541: 0,
1542: 0,
1543: SWP_NOZORDER | SWP_NOSIZE);
1544:
1545: SetWindowPos(hWnd2,
1546: NULL,
1547: Rect1.left,
1548: Rect1.top,
1549: 0,
1550: 0,
1551: SWP_NOZORDER | SWP_NOSIZE);
1552:
1553: return;
1554:
1555: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.