![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to icon.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 icon.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * ICON.C
3: *
4: * Implements the OleUIChangeIcon function which invokes the complete
5: * Change Icon dialog.
6: *
7: * Copyright (c)1992 Microsoft Corporation, All Right Reserved
8: */
9:
10: #define STRICT 1
11: #include "ole2ui.h"
12: #include "common.h"
13: #include "utility.h"
14: #include "icon.h"
15: #include "geticon.h"
16:
17: /*
18: * OleUIChangeIcon
19: *
20: * Purpose:
21: * Invokes the standard OLE Change Icon dialog box allowing the user
22: * to select an icon from an icon file, executable, or DLL.
23: *
24: * Parameters:
25: * lpCI LPOLEUIChangeIcon pointing to the in-out structure
26: * for this dialog.
27: *
28: * Return Value:
29: * UINT OLEUI_SUCCESS or OLEUI_OK if all is well, otherwise
30: * an error value.
31: */
32:
33: STDAPI_(UINT) OleUIChangeIcon(LPOLEUICHANGEICON lpCI)
34: {
35: UINT uRet;
36: HGLOBAL hMemDlg=NULL;
37:
38: uRet=UStandardValidation((LPOLEUISTANDARD)lpCI, sizeof(OLEUICHANGEICON)
39: , &hMemDlg);
40:
41: if (OLEUI_SUCCESS!=uRet)
42: return uRet;
43:
44: if (NULL==lpCI->hMetaPict)
45: uRet=OLEUI_CIERR_MUSTHAVECURRENTMETAFILE;
46:
47: if (lpCI->dwFlags & CIF_USEICONEXE)
48: {
49: if ( (NULL == lpCI->szIconExe)
50: || (IsBadReadPtr(lpCI->szIconExe, lpCI->cchIconExe))
51: || (IsBadWritePtr(lpCI->szIconExe, lpCI->cchIconExe)) )
52: uRet = OLEUI_CIERR_SZICONEXEINVALID;
53:
54: }
55:
56: // REVIEW: how do we validate the CLSID?
57: /*
58: if ('\0'==*((LPSTR)&lpCI->clsid))
59: uRet=OLEUI_CIERR_MUSTHAVECLSID;
60: */
61: if (OLEUI_ERR_STANDARDMIN <= uRet)
62: {
63: if (NULL!=hMemDlg)
64: FreeResource(hMemDlg);
65:
66: return uRet;
67: }
68:
69: //Now that we've validated everything, we can invoke the dialog.
70: return UStandardInvocation(ChangeIconDialogProc, (LPOLEUISTANDARD)lpCI
71: , hMemDlg, MAKEINTRESOURCE(IDD_CHANGEICON));
72: }
73:
74:
75:
76:
77:
78: /*
79: * ChangeIconDialogProc
80: *
81: * Purpose:
82: * Implements the OLE Change Icon dialog as invoked through the
83: * OleUIChangeIcon function.
84: *
85: * Parameters:
86: * Standard
87: *
88: * Return Value:
89: * Standard
90: */
91:
92: BOOL CALLBACK EXPORT ChangeIconDialogProc(HWND hDlg, UINT iMsg
93: , WPARAM wParam, LPARAM lParam)
94: {
95: LPCHANGEICON lpCI;
96: HICON hIcon;
97: HGLOBAL hMetaPict;
98: BOOL fOK=FALSE;
99: UINT uRet=0;
100: LPSTR psz;
101: char szTemp[OLEUI_CCHPATHMAX];
102:
103: //Declare Win16/Win32 compatible WM_COMMAND parameters.
104: COMMANDPARAMS(wID, wCode, hWndMsg);
105:
106: lpCI=(LPCHANGEICON)LpvStandardEntry(hDlg, iMsg, wParam, lParam, &uRet);
107:
108: //If the hook processed the message, we're done.
109: if (0!=uRet)
110: return uRet;
111:
112: //Process the temination message
113: if (iMsg==uMsgEndDialog)
114: {
115: //Insure that icons are properly destroyed.
116: SendDlgItemMessage(hDlg, ID_ICONLIST, LB_RESETCONTENT, 0, 0L);
117:
118: StandardCleanup(lpCI, hDlg);
119: EndDialog(hDlg, wParam);
120: return TRUE;
121: }
122:
123: switch (iMsg)
124: {
125: case WM_INITDIALOG:
126: FChangeIconInit(hDlg, wParam, lParam);
127: return TRUE;
128:
129:
130: case WM_MEASUREITEM:
131: {
132: LPMEASUREITEMSTRUCT lpMI=(LPMEASUREITEMSTRUCT)lParam;
133:
134: //All icons are system metric+padding in width and height
135: lpMI->itemWidth =GetSystemMetrics(SM_CXICON)+CXICONPAD;
136: lpMI->itemHeight=GetSystemMetrics(SM_CYICON)+CYICONPAD;
137: }
138: break;
139:
140:
141: case WM_DRAWITEM:
142: return FDrawListIcon((LPDRAWITEMSTRUCT)lParam);
143:
144:
145: case WM_DELETEITEM:
146: //Free the GDI object for the item
147: DestroyIcon((HICON)LOWORD(((LPDELETEITEMSTRUCT)lParam)->itemData));
148: break;
149:
150:
151: case WM_COMMAND:
152: switch (wID)
153: {
154: case ID_CURRENT:
155: case ID_DEFAULT:
156: case ID_FROMFILE:
157: UpdateResultIcon(lpCI, hDlg, wID);
158: break;
159:
160: case ID_LABELEDIT:
161: //When the edit loses focus, update the result display
162: if (EN_KILLFOCUS==wCode)
163: {
164: GetDlgItemText(hDlg, ID_LABELEDIT, szTemp, sizeof(szTemp));
165: SetDlgItemText(hDlg, ID_RESULTLABEL, szTemp);
166: }
167: break;
168:
169: case ID_FROMFILEEDIT:
170: //If the text changed, remove any selection in the list.
171: GetDlgItemText(hDlg, ID_FROMFILEEDIT, szTemp, sizeof(szTemp));
172:
173: if (lstrcmpi(szTemp, lpCI->szFile))
174: {
175: SendDlgItemMessage(hDlg, ID_ICONLIST, LB_SETCURSEL
176: , (WPARAM)-1, 0);
177:
178: //Also force selection of ID_FROMFILE
179: CheckRadioButton(hDlg, ID_CURRENT, ID_FROMFILE, ID_FROMFILE);
180: }
181: break;
182:
183:
184: case ID_ICONLIST:
185: switch (wCode)
186: {
187: case LBN_SETFOCUS:
188: //If we got the focus, see about updating.
189: GetDlgItemText(hDlg, ID_FROMFILEEDIT, szTemp
190: , sizeof(szTemp));
191:
192: //Check if file changed and update the list if so
193: if (0!=lstrcmpi(szTemp, lpCI->szFile))
194: {
195: lstrcpy(lpCI->szFile, szTemp);
196: UFillIconList(hDlg, ID_ICONLIST, lpCI->szFile);
197: UpdateResultIcon(lpCI, hDlg, ID_FROMFILE);
198: }
199: break;
200:
201: case LBN_SELCHANGE:
202: UpdateResultIcon(lpCI, hDlg, ID_FROMFILE);
203: break;
204:
205: case LBN_DBLCLK:
206: //Same as pressing OK.
207: SendCommand(hDlg, IDOK, BN_CLICKED, hWndMsg);
208: break;
209: }
210: break;
211:
212:
213: case ID_BROWSE:
214: {
215: DWORD dwOfnFlags;
216:
217: /*
218: * To allow the hook to customize the browse dialog, we
219: * send OLEUI_MSG_BROWSE. If the hook returns FALSE
220: * we use the default, otherwise we trust that it retrieved
221: * a filename for us. This mechanism prevents hooks from
222: * trapping ID_BROWSE to customize the dialog and from
223: * trying to figure out what we do after we have the name.
224: */
225:
226: lstrcpy(szTemp, lpCI->szFile); //Copy for reference
227:
228: uRet=UStandardHook(lpCI, hDlg, uMsgBrowse, OLEUI_CCHPATHMAX
229: , (LONG)(LPSTR)lpCI->szFile);
230:
231: dwOfnFlags = OFN_FILEMUSTEXIST;
232: // dont show the help button: easiest fix for #4567 since there is no hook proc
233: // if (lpCI->lpOCI->dwFlags & CIF_SHOWHELP)
234: // dwOfnFlags |= OFN_SHOWHELP;
235:
236: if (0==uRet)
237: uRet=(BOOL)Browse(hDlg, lpCI->szFile, NULL, OLEUI_CCHPATHMAX, IDS_ICONFILTERS, dwOfnFlags);
238:
239: /*
240: * Only reinitialize if the file changed, so if we got
241: * TRUE from the hook but the user hit Cancel, we don't
242: * spend time unecessarily refilling the list.
243: */
244: if (0!=uRet && 0!=lstrcmpi(szTemp, lpCI->szFile))
245: {
246: CheckRadioButton(hDlg, ID_CURRENT, ID_FROMFILE, ID_FROMFILE);
247: SetDlgItemText(hDlg, ID_FROMFILEEDIT, lpCI->szFile);
248: UFillIconList(hDlg, ID_ICONLIST, lpCI->szFile);
249: UpdateResultIcon(lpCI, hDlg, ID_FROMFILE);
250: }
251: }
252: break;
253:
254:
255: case IDOK:
256: /*
257: * If the user pressed enter, compare the current file
258: * and the one we have stored. If they match, then
259: * refill the listbox instead of closing down. This is
260: * so the user can press Enter in the edit control as
261: * they would expect to be able to do.
262: */
263: GetDlgItemText(hDlg, ID_FROMFILEEDIT, szTemp, sizeof(szTemp));
264:
265: //Check if the file changed at all.
266: if (0!=lstrcmpi(szTemp, lpCI->szFile))
267: {
268: lstrcpy(lpCI->szFile, szTemp);
269: UFillIconList(hDlg, ID_ICONLIST, lpCI->szFile);
270: UpdateResultIcon(lpCI, hDlg, ID_FROMFILE);
271:
272: //Eat this message to prevent focus change.
273: return TRUE;
274: }
275:
276:
277: if ((HWND)LOWORD(lParam) != GetFocus())
278: SetFocus((HWND)LOWORD(lParam));
279:
280: /*
281: * On closing, create a new metafilepict with the
282: * current icon and label, destroying the old structure.
283: *
284: * Since we make a copy of the icon by placing it into
285: * the metafile, we have to make sure we delete the
286: * icon in the current field. When the listbox is
287: * destroyed WM_DELETEITEMs will clean it up appropriately.
288: */
289:
290: hIcon=(HICON)SendDlgItemMessage(hDlg, ID_RESULTICON
291: , STM_GETICON, 0, 0L);
292:
293: /*
294: * If default is selected then we get the source
295: * information from registrion database for the
296: * current class to put in the metafile. If current
297: * is selected the we just retrieve the original file
298: * again and recreate the metafile. If from file is
299: * selected we use the current filename from the
300: * control and the current listbox selection.
301: */
302:
303: psz=lpCI->szFile;
304:
305: if (lpCI->dwFlags & CIF_SELECTDEFAULT)
306: {
307: psz=lpCI->szDefIconFile;
308: lpCI->iIcon=lpCI->iDefIcon;
309: hIcon=lpCI->hDefIcon;
310: }
311:
312: if (lpCI->dwFlags & CIF_SELECTCURRENT)
313: {
314: //Go get the current icon source back.
315: OleUIMetafilePictExtractIconSource(lpCI->lpOCI->hMetaPict
316: , psz, &lpCI->iIcon);
317: }
318:
319: if (lpCI->dwFlags & CIF_SELECTFROMFILE)
320: {
321: GetDlgItemText(hDlg, ID_FROMFILEEDIT, psz, OLEUI_CCHPATHMAX);
322:
323: lpCI->iIcon=(UINT)SendDlgItemMessage(hDlg
324: , ID_ICONLIST, LB_GETCURSEL, 0, 0L);
325: }
326:
327:
328: //Get the label and go create the metafile
329: GetDlgItemText(hDlg, ID_LABELEDIT, szTemp, sizeof(szTemp));
330:
331: //If psz is NULL (default) we get no source comments.
332: hMetaPict=OleUIMetafilePictFromIconAndLabel(hIcon
333: , szTemp, psz, lpCI->iIcon);
334:
335: //Clean up the current icon that we extracted.
336: hIcon=(HICON)SendDlgItemMessage(hDlg, ID_CURRENTICON
337: , STM_GETICON, 0, 0L);
338: DestroyIcon(hIcon);
339:
340: //Clean up the default icon
341: DestroyIcon(lpCI->hDefIcon);
342:
343: if (NULL==hMetaPict)
344: SendMessage(hDlg, uMsgEndDialog, OLEUI_FALSE, 0L);
345:
346: OleUIMetafilePictIconFree(lpCI->lpOCI->hMetaPict);
347: lpCI->lpOCI->hMetaPict=hMetaPict;
348:
349: lpCI->lpOCI->dwFlags = lpCI->dwFlags;
350:
351: SendMessage(hDlg, uMsgEndDialog, OLEUI_OK, 0L);
352: break;
353:
354:
355: case IDCANCEL:
356: //Clean up the current icon that we extracted.
357: hIcon=(HICON)SendDlgItemMessage(hDlg, ID_CURRENTICON
358: , STM_GETICON, 0, 0L);
359: DestroyIcon(hIcon);
360:
361: //Clean up the default icon
362: DestroyIcon(lpCI->hDefIcon);
363:
364: //We leave hMetaPict intact on Cancel; caller's responsibility
365: SendMessage(hDlg, uMsgEndDialog, OLEUI_CANCEL, 0L);
366: break;
367:
368:
369: case ID_OLEUIHELP:
370: PostMessage(lpCI->lpOCI->hWndOwner, uMsgHelp,
371: (WPARAM)hDlg, MAKELPARAM(IDD_CHANGEICON, 0));
372: break;
373: }
374: break;
375: }
376: return FALSE;
377: }
378:
379:
380:
381:
382: /*
383: * FChangeIconInit
384: *
385: * Purpose:
386: * WM_INITIDIALOG handler for the Change Icon dialog box.
387: *
388: * Parameters:
389: * hDlg HWND of the dialog
390: * wParam WPARAM of the message
391: * lParam LPARAM of the message
392: *
393: * Return Value:
394: * BOOL Value to return for WM_INITDIALOG.
395: */
396:
397: BOOL FChangeIconInit(HWND hDlg, WPARAM wParam, LPARAM lParam)
398: {
399: LPCHANGEICON lpCI;
400: LPOLEUICHANGEICON lpOCI;
401: HFONT hFont;
402: HWND hList;
403: UINT cyList;
404: RECT rc, rcG;
405: UINT uID;
406:
407: //1. Copy the structure at lParam into our instance memory.
408: lpCI=(LPCHANGEICON)LpvStandardInit(hDlg, sizeof(CHANGEICON), TRUE, &hFont);
409:
410: //PvStandardInit send a termination to us already.
411: if (NULL==lpCI)
412: return FALSE;
413:
414: //Save the original pointer and copy necessary information.
415: lpOCI=(LPOLEUICHANGEICON)lParam;
416:
417: lpCI->lpOCI =lpOCI;
418: lpCI->dwFlags=lpOCI->dwFlags;
419:
420: //Go extract the icon source from the metafile.
421: OleUIMetafilePictExtractIconSource(lpOCI->hMetaPict, lpCI->szFile, &lpCI->iIcon);
422:
423: //Go extract the icon and the label from the metafile
424: OleUIMetafilePictExtractLabel(lpOCI->hMetaPict, lpCI->szLabel, OLEUI_CCHLABELMAX, NULL);
425: lpCI->hCurIcon=OleUIMetafilePictExtractIcon(lpOCI->hMetaPict);
426:
427: //2. If we got a font, send it to the necessary controls.
428: if (NULL!=hFont)
429: {
430: SendDlgItemMessage(hDlg, ID_RESULTLABEL, WM_SETFONT
431: , (WPARAM)hFont, 0L);
432: }
433:
434:
435: //3. Show or hide the help button
436: if (!(lpCI->dwFlags & CIF_SHOWHELP))
437: StandardShowDlgItem(hDlg, ID_OLEUIHELP, SW_HIDE);
438:
439:
440: /*
441: * 4. Set text limits and initial control values. If we're given
442: * an intial label we set it in the edit and static controls.
443: * If we don't, then we copy the default contents of the static
444: * control into the edit control, meaning that only the default
445: * static control string need be localized.
446: */
447:
448: SendDlgItemMessage(hDlg, ID_LABELEDIT, EM_LIMITTEXT, OLEUI_CCHLABELMAX, 0L);
449: SendDlgItemMessage(hDlg, ID_FROMFILEEDIT, EM_LIMITTEXT, OLEUI_CCHPATHMAX, 0L);
450: SetDlgItemText(hDlg, ID_FROMFILEEDIT, lpCI->szFile);
451:
452: //Copy the label text into the edit and static controls.
453: SetDlgItemText(hDlg, ID_LABELEDIT, lpCI->szLabel);
454: SetDlgItemText(hDlg, ID_RESULTLABEL, lpCI->szLabel);
455:
456:
457: lpCI->hDefIcon = NULL;
458:
459: if (lpCI->dwFlags & CIF_USEICONEXE)
460: {
461: lpCI->hDefIcon = ExtractIcon(ghInst, lpCI->lpOCI->szIconExe, 0);
462:
463: if (NULL != lpCI->hDefIcon)
464: {
465: lstrcpy(lpCI->szDefIconFile, lpCI->lpOCI->szIconExe);
466: lpCI->iDefIcon = 0;
467: }
468: }
469:
470:
471: if (NULL == lpCI->hDefIcon)
472: {
473: HGLOBAL hMetaPict;
474:
475: hMetaPict = GetIconOfClass(ghInst,
476: &lpCI->lpOCI->clsid,
477: NULL,
478: TRUE);
479:
480: lpCI->hDefIcon = OleUIMetafilePictExtractIcon(hMetaPict);
481:
482: OleUIMetafilePictExtractIconSource(hMetaPict,
483: lpCI->szDefIconFile,
484: &lpCI->iDefIcon);
485:
486: OleUIMetafilePictIconFree(hMetaPict);
487: }
488:
489:
490: //Initialize all the icon displays.
491: SendDlgItemMessage(hDlg, ID_CURRENTICON, STM_SETICON
492: , (WPARAM)lpCI->hCurIcon, 0L);
493: SendDlgItemMessage(hDlg, ID_DEFAULTICON, STM_SETICON
494: , (WPARAM)lpCI->hDefIcon, 0L);
495: SendDlgItemMessage(hDlg, ID_RESULTICON, STM_SETICON
496: , (WPARAM)lpCI->hCurIcon, 0L);
497:
498:
499: /*
500: * 5. Since we cannot predict the size of icons on any display,
501: * we have to resize the icon listbox to the size of an icon
502: * (plus padding), a scrollbar, and two borders (top & bottom).
503: */
504: cyList=GetSystemMetrics(SM_CYICON)+GetSystemMetrics(SM_CYHSCROLL)
505: +GetSystemMetrics(SM_CYBORDER)*2+CYICONPAD;
506:
507: hList=GetDlgItem(hDlg, ID_ICONLIST);
508: GetClientRect(hList, &rc);
509: SetWindowPos(hList, NULL, 0, 0, rc.right, cyList
510: , SWP_NOMOVE | SWP_NOZORDER);
511:
512: //Set the columns in this multi-column listbox to hold one icon
513: SendMessage(hList, LB_SETCOLUMNWIDTH
514: , GetSystemMetrics(SM_CXICON)+CXICONPAD,0L);
515:
516: /*
517: * 5a. If the listbox expanded below the group box, then size
518: * the groupbox down, move the label static and exit controls
519: * down, and expand the entire dialog appropriately.
520: */
521:
522: GetWindowRect(hList, &rc);
523: GetWindowRect(GetDlgItem(hDlg, ID_GROUP), &rcG);
524:
525: if (rc.bottom > rcG.bottom)
526: {
527: //Calculate amount to move things down.
528: cyList=(rcG.bottom-rcG.top)-(rc.bottom-rc.top-cyList);
529:
530: //Expand the group box.
531: rcG.right -=rcG.left;
532: rcG.bottom-=rcG.top;
533: SetWindowPos(GetDlgItem(hDlg, ID_GROUP), NULL, 0, 0
534: , rcG.right, rcG.bottom+cyList
535: , SWP_NOMOVE | SWP_NOZORDER);
536:
537: //Expand the dialog box.
538: GetClientRect(hDlg, &rc);
539: SetWindowPos(hDlg, NULL, 0, 0, rc.right, rc.bottom+cyList
540: , SWP_NOMOVE | SWP_NOZORDER);
541:
542: //Move the label and edit controls down.
543: GetClientRect(GetDlgItem(hDlg, ID_LABEL), &rc);
544: SetWindowPos(GetDlgItem(hDlg, ID_LABEL), NULL, 0, cyList
545: , rc.right, rc.bottom, SWP_NOSIZE | SWP_NOZORDER);
546:
547: GetClientRect(GetDlgItem(hDlg, ID_LABELEDIT), &rc);
548: SetWindowPos(GetDlgItem(hDlg, ID_LABELEDIT), NULL, 0, cyList
549: , rc.right, rc.bottom, SWP_NOSIZE | SWP_NOZORDER);
550: }
551:
552:
553: /*
554: * 6. Select Current, Default, or From File radiobuttons appropriately.
555: * The CheckRadioButton call sends WM_COMMANDs which handle
556: * other actions. Note that if we check From File, which
557: * takes an icon from the list, we better fill the list.
558: * This will also fill the list even if default is selected.
559: */
560:
561: if (0!=UFillIconList(hDlg, ID_ICONLIST, lpCI->szFile))
562: {
563: //If szFile worked, then select the source icon in the listbox.
564: SendDlgItemMessage(hDlg, ID_ICONLIST, LB_SETCURSEL, lpCI->iIcon, 0L);
565: }
566:
567:
568: if (lpCI->dwFlags & CIF_SELECTCURRENT)
569: CheckRadioButton(hDlg, ID_CURRENT, ID_FROMFILE, ID_CURRENT);
570: else
571: {
572: uID=(lpCI->dwFlags & CIF_SELECTFROMFILE) ? ID_FROMFILE : ID_DEFAULT;
573: CheckRadioButton(hDlg, ID_CURRENT, ID_FROMFILE, uID);
574: }
575:
576: //7. Call the hook with lCustData in lParam
577: UStandardHook(lpCI, hDlg, WM_INITDIALOG, wParam, lpOCI->lCustData);
578: return TRUE;
579: }
580:
581:
582:
583:
584:
585: /*
586: * UFillIconList
587: *
588: * Purpose:
589: * Given a listbox and a filename, attempts to open that file and
590: * read all the icons that exist therein, adding them to the listbox
591: * hList as owner-draw items. If the file does not exist or has no
592: * icons, then you get no icons and an appropriate warning message.
593: *
594: * Parameters:
595: * hDlg HWND of the dialog containing the listbox.
596: * idList UINT identifier of the listbox to fill.
597: * pszFile LPSTR of the file from which to extract icons.
598: *
599: * Return Value:
600: * UINT Number of items added to the listbox. 0 on failure.
601: */
602:
603: UINT UFillIconList(HWND hDlg, UINT idList, LPSTR pszFile)
604: {
605: HWND hList;
606: UINT i;
607: UINT cIcons=0;
608: HCURSOR hCur;
609: HICON hIcon;
610: OFSTRUCT of;
611:
612: if (NULL==hDlg || !IsWindow(hDlg) || NULL==pszFile)
613: return 0;
614:
615: hList=GetDlgItem(hDlg, idList);
616:
617: if (NULL==hList)
618: return 0;
619:
620: //Clean out the listbox.
621: SendMessage(hList, LB_RESETCONTENT, 0, 0L);
622:
623: //If we have an empty string, just exit leaving the listbox empty as well
624: if (0==lstrlen(pszFile))
625: return 0;
626:
627: //Turn on the hourglass
628: hCur=HourGlassOn();
629:
630: //Check if the file is valid.
631: if (HFILE_ERROR!=OpenFile(pszFile, &of, OF_EXIST))
632: {
633: #ifdef EXTRACTICONWORKS
634: //Get the icon count for this file.
635: cIcons=(UINT)ExtractIcon(ghInst, pszFile, (UINT)-1);
636: #else
637: /*
638: * ExtractIcon in Windows 3.1 with -1 eats a selector, leaving an
639: * extra global memory object around for this applciation. Since
640: * changing icons may happen very often with all OLE apps in
641: * the system, we have to work around it. So we'll say we
642: * have lots of icons and just call ExtractIcon until it
643: * fails. We check if there's any around by trying to get
644: * the first one.
645: */
646: cIcons=0xFFFF;
647:
648: hIcon=ExtractIcon(ghInst, pszFile, 0);
649:
650: //Fake a failure with cIcons=0, or cleanup hIcon from this test.
651: if (32 > (UINT)hIcon)
652: cIcons=0;
653: else
654: DestroyIcon(hIcon);
655: #endif
656:
657: if (0!=cIcons)
658: {
659: SendMessage(hList, WM_SETREDRAW, FALSE, 0L);
660:
661: for (i=0; i<cIcons; i++)
662: {
663: hIcon=ExtractIcon(ghInst, pszFile, i);
664:
665: if (32 < (UINT)hIcon)
666: SendMessage(hList, LB_ADDSTRING, 0, (LONG)(UINT)hIcon);
667: #ifndef EXTRACTICONWORKS
668: else
669: {
670: //ExtractIcon failed, so let's leave now.
671: break;
672: }
673: #endif
674: }
675:
676: //Force complete repaint
677: SendMessage(hList, WM_SETREDRAW, TRUE, 0L);
678: InvalidateRect(hList, NULL, TRUE);
679:
680: //Select an icon
681: SendMessage(hList, LB_SETCURSEL, 0, 0L);
682: }
683: else
684: ErrorWithFile(hDlg, ghInst, IDS_CINOICONSINFILE, pszFile, MB_OK);
685: }
686: else
687: OpenFileError(hDlg, of.nErrCode, pszFile);
688:
689: HourGlassOff(hCur);
690: return cIcons;
691: }
692:
693:
694:
695:
696: /*
697: * FDrawListIcon
698: *
699: * Purpose:
700: * Handles WM_DRAWITEM for the icon listbox.
701: *
702: * Parameters:
703: * lpDI LPDRAWITEMSTRUCT from WM_DRAWITEM
704: *
705: * Return Value:
706: * BOOL TRUE if we did anything, FALSE if there are no items
707: * in the list.
708: */
709:
710: BOOL FDrawListIcon(LPDRAWITEMSTRUCT lpDI)
711: {
712: COLORREF cr;
713:
714: /*
715: * If there are no items in the list, then itemID is negative according
716: * to the Win3.1 SDK. Unfortunately DRAWITEMSTRUCT has an unsigned int
717: * for this field, so we need the typecast to do a signed comparison.
718: */
719: if ((int)lpDI->itemID < 0)
720: return FALSE;
721:
722: /*
723: * For selection or draw entire case we just draw the entire item all
724: * over again. For focus cases, we only call DrawFocusRect.
725: */
726:
727: if (lpDI->itemAction & (ODA_SELECT | ODA_DRAWENTIRE))
728: {
729: //Clear background and draw the icon.
730: if (lpDI->itemState & ODS_SELECTED)
731: cr=SetBkColor(lpDI->hDC, GetSysColor(COLOR_HIGHLIGHT));
732: else
733: cr=SetBkColor(lpDI->hDC, GetSysColor(COLOR_WINDOW));
734:
735: //Draw a cheap rectangle.
736: ExtTextOut(lpDI->hDC, 0, 0, ETO_OPAQUE, &lpDI->rcItem
737: , NULL, 0, NULL);
738:
739: DrawIcon(lpDI->hDC, lpDI->rcItem.left+(CXICONPAD/2)
740: , lpDI->rcItem.top+(CYICONPAD/2)
741: , (HICON)LOWORD(lpDI->itemData));
742:
743: //Restore original background for DrawFocusRect
744: SetBkColor(lpDI->hDC, cr);
745: }
746:
747: //Always change focus on the focus action.
748: if (lpDI->itemAction & ODA_FOCUS || lpDI->itemState & ODS_FOCUS)
749: DrawFocusRect(lpDI->hDC, &lpDI->rcItem);
750:
751: return TRUE;
752: }
753:
754:
755:
756:
757:
758: /*
759: * UpdateResultIcon
760: *
761: * Purpose:
762: * Updates the result icon using the current icon in the default display
763: * or the icon listbox depending on fFromDefault.
764: *
765: * Parameters:
766: * lpCI LPCHANGEICON containing dialog flags.
767: * hDlg HWND of the dialog
768: * uID UINT identifying the radiobutton selected.
769: *
770: * Return Value:
771: * None
772: */
773:
774: void UpdateResultIcon(LPCHANGEICON lpCI, HWND hDlg, UINT uID)
775: {
776: UINT iSel;
777: LONG lTemp=LB_ERR;
778:
779: lpCI->dwFlags &= ~(CIF_SELECTCURRENT | CIF_SELECTDEFAULT | CIF_SELECTFROMFILE);
780:
781: switch (uID)
782: {
783: case ID_CURRENT:
784: lTemp=SendDlgItemMessage(hDlg, ID_CURRENTICON, STM_GETICON, 0, 0L);
785: lpCI->dwFlags |= CIF_SELECTCURRENT;
786: break;
787:
788: case ID_DEFAULT:
789: lTemp=SendDlgItemMessage(hDlg, ID_DEFAULTICON, STM_GETICON, 0, 0L);
790: lpCI->dwFlags |= CIF_SELECTDEFAULT;
791: break;
792:
793: case ID_FROMFILE:
794: //Get the selected icon from the list and place it in the result
795: lpCI->dwFlags |= CIF_SELECTFROMFILE;
796:
797: iSel=(UINT)SendDlgItemMessage(hDlg, ID_ICONLIST, LB_GETCURSEL, 0, 0L);
798: if ((UINT)LB_ERR==iSel)
799: lTemp=SendDlgItemMessage(hDlg, ID_DEFAULTICON, STM_GETICON, 0, 0L);
800: else
801: SendDlgItemMessage(hDlg, ID_ICONLIST, LB_GETTEXT, iSel
802: , (LPARAM)(LPLONG)&lTemp);
803:
804: break;
805: }
806:
807: if ((LONG)LB_ERR!=lTemp)
808: SendDlgItemMessage(hDlg, ID_RESULTICON, STM_SETICON, LOWORD(lTemp), 0L);
809: return;
810: }
811:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.