![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to geticon.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 geticon.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / ole2ui |
1.1 root 1: /*
2: * GETICON.C
3: *
4: * Functions to create DVASPECT_ICON metafile from filename or classname.
5: *
6: * GetIconOfFile
7: * GetIconOfClass
8: * HIconAndSourceFromClass Extracts the first icon in a class's server path
9: * and returns the path and icon index to caller.
10: * FIconFileFromClass Retrieves the path to the exe/dll containing the
11: * default icon, and the index of the icon.
12: * OleUIMetafilePictFromIconAndLabel
13: * OleStdIconLabelTextOut
14: * PointerToNthField
15: * XformWidthInPixelsToHimetric Converts an int width into HiMetric units
16: * XformWidthInHimetricToPixels Converts an int width from HiMetric units
17: * XformHeightInPixelsToHimetric Converts an int height into HiMetric units
18: * XformHeightInHimetricToPixels Converts an int height from HiMetric units
19: *
20: * (c) Copyright Microsoft Corp. 1992-1993 All Rights Reserved
21: */
22:
23: #ifdef STANDALONE
24: #include <windows.h>
25: #include <shellapi.h>
26: #include <ole2.h>
27: #else
28: #define STRICT 1
29: #include "ole2ui.h"
30: #endif
31:
32: #include <stdlib.h>
33: #include <string.h>
34: #include <ctype.h>
35: #include <commdlg.h>
36: #include <memory.h>
37: #include <cderr.h>
38:
39: #include "geticon.h"
40:
41: static HINSTANCE s_hInst;
42:
43: static char szMaxWidth[] ="WWWWWWWWWW";
44:
45: //Strings for metafile comments.
46: static char szIconOnly[]="IconOnly"; //Where to stop to exclude label.
47:
48:
49: #ifdef STANDALONE
50: // these three values should be the same as in ole2ui.h
51: #define OLEUI_CCHKEYMAX 256
52: #define OLEUI_CCHPATHMAX 256
53: #define OLEUI_CCHLABELMAX 40
54: #else
55: static char szOLE2DLL[] = "ole2.dll"; // name of OLE 2.0 library
56: #endif
57:
58: #define ICONINDEX 0
59:
60: #define AUXUSERTYPE_SHORTNAME USERCLASSTYPE_SHORT // short name
61: #define HIMETRIC_PER_INCH 2540 // number HIMETRIC units per inch
62: #define PTS_PER_INCH 72 // number points (font size) per inch
63:
64: #define MAP_PIX_TO_LOGHIM(x,ppli) MulDiv(HIMETRIC_PER_INCH, (x), (ppli))
65: #define MAP_LOGHIM_TO_PIX(x,ppli) MulDiv((ppli), (x), HIMETRIC_PER_INCH)
66:
67: static char szVanillaDocIcon[] = "DefIcon";
68:
69: static char szDocument[40] = "";
70: static char szSeparators[] = " \t\\/!:";
71:
72: #define IS_SEPARATOR(c) ( (c) == ' ' || (c) == '\\' || (c) == '/' || (c) == '\t' || (c) == '!' || (c) == ':' )
73: #define IS_FILENAME_DELIM(c) ( (c) == '\\' || (c) == '/' || (c) == ':' )
74:
75:
76: STDAPI_(HGLOBAL) OleUIMetafilePictFromIconAndLabel(HICON, LPSTR, LPSTR, UINT);
77:
78:
79: /*******
80: *
81: * ICON METAFILE FORMAT:
82: *
83: * The metafile generated with OleUIMetafilePictFromIconAndLabel contains
84: * the following records which are used by the functions in DRAWICON.C
85: * to draw the icon with and without the label and to extract the icon,
86: * label, and icon source/index.
87: *
88: * SetWindowOrg
89: * SetWindowExt
90: * DrawIcon:
91: * Inserts records of DIBBITBLT or DIBSTRETCHBLT, once for the
92: * AND mask, one for the image bits.
93: * Escape with the comment "IconOnly"
94: * This indicates where to stop record enumeration to draw only
95: * the icon.
96: * SetTextColor
97: * SetBkColor
98: * CreateFont
99: * SelectObject on the font.
100: * ExtTextOut
101: * One or more ExtTextOuts occur if the label is wrapped. The
102: * text in these records is used to extract the label.
103: * SelectObject on the old font.
104: * DeleteObject on the font.
105: * Escape with a comment that contains the path to the icon source.
106: * Escape with a comment that is the ASCII of the icon index.
107: *
108: *******/
109:
110:
111:
112:
113: /*
114: * GetIconOfFile(HINSTANCE hInst, LPSTR lpszPath, BOOL fUseFileAsLabel)
115: *
116: * Purpose:
117: * Returns a hMetaPict containing an icon and label (filename) for the
118: * specified filename.
119: *
120: * Parameters:
121: * hinst
122: * lpszPath LPSTR path including filename to use
123: * fUseFileAsLabel BOOL TRUE if the icon's label is the filename, FALSE if
124: * there should be no label.
125: *
126: * Return Value:
127: * HGLOBAL hMetaPict containing the icon and label - if there's no
128: * class in reg db for the file in lpszPath, then we use
129: * Document. If lpszPath is NULL, then we return NULL.
130: */
131:
132: STDAPI_(HGLOBAL) GetIconOfFile(HINSTANCE hInst, LPSTR lpszPath, BOOL fUseFileAsLabel)
133: {
134:
135:
136: char szIconFile[OLEUI_CCHPATHMAX];
137: char szLabel[OLEUI_CCHLABELMAX];
138: LPSTR lpszClsid = NULL;
139: CLSID clsid;
140: HICON hDefIcon = NULL;
141: UINT IconIndex = 0;
142: HGLOBAL hMetaPict;
143: HRESULT hResult;
144:
145:
146:
147: if (NULL == lpszPath) // even if fUseFileAsLabel is FALSE, we still
148: return NULL; // need a valid filename to get the class.
149:
150: s_hInst = hInst;
151:
152: hResult = GetClassFile(lpszPath, &clsid);
153:
154: if (NOERROR == hResult) // use the clsid we got to get to the icon
155: {
156: hDefIcon = HIconAndSourceFromClass(&clsid,
157: (LPSTR)szIconFile,
158: &IconIndex);
159: }
160:
161: if ( (NOERROR != hResult) || (NULL == hDefIcon) )
162: {
163: // Here, either GetClassFile failed or HIconAndSourceFromClass failed.
164:
165: LPSTR lpszTemp;
166:
167: lpszTemp = lpszPath;
168:
169: while ((*lpszTemp != '.') && (*lpszTemp != '\0'))
170: lpszTemp++;
171:
172:
173: if ('.' != *lpszTemp)
174: goto UseVanillaDocument;
175:
176:
177: if (FALSE == GetAssociatedExecutable(lpszTemp, (LPSTR)szIconFile))
178: goto UseVanillaDocument;
179:
180: hDefIcon = ExtractIcon(s_hInst, szIconFile, IconIndex);
181: }
182:
183: if (hDefIcon <= (HICON)1) // ExtractIcon returns 1 if szExecutable is not exe,
184: { // 0 if there are no icons.
185: UseVanillaDocument:
186:
187: #ifdef STANDALONE
188: GetModuleFileName(s_hInst, (LPSTR)szIconFile, OLEUI_CCHPATHMAX);
189: IconIndex = ICONINDEX;
190: hDefIcon = LoadIcon(s_hInst, (LPSTR)szVanillaDocIcon);
191: #else
192: lstrcpy((LPSTR)szIconFile, (LPSTR)szOLE2DLL);
193: IconIndex = ICONINDEX;
194: hDefIcon = ExtractIcon(s_hInst, szIconFile, IconIndex);
195: #endif
196:
197: }
198:
199: // Now let's get the label we want to use.
200:
201: if (fUseFileAsLabel) // strip off path, so we just have the filename.
202: {
203: int istrlen;
204: LPSTR lpszBeginFile;
205:
206: istrlen = lstrlen(lpszPath);
207:
208: // set pointer to END of path, so we can walk backwards through it.
209: lpszBeginFile = lpszPath + istrlen -1;
210:
211: while ( (lpszBeginFile >= lpszPath)
212: && (!IS_FILENAME_DELIM(*lpszBeginFile)) )
213: lpszBeginFile--;
214:
215:
216: lpszBeginFile++; // step back over the delimiter
217:
218:
219: lstrcpyn(szLabel, lpszBeginFile, sizeof(szLabel));
220: }
221:
222: else // use the short user type (AuxUserType2) for the label
223: {
224:
225: if (0 == OleStdGetAuxUserType(&clsid, AUXUSERTYPE_SHORTNAME,
226: (LPSTR)szLabel, OLEUI_CCHLABELMAX, NULL)) {
227:
228: #if !defined( STANDALONE )
229: if ('\0'==szDocument[0]) {
230: LoadString(
231: s_hInst,IDS_DEFICONLABEL,szDocument,sizeof(szDocument));
232: }
233: #endif
234: lstrcpy(szLabel, szDocument);
235: }
236: }
237:
238:
239: hMetaPict = OleUIMetafilePictFromIconAndLabel(hDefIcon,
240: szLabel,
241: (LPSTR)szIconFile,
242: IconIndex);
243:
244: DestroyIcon(hDefIcon);
245:
246: return hMetaPict;
247:
248: }
249:
250: /*
251: * GetAssociatedExecutable
252: *
253: * Purpose: Finds the executable associated with the provided extension
254: *
255: * Parameters:
256: * lpszExtension LPSTR points to the extension we're trying to find an exe
257: * for. Does **NO** validation.
258: *
259: * lpszExecutable LPSTR points to where the exe name will be returned.
260: * No validation here either - pass in 128 char buffer.
261: *
262: * Return:
263: * BOOL TRUE if we found an exe, FALSE if we didn't.
264: *
265: */
266:
267: BOOL FAR PASCAL GetAssociatedExecutable(LPSTR lpszExtension, LPSTR lpszExecutable)
268:
269: {
270: HKEY hKey;
271: DWORD dw;
272: LRESULT lRet;
273: char szValue[OLEUI_CCHKEYMAX];
274: char szKey[OLEUI_CCHKEYMAX];
275: LPSTR lpszTemp, lpszExe;
276:
277:
278: lRet = RegOpenKey(HKEY_CLASSES_ROOT, NULL, &hKey);
279:
280: if (ERROR_SUCCESS != lRet)
281: return FALSE;
282:
283: dw = OLEUI_CCHPATHMAX;
284: lRet = RegQueryValue(hKey, lpszExtension, (LPSTR)szValue, &dw); //ProgId
285:
286: if (ERROR_SUCCESS != lRet)
287: {
288: RegCloseKey(hKey);
289: return FALSE;
290: }
291:
292:
293: // szValue now has ProgID
294: lstrcpy(szKey, szValue);
295: lstrcat(szKey, "\\Shell\\Open\\Command");
296:
297:
298: dw = OLEUI_CCHPATHMAX;
299: lRet = RegQueryValue(hKey, (LPSTR)szKey, (LPSTR)szValue, &dw);
300:
301: if (ERROR_SUCCESS != lRet)
302: {
303: RegCloseKey(hKey);
304: return FALSE;
305: }
306:
307: // szValue now has an executable name in it. Let's null-terminate
308: // at the first post-executable space (so we don't have cmd line
309: // args.
310:
311: lpszTemp = (LPSTR)szValue;
312:
313: while (('\0' != *lpszTemp) && (isspace(*lpszTemp)))
314: lpszTemp++; // Strip off leading spaces
315:
316: lpszExe = lpszTemp;
317:
318: while (('\0' != lpszTemp) && (!isspace(*lpszTemp)))
319: lpszTemp++; // Set through exe name
320:
321: *lpszTemp = '\0'; // null terminate at first space (or at end).
322:
323:
324: lstrcpy(lpszExecutable, lpszExe);
325:
326: return TRUE;
327:
328: }
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339: /*
340: * GetIconOfClass(HINSTANCE hInst, REFCLSID rclsid, LPSTR lpszLabel, BOOL fUseTypeAsLabel)
341: *
342: * Purpose:
343: * Returns a hMetaPict containing an icon and label (human-readable form
344: * of class) for the specified clsid.
345: *
346: * Parameters:
347: * hinst
348: * rclsid REFCLSID pointing to clsid to use.
349: * lpszLabel label to use for icon.
350: * fUseTypeAsLabel Use the clsid's user type name as the icon's label.
351: *
352: * Return Value:
353: * HGLOBAL hMetaPict containing the icon and label - if we
354: * don't find the clsid in the reg db then we
355: * return NULL.
356: */
357:
358: STDAPI_(HGLOBAL) GetIconOfClass(HINSTANCE hInst, REFCLSID rclsid, LPSTR lpszLabel, BOOL fUseTypeAsLabel)
359: {
360:
361: char szLabel[OLEUI_CCHLABELMAX];
362: char szIconFile[OLEUI_CCHPATHMAX];
363: HICON hDefIcon;
364: UINT IconIndex;
365: HGLOBAL hMetaPict;
366:
367:
368: s_hInst = hInst;
369:
370: if (!fUseTypeAsLabel) // Use string passed in as label
371: {
372: if (NULL != lpszLabel)
373: lstrcpyn(szLabel, lpszLabel, sizeof(szLabel));
374: else
375: *szLabel = '\0';
376: }
377: else // Use AuxUserType2 (short name) as label
378: {
379:
380: if (0 == OleStdGetAuxUserType(rclsid,
381: AUXUSERTYPE_SHORTNAME,
382: (LPSTR)szLabel,
383: OLEUI_CCHLABELMAX,
384: NULL))
385:
386: // If we can't get the AuxUserType2, then try the long name
387: if (0 == OleStdGetUserTypeOfClass(rclsid, szLabel, OLEUI_CCHKEYMAX, NULL)) {
388: #if !defined( STANDALONE )
389: if ('\0'==szDocument[0]) {
390: LoadString(
391: s_hInst,IDS_DEFICONLABEL,szDocument,sizeof(szDocument));
392: }
393: #endif
394: lstrcpy(szLabel, szDocument); // last resort
395: }
396: }
397:
398: // Get the icon, icon index, and path to icon file
399: hDefIcon = HIconAndSourceFromClass(rclsid,
400: (LPSTR)szIconFile,
401: &IconIndex);
402:
403: if (NULL == hDefIcon) // Use Vanilla Document
404: {
405: #ifdef STANDALONE
406: GetModuleFileName(s_hInst, (LPSTR)szIconFile, OLEUI_CCHPATHMAX);
407: IconIndex = ICONINDEX;
408: hDefIcon = LoadIcon(s_hInst, (LPSTR)szVanillaDocIcon);
409: #else
410: lstrcpy((LPSTR)szIconFile, (LPSTR)szOLE2DLL);
411: IconIndex = ICONINDEX;
412: hDefIcon = ExtractIcon(s_hInst, szIconFile, IconIndex);
413: #endif
414:
415: }
416:
417: // Create the metafile
418: hMetaPict = OleUIMetafilePictFromIconAndLabel(hDefIcon, szLabel,
419: (LPSTR)szIconFile, IconIndex);
420:
421: DestroyIcon(hDefIcon);
422:
423: return hMetaPict;
424:
425: }
426:
427:
428:
429:
430:
431: /*
432: * HIconAndSourceFromClass
433: *
434: * Purpose:
435: * Given an object class name, finds an associated executable in the
436: * registration database and extracts the first icon from that
437: * executable. If none is available or the class has no associated
438: * executable, this function returns NULL.
439: *
440: * Parameters:
441: * rclsid pointer to clsid to look up.
442: * pszSource LPSTR in which to place the source of the icon.
443: * This is assumed to be OLEUI_CCHPATHMAX
444: * puIcon UINT FAR * in which to store the index of the
445: * icon in pszSource.
446: *
447: * Return Value:
448: * HICON Handle to the extracted icon if there is a module
449: * associated to pszClass. NULL on failure to either
450: * find the executable or extract and icon.
451: */
452:
453: HICON FAR PASCAL HIconAndSourceFromClass(REFCLSID rclsid, LPSTR pszSource, UINT FAR *puIcon)
454: {
455: HICON hIcon;
456: int IconIndex;
457:
458: if (NULL==rclsid || NULL==pszSource)
459: return NULL;
460:
461: if (!FIconFileFromClass(rclsid, pszSource, OLEUI_CCHPATHMAX, &IconIndex))
462: return NULL;
463:
464: hIcon=ExtractIcon(s_hInst, pszSource, IconIndex);
465:
466: if ((HICON)32 > hIcon)
467: hIcon=NULL;
468: else
469: *puIcon= IconIndex;
470:
471: return hIcon;
472: }
473:
474:
475:
476: /*
477: * FIconFileFromClass
478: *
479: * Purpose:
480: * Looks up the path to executable that contains the class default icon.
481: *
482: * Parameters:
483: * rclsid pointer to CLSID to look up.
484: * pszEXE LPSTR at which to store the server name
485: * cch UINT size of pszEXE
486: * lpIndex LPUINT to index of icon within executable
487: *
488: * Return Value:
489: * BOOL TRUE if one or more characters were loaded into pszEXE.
490: * FALSE otherwise.
491: */
492:
493: BOOL FAR PASCAL FIconFileFromClass(REFCLSID rclsid, LPSTR pszEXE, UINT cch, UINT FAR *lpIndex)
494: {
495:
496: DWORD dw;
497: LONG lRet;
498: HKEY hKey;
499: LPMALLOC lpIMalloc;
500: HRESULT hrErr;
501: LPSTR lpBuffer;
502: LPSTR lpIndexString;
503: UINT cBufferSize = 136; // room for 128 char path and icon's index
504: char szKey[64];
505: LPSTR pszClass;
506:
507:
508: if (NULL==rclsid || NULL==pszEXE || 0==cch || IsEqualCLSID(rclsid,&CLSID_NULL))
509: return FALSE;
510:
511: //Here, we use CoGetMalloc and alloc a buffer (maxpathlen + 8) to
512: //pass to RegQueryValue. Then, we copy the exe to pszEXE and the
513: //index to *lpIndex.
514:
515: hrErr = CoGetMalloc(MEMCTX_TASK, &lpIMalloc);
516:
517: if (NOERROR != hrErr)
518: return FALSE;
519:
520: lpBuffer = (LPSTR)lpIMalloc->lpVtbl->Alloc(lpIMalloc, cBufferSize);
521:
522: if (NULL == lpBuffer)
523: {
524: lpIMalloc->lpVtbl->Release(lpIMalloc);
525: return FALSE;
526: }
527:
528:
529: if (CoIsOle1Class(rclsid))
530: {
531:
532: LPSTR lpszProgID;
533:
534: // we've got an ole 1.0 class on our hands, so we look at
535: // progID\protocol\stdfileedting\server to get the
536: // name of the executable.
537:
538: ProgIDFromCLSID(rclsid, &lpszProgID);
539:
540: //Open up the class key
541: lRet=RegOpenKey(HKEY_CLASSES_ROOT, lpszProgID, &hKey);
542:
543: if (ERROR_SUCCESS != lRet)
544: {
545: lpIMalloc->lpVtbl->Free(lpIMalloc, lpszProgID);
546: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
547: lpIMalloc->lpVtbl->Release(lpIMalloc);
548: return FALSE;
549: }
550:
551: dw=(DWORD)cBufferSize;
552: lRet = RegQueryValue(hKey, "Protocol\\StdFileEditing\\Server", lpBuffer, &dw);
553:
554: if (ERROR_SUCCESS != lRet)
555: {
556:
557: RegCloseKey(hKey);
558: lpIMalloc->lpVtbl->Free(lpIMalloc, lpszProgID);
559: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
560: lpIMalloc->lpVtbl->Release(lpIMalloc);
561: return FALSE;
562: }
563:
564:
565: // Use server and 0 as the icon index
566: lstrcpyn(pszEXE, lpBuffer, cch);
567:
568: *lpIndex = 0;
569:
570: RegCloseKey(hKey);
571: lpIMalloc->lpVtbl->Free(lpIMalloc, lpszProgID);
572: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
573: lpIMalloc->lpVtbl->Release(lpIMalloc);
574: return TRUE;
575:
576: }
577:
578:
579:
580: /*
581: * We have to go walking in the registration database under the
582: * classname, so we first open the classname key and then check
583: * under "\\DefaultIcon" to get the file that contains the icon.
584: */
585:
586: StringFromCLSID(rclsid, &pszClass);
587:
588: lstrcpy(szKey, "CLSID\\");
589: lstrcat(szKey, pszClass);
590:
591: //Open up the class key
592: lRet=RegOpenKey(HKEY_CLASSES_ROOT, szKey, &hKey);
593:
594: if (ERROR_SUCCESS != lRet)
595: {
596: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
597: lpIMalloc->lpVtbl->Free(lpIMalloc, pszClass);
598: lpIMalloc->lpVtbl->Release(lpIMalloc);
599: return FALSE;
600: }
601:
602: //Get the executable path and icon index.
603:
604: dw=(DWORD)cBufferSize;
605: lRet=RegQueryValue(hKey, "DefaultIcon", lpBuffer, &dw);
606:
607: if (ERROR_SUCCESS != lRet)
608: {
609: // no DefaultIcon key...try LocalServer
610:
611: dw=(DWORD)cBufferSize;
612: lRet=RegQueryValue(hKey, "LocalServer", lpBuffer, &dw);
613:
614: if (ERROR_SUCCESS != lRet)
615: {
616: // no LocalServer entry either...they're outta luck.
617:
618: RegCloseKey(hKey);
619: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
620: lpIMalloc->lpVtbl->Free(lpIMalloc, pszClass);
621: lpIMalloc->lpVtbl->Release(lpIMalloc);
622: return FALSE;
623: }
624:
625:
626: // Use server from LocalServer or Server and 0 as the icon index
627: lstrcpyn(pszEXE, lpBuffer, cch);
628:
629: *lpIndex = 0;
630:
631: RegCloseKey(hKey);
632: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
633: lpIMalloc->lpVtbl->Free(lpIMalloc, pszClass);
634: lpIMalloc->lpVtbl->Release(lpIMalloc);
635: return TRUE;
636: }
637:
638: RegCloseKey(hKey);
639:
640: // lpBuffer contains a string that looks like "<pathtoexe>,<iconindex>",
641: // so we need to separate the path and the icon index.
642:
643: lpIndexString = PointerToNthField(lpBuffer, 2, ',');
644:
645: if ('\0' == *lpIndexString) // no icon index specified - use 0 as default.
646: {
647: *lpIndex = 0;
648:
649: }
650: else
651: {
652: LPSTR lpTemp;
653: static char szTemp[16];
654:
655: lstrcpy((LPSTR)szTemp, lpIndexString);
656:
657: // Put the icon index part into *pIconIndex
658: *lpIndex = atoi((const char *)szTemp);
659:
660: // Null-terminate the exe part.
661: lpTemp = AnsiPrev(lpBuffer, lpIndexString);
662: *lpTemp = '\0';
663: }
664:
665: if (!lstrcpyn(pszEXE, lpBuffer, cch))
666: {
667: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
668: lpIMalloc->lpVtbl->Free(lpIMalloc, pszClass);
669: lpIMalloc->lpVtbl->Release(lpIMalloc);
670: return FALSE;
671: }
672:
673: // Free the memory we alloc'd and leave.
674: lpIMalloc->lpVtbl->Free(lpIMalloc, lpBuffer);
675: lpIMalloc->lpVtbl->Free(lpIMalloc, pszClass);
676: lpIMalloc->lpVtbl->Release(lpIMalloc);
677: return TRUE;
678: }
679:
680:
681:
682:
683: /*
684: * OleUIMetafilePictFromIconAndLabel
685: *
686: * Purpose:
687: * Creates a METAFILEPICT structure that container a metafile in which
688: * the icon and label are drawn. A comment record is inserted between
689: * the icon and the label code so our special draw function can stop
690: * playing before the label.
691: *
692: * Parameters:
693: * hIcon HICON to draw into the metafile
694: * pszLabel LPSTR to the label string.
695: * pszSourceFile LPSTR containing the local pathname of the icon
696: * as we either get from the user or from the reg DB.
697: * iIcon UINT providing the index into pszSourceFile where
698: * the icon came from.
699: *
700: * Return Value:
701: * HGLOBAL Global memory handle containing a METAFILEPICT where
702: * the metafile uses the MM_ANISOTROPIC mapping mode. The
703: * extents reflect both icon and label.
704: */
705:
706: STDAPI_(HGLOBAL) OleUIMetafilePictFromIconAndLabel(HICON hIcon, LPSTR pszLabel
707: , LPSTR pszSourceFile, UINT iIcon)
708: {
709: HDC hDC, hDCScreen;
710: HMETAFILE hMF;
711: HGLOBAL hMem;
712: LPMETAFILEPICT pMF;
713: UINT cxIcon, cyIcon;
714: UINT cxText, cyText;
715: UINT cx, cy;
716: UINT cchLabel = 0;
717: HFONT hFont, hFontT;
718: int cyFont;
719: char szIndex[10];
720: RECT TextRect;
721: SIZE size;
722: POINT point;
723:
724: if (NULL==hIcon) // null label is valid
725: return NULL;
726:
727: //Create a memory metafile
728: hDC=(HDC)CreateMetaFile(NULL);
729:
730: if (NULL==hDC)
731: return NULL;
732:
733: //Allocate the metafilepict
734: hMem=GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(METAFILEPICT));
735:
736: if (NULL==hMem)
737: {
738: hMF=CloseMetaFile(hDC);
739: DeleteMetaFile(hMF);
740: return NULL;
741: }
742:
743:
744: if (NULL!=pszLabel)
745: {
746: cchLabel=lstrlen(pszLabel);
747:
748: if (cchLabel >= OLEUI_CCHLABELMAX)
749: pszLabel[cchLabel] = '\0'; // truncate string
750: }
751:
752: //Need to use the screen DC for these operations
753: hDCScreen=GetDC(NULL);
754: cyFont=-(8*GetDeviceCaps(hDCScreen, LOGPIXELSY))/72;
755:
756: //cyFont was calculated to give us 8 point.
757: hFont=CreateFont(cyFont, 5, 0, 0, FW_NORMAL, 0, 0, 0, ANSI_CHARSET
758: , OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, PROOF_QUALITY
759: , FF_SWISS, "MS Sans Serif");
760:
761: hFontT=SelectObject(hDCScreen, hFont);
762:
763: GetTextExtentPoint(hDCScreen,szMaxWidth,lstrlen(szMaxWidth),&size);
764: SelectObject(hDCScreen, hFontT);
765:
766: ReleaseDC(NULL, hDCScreen);
767:
768: cxText = size.cx;
769: cyText = size.cy * 2;
770:
771: cxIcon = GetSystemMetrics(SM_CXICON);
772: cyIcon = GetSystemMetrics(SM_CYICON);
773:
774:
775: // If we have no label, then we want the metafile to be the width of
776: // the icon (plus margin), not the width of the fattest string.
777: if ( (NULL == pszLabel) || ('\0' == *pszLabel) )
778: cx = cxIcon + cxIcon / 4;
779: else
780: cx = max(cxText, cxIcon);
781:
782: cy=cyIcon+cyText+4;
783:
784: //Set the metafile size to fit the icon and label
785: SetWindowOrgEx(hDC, 0, 0, &point);
786: SetWindowExtEx(hDC, cx, cy, &size);
787:
788: //Set up rectangle to pass to OleStdIconLabelTextOut
789: SetRectEmpty(&TextRect);
790:
791: TextRect.right = cx;
792: TextRect.bottom = cy;
793:
794: //Draw the icon and the text, centered with respect to each other.
795: DrawIcon(hDC, (cx-cxIcon)/2, 0, hIcon);
796:
797: //String that indicates where to stop if we're only doing icons
798: Escape(hDC, MFCOMMENT, lstrlen(szIconOnly)+1, szIconOnly, NULL);
799:
800: SetTextColor(hDC, GetSysColor(COLOR_WINDOWTEXT));
801: SetBkMode(hDC, TRANSPARENT);
802:
803: OleStdIconLabelTextOut(hDC,
804: hFont,
805: 0,
806: cy - cyText,
807: ETO_CLIPPED,
808: &TextRect,
809: pszLabel,
810: cchLabel,
811: NULL);
812:
813: //Write comments containing the icon source file and index.
814: if (NULL!=pszSourceFile)
815: {
816: //+1 on string lengths insures the null terminator is embedded.
817: Escape(hDC, MFCOMMENT, lstrlen(pszSourceFile)+1, pszSourceFile, NULL);
818:
819: cchLabel=wsprintf(szIndex, "%u", iIcon);
820: Escape(hDC, MFCOMMENT, cchLabel+1, szIndex, NULL);
821: }
822:
823: //All done with the metafile, now stuff it all into a METAFILEPICT.
824: hMF=CloseMetaFile(hDC);
825:
826: if (NULL==hMF)
827: {
828: GlobalFree(hMem);
829: return NULL;
830: }
831:
832: //Fill out the structure
833: pMF=(LPMETAFILEPICT)GlobalLock(hMem);
834:
835: //Transform to HIMETRICS
836: cx=XformWidthInPixelsToHimetric(hDCScreen, cx);
837: cy=XformHeightInPixelsToHimetric(hDCScreen, cy);
838:
839: pMF->mm=MM_ANISOTROPIC;
840: pMF->xExt=cx;
841: pMF->yExt=cy;
842: pMF->hMF=hMF;
843:
844: GlobalUnlock(hMem);
845:
846: DeleteObject(hFont);
847:
848: return hMem;
849: }
850:
851:
852:
853: /*
854: * OleStdIconLabelTextOut
855: *
856: * Purpose:
857: * Replacement for DrawText to be used in the "Display as Icon" metafile.
858: * Uses ExtTextOut to output a string center on (at most) two lines.
859: * Uses a very simple word wrap algorithm to split the lines.
860: *
861: * Parameters: (same as for ExtTextOut, except for hFont)
862: * hDC device context to draw into; if this is NULL, then we don't
863: * ETO the text, we just return the index of the beginning
864: * of the second line
865: * hFont font to use
866: * nXStart x-coordinate of starting position
867: * nYStart y-coordinate of starting position
868: * fuOptions rectangle type
869: * lpRect rect far * containing rectangle to draw text in.
870: * lpszString string to draw
871: * cchString length of string (truncated if over OLEUI_CCHLABELMAX)
872: * lpDX spacing between character cells
873: *
874: * Return Value:
875: * UINT Index of beginning of last line (0 if there's only one
876: * line of text).
877: *
878: */
879:
880: STDAPI_(UINT) OleStdIconLabelTextOut(HDC hDC,
881: HFONT hFont,
882: int nXStart,
883: int nYStart,
884: UINT fuOptions,
885: RECT FAR * lpRect,
886: LPSTR lpszString,
887: UINT cchString,
888: int FAR * lpDX)
889: {
890:
891: HDC hDCScreen;
892: static char szTempBuff[OLEUI_CCHLABELMAX];
893: int cxString, cyString, cxMaxString;
894: int cxFirstLine, cyFirstLine, cxSecondLine;
895: int index;
896: int cch = cchString;
897: char chKeep;
898: LPSTR lpszSecondLine;
899: HFONT hFontT;
900: BOOL fPrintText = TRUE;
901: UINT iLastLineStart = 0;
902: SIZE size;
903:
904: // Initialization stuff...
905:
906: if (NULL == hDC) // If we got NULL as the hDC, then we don't actually call ETO
907: fPrintText = FALSE;
908:
909:
910: // Make a copy of the string (NULL or non-NULL) that we're using
911: if (NULL == lpszString)
912: *szTempBuff = '\0';
913:
914: else
915: lstrcpyn(szTempBuff, lpszString, sizeof(szTempBuff));
916:
917: // set maximum width
918: cxMaxString = lpRect->right - lpRect->left;
919:
920: // get screen DC to do text size calculations
921: hDCScreen = GetDC(NULL);
922:
923: hFontT=SelectObject(hDCScreen, hFont);
924:
925: // get the extent of our label
926: GetTextExtentPoint(hDCScreen, szTempBuff, cch, &size);
927:
928: cxString = size.cx;
929: cyString = size.cy;
930:
931: // Select in the font we want to use
932: if (fPrintText)
933: SelectObject(hDC, hFont);
934:
935: // String is smaller than max string - just center, ETO, and return.
936: if (cxString <= cxMaxString)
937: {
938:
939: if (fPrintText)
940: ExtTextOut(hDC,
941: nXStart + (lpRect->right - cxString) / 2,
942: nYStart,
943: fuOptions,
944: lpRect,
945: szTempBuff,
946: cch,
947: NULL);
948:
949: iLastLineStart = 0; // only 1 line of text
950: goto CleanupAndLeave;
951: }
952:
953: // String is too long...we've got to word-wrap it.
954:
955:
956: // Are there any spaces, slashes, tabs, or bangs in string?
957:
958: if (lstrlen(szTempBuff) != (int)strcspn(szTempBuff, szSeparators))
959: {
960: // Yep, we've got spaces, so we'll try to find the largest
961: // space-terminated string that will fit on the first line.
962:
963: index = cch;
964:
965:
966: while (index >= 0)
967: {
968:
969: char cchKeep;
970:
971: // scan the string backwards for spaces, slashes, tabs, or bangs
972:
973: while (!IS_SEPARATOR(szTempBuff[index]) )
974: index--;
975:
976:
977: if (index <= 0)
978: break;
979:
980: cchKeep = szTempBuff[index]; // remember what char was there
981:
982: szTempBuff[index] = '\0'; // just for now
983:
984: GetTextExtentPoint(
985: hDCScreen, (LPSTR)szTempBuff,lstrlen((LPSTR)szTempBuff),&size);
986:
987: cxFirstLine = size.cx;
988: cyFirstLine = size.cy;
989:
990: szTempBuff[index] = cchKeep; // put the right char back
991:
992: if (cxFirstLine <= cxMaxString)
993: {
994:
995: iLastLineStart = index + 1;
996:
997: if (!fPrintText)
998: goto CleanupAndLeave;
999:
1000: ExtTextOut(hDC,
1001: nXStart + (lpRect->right - cxFirstLine) / 2,
1002: nYStart,
1003: fuOptions,
1004: lpRect,
1005: (LPSTR)szTempBuff,
1006: index + 1,
1007: lpDX);
1008:
1009: lpszSecondLine = (LPSTR)szTempBuff;
1010:
1011: lpszSecondLine += index + 1;
1012:
1013: GetTextExtentPoint(hDCScreen,
1014: lpszSecondLine,
1015: lstrlen(lpszSecondLine),
1016: &size);
1017:
1018: // If the second line is wider than the rectangle, we
1019: // just want to clip the text.
1020: cxSecondLine = min(size.cx, cxMaxString);
1021:
1022: ExtTextOut(hDC,
1023: nXStart + (lpRect->right - cxSecondLine) / 2,
1024: nYStart + cyFirstLine,
1025: fuOptions,
1026: lpRect,
1027: lpszSecondLine,
1028: lstrlen(lpszSecondLine),
1029: lpDX);
1030:
1031: goto CleanupAndLeave;
1032:
1033: } // end if
1034:
1035: index--;
1036:
1037: } // end while
1038:
1039: } // end if
1040:
1041: // Here, there are either no spaces in the string (strchr(szTempBuff, ' ')
1042: // returned NULL), or there spaces in the string, but they are
1043: // positioned so that the first space terminated string is still
1044: // longer than one line. So, we walk backwards from the end of the
1045: // string until we find the largest string that will fit on the first
1046: // line , and then we just clip the second line.
1047:
1048: cch = lstrlen((LPSTR)szTempBuff);
1049:
1050: chKeep = szTempBuff[cch];
1051: szTempBuff[cch] = '\0';
1052:
1053: GetTextExtentPoint(hDCScreen, szTempBuff, lstrlen(szTempBuff),&size);
1054:
1055: cxFirstLine = size.cx;
1056: cyFirstLine = size.cy;
1057:
1058: while (cxFirstLine > cxMaxString)
1059: {
1060: // We allow 40 characters in the label, but the metafile is
1061: // only as wide as 10 W's (for aesthetics - 20 W's wide looked
1062: // dumb. This means that if we split a long string in half (in
1063: // terms of characters), then we could still be wider than the
1064: // metafile. So, if this is the case, we just step backwards
1065: // from the halfway point until we get something that will fit.
1066: // Since we just let ETO clip the second line
1067:
1068: szTempBuff[cch--] = chKeep;
1069: if (0 == cch)
1070: goto CleanupAndLeave;
1071:
1072: chKeep = szTempBuff[cch];
1073: szTempBuff[cch] = '\0';
1074:
1075: GetTextExtentPoint(
1076: hDCScreen, szTempBuff, lstrlen(szTempBuff), &size);
1077: cxFirstLine = size.cx;
1078: }
1079:
1080: iLastLineStart = cch;
1081:
1082: if (!fPrintText)
1083: goto CleanupAndLeave;
1084:
1085: ExtTextOut(hDC,
1086: nXStart + (lpRect->right - cxFirstLine) / 2,
1087: nYStart,
1088: fuOptions,
1089: lpRect,
1090: (LPSTR)szTempBuff,
1091: lstrlen((LPSTR)szTempBuff),
1092: lpDX);
1093:
1094: szTempBuff[cch] = chKeep;
1095: lpszSecondLine = szTempBuff;
1096: lpszSecondLine += cch;
1097:
1098: GetTextExtentPoint(
1099: hDCScreen, (LPSTR)lpszSecondLine, lstrlen(lpszSecondLine), &size);
1100:
1101: // If the second line is wider than the rectangle, we
1102: // just want to clip the text.
1103: cxSecondLine = min(size.cx, cxMaxString);
1104:
1105: ExtTextOut(hDC,
1106: nXStart + (lpRect->right - cxSecondLine) / 2,
1107: nYStart + cyFirstLine,
1108: fuOptions,
1109: lpRect,
1110: lpszSecondLine,
1111: lstrlen(lpszSecondLine),
1112: lpDX);
1113:
1114: CleanupAndLeave:
1115: SelectObject(hDCScreen, hFontT);
1116: ReleaseDC(NULL, hDCScreen);
1117: return iLastLineStart;
1118:
1119: }
1120:
1121:
1122: /*
1123: * OleStdGetUserTypeOfClass(REFCLSID, LPSTR, UINT, HKEY)
1124: *
1125: * Purpose:
1126: * Returns the user type (human readable class name) of the specified class.
1127: *
1128: * Parameters:
1129: * rclsid pointer to the clsid to retrieve user type of.
1130: * lpszUserType pointer to buffer to return user type in.
1131: * cch length of buffer pointed to by lpszUserType
1132: * hKey hKey for reg db - if this is NULL, then we
1133: * open and close the reg db within this function. If it
1134: * is non-NULL, then we assume it's a valid key to the
1135: * \ root and use it without closing it. (useful
1136: * if you're doing lots of reg db stuff).
1137: *
1138: * Return Value:
1139: * UINT Number of characters in returned string. 0 on error.
1140: *
1141: */
1142: STDAPI_(UINT) OleStdGetUserTypeOfClass(REFCLSID rclsid, LPSTR lpszUserType, UINT cch, HKEY hKey)
1143: {
1144:
1145: DWORD dw;
1146: LONG lRet;
1147: LPSTR lpszCLSID, lpszProgID;
1148: BOOL fFreeProgID = FALSE;
1149: BOOL bCloseRegDB = FALSE;
1150: char szKey[128];
1151: LPMALLOC lpIMalloc;
1152:
1153: if (hKey == NULL)
1154: {
1155:
1156: //Open up the root key.
1157: lRet=RegOpenKey(HKEY_CLASSES_ROOT, NULL, &hKey);
1158:
1159: if ((LONG)ERROR_SUCCESS!=lRet)
1160: return (UINT)FALSE;
1161:
1162: bCloseRegDB = TRUE;
1163: }
1164:
1165: // Get a string containing the class name
1166: StringFromCLSID(rclsid, &lpszCLSID);
1167:
1168: wsprintf(szKey, "CLSID\\%s", lpszCLSID);
1169:
1170:
1171: dw=cch;
1172: lRet = RegQueryValue(hKey, szKey, lpszUserType, &dw);
1173:
1174: if ((LONG)ERROR_SUCCESS!=lRet)
1175: dw = 0;
1176:
1177: if ( ((LONG)ERROR_SUCCESS!=lRet) && (CoIsOle1Class(rclsid)) )
1178: {
1179: // We've got an OLE 1.0 class, so let's try to get the user type
1180: // name from the ProgID entry.
1181:
1182: ProgIDFromCLSID(rclsid, &lpszProgID);
1183: fFreeProgID = TRUE;
1184:
1185: dw = cch;
1186: lRet = RegQueryValue(hKey, lpszProgID, lpszUserType, &dw);
1187:
1188: if ((LONG)ERROR_SUCCESS != lRet)
1189: dw = 0;
1190: }
1191:
1192:
1193: if (NOERROR == CoGetMalloc(MEMCTX_TASK, &lpIMalloc))
1194: {
1195: if (fFreeProgID)
1196: lpIMalloc->lpVtbl->Free(lpIMalloc, (LPVOID)lpszProgID);
1197:
1198: lpIMalloc->lpVtbl->Free(lpIMalloc, (LPVOID)lpszCLSID);
1199: lpIMalloc->lpVtbl->Release(lpIMalloc);
1200: }
1201:
1202: if (bCloseRegDB)
1203: RegCloseKey(hKey);
1204:
1205: return (UINT)dw;
1206:
1207: }
1208:
1209:
1210:
1211: /*
1212: * OleStdGetAuxUserType(RCLSID, WORD, LPSTR, int, HKEY)
1213: *
1214: * Purpose:
1215: * Returns the specified AuxUserType from the reg db.
1216: *
1217: * Parameters:
1218: * rclsid pointer to the clsid to retrieve aux user type of.
1219: * hKey hKey for reg db - if this is NULL, then we
1220: * open and close the reg db within this function. If it
1221: * is non-NULL, then we assume it's a valid key to the
1222: * \ root and use it without closing it. (useful
1223: * if you're doing lots of reg db stuff).
1224: * wAuxUserType which aux user type field to look for. In 4/93 release
1225: * 2 is short name and 3 is exe name.
1226: * lpszUserType pointer to buffer to return user type in.
1227: * cch length of buffer pointed to by lpszUserType
1228: *
1229: * Return Value:
1230: * UINT Number of characters in returned string. 0 on error.
1231: *
1232: */
1233: STDAPI_(UINT) OleStdGetAuxUserType(REFCLSID rclsid,
1234: WORD wAuxUserType,
1235: LPSTR lpszAuxUserType,
1236: int cch,
1237: HKEY hKey)
1238: {
1239: HKEY hThisKey;
1240: BOOL fCloseRegDB = FALSE;
1241: DWORD dw;
1242: LRESULT lRet;
1243: LPSTR lpszCLSID;
1244: LPMALLOC lpIMalloc;
1245: char szKey[OLEUI_CCHKEYMAX];
1246: char szTemp[32];
1247:
1248: lpszAuxUserType[0] = '\0';
1249:
1250: if (NULL == hKey)
1251: {
1252: lRet = RegOpenKey(HKEY_CLASSES_ROOT, NULL, &hThisKey);
1253:
1254: if (ERROR_SUCCESS != lRet)
1255: return 0;
1256: }
1257: else
1258: hThisKey = hKey;
1259:
1260: StringFromCLSID(rclsid, &lpszCLSID);
1261:
1262: lstrcpy(szKey, "CLSID\\");
1263: lstrcat(szKey, lpszCLSID);
1264: wsprintf(szTemp, "\\AuxUserType\\%d", wAuxUserType);
1265: lstrcat(szKey, szTemp);
1266:
1267: dw = cch;
1268:
1269: lRet = RegQueryValue(hThisKey, szKey, lpszAuxUserType, &dw);
1270:
1271: if (ERROR_SUCCESS != lRet) {
1272: dw = 0;
1273: lpszAuxUserType[0] = '\0';
1274: }
1275:
1276:
1277: if (fCloseRegDB)
1278: RegCloseKey(hThisKey);
1279:
1280: if (NOERROR == CoGetMalloc(MEMCTX_TASK, &lpIMalloc))
1281: {
1282: lpIMalloc->lpVtbl->Free(lpIMalloc, (LPVOID)lpszCLSID);
1283: lpIMalloc->lpVtbl->Release(lpIMalloc);
1284: }
1285:
1286: return (UINT)dw;
1287: }
1288:
1289:
1290:
1291: /*
1292: * PointerToNthField
1293: *
1294: * Purpose:
1295: * Returns a pointer to the beginning of the nth field.
1296: * Assumes null-terminated string.
1297: *
1298: * Parameters:
1299: * lpszString string to parse
1300: * nField field to return starting index of.
1301: * chDelimiter char that delimits fields
1302: *
1303: * Return Value:
1304: * LPSTR pointer to beginning of nField field.
1305: * NOTE: If the null terminator is found
1306: * Before we find the Nth field, then
1307: * we return a pointer to the null terminator -
1308: * calling app should be sure to check for
1309: * this case.
1310: *
1311: */
1312: LPSTR FAR PASCAL PointerToNthField(LPSTR lpszString, int nField, char chDelimiter)
1313: {
1314: LPSTR lpField = lpszString;
1315: int cFieldFound = 1;
1316:
1317: if (1 ==nField)
1318: return lpszString;
1319:
1320: while (*lpField != '\0')
1321: {
1322:
1323: if (*lpField++ == chDelimiter)
1324: {
1325:
1326: cFieldFound++;
1327:
1328: if (nField == cFieldFound)
1329: return lpField;
1330: }
1331: }
1332:
1333: return lpField;
1334:
1335: }
1336:
1337:
1338:
1339:
1340:
1341: /*
1342: * XformWidthInPixelsToHimetric
1343: * XformWidthInHimetricToPixels
1344: * XformHeightInPixelsToHimetric
1345: * XformHeightInHimetricToPixels
1346: *
1347: * Functions to convert an int between a device coordinate system and
1348: * logical HiMetric units.
1349: *
1350: * Parameters:
1351: * hDC HDC providing reference to the pixel mapping. If
1352: * NULL, a screen DC is used.
1353: *
1354: * Size Functions:
1355: * lpSizeSrc LPSIZEL providing the structure to convert. This
1356: * contains pixels in XformSizeInPixelsToHimetric and
1357: * logical HiMetric units in the complement function.
1358: * lpSizeDst LPSIZEL providing the structure to receive converted
1359: * units. This contains pixels in
1360: * XformSizeInPixelsToHimetric and logical HiMetric
1361: * units in the complement function.
1362: *
1363: * Width Functions:
1364: * iWidth int containing the value to convert.
1365: *
1366: * Return Value:
1367: * Size Functions: None
1368: * Width Functions: Converted value of the input parameters.
1369: *
1370: * NOTE:
1371: * When displaying on the screen, Window apps display everything enlarged
1372: * from its actual size so that it is easier to read. For example, if an
1373: * app wants to display a 1in. horizontal line, that when printed is
1374: * actually a 1in. line on the printed page, then it will display the line
1375: * on the screen physically larger than 1in. This is described as a line
1376: * that is "logically" 1in. along the display width. Windows maintains as
1377: * part of the device-specific information about a given display device:
1378: * LOGPIXELSX -- no. of pixels per logical in along the display width
1379: * LOGPIXELSY -- no. of pixels per logical in along the display height
1380: *
1381: * The following formula converts a distance in pixels into its equivalent
1382: * logical HIMETRIC units:
1383: *
1384: * DistInHiMetric = (HIMETRIC_PER_INCH * DistInPix)
1385: * -------------------------------
1386: * PIXELS_PER_LOGICAL_IN
1387: *
1388: */
1389: STDAPI_(int) XformWidthInPixelsToHimetric(HDC hDC, int iWidthInPix)
1390: {
1391: int iXppli; //Pixels per logical inch along width
1392: int iWidthInHiMetric;
1393: BOOL fSystemDC=FALSE;
1394:
1395: if (NULL==hDC)
1396: {
1397: hDC=GetDC(NULL);
1398: fSystemDC=TRUE;
1399: }
1400:
1401: iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
1402:
1403: //We got pixel units, convert them to logical HIMETRIC along the display
1404: iWidthInHiMetric = MAP_PIX_TO_LOGHIM(iWidthInPix, iXppli);
1405:
1406: if (fSystemDC)
1407: ReleaseDC(NULL, hDC);
1408:
1409: return iWidthInHiMetric;
1410: }
1411:
1412:
1413: STDAPI_(int) XformWidthInHimetricToPixels(HDC hDC, int iWidthInHiMetric)
1414: {
1415: int iXppli; //Pixels per logical inch along width
1416: int iWidthInPix;
1417: BOOL fSystemDC=FALSE;
1418:
1419: if (NULL==hDC)
1420: {
1421: hDC=GetDC(NULL);
1422: fSystemDC=TRUE;
1423: }
1424:
1425: iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
1426:
1427: //We got logical HIMETRIC along the display, convert them to pixel units
1428: iWidthInPix = MAP_LOGHIM_TO_PIX(iWidthInHiMetric, iXppli);
1429:
1430: if (fSystemDC)
1431: ReleaseDC(NULL, hDC);
1432:
1433: return iWidthInPix;
1434: }
1435:
1436:
1437: STDAPI_(int) XformHeightInPixelsToHimetric(HDC hDC, int iHeightInPix)
1438: {
1439: int iYppli; //Pixels per logical inch along height
1440: int iHeightInHiMetric;
1441: BOOL fSystemDC=FALSE;
1442:
1443: if (NULL==hDC)
1444: {
1445: hDC=GetDC(NULL);
1446: fSystemDC=TRUE;
1447: }
1448:
1449: iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
1450:
1451: //* We got pixel units, convert them to logical HIMETRIC along the display
1452: iHeightInHiMetric = MAP_PIX_TO_LOGHIM(iHeightInPix, iYppli);
1453:
1454: if (fSystemDC)
1455: ReleaseDC(NULL, hDC);
1456:
1457: return iHeightInHiMetric;
1458: }
1459:
1460:
1461: STDAPI_(int) XformHeightInHimetricToPixels(HDC hDC, int iHeightInHiMetric)
1462: {
1463: int iYppli; //Pixels per logical inch along height
1464: int iHeightInPix;
1465: BOOL fSystemDC=FALSE;
1466:
1467: if (NULL==hDC)
1468: {
1469: hDC=GetDC(NULL);
1470: fSystemDC=TRUE;
1471: }
1472:
1473: iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
1474:
1475: //* We got logical HIMETRIC along the display, convert them to pixel units
1476: iHeightInPix = MAP_LOGHIM_TO_PIX(iHeightInHiMetric, iYppli);
1477:
1478: if (fSystemDC)
1479: ReleaseDC(NULL, hDC);
1480:
1481: return iHeightInPix;
1482: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.