#include <user32.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for exticon.c:

Classes
struct	icoICONDIRENTRY

struct	icoICONDIR

struct	NE_NAMEINFO

struct	NE_TYPEINFO

Macros
#define	ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

#define	NE_RSCTYPE_ICON 0x8003

#define	NE_RSCTYPE_GROUP_ICON 0x800e

Typedefs
typedef struct icoICONDIRENTRY *	LPicoICONDIRENTRY

typedef struct icoICONDIR *	LPicoICONDIR

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (icon)

DWORD	get_best_icon_file_offset (const LPBYTE dir, DWORD dwFileSize, int cxDesired, int cyDesired, BOOL bIcon, DWORD fuLoad, POINT *ptHotSpot)

static const IMAGE_RESOURCE_DIRECTORY *	find_entry_by_id (const IMAGE_RESOURCE_DIRECTORY dir, WORD id, const void root)

static const IMAGE_RESOURCE_DIRECTORY *	find_entry_default (const IMAGE_RESOURCE_DIRECTORY dir, const void root)

static DWORD	USER32_GetResourceTable (LPBYTE peimage, DWORD pesize, LPBYTE *retptr)

static BYTE *	USER32_LoadResource (LPBYTE peimage, NE_NAMEINFO pNInfo, WORD sizeShift, ULONG uSize)

static BYTE *	ICO_LoadIcon (LPBYTE peimage, LPicoICONDIRENTRY lpiIDE, ULONG *uSize)

static BYTE *	ICO_GetIconDirectory (LPBYTE peimage, LPicoICONDIR lplpiID, ULONG uSize)

static UINT	ICO_ExtractIconExW (LPCWSTR lpszExeFileName, HICON RetPtr, INT nIconIndex, UINT nIcons, UINT cxDesired, UINT cyDesired, UINT pIconId, UINT flags)

UINT WINAPI	PrivateExtractIconsW (LPCWSTR lpwstrFile, int nIndex, int sizeX, int sizeY, HICON phicon, UINT pIconId, UINT nIcons, UINT flags)

UINT WINAPI	PrivateExtractIconsA (LPCSTR lpstrFile, int nIndex, int sizeX, int sizeY, HICON phicon, UINT piconid, UINT nIcons, UINT flags)

UINT WINAPI	PrivateExtractIconExW (LPCWSTR lpwstrFile, int nIndex, HICON phIconLarge, HICON phIconSmall, UINT nIcons)

UINT WINAPI	PrivateExtractIconExA (LPCSTR lpstrFile, int nIndex, HICON phIconLarge, HICON phIconSmall, UINT nIcons)

Macro Definition Documentation

◆ ARRAY_SIZE

#define ARRAY_SIZE ( x ) (sizeof(x) / sizeof((x)[0]))

Definition at line 28 of file exticon.c.

◆ NE_RSCTYPE_GROUP_ICON

#define NE_RSCTYPE_GROUP_ICON 0x800e

Definition at line 92 of file exticon.c.

◆ NE_RSCTYPE_ICON

#define NE_RSCTYPE_ICON 0x8003

Definition at line 91 of file exticon.c.

Typedef Documentation

◆ LPicoICONDIR

typedef struct icoICONDIR * LPicoICONDIR

◆ LPicoICONDIRENTRY

typedef struct icoICONDIRENTRY * LPicoICONDIRENTRY

Function Documentation

◆ find_entry_by_id()

static const IMAGE_RESOURCE_DIRECTORY * find_entry_by_id	(	const IMAGE_RESOURCE_DIRECTORY *	dir,
		WORD	id,
		const void *	root
	)

static

Definition at line 126 of file exticon.c.

{
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
    int min, max, pos;
 
    entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
    min = dir->NumberOfNamedEntries;
    max = min + dir->NumberOfIdEntries - 1;
    while (min <= max)
    {
        pos = (min + max) / 2;
        if (entry[pos].Id == id)
            return (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry[pos].OffsetToDirectory);
        if (entry[pos].Id > id) max = pos - 1;
        else min = pos + 1;
    }
    return NULL;
}

Referenced by ICO_ExtractIconExW().

◆ find_entry_default()

static const IMAGE_RESOURCE_DIRECTORY * find_entry_default	(	const IMAGE_RESOURCE_DIRECTORY *	dir,
		const void *	root
	)

static

Definition at line 152 of file exticon.c.

{
    const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry;
    entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1);
    return (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry->OffsetToDirectory);
}

Referenced by ICO_ExtractIconExW().

◆ get_best_icon_file_offset()

DWORD get_best_icon_file_offset	(	const LPBYTE	dir,
		DWORD	dwFileSize,
		int	cxDesired,
		int	cyDesired,
		BOOL	bIcon,
		DWORD	fuLoad,
		POINT *	ptHotSpot
	)

Referenced by ICO_ExtractIconExW().

◆ ICO_ExtractIconExW()

static UINT ICO_ExtractIconExW	(	LPCWSTR	lpszExeFileName,
		HICON *	RetPtr,
		INT	nIconIndex,
		UINT	nIcons,
		UINT	cxDesired,
		UINT	cyDesired,
		UINT *	pIconId,
		UINT	flags
	)

static

Definition at line 280 of file exticon.c.

{
    UINT        ret = 0;
    UINT        cx1, cx2, cy1, cy2;
    LPBYTE      pData;
    DWORD       sig;
    HANDLE      hFile;
    UINT16      iconDirCount = 0,iconCount = 0;
    LPBYTE      peimage;
    HANDLE      fmapping;
    DWORD       fsizeh,fsizel;
#ifdef __REACTOS__
    WCHAR       szExpandedExePath[MAX_PATH];
#endif
        WCHAR       szExePath[MAX_PATH];
        DWORD       dwSearchReturn;
 
#ifdef __REACTOS__
    TRACE("%s, %d, %d, %p, 0x%08x, %d\n", debugstr_w(lpszExeFileName), nIconIndex, nIcons, pIconId, flags, fIconEx);
#else
    TRACE("%s, %d, %d %p 0x%08x\n", debugstr_w(lpszExeFileName), nIconIndex, nIcons, pIconId, flags);
#endif
 
#ifdef __REACTOS__
    if (RetPtr)
        *RetPtr = NULL;
 
    if (ExpandEnvironmentStringsW(lpszExeFileName, szExpandedExePath, ARRAY_SIZE(szExpandedExePath)))
        lpszExeFileName = szExpandedExePath;
#endif
 
        dwSearchReturn = SearchPathW(NULL, lpszExeFileName, NULL, ARRAY_SIZE(szExePath), szExePath, NULL);
        if ((dwSearchReturn == 0) || (dwSearchReturn > ARRAY_SIZE(szExePath)))
        {
#ifdef __REACTOS__
            WARN("File %s not found or path too long and fIconEx is '%d'\n",
                 debugstr_w(lpszExeFileName), fIconEx);
            if (fIconEx && !RetPtr && !pIconId)
                return 0;
            else
                return -1;
#else
            WARN("File %s not found or path too long\n", debugstr_w(lpszExeFileName));
            return -1;
#endif
        }
 
    hFile = CreateFileW(szExePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
    if (hFile == INVALID_HANDLE_VALUE) return ret;
    fsizel = GetFileSize(hFile,&fsizeh);
 
    /* Map the file */
    fmapping = CreateFileMappingW(hFile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
    CloseHandle(hFile);
    if (!fmapping)
    {
          WARN("CreateFileMapping error %ld\n", GetLastError() );
      return 0xFFFFFFFF;
    }
 
    if (!(peimage = MapViewOfFile(fmapping, FILE_MAP_READ, 0, 0, 0)))
    {
          WARN("MapViewOfFile error %ld\n", GetLastError() );
      CloseHandle(fmapping);
      return 0xFFFFFFFF;
    }
    CloseHandle(fmapping);
 
#ifdef __REACTOS__
    /* Check if we have a min size of 2 headers RIFF & 'icon'
     * at 8 chars each plus an anih header of 36 byptes.
     * Also, is this resource an animjated icon/cursor (RIFF) */
    if ((fsizel >= 52) && !memcmp(peimage, "RIFF", 4))
    {
        UINT anihOffset;
        UINT anihMax;
        /* Get size of the animation data */
        ULONG uSize = MAKEWORD(peimage[4], peimage[5]);
 
        /* Check if uSize is reasonable with respect to fsizel */
        if ((uSize < strlen("anih")) || (uSize > fsizel))
            goto end;
 
        /* Look though the reported size less search string length */
        anihMax = uSize - strlen("anih"); 
        /* Search for 'anih' indicating animation header */
        for (anihOffset = 0; anihOffset < anihMax; anihOffset++)
        {
            if (memcmp(&peimage[anihOffset], "anih", 4) == 0)
                break;
        }
 
        if (anihOffset + sizeof(aniheader) > fsizel)
            goto end;
 
        /* Get count of images for return value */
        ret = MAKEWORD(peimage[anihOffset + 12], peimage[anihOffset + 13]);
 
        TRACE("RIFF File with '%u' images at Offset '%u'.\n", ret, anihOffset);
 
        cx1 = LOWORD(cxDesired);
        cy1 = LOWORD(cyDesired);
 
        if (RetPtr)
        {
            RetPtr[0] = CreateIconFromResourceEx(peimage, uSize, TRUE, 0x00030000, cx1, cy1, flags);
        }
        goto end;
    }
#endif
 
    cx1 = LOWORD(cxDesired);
    cx2 = HIWORD(cxDesired);
    cy1 = LOWORD(cyDesired);
    cy2 = HIWORD(cyDesired);
 
    if (pIconId) /* Invalidate first icon identifier */
        *pIconId = 0xFFFFFFFF;
 
    if (!pIconId) /* if no icon identifier array present use the icon handle array as intermediate storage */
      pIconId = (UINT*)RetPtr;
 
    sig = USER32_GetResourceTable(peimage, fsizel, &pData);
 
/* NE exe/dll */
    if (sig==IMAGE_OS2_SIGNATURE)
    {
      BYTE      *pCIDir = 0;
      NE_TYPEINFO   *pTInfo = (NE_TYPEINFO*)(pData + 2);
      NE_NAMEINFO   *pIconStorage = NULL;
      NE_NAMEINFO   *pIconDir = NULL;
      LPicoICONDIR  lpiID = NULL;
      ULONG     uSize = 0;
 
          TRACE("-- OS2/icon Signature (0x%08x)\n", sig);
 
      if (pData == (BYTE*)-1)
      {
        pCIDir = ICO_GetIconDirectory(peimage, &lpiID, &uSize); /* check for .ICO file */
        if (pCIDir)
        {
          iconDirCount = 1; iconCount = lpiID->idCount;
              TRACE("-- icon found %p 0x%08x 0x%08x 0x%08x\n", pCIDir, uSize, iconDirCount, iconCount);
        }
      }
      else while (pTInfo->type_id && !(pIconStorage && pIconDir))
      {
        if (pTInfo->type_id == NE_RSCTYPE_GROUP_ICON)   /* find icon directory and icon repository */
        {
          iconDirCount = pTInfo->count;
          pIconDir = ((NE_NAMEINFO*)(pTInfo + 1));
          TRACE("\tfound directory - %i icon families\n", iconDirCount);
        }
        if (pTInfo->type_id == NE_RSCTYPE_ICON)
        {
          iconCount = pTInfo->count;
          pIconStorage = ((NE_NAMEINFO*)(pTInfo + 1));
          TRACE("\ttotal icons - %i\n", iconCount);
        }
        pTInfo = (NE_TYPEINFO *)((char*)(pTInfo+1)+pTInfo->count*sizeof(NE_NAMEINFO));
      }
 
      if ((pIconStorage && pIconDir) || lpiID)    /* load resources and create icons */
      {
        if (nIcons == 0)
        {
          ret = iconDirCount;
              if (lpiID)    /* *.ico file, deallocate heap pointer*/
            HeapFree(GetProcessHeap(), 0, pCIDir);
        }
        else if (nIconIndex < iconDirCount)
        {
          UINT16   i, icon;
          if (nIcons > iconDirCount - nIconIndex)
            nIcons = iconDirCount - nIconIndex;
 
          for (i = 0; i < nIcons; i++)
          {
            /* .ICO files have only one icon directory */
            if (lpiID == NULL)  /* not *.ico */
              pCIDir = USER32_LoadResource(peimage, pIconDir + i + nIconIndex, *(WORD*)pData, &uSize);
            pIconId[i] = LookupIconIdFromDirectoryEx(pCIDir, TRUE, cx1, cy1, flags);
                if (cx2 && cy2) pIconId[++i] = LookupIconIdFromDirectoryEx(pCIDir, TRUE,  cx2, cy2, flags);
          }
              if (lpiID)    /* *.ico file, deallocate heap pointer*/
            HeapFree(GetProcessHeap(), 0, pCIDir);
 
          for (icon = 0; icon < nIcons; icon++)
          {
            pCIDir = NULL;
            if (lpiID)
              pCIDir = ICO_LoadIcon(peimage, lpiID->idEntries + (int)pIconId[icon], &uSize);
            else
              for (i = 0; i < iconCount; i++)
                if (pIconStorage[i].id == ((int)pIconId[icon] | 0x8000) )
                  pCIDir = USER32_LoadResource(peimage, pIconStorage + i, *(WORD*)pData, &uSize);
 
            if (pCIDir)
                {
              RetPtr[icon] = CreateIconFromResourceEx(pCIDir, uSize, TRUE, 0x00030000,
                                                                 cx1, cy1, flags);
                  if (cx2 && cy2)
                      RetPtr[++icon] = CreateIconFromResourceEx(pCIDir, uSize, TRUE, 0x00030000,
                                                                       cx2, cy2, flags);
                }
            else
              RetPtr[icon] = 0;
          }
          ret = icon;   /* return number of retrieved icons */
        }
      }
    }
    else
    if (sig == 1 || sig == 2) /* .ICO or .CUR file */
    {
        TRACE("-- icon Signature (0x%08x)\n", sig);
 
        if (pData == (BYTE*)-1)
        {
            INT cx[2] = {cx1, cx2}, cy[2] = {cy1, cy2};
            INT index;
 
            for(index = 0; index < (cx2 || cy2 ? 2 : 1); index++)
            {
                DWORD dataOffset;
                LPBYTE imageData;
                POINT hotSpot;
#ifndef __REACTOS__
                LPICONIMAGE entry;
#endif
 
                dataOffset = get_best_icon_file_offset(peimage, fsizel, cx[index], cy[index], sig == 1, flags, sig == 1 ? NULL : &hotSpot);
 
                if (dataOffset)
                {
                    HICON icon;
                    WORD *cursorData = NULL;
#ifdef __REACTOS__
                    BITMAPINFOHEADER bi;
                    DWORD cbColorTable = 0, cbTotal;
#endif
 
                    imageData = peimage + dataOffset;
#ifdef __REACTOS__
                    /* Calculate the size of color table */
                    ZeroMemory(&bi, sizeof(bi));
                    CopyMemory(&bi, imageData, sizeof(BITMAPCOREHEADER));
                    if (bi.biBitCount <= 8)
                    {
                        if (bi.biSize >= sizeof(BITMAPINFOHEADER))
                        {
                            CopyMemory(&bi, imageData, sizeof(BITMAPINFOHEADER));
                            if (bi.biClrUsed)
                                cbColorTable = bi.biClrUsed * sizeof(RGBQUAD);
                            else
                                cbColorTable = (1 << bi.biBitCount) * sizeof(RGBQUAD);
                        }
                        else if (bi.biSize == sizeof(BITMAPCOREHEADER))
                        {
                            cbColorTable = (1 << bi.biBitCount) * sizeof(RGBTRIPLE);
                        }
                    }
 
                    /* biSizeImage is the size of the raw bitmap data.
                     * https://en.wikipedia.org/wiki/BMP_file_format */
                    if (bi.biSizeImage == 0)
                    {
                         /* Calculate image size */
#define WIDTHBYTES(width, bits) (((width) * (bits) + 31) / 32 * 4)
                        bi.biSizeImage = WIDTHBYTES(bi.biWidth, bi.biBitCount) * (bi.biHeight / 2);
                        bi.biSizeImage += WIDTHBYTES(bi.biWidth, 1) * (bi.biHeight / 2);
#undef WIDTHBYTES
                    }
 
                    /* Calculate total size */
                    cbTotal = bi.biSize + cbColorTable + bi.biSizeImage;
#else
                    entry = (LPICONIMAGE)(imageData);
#endif
 
                    if(sig == 2)
                    {
                        /* we need to prepend the bitmap data with hot spots for CreateIconFromResourceEx */
#ifdef __REACTOS__
                        cursorData = HeapAlloc(GetProcessHeap(), 0, 2 * sizeof(WORD) + cbTotal);
#else
                        cursorData = HeapAlloc(GetProcessHeap(), 0, entry->icHeader.biSizeImage + 2 * sizeof(WORD));
#endif
 
                        if(!cursorData)
                            continue;
 
                        cursorData[0] = hotSpot.x;
                        cursorData[1] = hotSpot.y;
 
#ifdef __REACTOS__
                        CopyMemory(cursorData + 2, imageData, cbTotal);
#else
                        memcpy(cursorData + 2, imageData, entry->icHeader.biSizeImage);
#endif
 
                        imageData = (LPBYTE)cursorData;
                    }
 
#ifdef __REACTOS__
                    icon = CreateIconFromResourceEx(imageData, cbTotal, sig == 1, 0x00030000, cx[index], cy[index], flags);
                    if (fIconEx && sig == 1)
                        iconCount = 1;
#else
                    icon = CreateIconFromResourceEx(imageData, entry->icHeader.biSizeImage, sig == 1, 0x00030000, cx[index], cy[index], flags);
#endif
 
                    HeapFree(GetProcessHeap(), 0, cursorData);
 
                    if (icon)
                    {
                        if (RetPtr)
                            RetPtr[index] = icon;
                        else
                            DestroyIcon(icon);
 
                        iconCount = 1;
                        break;
                    }
                }
            }
        }
        ret = iconCount;    /* return number of retrieved icons */
    }
/* end ico file */
 
/* exe/dll */
    else if( sig == IMAGE_NT_SIGNATURE )
    {
        BYTE *idata, *igdata;
        const IMAGE_RESOURCE_DIRECTORY *rootresdir, *iconresdir, *icongroupresdir;
        const IMAGE_RESOURCE_DATA_ENTRY *idataent, *igdataent;
        const IMAGE_RESOURCE_DIRECTORY_ENTRY *xresent;
        ULONG size;
        UINT i;
 
        rootresdir = RtlImageDirectoryEntryToData((HMODULE)peimage, FALSE, IMAGE_DIRECTORY_ENTRY_RESOURCE, &size);
        if (!rootresdir)
        {
            WARN("haven't found section for resource directory.\n");
            goto end;
        }
 
#ifdef __REACTOS__
        /* Check for boundary limit (and overflow) */
        if (((ULONG_PTR)(rootresdir + 1) < (ULONG_PTR)rootresdir) ||
            ((ULONG_PTR)(rootresdir + 1) > (ULONG_PTR)peimage + fsizel))
        {
            goto end;
        }
#endif
 
      /* search for the group icon directory */
      if (!(icongroupresdir = find_entry_by_id(rootresdir, LOWORD(RT_GROUP_ICON), rootresdir)))
      {
        WARN("No Icongroupresourcedirectory!\n");
        goto end;       /* failure */
      }
      iconDirCount = icongroupresdir->NumberOfNamedEntries + icongroupresdir->NumberOfIdEntries;
 
      /* only number of icons requested */
      if( !pIconId )
      {
        ret = iconDirCount;
        goto end;       /* success */
      }
 
      if( nIconIndex < 0 )
      {
        /* search resource id */
        int n = 0;
        int iId = abs(nIconIndex);
        const IMAGE_RESOURCE_DIRECTORY_ENTRY* xprdeTmp = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(icongroupresdir+1);
 
        while(n<iconDirCount && xprdeTmp)
        {
              if(xprdeTmp->Id ==  iId)
              {
                  nIconIndex = n;
                  break;
              }
              n++;
              xprdeTmp++;
        }
        if (nIconIndex < 0)
        {
          WARN("resource id %d not found\n", iId);
          goto end;     /* failure */
        }
      }
      else
      {
        /* check nIconIndex to be in range */
        if (nIconIndex >= iconDirCount)
        {
          WARN("nIconIndex %d is larger than iconDirCount %d\n",nIconIndex,iconDirCount);
          goto end;     /* failure */
        }
      }
 
      /* assure we don't get too much */
      if( nIcons > iconDirCount - nIconIndex )
        nIcons = iconDirCount - nIconIndex;
 
      /* starting from specified index */
      xresent = (const IMAGE_RESOURCE_DIRECTORY_ENTRY*)(icongroupresdir+1) + nIconIndex;
 
      for (i=0; i < nIcons; i++,xresent++)
      {
        const IMAGE_RESOURCE_DIRECTORY *resdir;
 
        /* go down this resource entry, name */
            resdir = (const IMAGE_RESOURCE_DIRECTORY *)((const char *)rootresdir + xresent->OffsetToDirectory);
 
        /* default language (0) */
        resdir = find_entry_default(resdir,rootresdir);
        igdataent = (const IMAGE_RESOURCE_DATA_ENTRY*)resdir;
 
        /* lookup address in mapped image for virtual address */
        igdata = RtlImageRvaToVa(RtlImageNtHeader((HMODULE)peimage), (HMODULE)peimage, igdataent->OffsetToData, NULL);
        if (!igdata)
        {
          FIXME("no matching real address for icongroup!\n");
          goto end; /* failure */
        }
        pIconId[i] = LookupIconIdFromDirectoryEx(igdata, TRUE, cx1, cy1, flags);
            if (cx2 && cy2) pIconId[++i] = LookupIconIdFromDirectoryEx(igdata, TRUE, cx2, cy2, flags);
      }
 
      if (!(iconresdir=find_entry_by_id(rootresdir,LOWORD(RT_ICON),rootresdir)))
      {
        WARN("No Iconresourcedirectory!\n");
        goto end;       /* failure */
      }
 
      for (i=0; i<nIcons; i++)
      {
        const IMAGE_RESOURCE_DIRECTORY *xresdir;
        xresdir = find_entry_by_id(iconresdir, LOWORD(pIconId[i]), rootresdir);
            if( !xresdir )
            {
              WARN("icon entry %d not found\n", LOWORD(pIconId[i]));
          RetPtr[i]=0;
          continue;
            }
        xresdir = find_entry_default(xresdir, rootresdir);
        idataent = (const IMAGE_RESOURCE_DATA_ENTRY*)xresdir;
 
        idata = RtlImageRvaToVa(RtlImageNtHeader((HMODULE)peimage), (HMODULE)peimage, idataent->OffsetToData, NULL);
        if (!idata)
        {
          WARN("no matching real address found for icondata!\n");
          RetPtr[i]=0;
          continue;
        }
        RetPtr[i] = CreateIconFromResourceEx(idata, idataent->Size, TRUE, 0x00030000, cx1, cy1, flags);
            if (cx2 && cy2)
                RetPtr[++i] = CreateIconFromResourceEx(idata, idataent->Size, TRUE, 0x00030000, cx2, cy2, flags);
      }
      ret = i;  /* return number of retrieved icons */
    }           /* if(sig == IMAGE_NT_SIGNATURE) */
 
end:
    UnmapViewOfFile(peimage);   /* success */
    return ret;
}

Referenced by PrivateExtractIconExW(), and PrivateExtractIconsW().

◆ ICO_GetIconDirectory()

static BYTE * ICO_GetIconDirectory	(	LPBYTE	peimage,
		LPicoICONDIR *	lplpiID,
		ULONG *	uSize
	)

static

Definition at line 234 of file exticon.c.

{
    CURSORICONDIR   * lpcid;    /* icon resource in resource-dir format */
    CURSORICONDIR   * lpID;     /* icon resource in resource format */
    int     i;
 
    TRACE("%p %p\n", peimage, lplpiID);
 
    lpcid = (CURSORICONDIR*)peimage;
 
    if( lpcid->idReserved || (lpcid->idType != 1) || (!lpcid->idCount) )
      return 0;
 
    /* allocate the phony ICONDIR structure */
        *uSize = FIELD_OFFSET(CURSORICONDIR, idEntries[lpcid->idCount]);
    if( (lpID = HeapAlloc(GetProcessHeap(),0, *uSize) ))
    {
      /* copy the header */
      lpID->idReserved = lpcid->idReserved;
      lpID->idType = lpcid->idType;
      lpID->idCount = lpcid->idCount;
 
      /* copy the entries */
      for( i=0; i < lpcid->idCount; i++ )
      {
            memcpy(&lpID->idEntries[i], &lpcid->idEntries[i], sizeof(CURSORICONDIRENTRY) - 2);
        lpID->idEntries[i].wResId = i;
      }
 
      *lplpiID = (LPicoICONDIR)peimage;
      return (BYTE *)lpID;
    }
    return 0;
}

Referenced by ICO_ExtractIconExW().

◆ ICO_LoadIcon()

static BYTE * ICO_LoadIcon	(	LPBYTE	peimage,
		LPicoICONDIRENTRY	lpiIDE,
		ULONG *	uSize
	)

static

Definition at line 221 of file exticon.c.

{
    TRACE("%p %p\n", peimage, lpiIDE);
 
    *uSize = lpiIDE->dwBytesInRes;
    return peimage + lpiIDE->dwImageOffset;
}

Referenced by ICO_ExtractIconExW().

◆ PrivateExtractIconExA()

UINT WINAPI PrivateExtractIconExA	(	LPCSTR	lpstrFile,
		int	nIndex,
		HICON *	phIconLarge,
		HICON *	phIconSmall,
		UINT	nIcons
	)

Definition at line 925 of file exticon.c.

{
    UINT ret;
    INT len = MultiByteToWideChar(CP_ACP, 0, lpstrFile, -1, NULL, 0);
    LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
#ifdef __REACTOS__
    if (lpwstrFile == NULL)
        return 0;
#endif
 
    TRACE("%s %d %p %p %d\n", lpstrFile, nIndex, phIconLarge, phIconSmall, nIcons);
 
    MultiByteToWideChar(CP_ACP, 0, lpstrFile, -1, lpwstrFile, len);
    ret = PrivateExtractIconExW(lpwstrFile, nIndex, phIconLarge, phIconSmall, nIcons);
    HeapFree(GetProcessHeap(), 0, lpwstrFile);
    return ret;
}

◆ PrivateExtractIconExW()

UINT WINAPI PrivateExtractIconExW	(	LPCWSTR	lpwstrFile,
		int	nIndex,
		HICON *	phIconLarge,
		HICON *	phIconSmall,
		UINT	nIcons
	)

Definition at line 847 of file exticon.c.

{
    DWORD cyicon, cysmicon, cxicon, cxsmicon;
    UINT ret = 0;
 
    TRACE("%s %d %p %p %d\n",
    debugstr_w(lpwstrFile),nIndex,phIconLarge, phIconSmall, nIcons);
 
#ifdef __REACTOS__
    if (nIndex == -1 || (!phIconSmall && !phIconLarge))
      /* get the number of icons */
      return ICO_ExtractIconExW(lpwstrFile, NULL, 0, 0, 0, 0, NULL,
                                LR_DEFAULTCOLOR, FALSE);
#else
    if (nIndex == -1)
      /* get the number of icons */
      return ICO_ExtractIconExW(lpwstrFile, NULL, 0, 0, 0, 0, NULL, LR_DEFAULTCOLOR);
#endif
 
    if (nIcons == 1 && phIconSmall && phIconLarge)
    {
      HICON hIcon[2];
      cxicon = GetSystemMetrics(SM_CXICON);
      cyicon = GetSystemMetrics(SM_CYICON);
      cxsmicon = GetSystemMetrics(SM_CXSMICON);
      cysmicon = GetSystemMetrics(SM_CYSMICON);
 
#ifdef __REACTOS__
      ret = ICO_ExtractIconExW(lpwstrFile, hIcon, nIndex, 2,
                               cxicon | (cxsmicon<<16),
                               cyicon | (cysmicon<<16), NULL,
                               LR_DEFAULTCOLOR, FALSE);
#else
          ret = ICO_ExtractIconExW(lpwstrFile, hIcon, nIndex, 2, cxicon | (cxsmicon<<16),
                               cyicon | (cysmicon<<16), NULL, LR_DEFAULTCOLOR);
#endif
      *phIconLarge = hIcon[0];
      *phIconSmall = hIcon[1];
      return ret;
    }
 
    if (phIconSmall)
    {
      /* extract n small icons */
      cxsmicon = GetSystemMetrics(SM_CXSMICON);
      cysmicon = GetSystemMetrics(SM_CYSMICON);
#ifdef __REACTOS__
      ret = ICO_ExtractIconExW(lpwstrFile, phIconSmall, nIndex, nIcons, cxsmicon,
                               cysmicon, NULL, LR_DEFAULTCOLOR, FALSE);
#else
      ret = ICO_ExtractIconExW(lpwstrFile, phIconSmall, nIndex, nIcons, cxsmicon,
                               cysmicon, NULL, LR_DEFAULTCOLOR);
#endif
    }
       if (phIconLarge)
    {
      /* extract n large icons */
      cxicon = GetSystemMetrics(SM_CXICON);
      cyicon = GetSystemMetrics(SM_CYICON);
#ifdef __REACTOS__
       ret = ICO_ExtractIconExW(lpwstrFile, phIconLarge, nIndex, nIcons, cxicon,
                                cyicon, NULL, LR_DEFAULTCOLOR, FALSE);
#else
         ret = ICO_ExtractIconExW(lpwstrFile, phIconLarge, nIndex, nIcons, cxicon,
                               cyicon, NULL, LR_DEFAULTCOLOR);
#endif
    }
    return ret;
}

Referenced by ExtractIconExW(), and PrivateExtractIconExA().

◆ PrivateExtractIconsA()

UINT WINAPI PrivateExtractIconsA	(	LPCSTR	lpstrFile,
		int	nIndex,
		int	sizeX,
		int	sizeY,
		HICON *	phicon,
		UINT *	piconid,
		UINT	nIcons,
		UINT	flags
	)

Definition at line 817 of file exticon.c.

{
    UINT ret;
    INT len = MultiByteToWideChar(CP_ACP, 0, lpstrFile, -1, NULL, 0);
    LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
#ifdef __REACTOS__
    if (lpwstrFile == NULL)
        return 0;
#endif
 
    MultiByteToWideChar(CP_ACP, 0, lpstrFile, -1, lpwstrFile, len);
    ret = PrivateExtractIconsW(lpwstrFile, nIndex, sizeX, sizeY, phicon, piconid, nIcons, flags);
 
    HeapFree(GetProcessHeap(), 0, lpwstrFile);
    return ret;
}

◆ PrivateExtractIconsW()

UINT WINAPI PrivateExtractIconsW	(	LPCWSTR	lpwstrFile,
		int	nIndex,
		int	sizeX,
		int	sizeY,
		HICON *	phicon,
		UINT *	pIconId,
		UINT	nIcons,
		UINT	flags
	)

Definition at line 788 of file exticon.c.

{
    TRACE("%s %d %dx%d %p %p %d 0x%08x\n",
          debugstr_w(lpwstrFile), nIndex, sizeX, sizeY, phicon, pIconId, nIcons, flags);
 
    if ((nIcons & 1) && HIWORD(sizeX) && HIWORD(sizeY))
    {
      WARN("Uneven number %d of icons requested for small and large icons!\n", nIcons);
    }
#ifdef __REACTOS__
    return ICO_ExtractIconExW(lpwstrFile, phicon, nIndex, nIcons, sizeX, sizeY,
                              pIconId, flags, TRUE);
#else
    return ICO_ExtractIconExW(lpwstrFile, phicon, nIndex, nIcons, sizeX, sizeY, pIconId, flags);
#endif
}

Referenced by PrivateExtractIconsA().

◆ USER32_GetResourceTable()

static DWORD USER32_GetResourceTable	(	LPBYTE	peimage,
		DWORD	pesize,
		LPBYTE *	retptr
	)

static

Definition at line 163 of file exticon.c.

{
    IMAGE_DOS_HEADER    * mz_header;
 
    TRACE("%p %p\n", peimage, retptr);
 
    *retptr = NULL;
 
    mz_header = (IMAGE_DOS_HEADER*) peimage;
 
    if (mz_header->e_magic != IMAGE_DOS_SIGNATURE)
    {
      if (mz_header->e_cblp == 1 || mz_header->e_cblp == 2) /* .ICO or .CUR file ? */
      {
        *retptr = (LPBYTE)-1;   /* ICONHEADER.idType, must be 1 */
        return mz_header->e_cblp;
      }
      else
        return 0; /* failed */
    }
    if (mz_header->e_lfanew >= pesize) {
        return 0; /* failed, happens with PKZIP DOS Exes for instance. */
    }
    if (*((DWORD*)(peimage + mz_header->e_lfanew)) == IMAGE_NT_SIGNATURE )
      return IMAGE_NT_SIGNATURE;
 
    if (*((WORD*)(peimage + mz_header->e_lfanew)) == IMAGE_OS2_SIGNATURE )
    {
      IMAGE_OS2_HEADER  * ne_header;
 
      ne_header = (IMAGE_OS2_HEADER*)(peimage + mz_header->e_lfanew);
 
      if (ne_header->ne_magic != IMAGE_OS2_SIGNATURE)
        return 0;
 
      if( (ne_header->ne_restab - ne_header->ne_rsrctab) <= sizeof(NE_TYPEINFO) )
        *retptr = (LPBYTE)-1;
      else
        *retptr = peimage + mz_header->e_lfanew + ne_header->ne_rsrctab;
 
      return IMAGE_OS2_SIGNATURE;
    }
    return 0; /* failed */
}

Referenced by ICO_ExtractIconExW().

◆ USER32_LoadResource()

static BYTE * USER32_LoadResource	(	LPBYTE	peimage,
		NE_NAMEINFO *	pNInfo,
		WORD	sizeShift,
		ULONG *	uSize
	)

static

Definition at line 210 of file exticon.c.

{
    TRACE("%p %p 0x%08x\n", peimage, pNInfo, sizeShift);
 
    *uSize = (DWORD)pNInfo->length << sizeShift;
    return peimage + ((DWORD)pNInfo->offset << sizeShift);
}

Referenced by ICO_ExtractIconExW().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( icon )

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ ARRAY_SIZE

◆ NE_RSCTYPE_GROUP_ICON

◆ NE_RSCTYPE_ICON

Typedef Documentation

◆ LPicoICONDIR

◆ LPicoICONDIRENTRY

Function Documentation

◆ find_entry_by_id()

◆ find_entry_default()

◆ get_best_icon_file_offset()

◆ ICO_ExtractIconExW()

◆ ICO_GetIconDirectory()

◆ ICO_LoadIcon()

◆ PrivateExtractIconExA()

◆ PrivateExtractIconExW()

◆ PrivateExtractIconsA()

◆ PrivateExtractIconsW()

◆ USER32_GetResourceTable()

◆ USER32_LoadResource()

◆ WINE_DEFAULT_DEBUG_CHANNEL()