1970 lines
56 KiB
C
1970 lines
56 KiB
C
/*++
|
|
|
|
Copyright (c) 1993-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
devicon.c
|
|
|
|
Abstract:
|
|
|
|
Device Installer routines dealing with retrieval/display of icons.
|
|
|
|
Author:
|
|
|
|
Lonny McMichael (lonnym) 28-Aug--1995
|
|
|
|
Notes:
|
|
|
|
You must include "basetyps.h" first.
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#include <shellapi.h>
|
|
|
|
|
|
MINI_ICON_LIST GlobalMiniIconList;
|
|
|
|
|
|
/*++
|
|
|
|
Class-to-Icon conversion tables exist in two places. First, there
|
|
is the built-in one defined below that is based on a hard-wired
|
|
bitmap in the resource. The second is a linked list of CLASSICON
|
|
structures that is created every time a new class with an icon
|
|
comes along.
|
|
|
|
Check out resource\ilwinmsd.bmp to see the mini-icons. The icons
|
|
are referenced via their (zero-based) index (e.g., computer is 0,
|
|
chip is 1, display is 2, etc.). Today, the bitmap indexes look as follows:
|
|
|
|
0 - computer
|
|
1 - chip
|
|
2 - display
|
|
3 - network
|
|
4 - windows
|
|
5 - mouse
|
|
6 - keyboard
|
|
7 - phone
|
|
8 - sound
|
|
9 - drives
|
|
10 - plugs
|
|
11 - generic
|
|
12 - check
|
|
13 - uncheck
|
|
14 - printer
|
|
15 - nettrans
|
|
16 - netclient
|
|
17 - netservice
|
|
18 - unknown
|
|
19 - Fax machine
|
|
20 - greyed check
|
|
21 - dial up networking
|
|
22 - direct cable connection
|
|
23 - briefcase (filesync)
|
|
24 - Exchange
|
|
25 - partial check
|
|
26 - Generic folder / Accessories
|
|
27 - media (music)
|
|
28 - Quick View
|
|
29 - old MSN
|
|
30 - calculator
|
|
31 - FAT32 Converter
|
|
32 - Document Templates
|
|
33 - disk compression
|
|
34 - Games
|
|
35 - HyperTerminal
|
|
36 - package
|
|
37 - mspaint
|
|
38 - Screensavers
|
|
39 - WordPad
|
|
40 - Clipboard Viewer
|
|
41 - Accessibility Options
|
|
42 - backup
|
|
43 - Desktop Wallpaper
|
|
44 - Character Map
|
|
45 - Mouse Pointers
|
|
46 - Net Watcher
|
|
47 - phone dialer
|
|
48 - resource monitor
|
|
49 - Online User's Guide
|
|
50 - Multilanguage Support
|
|
51 - Audio Compression
|
|
52 - CD player
|
|
53 - Media Player
|
|
54 - WAV sounds
|
|
55 - Sample Sounds
|
|
56 - Video Compression
|
|
57 - Volume Control
|
|
58 - Musica sound scheme
|
|
59 - Jungle sound scheme
|
|
60 - Robotz sound scheme
|
|
61 - Utopia sound scheme
|
|
62 - Eudcedit
|
|
63 - Minesweeper
|
|
64 - Pinball
|
|
65 - Imaging
|
|
66 - Clock
|
|
67 - Infrared
|
|
68 - MS Wallet
|
|
69 - FrontPage Express (aka FrontPad)
|
|
70 - MS Agent
|
|
71 - Internet Tools
|
|
72 - NetShow Player
|
|
73 - Net Meeting
|
|
74 - DVD Player
|
|
75 - Freecell
|
|
76 - Athena / Outlook Express / Internet Mail and News
|
|
77 - Desktop Themes
|
|
78 - Baseball theme
|
|
79 - Dangerous Creatures theme
|
|
80 - Inside your Computer theme
|
|
81 - Jungle theme
|
|
82 - Leonardo da Vinci theme
|
|
83 - More Windows theme
|
|
84 - Mystery theme
|
|
85 - Nature theme
|
|
86 - Science theme
|
|
87 - Space theme
|
|
88 - Sports theme
|
|
89 - The 60's USA theme
|
|
90 - The Golden Era theme
|
|
91 - Travel theme
|
|
92 - Underwater theme
|
|
93 - Windows 95 theme
|
|
94 - Personal Web Server
|
|
95 - Real Audio
|
|
96 - Web Publisher / WebPost
|
|
97 - WaveTop
|
|
98 - WebTV
|
|
|
|
--*/
|
|
|
|
CONST INT UnknownClassMiniIconIndex = 11;
|
|
|
|
CONST CLASSICON MiniIconXlate[] = { {&GUID_DEVCLASS_COMPUTER, 0, NULL},
|
|
{&GUID_DEVCLASS_DISPLAY, 2, NULL},
|
|
{&GUID_DEVCLASS_MOUSE, 5, NULL},
|
|
{&GUID_DEVCLASS_KEYBOARD, 6, NULL},
|
|
{&GUID_DEVCLASS_FDC, 9, NULL},
|
|
{&GUID_DEVCLASS_HDC, 9, NULL},
|
|
{&GUID_DEVCLASS_PORTS, 10, NULL},
|
|
{&GUID_DEVCLASS_NET, 15, NULL},
|
|
{&GUID_DEVCLASS_SYSTEM, 0, NULL},
|
|
{&GUID_DEVCLASS_SOUND, 8, NULL},
|
|
{&GUID_DEVCLASS_PRINTER, 14, NULL},
|
|
{&GUID_DEVCLASS_MONITOR, 2, NULL},
|
|
{&GUID_DEVCLASS_NETTRANS, 3, NULL},
|
|
{&GUID_DEVCLASS_NETCLIENT, 16, NULL},
|
|
{&GUID_DEVCLASS_NETSERVICE, 17, NULL},
|
|
{&GUID_DEVCLASS_UNKNOWN, 18, NULL},
|
|
{&GUID_DEVCLASS_LEGACYDRIVER, 11, NULL},
|
|
{&GUID_DEVCLASS_MTD, 9, NULL}
|
|
};
|
|
|
|
#define MINIX 16
|
|
#define MINIY 16
|
|
|
|
#define RGB_WHITE (RGB(255, 255, 255))
|
|
#define RGB_BLACK (RGB(0, 0, 0))
|
|
#define RGB_TRANSPARENT (RGB(0, 128, 128))
|
|
|
|
|
|
// This should removed when WINVER defined >= 0x0500 for this project.
|
|
#ifndef NOMIRRORBITMAP
|
|
|
|
#ifdef UNICODE
|
|
#define NOMIRRORBITMAP (DWORD)0x80000000 /* Do not Mirror the bitmap in this call */
|
|
#else
|
|
#define NOMIRRORBITMAP (DWORD)0x0
|
|
#endif //UNICODE
|
|
|
|
#endif
|
|
|
|
//
|
|
// Private function prototypes.
|
|
//
|
|
INT
|
|
NewMiniIcon(
|
|
IN CONST GUID *ClassGuid,
|
|
IN HICON hIcon OPTIONAL
|
|
);
|
|
|
|
|
|
INT
|
|
WINAPI
|
|
SetupDiDrawMiniIcon(
|
|
IN HDC hdc,
|
|
IN RECT rc,
|
|
IN INT MiniIconIndex,
|
|
IN DWORD Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine draws the specified mini-icon at the requested location.
|
|
|
|
Arguments:
|
|
|
|
hdc - Supplies the handle of the device context in which the mini-icon
|
|
will be drawn.
|
|
|
|
rc - Supplies the rectangle in the specified HDC to draw the icon in.
|
|
|
|
MiniIconIndex - The index of the mini-icon, as retrieved from
|
|
SetupDiLoadClassIcon or SetupDiGetClassBitmapIndex. The following are
|
|
pre-defined indices that may be used.
|
|
|
|
0 Computer
|
|
2 display
|
|
5 mouse
|
|
6 keyboard
|
|
9 fdc
|
|
9 hdc
|
|
10 ports
|
|
15 net
|
|
0 system
|
|
8 sound
|
|
14 printer
|
|
2 monitor
|
|
3 nettrans
|
|
16 netclient
|
|
17 netservice
|
|
18 unknown
|
|
|
|
Flags - Controls the drawing operation. The LOWORD contains the actual flags
|
|
defined as follows:
|
|
|
|
DMI_MASK - Draw the mini-icon's mask into HDC.
|
|
|
|
DMI_BKCOLOR - Use the system color index specified in the HIWORD of Flags
|
|
as the background color. If not specified, COLOR_WINDOW is used.
|
|
|
|
DMI_USERECT - If set, SetupDiDrawMiniIcon will use the supplied rect,
|
|
stretching the icon to fit as appropriate.
|
|
|
|
Return Value:
|
|
|
|
This function returns the offset from the left of rc where the string should
|
|
start.
|
|
|
|
Remarks:
|
|
|
|
By default, the icon will be centered vertically and butted against the left
|
|
corner of the specified rectangle.
|
|
|
|
--*/
|
|
{
|
|
HBITMAP hbmOld;
|
|
DWORD rgbBk, rgbText;
|
|
INT ret = 0;
|
|
|
|
if(!LockMiniIconList(&GlobalMiniIconList)) {
|
|
return 0;
|
|
}
|
|
|
|
CreateMiniIcons();
|
|
|
|
if(GlobalMiniIconList.hbmMiniImage) {
|
|
//
|
|
// Set the Foreground and background color for the
|
|
// conversion of the Mono Mask image
|
|
//
|
|
if(Flags & DMI_MASK) {
|
|
rgbBk = SetBkColor(hdc, RGB_WHITE);
|
|
} else {
|
|
rgbBk = SetBkColor(hdc,
|
|
GetSysColor(((int)(Flags & DMI_BKCOLOR
|
|
? HIWORD(Flags)
|
|
: COLOR_WINDOW)))
|
|
);
|
|
}
|
|
rgbText = SetTextColor(hdc, RGB_BLACK);
|
|
|
|
if(Flags & DMI_USERECT) {
|
|
//
|
|
// Copy the converted mask into the dest. The transparent
|
|
// areas will be drawn with the current window color.
|
|
//
|
|
hbmOld = SelectObject(GlobalMiniIconList.hdcMiniMem,
|
|
GlobalMiniIconList.hbmMiniMask
|
|
);
|
|
StretchBlt(hdc,
|
|
rc.left,
|
|
rc.top,
|
|
rc.right - rc.left,
|
|
rc.bottom - rc.top,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
MINIX * MiniIconIndex,
|
|
0,
|
|
MINIX,
|
|
MINIY,
|
|
SRCCOPY | NOMIRRORBITMAP);
|
|
|
|
if(!(Flags & DMI_MASK)) {
|
|
//
|
|
// OR the image into the dest
|
|
//
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem,
|
|
GlobalMiniIconList.hbmMiniImage
|
|
);
|
|
StretchBlt(hdc,
|
|
rc.left,
|
|
rc.top,
|
|
rc.right - rc.left,
|
|
rc.bottom - rc.top,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
MINIX * MiniIconIndex,
|
|
0,
|
|
MINIX,
|
|
MINIY,
|
|
SRCPAINT | NOMIRRORBITMAP);
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Copy the converted mask into the dest. The transparent
|
|
// areas will be drawn with the current window color.
|
|
//
|
|
hbmOld = SelectObject(GlobalMiniIconList.hdcMiniMem,
|
|
GlobalMiniIconList.hbmMiniMask
|
|
);
|
|
BitBlt(hdc,
|
|
rc.left,
|
|
rc.top + (rc.bottom - rc.top - MINIY)/2,
|
|
MINIX,
|
|
MINIY,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
MINIX * MiniIconIndex,
|
|
0,
|
|
SRCCOPY | NOMIRRORBITMAP
|
|
);
|
|
|
|
|
|
if(!(Flags & DMI_MASK)) {
|
|
//
|
|
// OR the image into the dest
|
|
//
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem,
|
|
GlobalMiniIconList.hbmMiniImage
|
|
);
|
|
BitBlt(hdc,
|
|
rc.left,
|
|
rc.top + (rc.bottom - rc.top - MINIY)/2,
|
|
MINIX,
|
|
MINIY,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
MINIX * MiniIconIndex,
|
|
0,
|
|
SRCPAINT | NOMIRRORBITMAP
|
|
);
|
|
}
|
|
}
|
|
|
|
SetBkColor(hdc, rgbBk);
|
|
SetTextColor(hdc, rgbText);
|
|
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem, hbmOld);
|
|
if(Flags & DMI_USERECT) {
|
|
ret = rc.right - rc.left + 2; // offset to string from left edge
|
|
} else {
|
|
ret = MINIX + 2; // offset to string from left edge
|
|
}
|
|
}
|
|
|
|
UnlockMiniIconList(&GlobalMiniIconList);
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
pSetupDiLoadClassIcon(
|
|
IN CONST GUID *ClassGuid,
|
|
OUT HICON *LargeIcon, OPTIONAL
|
|
OUT HICON *SmallIcon, OPTIONAL
|
|
OUT LPINT MiniIconIndex OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine loads both the large and mini-icons for the specified class
|
|
|
|
Arguments:
|
|
|
|
ClassGuid - Supplies the GUID of the class for which the icon(s) should
|
|
be loaded.
|
|
|
|
LargeIcon - Optionally, supplies a pointer to a variable that will receive
|
|
a handle to the loaded large icon for the specified class. If this
|
|
parameter is not specified, the large icon will not be loaded.
|
|
|
|
SmallIcon - Optionally, supplies a pointer to a variable that will receive
|
|
a handle to the loaded small icon for the specified class. If this
|
|
parameter is not specified, the small icon will not be loaded.
|
|
|
|
MiniIconIndex - Optionally, supplies a pointer to a variable that will
|
|
receive the index of the mini-icon for the specified class. The
|
|
mini-icon is stored in the device installer's mini-icon cache.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is TRUE.
|
|
|
|
If the function fails, the return value is FALSE. To get extended error
|
|
information, call GetLastError.
|
|
|
|
Remarks:
|
|
|
|
The icons of the class are either pre-defined, and loaded from the device
|
|
installer's internal cache, or they are loaded directly from the class
|
|
installer's executable. This function will query the registry value ICON in
|
|
the specified class's section. If this value is specified then it indicates
|
|
what mini icon to load. If the icon value is negative the absolute value
|
|
represents a predefined icon. See SetupDiDrawMiniIcon for a list of pre-defined
|
|
mini icons. If the icon value is positive it represents an icon in the class
|
|
installer's executable, and will be extracted (the number one is reserved).
|
|
This function also uses the INSTALLER value first and ENUMPROPPAGES value second
|
|
to determine what executable to extract the icon(s) from.
|
|
|
|
--*/
|
|
{
|
|
HKEY hk = INVALID_HANDLE_VALUE;
|
|
DWORD Err;
|
|
HICON hRetLargeIcon = NULL;
|
|
HICON hRetSmallIcon = NULL;
|
|
INT ClassIconIndex;
|
|
DWORD RegDataType, StringSize;
|
|
PTSTR EndPtr;
|
|
BOOL bGetMini = FALSE;
|
|
BOOL bDestroyLargeIcon = FALSE, bDestroySmallIcon = FALSE;
|
|
TCHAR TempString[MAX_PATH];
|
|
TCHAR FullPath[MAX_PATH];
|
|
UINT IconsExtracted;
|
|
|
|
if(!LockMiniIconList(&GlobalMiniIconList)) {
|
|
SetLastError(ERROR_CANT_LOAD_CLASS_ICON);
|
|
return FALSE;
|
|
}
|
|
|
|
try {
|
|
|
|
if(MiniIconIndex) {
|
|
*MiniIconIndex = -1;
|
|
}
|
|
|
|
if((hk = SetupDiOpenClassRegKey(ClassGuid, KEY_READ)) == INVALID_HANDLE_VALUE) {
|
|
goto clean0;
|
|
}
|
|
|
|
StringSize = sizeof(TempString);
|
|
Err = RegQueryValueEx(hk,
|
|
pszInsIcon,
|
|
NULL,
|
|
&RegDataType,
|
|
(PBYTE)TempString,
|
|
&StringSize
|
|
);
|
|
|
|
if((Err == ERROR_SUCCESS) && (RegDataType == REG_SZ) && (StringSize > sizeof(TCHAR))) {
|
|
|
|
if((ClassIconIndex = _tcstol(TempString, &EndPtr, 10)) == 1) {
|
|
//
|
|
// Positive values indicate that we should access an icon
|
|
// directly using its ID. Since ExtractIconEx uses negative
|
|
// values to indicate these IDs, and since the value -1 has
|
|
// a special meaning to that API, we must disallow a ClassIconIndex
|
|
// of +1.
|
|
//
|
|
goto clean1;
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Icon index not specified, so assume index is 0.
|
|
//
|
|
ClassIconIndex = 0;
|
|
}
|
|
|
|
if(MiniIconIndex) {
|
|
//
|
|
// If mini-icon is already around, then we're done with it.
|
|
//
|
|
if(!SetupDiGetClassBitmapIndex(ClassGuid, MiniIconIndex)) {
|
|
//
|
|
// mini-icon not around--set flag to show we didn't get it.
|
|
//
|
|
bGetMini = TRUE;
|
|
}
|
|
}
|
|
|
|
if(ClassIconIndex < 0) {
|
|
INT ClassIconIndexNeg = -ClassIconIndex;
|
|
//
|
|
// Icon index is negative. This means that this class is one
|
|
// of our special classes with icons in setupapi.dll
|
|
//
|
|
if(LargeIcon) {
|
|
hRetLargeIcon = LoadIcon(MyDllModuleHandle,
|
|
MAKEINTRESOURCE(ClassIconIndexNeg)
|
|
);
|
|
}
|
|
|
|
if(bGetMini || SmallIcon) {
|
|
//
|
|
// Retrieve the small icon as well. If the resource doesn't
|
|
// have a small icon then the big one will get smushed, but it's
|
|
// better than getting the default icon.
|
|
//
|
|
hRetSmallIcon = LoadImage(MyDllModuleHandle,
|
|
MAKEINTRESOURCE(ClassIconIndexNeg),
|
|
IMAGE_ICON,
|
|
MINIX,
|
|
MINIY,
|
|
0
|
|
);
|
|
|
|
if(hRetSmallIcon && bGetMini) {
|
|
*MiniIconIndex = NewMiniIcon(ClassGuid, hRetSmallIcon);
|
|
}
|
|
}
|
|
|
|
} else if(bGetMini || LargeIcon || SmallIcon) {
|
|
//
|
|
// Look for the binary containing the icon(s) first in the
|
|
// "Installer32" entry, and if not found, then in the "EnumPropPages32"
|
|
// entry.
|
|
//
|
|
lstrcpyn(FullPath, SystemDirectory, MAX_PATH);
|
|
|
|
StringSize = sizeof(TempString);
|
|
Err = RegQueryValueEx(hk,
|
|
pszInstaller32,
|
|
NULL,
|
|
&RegDataType,
|
|
(PBYTE)TempString,
|
|
&StringSize
|
|
);
|
|
|
|
if((Err != ERROR_SUCCESS) || (RegDataType != REG_SZ) ||
|
|
(StringSize < sizeof(TCHAR))) {
|
|
|
|
StringSize = sizeof(TempString);
|
|
Err = RegQueryValueEx(hk,
|
|
pszEnumPropPages32,
|
|
NULL,
|
|
&RegDataType,
|
|
(PBYTE)TempString,
|
|
&StringSize
|
|
);
|
|
|
|
if((Err != ERROR_SUCCESS) || (RegDataType != REG_SZ) ||
|
|
(StringSize < sizeof(TCHAR))) {
|
|
|
|
goto clean1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Remove function name, if present, from installer name.
|
|
//
|
|
for(EndPtr = TempString + ((StringSize / sizeof(TCHAR)) - 1);
|
|
EndPtr >= TempString;
|
|
EndPtr--) {
|
|
|
|
if(*EndPtr == TEXT(',')) {
|
|
*EndPtr = TEXT('\0');
|
|
break;
|
|
}
|
|
//
|
|
// If we hit a double-quote mark, we terminate the search.
|
|
//
|
|
if(*EndPtr == TEXT('\"')) {
|
|
break;
|
|
}
|
|
}
|
|
pSetupConcatenatePaths(FullPath, TempString, MAX_PATH, NULL);
|
|
|
|
IconsExtracted = ExtractIconEx(FullPath,
|
|
-ClassIconIndex,
|
|
LargeIcon ? &hRetLargeIcon : NULL,
|
|
(bGetMini || SmallIcon) ? &hRetSmallIcon : NULL,
|
|
1
|
|
);
|
|
if((IconsExtracted != (UINT)-1) && (IconsExtracted > 0)) {
|
|
|
|
if(hRetLargeIcon) {
|
|
bDestroyLargeIcon = TRUE;
|
|
}
|
|
if(hRetSmallIcon) {
|
|
*MiniIconIndex = NewMiniIcon(ClassGuid, hRetSmallIcon);
|
|
bDestroySmallIcon = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
clean1:
|
|
RegCloseKey(hk);
|
|
hk = INVALID_HANDLE_VALUE;
|
|
|
|
clean0:
|
|
//
|
|
// Assume success, unless we hit some really big problem below.
|
|
//
|
|
Err = NO_ERROR;
|
|
|
|
if(LargeIcon && !hRetLargeIcon) {
|
|
//
|
|
// We didn't retrieve a large icon, so use a default.
|
|
//
|
|
if(!(hRetLargeIcon = LoadIcon(MyDllModuleHandle, MAKEINTRESOURCE(ICON_DEFAULT)))) {
|
|
Err = GetLastError();
|
|
}
|
|
}
|
|
|
|
if (SmallIcon && !hRetSmallIcon) {
|
|
//
|
|
// We didn't retrieve a small icon, so use a default.
|
|
//
|
|
if (!(hRetSmallIcon = LoadImage(MyDllModuleHandle,
|
|
MAKEINTRESOURCE(ICON_DEFAULT),
|
|
IMAGE_ICON,
|
|
GetSystemMetrics(SM_CXSMICON),
|
|
GetSystemMetrics(SM_CYSMICON),
|
|
0
|
|
))) {
|
|
Err = GetLastError();
|
|
}
|
|
}
|
|
|
|
if(Err == NO_ERROR) {
|
|
|
|
if(LargeIcon) {
|
|
*LargeIcon = hRetLargeIcon;
|
|
}
|
|
|
|
if (SmallIcon) {
|
|
*SmallIcon = hRetSmallIcon;
|
|
}
|
|
|
|
if(MiniIconIndex && (*MiniIconIndex == -1)) {
|
|
SetupDiGetClassBitmapIndex(NULL, MiniIconIndex);
|
|
}
|
|
}
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
|
|
if(hk != INVALID_HANDLE_VALUE) {
|
|
RegCloseKey(hk);
|
|
}
|
|
}
|
|
|
|
if(Err != NO_ERROR) {
|
|
if (bDestroyLargeIcon) {
|
|
DestroyIcon(hRetLargeIcon);
|
|
}
|
|
|
|
if (bDestroySmallIcon) {
|
|
DestroyIcon(hRetSmallIcon);
|
|
}
|
|
}
|
|
|
|
UnlockMiniIconList(&GlobalMiniIconList);
|
|
|
|
SetLastError(Err);
|
|
|
|
return (Err == NO_ERROR);
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupDiLoadClassIcon(
|
|
IN CONST GUID *ClassGuid,
|
|
OUT HICON *LargeIcon, OPTIONAL
|
|
OUT LPINT MiniIconIndex OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine loads both the large and mini-icons for the specified class
|
|
|
|
Arguments:
|
|
|
|
ClassGuid - Supplies the GUID of the class for which the icon(s) should
|
|
be loaded.
|
|
|
|
LargeIcon - Optionally, supplies a pointer to a variable that will receive
|
|
a handle to the loaded large icon for the specified class. If this
|
|
parameter is not specified, the large icon will not be loaded.
|
|
|
|
MiniIconIndex - Optionally, supplies a pointer to a variable that will
|
|
receive the index of the mini-icon for the specified class. The
|
|
mini-icon is stored in the device installer's mini-icon cache.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is TRUE.
|
|
|
|
If the function fails, the return value is FALSE. To get extended error
|
|
information, call GetLastError.
|
|
|
|
Remarks:
|
|
|
|
The icons of the class are either pre-defined, and loaded from the device
|
|
installer's internal cache, or they are loaded directly from the class
|
|
installer's executable. This function will query the registry value ICON in
|
|
the specified class's section. If this value is specified then it indicates
|
|
what mini icon to load. If the icon value is negative the absolute value
|
|
represents a predefined icon. See SetupDiDrawMiniIcon for a list of pre-defined
|
|
mini icons. If the icon value is positive it represents an icon in the class
|
|
installer's executable, and will be extracted (the number one is reserved).
|
|
This function also uses the INSTALLER value first and ENUMPROPPAGES value second
|
|
to determine what executable to extract the icon(s) from.
|
|
|
|
--*/
|
|
{
|
|
return (pSetupDiLoadClassIcon(ClassGuid,
|
|
LargeIcon,
|
|
NULL,
|
|
MiniIconIndex
|
|
));
|
|
}
|
|
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupDiGetClassBitmapIndex(
|
|
IN CONST GUID *ClassGuid, OPTIONAL
|
|
OUT PINT MiniIconIndex
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the index of the mini-icon for the specified class.
|
|
|
|
Arguments:
|
|
|
|
ClassGuid - Optionally, supplies the GUID of the class to get the mini-icon
|
|
index for. If this parameter is not specified, the index of the 'unknown'
|
|
icon is returned.
|
|
|
|
MiniIconIndex - Supplies a pointer to a variable that receives the index of
|
|
the mini-icon for the specified class. This buffer is always filled in,
|
|
and receives the index of the unknown mini-icon if there is no mini-icon
|
|
for the specified class (i.e., the return value is FALSE).
|
|
|
|
Return Value:
|
|
|
|
If there was a mini-icon for the specified class, the return value is TRUE.
|
|
|
|
If there was not a mini-icon for the specified class, or if no class was
|
|
specified, the return value is FALSE (and GetLastError returns
|
|
ERROR_NO_DEVICE_CLASS_ICON). In this case, MiniIconIndex will contain the
|
|
index of the unknown mini-icon.
|
|
|
|
--*/
|
|
{
|
|
BOOL bRet = FALSE; // assume not found
|
|
int i;
|
|
PCLASSICON pci;
|
|
DWORD Err;
|
|
|
|
if(ClassGuid) {
|
|
//
|
|
// First check the built-in list.
|
|
//
|
|
for(i = 0; !bRet && (i < ARRAYSIZE(MiniIconXlate)); i++) {
|
|
|
|
if(IsEqualGUID(MiniIconXlate[i].ClassGuid, ClassGuid)) {
|
|
*MiniIconIndex = MiniIconXlate[i].MiniBitmapIndex;
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Next check the "new stuff" list to see if it's there.
|
|
//
|
|
if(!bRet && LockMiniIconList(&GlobalMiniIconList)) {
|
|
|
|
for(pci = GlobalMiniIconList.ClassIconList;
|
|
!bRet && pci;
|
|
pci = pci->Next) {
|
|
|
|
if(IsEqualGUID(pci->ClassGuid, ClassGuid)) {
|
|
*MiniIconIndex = pci->MiniBitmapIndex;
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
UnlockMiniIconList(&GlobalMiniIconList);
|
|
}
|
|
}
|
|
|
|
//
|
|
// If no match was found, snag the "unknown" class.
|
|
//
|
|
if(!bRet) {
|
|
*MiniIconIndex = UnknownClassMiniIconIndex;
|
|
Err = ERROR_NO_DEVICE_ICON;
|
|
} else {
|
|
Err = NO_ERROR;
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CreateMiniIcons(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine loads the default bitmap of mini-icons and turns it into
|
|
the image/mask pair that will be the cornerstone of mini-icon management.
|
|
THIS FUNCTION ASSUMES THE MINI-ICON LOCK HAS ALREADY BEEN ACQUIRED!
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is TRUE, otherwise it is FALSE.
|
|
|
|
--*/
|
|
{
|
|
HDC hdc, hdcMem;
|
|
HBITMAP hbmOld;
|
|
BITMAP bm;
|
|
BOOL bRet = FALSE; // assume failure
|
|
|
|
if(GlobalMiniIconList.hdcMiniMem) {
|
|
//
|
|
// Then the mini-icon list has already been built, so
|
|
// return success.
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
hdc = GetDC(NULL);
|
|
if (!hdc) {
|
|
goto clean0;
|
|
}
|
|
GlobalMiniIconList.hdcMiniMem = CreateCompatibleDC(hdc);
|
|
ReleaseDC(NULL, hdc);
|
|
if(!GlobalMiniIconList.hdcMiniMem) {
|
|
goto clean0;
|
|
}
|
|
|
|
|
|
if(!(hdcMem = CreateCompatibleDC(GlobalMiniIconList.hdcMiniMem))) {
|
|
goto clean0;
|
|
}
|
|
|
|
if(!(GlobalMiniIconList.hbmMiniImage = LoadBitmap(MyDllModuleHandle,
|
|
MAKEINTRESOURCE(BMP_DRIVERTYPES)))) {
|
|
goto clean1;
|
|
}
|
|
|
|
|
|
GetObject(GlobalMiniIconList.hbmMiniImage, sizeof(bm), &bm);
|
|
|
|
if(!(GlobalMiniIconList.hbmMiniMask = CreateBitmap(bm.bmWidth,
|
|
bm.bmHeight,
|
|
1,
|
|
1,
|
|
NULL))) {
|
|
goto clean1;
|
|
}
|
|
|
|
|
|
hbmOld = SelectObject(hdcMem, GlobalMiniIconList.hbmMiniImage);
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem,
|
|
GlobalMiniIconList.hbmMiniMask
|
|
);
|
|
|
|
//
|
|
// make the mask. white where transparent, black where opaque
|
|
//
|
|
SetBkColor(hdcMem, RGB_TRANSPARENT);
|
|
BitBlt(GlobalMiniIconList.hdcMiniMem,
|
|
0,
|
|
0,
|
|
bm.bmWidth,
|
|
bm.bmHeight,
|
|
hdcMem,
|
|
0,
|
|
0,
|
|
SRCCOPY
|
|
);
|
|
|
|
//
|
|
// black-out all of the transparent parts of the image, in preparation
|
|
// for drawing.
|
|
//
|
|
SetBkColor(hdcMem, RGB_BLACK);
|
|
SetTextColor(hdcMem, RGB_WHITE);
|
|
BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight, GlobalMiniIconList.hdcMiniMem, 0, 0, SRCAND);
|
|
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem, hbmOld);
|
|
|
|
GlobalMiniIconList.NumClassImages = bm.bmWidth/MINIX;
|
|
bRet = TRUE;
|
|
|
|
SelectObject(hdcMem, hbmOld);
|
|
|
|
clean1:
|
|
DeleteObject(hdcMem);
|
|
|
|
clean0:
|
|
//
|
|
// If failure, clean up anything we might have built
|
|
//
|
|
if(!bRet) {
|
|
DestroyMiniIcons();
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
INT
|
|
NewMiniIcon(
|
|
IN CONST GUID *ClassGuid,
|
|
IN HICON hIcon OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
It's a new class, and we have a mini-icon for it, so let's add it
|
|
to the mini-icon database. First pull out the image and mask
|
|
bitmaps. Then add these to the mini-icon bitmap. If this all
|
|
works, add the new class to the list
|
|
|
|
THIS FUNCTION ASSUMES THE MINI-ICON LOCK HAS ALREADY BEEN ACQUIRED!
|
|
|
|
Arguments:
|
|
|
|
ClassGuid - Supplies a pointer to the class GUID for this mini-icon.
|
|
|
|
hIcon - Optionally, supplies a handle to the mini-icon to be added to
|
|
the database. If this parameter is not specified, then the index
|
|
for the "unknown class" icon will be returned.
|
|
|
|
Return Value:
|
|
|
|
Index for class (set to "unknown class" if error)
|
|
|
|
--*/
|
|
{
|
|
INT iBitmap = -1;
|
|
ICONINFO ii;
|
|
PCLASSICON pci = NULL;
|
|
|
|
if(hIcon && GetIconInfo(hIcon, &ii)) {
|
|
|
|
try {
|
|
|
|
if((iBitmap = pSetupAddMiniIconToList(ii.hbmColor, ii.hbmMask)) != -1) {
|
|
//
|
|
// Allocate an extra GUID's worth of memory, so we can store
|
|
// the class GUID in the same chunk of memory as the CLASSICON
|
|
// node.
|
|
//
|
|
if(pci = (PCLASSICON)MyMalloc(sizeof(CLASSICON) + sizeof(GUID))) {
|
|
|
|
CopyMemory((PBYTE)pci + sizeof(CLASSICON),
|
|
ClassGuid,
|
|
sizeof(GUID)
|
|
);
|
|
pci->ClassGuid = (LPGUID)((PBYTE)pci + sizeof(CLASSICON));
|
|
pci->MiniBitmapIndex = iBitmap;
|
|
|
|
pci->Next = GlobalMiniIconList.ClassIconList;
|
|
GlobalMiniIconList.ClassIconList = pci;
|
|
}
|
|
}
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
if(pci) {
|
|
MyFree(pci);
|
|
}
|
|
|
|
iBitmap = -1;
|
|
}
|
|
|
|
DeleteObject(ii.hbmColor);
|
|
DeleteObject(ii.hbmMask);
|
|
}
|
|
|
|
if(iBitmap == -1) {
|
|
SetupDiGetClassBitmapIndex(NULL, &iBitmap);
|
|
}
|
|
|
|
return iBitmap;
|
|
}
|
|
|
|
|
|
INT
|
|
pSetupAddMiniIconToList(
|
|
IN HBITMAP hbmImage,
|
|
IN HBITMAP hbmMask
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given the image and mask bitmaps of a mini-icon, add these to the
|
|
mini-icon bitmap.
|
|
|
|
THIS FUNCTION ASSUMES THE MINI-ICON LOCK HAS ALREADY BEEN ACQUIRED!
|
|
|
|
Arguments:
|
|
|
|
hbmImage - Supplies the handle of the bitmap for the mini-icon.
|
|
|
|
hbmMask - Supplies the handle of the bitmap for the mini-icon's mask.
|
|
|
|
Return Value:
|
|
|
|
If success, returns the index of the added mini-icon.
|
|
If failure, returns -1.
|
|
|
|
--*/
|
|
{
|
|
HBITMAP hbmNewImage, hbmNewMask, hbmOld;
|
|
HDC hdcMem;
|
|
BITMAP bm;
|
|
INT iIcon = -1; // assume failure
|
|
|
|
if(!CreateMiniIcons()) {
|
|
goto AddIcon_Exit;
|
|
}
|
|
|
|
MYASSERT(GlobalMiniIconList.hdcMiniMem);
|
|
|
|
if(!(hdcMem = CreateCompatibleDC(GlobalMiniIconList.hdcMiniMem))) {
|
|
goto AddIcon_Exit;
|
|
}
|
|
|
|
//
|
|
// Create a New global Bitmap for the minis
|
|
//
|
|
hbmOld = SelectObject(GlobalMiniIconList.hdcMiniMem,
|
|
GlobalMiniIconList.hbmMiniImage
|
|
);
|
|
|
|
if(!(hbmNewImage = CreateCompatibleBitmap(GlobalMiniIconList.hdcMiniMem,
|
|
MINIX * (GlobalMiniIconList.NumClassImages + 1),
|
|
MINIY))) {
|
|
goto AddIcon_Exit1;
|
|
}
|
|
|
|
//
|
|
// Copy the current Mini bitmap
|
|
//
|
|
SelectObject(hdcMem, hbmNewImage);
|
|
BitBlt(hdcMem,
|
|
0,
|
|
0,
|
|
MINIX * GlobalMiniIconList.NumClassImages,
|
|
MINIY,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
0,
|
|
0,
|
|
SRCCOPY
|
|
);
|
|
|
|
//
|
|
// Fit the New icon into ours. We need to stretch it to fit correctly.
|
|
//
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem, hbmImage);
|
|
GetObject(hbmImage, sizeof(bm), &bm);
|
|
StretchBlt(hdcMem,
|
|
MINIX * GlobalMiniIconList.NumClassImages,
|
|
0,
|
|
MINIX,
|
|
MINIY,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
0,
|
|
0,
|
|
bm.bmWidth,
|
|
bm.bmHeight,
|
|
SRCCOPY
|
|
);
|
|
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem, hbmOld);
|
|
|
|
DeleteObject(GlobalMiniIconList.hbmMiniImage);
|
|
GlobalMiniIconList.hbmMiniImage = hbmNewImage;
|
|
|
|
//
|
|
// Next, copy the mask.
|
|
//
|
|
hbmOld = SelectObject(GlobalMiniIconList.hdcMiniMem,
|
|
GlobalMiniIconList.hbmMiniMask
|
|
);
|
|
if(!(hbmNewMask = CreateBitmap(MINIX * (GlobalMiniIconList.NumClassImages + 1),
|
|
MINIY,
|
|
1,
|
|
1,
|
|
NULL))) {
|
|
goto AddIcon_Exit1;
|
|
}
|
|
|
|
SelectObject(hdcMem, hbmNewMask);
|
|
BitBlt(hdcMem,
|
|
0,
|
|
0,
|
|
MINIX * GlobalMiniIconList.NumClassImages,
|
|
MINIY,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
0,
|
|
0,
|
|
SRCCOPY
|
|
);
|
|
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem, hbmMask);
|
|
GetObject(hbmMask, sizeof(bm), &bm);
|
|
StretchBlt(hdcMem,
|
|
MINIX * GlobalMiniIconList.NumClassImages,
|
|
0,
|
|
MINIX,
|
|
MINIY,
|
|
GlobalMiniIconList.hdcMiniMem,
|
|
0,
|
|
0,
|
|
bm.bmWidth,
|
|
bm.bmHeight,
|
|
SRCCOPY
|
|
);
|
|
|
|
SelectObject(GlobalMiniIconList.hdcMiniMem, hbmOld);
|
|
|
|
DeleteObject(GlobalMiniIconList.hbmMiniMask);
|
|
GlobalMiniIconList.hbmMiniMask = hbmNewMask;
|
|
|
|
iIcon = GlobalMiniIconList.NumClassImages;
|
|
GlobalMiniIconList.NumClassImages++; // one more image on the table
|
|
|
|
AddIcon_Exit1:
|
|
DeleteDC(hdcMem);
|
|
|
|
AddIcon_Exit:
|
|
return iIcon;
|
|
}
|
|
|
|
|
|
VOID
|
|
DestroyMiniIcons(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine destroys the mini-icon bitmaps, if they exist.
|
|
THIS FUNCTION ASSUMES THE MINI-ICON LOCK HAS ALREADY BEEN ACQUIRED!
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PCLASSICON pci;
|
|
|
|
if(GlobalMiniIconList.hdcMiniMem) {
|
|
DeleteDC(GlobalMiniIconList.hdcMiniMem);
|
|
GlobalMiniIconList.hdcMiniMem = NULL;
|
|
}
|
|
|
|
if(GlobalMiniIconList.hbmMiniImage) {
|
|
DeleteObject(GlobalMiniIconList.hbmMiniImage);
|
|
GlobalMiniIconList.hbmMiniImage = NULL;
|
|
}
|
|
|
|
if(GlobalMiniIconList.hbmMiniMask) {
|
|
DeleteObject(GlobalMiniIconList.hbmMiniMask);
|
|
GlobalMiniIconList.hbmMiniMask = NULL;
|
|
}
|
|
|
|
GlobalMiniIconList.NumClassImages = 0;
|
|
|
|
//
|
|
// Free up any additional class icon guys that were created
|
|
//
|
|
while(GlobalMiniIconList.ClassIconList) {
|
|
pci = GlobalMiniIconList.ClassIconList;
|
|
GlobalMiniIconList.ClassIconList = pci->Next;
|
|
MyFree(pci);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupDiGetClassImageList(
|
|
OUT PSP_CLASSIMAGELIST_DATA ClassImageListData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
See SetupDiGetClassImageListEx for details.
|
|
|
|
--*/
|
|
{
|
|
return SetupDiGetClassImageListEx(ClassImageListData, NULL, NULL);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// ANSI version
|
|
//
|
|
BOOL
|
|
WINAPI
|
|
SetupDiGetClassImageListExA(
|
|
OUT PSP_CLASSIMAGELIST_DATA ClassImageListData,
|
|
IN PCSTR MachineName, OPTIONAL
|
|
IN PVOID Reserved
|
|
)
|
|
{
|
|
PCWSTR UnicodeMachineName;
|
|
DWORD rc;
|
|
BOOL b;
|
|
|
|
b = FALSE;
|
|
|
|
if(MachineName) {
|
|
rc = pSetupCaptureAndConvertAnsiArg(MachineName, &UnicodeMachineName);
|
|
} else {
|
|
UnicodeMachineName = NULL;
|
|
rc = NO_ERROR;
|
|
}
|
|
|
|
if(rc == NO_ERROR) {
|
|
b = SetupDiGetClassImageListExW(ClassImageListData, UnicodeMachineName, Reserved);
|
|
rc = GetLastError();
|
|
if(UnicodeMachineName) {
|
|
MyFree(UnicodeMachineName);
|
|
}
|
|
}
|
|
|
|
SetLastError(rc);
|
|
return b;
|
|
}
|
|
#else
|
|
//
|
|
// Unicode version
|
|
//
|
|
BOOL
|
|
WINAPI
|
|
SetupDiGetClassImageListExW(
|
|
OUT PSP_CLASSIMAGELIST_DATA ClassImageListData,
|
|
IN PCWSTR MachineName, OPTIONAL
|
|
IN PVOID Reserved
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(ClassImageListData);
|
|
UNREFERENCED_PARAMETER(MachineName);
|
|
UNREFERENCED_PARAMETER(Reserved);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return(FALSE);
|
|
}
|
|
#endif
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupDiGetClassImageListEx(
|
|
OUT PSP_CLASSIMAGELIST_DATA ClassImageListData,
|
|
IN PCTSTR MachineName, OPTIONAL
|
|
IN PVOID Reserved
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine builds an image list containing bitmaps for every installed class,
|
|
and returns a data structure containing the list.
|
|
|
|
Arguments:
|
|
|
|
ClassImageListData - Supplies the address of a SP_CLASSIMAGELIST_DATA structure
|
|
that will receive information regarding the class list (including a handle
|
|
to the image list). The cbSize field of this structure must be initialized
|
|
with the size of the structure (in bytes) before calling this routine, or the
|
|
API will fail.
|
|
|
|
MachineName - Optionally, specifies the name of the remote machine whose installed
|
|
classes are to be used in building the class image list. If this parameter is
|
|
not specified, the local machine is used.
|
|
|
|
NOTE: Presently, class-specific icons can only be displayed if the class is
|
|
also present on the local machine. Thus, if the remote machine has
|
|
class x, but class x is not installed locally, then the generic (unknown)
|
|
icon will be returned.
|
|
|
|
Reserved - Reserved for future use--must be NULL.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is TRUE.
|
|
|
|
If the function fails, the return value is FALSE. To get extended error
|
|
information, call GetLastError.
|
|
|
|
Remarks:
|
|
|
|
The image list contained in structure filled in by this API should NOT be
|
|
destroyed by calling ImageList_Destroy. Instead, SetupDiDestroyClassImageList
|
|
should be called, for proper clean-up to occur.
|
|
|
|
--*/
|
|
{
|
|
DWORD Err = NO_ERROR;
|
|
int cxMiniIcon, cyMiniIcon;
|
|
int MiniIconIndex = 0, DefaultIndex = 0;
|
|
int GuidCount, i;
|
|
int iIcon, iIndex;
|
|
HDC hDC = NULL, hMemImageDC = NULL;
|
|
HBITMAP hbmMiniImage = NULL, hbmMiniMask = NULL, hbmOldImage = NULL;
|
|
RECT rc;
|
|
CONST GUID *pClassGuid = NULL;
|
|
BOOL bUseBitmap, ComputerClassFound = FALSE;
|
|
HICON hiLargeIcon = NULL, hiSmallIcon = NULL, hIcon = NULL;
|
|
HBRUSH hOldBrush;
|
|
PCLASSICON pci = NULL;
|
|
PCLASS_IMAGE_LIST ImageData = NULL;
|
|
BOOL DestroyLock = FALSE;
|
|
HIMAGELIST ImageList = NULL;
|
|
DWORD dwLayout = 0;
|
|
UINT ImageListFlags = 0;
|
|
|
|
//
|
|
// Make sure the caller didn't pass us anything in the Reserved parameter.
|
|
//
|
|
if(Reserved) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
try {
|
|
|
|
if(ClassImageListData->cbSize != sizeof(SP_CLASSIMAGELIST_DATA)) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Allocate and initialize the image list, including setting up the
|
|
// synchronization lock. Destroy it when done.
|
|
//
|
|
if(ImageData = MyMalloc(sizeof(CLASS_IMAGE_LIST))) {
|
|
ZeroMemory(ImageData, sizeof(CLASS_IMAGE_LIST));
|
|
} else {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
if(InitializeSynchronizedAccess(&ImageData->Lock)) {
|
|
DestroyLock = TRUE;
|
|
}
|
|
|
|
//
|
|
// Build the class image list. Create an Image List with no mask,
|
|
// 1 image, and a growth factor of 1.
|
|
//
|
|
cxMiniIcon = GetSystemMetrics(SM_CXSMICON);
|
|
cyMiniIcon = GetSystemMetrics(SM_CYSMICON);
|
|
|
|
ImageListFlags = ILC_MASK;
|
|
|
|
//
|
|
// Check which color depth we are running in. Set the ILC_COLOR32
|
|
// imagelist create flag if we are running at greate than 8bit (256)
|
|
// color depth.
|
|
//
|
|
hDC = GetDC(NULL);
|
|
if (hDC) {
|
|
if (GetDeviceCaps(hDC, BITSPIXEL) > 8) {
|
|
ImageListFlags |= ILC_COLOR32;
|
|
}
|
|
|
|
ReleaseDC(NULL, hDC);
|
|
hDC = NULL;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// If we are running on an RTL build then we need to set the ILC_MIRROR
|
|
// flag when calling ImageList_Create to un-mirror the icons. By
|
|
// default the icons are mirrored.
|
|
//
|
|
if (GetProcessDefaultLayout(&dwLayout) &&
|
|
(dwLayout & LAYOUT_RTL)) {
|
|
ImageListFlags |= ILC_MIRROR;
|
|
}
|
|
#endif
|
|
|
|
if(!(ImageList = ImageList_Create(cxMiniIcon,
|
|
cyMiniIcon,
|
|
ImageListFlags,
|
|
1,
|
|
1)))
|
|
{
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
ImageList_SetBkColor(ImageList, GetSysColor(COLOR_WINDOW));
|
|
|
|
//
|
|
// Create a DC to draw the mini icons into. This is needed
|
|
// for the system defined Minis
|
|
//
|
|
if(!(hDC = GetDC(HWND_DESKTOP)) ||
|
|
!(hMemImageDC = CreateCompatibleDC(hDC)))
|
|
{
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Create a bitmap to draw the icons on. Defer checking for creation
|
|
// of bitmap until afer freeing DC, so it only has to be done once.
|
|
//
|
|
hbmMiniImage = CreateCompatibleBitmap(hDC, cxMiniIcon, cyMiniIcon);
|
|
hbmMiniMask = CreateCompatibleBitmap(hDC, cxMiniIcon, cyMiniIcon);
|
|
|
|
ReleaseDC(HWND_DESKTOP, hDC);
|
|
hDC = NULL;
|
|
|
|
//
|
|
// Did the bitmap get created?
|
|
//
|
|
if (!hbmMiniImage || ! hbmMiniMask) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Select our bitmap into the memory DC.
|
|
//
|
|
hbmOldImage = SelectObject(hMemImageDC, hbmMiniImage);
|
|
|
|
//
|
|
// Prepare to draw the mini icon onto the memory DC
|
|
//
|
|
rc.left = 0;
|
|
rc.top = 0;
|
|
rc.right = cxMiniIcon;
|
|
rc.bottom = cyMiniIcon;
|
|
|
|
//
|
|
// Get the Index of the Default mini icon.
|
|
//
|
|
SetupDiGetClassBitmapIndex(NULL, &DefaultIndex);
|
|
|
|
//
|
|
// Enumerate all classes, and for each class, draw its bitmap.
|
|
//
|
|
GuidCount = 32;
|
|
ImageData->ClassGuidList = (LPGUID)MyMalloc(sizeof(GUID) * GuidCount);
|
|
|
|
if (!SetupDiBuildClassInfoListEx(0,
|
|
ImageData->ClassGuidList,
|
|
GuidCount,
|
|
&GuidCount,
|
|
MachineName,
|
|
NULL)) {
|
|
|
|
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
|
|
//
|
|
// Realloc buffer and try again.
|
|
//
|
|
MyFree(ImageData->ClassGuidList);
|
|
|
|
if(!(ImageData->ClassGuidList = MyMalloc(sizeof(GUID) * GuidCount))) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
if (!SetupDiBuildClassInfoListEx(0,
|
|
ImageData->ClassGuidList,
|
|
GuidCount,
|
|
&GuidCount,
|
|
MachineName,
|
|
NULL)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
} else {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Retrieve the icon for each class in the class list.
|
|
//
|
|
for (pClassGuid = ImageData->ClassGuidList, i = 0;
|
|
i < GuidCount;
|
|
pClassGuid++, i++) {
|
|
|
|
if (!pSetupDiLoadClassIcon(pClassGuid,
|
|
&hiLargeIcon,
|
|
&hiSmallIcon,
|
|
&MiniIconIndex)) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// If the returned Mini Icon index is not the Default one, then
|
|
// we use the MiniBitmap, since it is a pre-defined one in SETUPAPI.
|
|
// If the Mini is not pre-defined, and there is no Class Installer
|
|
// then we use the Mini, since it is a valid default. If there
|
|
// is no Mini, and there is a class installer, then we will use
|
|
// the Class installer's big Icon, and have the Image list crunch
|
|
// it for us.
|
|
//
|
|
bUseBitmap = FALSE;
|
|
|
|
if (DefaultIndex != MiniIconIndex) {
|
|
|
|
SetupDiDrawMiniIcon(hMemImageDC,
|
|
rc,
|
|
MiniIconIndex,
|
|
DMI_USERECT);
|
|
|
|
SelectObject(hMemImageDC, hbmMiniMask);
|
|
|
|
SetupDiDrawMiniIcon(hMemImageDC,
|
|
rc,
|
|
MiniIconIndex,
|
|
DMI_MASK | DMI_USERECT);
|
|
bUseBitmap = TRUE;
|
|
}
|
|
|
|
//
|
|
// Deselect the bitmap from our DC BEFORE calling ImageList
|
|
// functions.
|
|
//
|
|
SelectObject(hMemImageDC, hbmOldImage);
|
|
|
|
//
|
|
// Add the image. Allocate a new PCI.
|
|
//
|
|
if(!(pci = (PCLASSICON)MyMalloc(sizeof(CLASSICON)))) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
if (hiSmallIcon) {
|
|
pci->MiniBitmapIndex = (UINT)ImageList_AddIcon(ImageList, hiSmallIcon);
|
|
} else if (bUseBitmap) {
|
|
pci->MiniBitmapIndex = (UINT)ImageList_Add(ImageList, hbmMiniImage, hbmMiniMask);
|
|
} else {
|
|
pci->MiniBitmapIndex = (UINT)ImageList_AddIcon(ImageList, hiLargeIcon);
|
|
}
|
|
|
|
if (hiLargeIcon) {
|
|
DestroyIcon(hiLargeIcon);
|
|
hiLargeIcon = NULL;
|
|
}
|
|
|
|
if (hiSmallIcon) {
|
|
DestroyIcon(hiSmallIcon);
|
|
hiSmallIcon = NULL;
|
|
}
|
|
|
|
if(pci->MiniBitmapIndex == (UINT)-1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
MyFree(pci);
|
|
pci = NULL;
|
|
goto clean0;
|
|
}
|
|
|
|
pci->ClassGuid = pClassGuid;
|
|
|
|
//
|
|
// Link it in.
|
|
//
|
|
pci->Next = ImageData->ClassIconList;
|
|
ImageData->ClassIconList = pci;
|
|
|
|
//
|
|
// Reset pci to NULL so we won't try to free it later.
|
|
//
|
|
pci = NULL;
|
|
|
|
//
|
|
// Select our bitmap back for the next ICON.
|
|
//
|
|
SelectObject(hMemImageDC, hbmMiniImage);
|
|
|
|
if(IsEqualGUID(pClassGuid, &GUID_DEVCLASS_UNKNOWN)) {
|
|
ImageData->UnknownImageIndex = i;
|
|
}
|
|
|
|
//
|
|
// Check to see if we've encountered the computer class. This used
|
|
// to be a special pseudo-class used solely by DevMgr to retrieve
|
|
// the icon for the root of the device tree. Now, we use this class
|
|
// for specifying the 'drivers' for the computer itself (i.e., the
|
|
// HALs and the appropriate versions of files that are different for
|
|
// MP vs. UP.
|
|
//
|
|
// We should encounter this class GUID, but if we don't, then we
|
|
// want to maintain the old behavior of adding this in manually
|
|
// later on.
|
|
//
|
|
if(!ComputerClassFound && IsEqualGUID(pClassGuid, &GUID_DEVCLASS_COMPUTER)) {
|
|
ComputerClassFound = TRUE;
|
|
}
|
|
}
|
|
|
|
if(!ComputerClassFound) {
|
|
//
|
|
// Special Case for the Internal Class "Computer"
|
|
//
|
|
if(!(pci = (PCLASSICON)MyMalloc(sizeof(CLASSICON)))) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
pci->ClassGuid = &GUID_DEVCLASS_COMPUTER;
|
|
SelectObject(hMemImageDC, hbmMiniImage);
|
|
hOldBrush = SelectObject(hMemImageDC, GetSysColorBrush(COLOR_WINDOW));
|
|
PatBlt(hMemImageDC, 0, 0, cxMiniIcon, cyMiniIcon, PATCOPY);
|
|
SelectObject(hMemImageDC, hOldBrush);
|
|
|
|
SetupDiGetClassBitmapIndex((LPGUID)pci->ClassGuid, &MiniIconIndex);
|
|
|
|
SetupDiDrawMiniIcon(hMemImageDC,
|
|
rc,
|
|
MiniIconIndex,
|
|
DMI_USERECT);
|
|
|
|
SelectObject(hMemImageDC, hbmMiniMask);
|
|
SetupDiDrawMiniIcon(hMemImageDC,
|
|
rc,
|
|
MiniIconIndex,
|
|
DMI_MASK | DMI_USERECT);
|
|
|
|
//
|
|
// Deselect the bitmap from our DC BEFORE calling ImageList
|
|
// functions.
|
|
//
|
|
SelectObject(hMemImageDC, hbmOldImage);
|
|
|
|
pci->MiniBitmapIndex = ImageList_Add(ImageList, hbmMiniImage, hbmMiniMask);
|
|
|
|
if(pci->MiniBitmapIndex == (UINT)-1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
MyFree(pci);
|
|
pci = NULL;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// Link it in.
|
|
//
|
|
pci->Next = ImageData->ClassIconList;
|
|
ImageData->ClassIconList = pci;
|
|
|
|
//
|
|
// Reset pci to NULL so we won't try to free it later.
|
|
//
|
|
pci = NULL;
|
|
}
|
|
|
|
//
|
|
// Add the Overlay ICONs.
|
|
//
|
|
for (iIcon = IDI_CLASSICON_OVERLAYFIRST;
|
|
iIcon <= IDI_CLASSICON_OVERLAYLAST;
|
|
++iIcon) {
|
|
|
|
if(!(hIcon = LoadIcon(MyDllModuleHandle, MAKEINTRESOURCE(iIcon)))) {
|
|
Err = GetLastError();
|
|
goto clean0;
|
|
}
|
|
|
|
iIndex = ImageList_AddIcon(ImageList, hIcon);
|
|
|
|
if(iIndex == -1) {
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto clean0;
|
|
}
|
|
|
|
if(!ImageList_SetOverlayImage(ImageList, iIndex, iIcon - IDI_CLASSICON_OVERLAYFIRST + 1)) {
|
|
Err = ERROR_INVALID_DATA;
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we get to this point, then we've successfully constructed the entire
|
|
// image list, and associated CLASSICON nodes. Now, store this information
|
|
// in the caller's SP_CLASSIMAGELIST_DATA buffer.
|
|
//
|
|
ClassImageListData->Reserved = (ULONG_PTR)ImageData;
|
|
ClassImageListData->ImageList = ImageList;
|
|
|
|
clean0: ; // nothing to do.
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
|
|
if(hDC) {
|
|
ReleaseDC(HWND_DESKTOP, hDC);
|
|
}
|
|
|
|
if(pci) {
|
|
MyFree(pci);
|
|
}
|
|
|
|
//
|
|
// Reference the following variables so the compiler will respect statement
|
|
// ordering w.r.t. assignment.
|
|
//
|
|
ImageData = ImageData;
|
|
DestroyLock = DestroyLock;
|
|
ImageList = ImageList;
|
|
}
|
|
|
|
if (hbmMiniImage) {
|
|
DeleteObject(hbmMiniImage);
|
|
}
|
|
if (hbmMiniMask) {
|
|
DeleteObject(hbmMiniMask);
|
|
}
|
|
if (hMemImageDC) {
|
|
DeleteDC(hMemImageDC);
|
|
}
|
|
|
|
if(Err != NO_ERROR) {
|
|
|
|
if(ImageData) {
|
|
if(DestroyLock) {
|
|
DestroySynchronizedAccess(&ImageData->Lock);
|
|
}
|
|
if(ImageData->ClassGuidList) {
|
|
MyFree(ImageData->ClassGuidList);
|
|
}
|
|
while(ImageData->ClassIconList) {
|
|
pci = ImageData->ClassIconList;
|
|
ImageData->ClassIconList = pci->Next;
|
|
MyFree(pci);
|
|
}
|
|
MyFree(ImageData);
|
|
}
|
|
|
|
if(ImageList) {
|
|
ImageList_Destroy(ImageList);
|
|
}
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return (Err == NO_ERROR);
|
|
}
|
|
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupDiDestroyClassImageList(
|
|
IN PSP_CLASSIMAGELIST_DATA ClassImageListData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine destroys a class image list built by a call to SetupDiGetClassImageList.
|
|
|
|
Arguments:
|
|
|
|
ClassImageListData - Supplies the address of a SP_CLASSIMAGELIST_DATA structure
|
|
containing the class image list to be destroyed.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is TRUE.
|
|
|
|
If the function fails, the return value is FALSE. To get extended error
|
|
information, call GetLastError.
|
|
|
|
--*/
|
|
{
|
|
DWORD Err = NO_ERROR;
|
|
PCLASS_IMAGE_LIST ImageData = NULL;
|
|
PCLASSICON pci;
|
|
|
|
try {
|
|
|
|
if(ClassImageListData->cbSize != sizeof(SP_CLASSIMAGELIST_DATA)) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
goto clean0;
|
|
}
|
|
|
|
if (ClassImageListData->Reserved == 0x0) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
goto clean0;
|
|
}
|
|
|
|
|
|
ImageData = (PCLASS_IMAGE_LIST)ClassImageListData->Reserved;
|
|
|
|
if (!LockImageList(ImageData)) {
|
|
Err = ERROR_CANT_LOAD_CLASS_ICON;
|
|
goto clean0;
|
|
}
|
|
|
|
if (ClassImageListData->ImageList) {
|
|
ImageList_Destroy(ClassImageListData->ImageList);
|
|
}
|
|
|
|
if (ImageData->ClassGuidList) {
|
|
MyFree(ImageData->ClassGuidList);
|
|
}
|
|
|
|
while(ImageData->ClassIconList) {
|
|
pci = ImageData->ClassIconList;
|
|
ImageData->ClassIconList = pci->Next;
|
|
MyFree(pci);
|
|
}
|
|
|
|
DestroySynchronizedAccess(&ImageData->Lock);
|
|
MyFree(ImageData);
|
|
ClassImageListData->Reserved = 0;
|
|
|
|
|
|
clean0: ; // nothing to do.
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return (Err == NO_ERROR);
|
|
}
|
|
|
|
|
|
BOOL
|
|
WINAPI
|
|
SetupDiGetClassImageIndex(
|
|
IN PSP_CLASSIMAGELIST_DATA ClassImageListData,
|
|
IN CONST GUID *ClassGuid,
|
|
OUT PINT ImageIndex
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine retrieves the index within the class image list of a specified
|
|
class.
|
|
|
|
Arguments:
|
|
|
|
ClassImageListData - Supplies the address of a SP_CLASSIMAGELIST_DATA
|
|
structure containing the specified class's image.
|
|
|
|
ClassGuid - Supplies the address of the GUID for the class whose index is
|
|
to be retrieved.
|
|
|
|
ImageIndex - Supplies the address of a variable that receives the index of
|
|
the specified class's image within the class image list.
|
|
|
|
Return Value:
|
|
|
|
If the function succeeds, the return value is TRUE.
|
|
|
|
If the function fails, the return value is FALSE. To get extended error
|
|
information, call GetLastError.
|
|
|
|
--*/
|
|
{
|
|
DWORD Err = NO_ERROR;
|
|
BOOL bFound = FALSE, bLocked = FALSE;
|
|
PCLASS_IMAGE_LIST ImageData = NULL;
|
|
PCLASSICON pci;
|
|
|
|
|
|
try {
|
|
|
|
if(ClassImageListData->cbSize != sizeof(SP_CLASSIMAGELIST_DATA)) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
goto clean0;
|
|
}
|
|
|
|
if (ClassImageListData->Reserved == 0x0) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
goto clean0;
|
|
}
|
|
|
|
ImageData = (PCLASS_IMAGE_LIST)ClassImageListData->Reserved;
|
|
|
|
if (!LockImageList(ImageData)) {
|
|
Err = ERROR_CANT_LOAD_CLASS_ICON;
|
|
goto clean0;
|
|
}
|
|
bLocked = TRUE;
|
|
|
|
|
|
if (ClassGuid) {
|
|
//
|
|
// check the "new stuff" list to see if it's there
|
|
//
|
|
for (pci = ImageData->ClassIconList;
|
|
!bFound && pci;
|
|
pci = pci->Next) {
|
|
|
|
if(IsEqualGUID(pci->ClassGuid, ClassGuid)) {
|
|
*ImageIndex = pci->MiniBitmapIndex;
|
|
bFound = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// if no match was found, snag the "unknown" class
|
|
//
|
|
if (!bFound) {
|
|
*ImageIndex = ImageData->UnknownImageIndex;
|
|
}
|
|
|
|
|
|
clean0: ; // nothing to do.
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_USER_BUFFER;
|
|
}
|
|
|
|
if (bLocked && ImageData) {
|
|
UnlockImageList(ImageData);
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return (Err == NO_ERROR);
|
|
}
|