| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef UI_GFX_ICON_UTIL_H_ |
| #define UI_GFX_ICON_UTIL_H_ |
| |
| #include <windows.h> |
| #include <string> |
| #include <vector> |
| |
| #include "base/basictypes.h" |
| #include "base/gtest_prod_util.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "ui/gfx/gfx_export.h" |
| #include "ui/gfx/point.h" |
| #include "ui/gfx/size.h" |
| |
| namespace base { |
| class FilePath; |
| } |
| |
| namespace gfx { |
| class ImageFamily; |
| class Size; |
| } |
| class SkBitmap; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // The IconUtil class contains helper functions for manipulating Windows icons. |
| // The class interface contains methods for converting an HICON handle into an |
| // SkBitmap object and vice versa. The class can also create a .ico file given |
| // a PNG image contained in an SkBitmap object. The following code snippet |
| // shows an example usage of IconUtil::CreateHICONFromSkBitmap(): |
| // |
| // SkBitmap bitmap; |
| // |
| // // Fill |bitmap| with valid data |
| // bitmap.setConfig(...); |
| // bitmap.allocPixels(); |
| // |
| // ... |
| // |
| // // Convert the bitmap into a Windows HICON |
| // HICON icon = IconUtil::CreateHICONFromSkBitmap(bitmap); |
| // if (icon == NULL) { |
| // // Handle error |
| // ... |
| // } |
| // |
| // // Use the icon with a WM_SETICON message |
| // ::SendMessage(hwnd, WM_SETICON, static_cast<WPARAM>(ICON_BIG), |
| // reinterpret_cast<LPARAM>(icon)); |
| // |
| // // Destroy the icon when we are done |
| // ::DestroyIcon(icon); |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| class GFX_EXPORT IconUtil { |
| public: |
| // The size of the large icon entries in .ico files on Windows Vista+. |
| static const int kLargeIconSize = 256; |
| // The size of icons in the medium icons view on Windows Vista+. This is the |
| // maximum size Windows will display an icon that does not have a 256x256 |
| // image, even at the large or extra large icons views. |
| static const int kMediumIconSize = 48; |
| |
| // The dimensions for icon images in Windows icon files. All sizes are square; |
| // that is, the value 48 means a 48x48 pixel image. Sizes are listed in |
| // ascending order. |
| static const int kIconDimensions[]; |
| |
| // The number of elements in kIconDimensions. |
| static const size_t kNumIconDimensions; |
| // The number of elements in kIconDimensions <= kMediumIconSize. |
| static const size_t kNumIconDimensionsUpToMediumSize; |
| |
| // Given an SkBitmap object, the function converts the bitmap to a Windows |
| // icon and returns the corresponding HICON handle. If the function cannot |
| // convert the bitmap, NULL is returned. |
| // |
| // The client is responsible for destroying the icon when it is no longer |
| // needed by calling ::DestroyIcon(). |
| static HICON CreateHICONFromSkBitmap(const SkBitmap& bitmap); |
| |
| // Given a valid HICON handle representing an icon, this function converts |
| // the icon into an SkBitmap object containing an ARGB bitmap using the |
| // dimensions specified in |s|. |s| must specify valid dimensions (both |
| // width() an height() must be greater than zero). If the function cannot |
| // convert the icon to a bitmap (most probably due to an invalid parameter), |
| // the return value is NULL. |
| // |
| // The client owns the returned bitmap object and is responsible for deleting |
| // it when it is no longer needed. |
| static SkBitmap* CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s); |
| |
| // Loads an icon resource as a SkBitmap for the specified |size| from a |
| // loaded .dll or .exe |module|. Supports loading smaller icon sizes as well |
| // as the Vista+ 256x256 PNG icon size. If the icon could not be loaded or |
| // found, returns a NULL scoped_ptr. |
| static scoped_ptr<SkBitmap> CreateSkBitmapFromIconResource(HMODULE module, |
| int resource_id, |
| int size); |
| |
| // Given a valid HICON handle representing an icon, this function converts |
| // the icon into an SkBitmap object containing an ARGB bitmap using the |
| // dimensions of HICON. If the function cannot convert the icon to a bitmap |
| // (most probably due to an invalid parameter), the return value is NULL. |
| // |
| // The client owns the returned bitmap object and is responsible for deleting |
| // it when it is no longer needed. |
| static SkBitmap* CreateSkBitmapFromHICON(HICON icon); |
| |
| // Creates Windows .ico file at |icon_path|. The icon file is created with |
| // multiple BMP representations at varying predefined dimensions (by resizing |
| // an appropriately sized image from |image_family|) because Windows uses |
| // different image sizes when loading icons, depending on where the icon is |
| // drawn (ALT+TAB window, desktop shortcut, Quick Launch, etc.). |
| // |
| // If |image_family| contains an image larger than 48x48, the resulting icon |
| // will contain all sizes up to 256x256. The 256x256 image will be stored in |
| // PNG format inside the .ico file. If not, the resulting icon will contain |
| // all sizes up to 48x48. |
| // |
| // The function returns true on success and false otherwise. Returns false if |
| // |image_family| is empty. |
| static bool CreateIconFileFromImageFamily( |
| const gfx::ImageFamily& image_family, |
| const base::FilePath& icon_path); |
| |
| // Creates a cursor of the specified size from the DIB passed in. |
| // Returns the cursor on success or NULL on failure. |
| static HICON CreateCursorFromDIB(const gfx::Size& icon_size, |
| const gfx::Point& hotspot, |
| const void* dib_bits, |
| size_t dib_size); |
| |
| private: |
| // The icon format is published in the MSDN but there is no definition of |
| // the icon file structures in any of the Windows header files so we need to |
| // define these structure within the class. We must make sure we use 2 byte |
| // packing so that the structures are layed out properly within the file. |
| // See: http://msdn.microsoft.com/en-us/library/ms997538.aspx |
| #pragma pack(push) |
| #pragma pack(2) |
| |
| // ICONDIRENTRY contains meta data for an individual icon image within a |
| // .ico file. |
| struct ICONDIRENTRY { |
| BYTE bWidth; |
| BYTE bHeight; |
| BYTE bColorCount; |
| BYTE bReserved; |
| WORD wPlanes; |
| WORD wBitCount; |
| DWORD dwBytesInRes; |
| DWORD dwImageOffset; |
| }; |
| |
| // ICONDIR Contains information about all the icon images contained within a |
| // single .ico file. |
| struct ICONDIR { |
| WORD idReserved; |
| WORD idType; |
| WORD idCount; |
| ICONDIRENTRY idEntries[1]; |
| }; |
| |
| // GRPICONDIRENTRY contains meta data for an individual icon image within a |
| // RT_GROUP_ICON resource in an .exe or .dll. |
| struct GRPICONDIRENTRY { |
| BYTE bWidth; |
| BYTE bHeight; |
| BYTE bColorCount; |
| BYTE bReserved; |
| WORD wPlanes; |
| WORD wBitCount; |
| DWORD dwBytesInRes; |
| WORD nID; |
| }; |
| |
| // GRPICONDIR Contains information about all the icon images contained within |
| // a RT_GROUP_ICON resource in an .exe or .dll. |
| struct GRPICONDIR { |
| WORD idReserved; |
| WORD idType; |
| WORD idCount; |
| GRPICONDIRENTRY idEntries[1]; |
| }; |
| |
| // Contains the actual icon image. |
| struct ICONIMAGE { |
| BITMAPINFOHEADER icHeader; |
| RGBQUAD icColors[1]; |
| BYTE icXOR[1]; |
| BYTE icAND[1]; |
| }; |
| #pragma pack(pop) |
| |
| friend class IconUtilTest; |
| |
| // Used for indicating that the .ico contains an icon (rather than a cursor) |
| // image. This value is set in the |idType| field of the ICONDIR structure. |
| static const int kResourceTypeIcon = 1; |
| |
| // Returns true if any pixel in the given pixels buffer has an non-zero alpha. |
| static bool PixelsHaveAlpha(const uint32* pixels, size_t num_pixels); |
| |
| // A helper function that initializes a BITMAPV5HEADER structure with a set |
| // of values. |
| static void InitializeBitmapHeader(BITMAPV5HEADER* header, int width, |
| int height); |
| |
| // Given a single SkBitmap object and pointers to the corresponding icon |
| // structures within the icon data buffer, this function sets the image |
| // information (dimensions, color depth, etc.) in the icon structures and |
| // also copies the underlying icon image into the appropriate location. |
| // The width and height of |bitmap| must be < 256. |
| // (Note that the 256x256 icon is treated specially, as a PNG, and should not |
| // use this method.) |
| // |
| // The function will set the data pointed to by |image_byte_count| with the |
| // number of image bytes written to the buffer. Note that the number of bytes |
| // includes only the image data written into the memory pointed to by |
| // |icon_image|. |
| static void SetSingleIconImageInformation(const SkBitmap& bitmap, |
| size_t index, |
| ICONDIR* icon_dir, |
| ICONIMAGE* icon_image, |
| size_t image_offset, |
| size_t* image_byte_count); |
| |
| // Copies the bits of an SkBitmap object into a buffer holding the bits of |
| // the corresponding image for an icon within the .ico file. |
| static void CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap, |
| unsigned char* buffer, |
| size_t buffer_size); |
| |
| // Given a set of bitmaps with varying dimensions, this function computes |
| // the amount of memory needed in order to store the bitmaps as image icons |
| // in a .ico file. |
| static size_t ComputeIconFileBufferSize(const std::vector<SkBitmap>& set); |
| |
| // A helper function for computing various size components of a given bitmap. |
| // The different sizes can be used within the various .ico file structures. |
| // |
| // |xor_mask_size| - the size, in bytes, of the XOR mask in the ICONIMAGE |
| // structure. |
| // |and_mask_size| - the size, in bytes, of the AND mask in the ICONIMAGE |
| // structure. |
| // |bytes_in_resource| - the total number of bytes set in the ICONIMAGE |
| // structure. This value is equal to the sum of the |
| // bytes in the AND mask and the XOR mask plus the size |
| // of the BITMAPINFOHEADER structure. Note that since |
| // only 32bpp are handled by the IconUtil class, the |
| // icColors field in the ICONIMAGE structure is ignored |
| // and is not accounted for when computing the |
| // different size components. |
| static void ComputeBitmapSizeComponents(const SkBitmap& bitmap, |
| size_t* xor_mask_size, |
| size_t* bytes_in_resource); |
| |
| // A helper function of CreateSkBitmapFromHICON. |
| static SkBitmap CreateSkBitmapFromHICONHelper(HICON icon, |
| const gfx::Size& s); |
| |
| // Prevent clients from instantiating objects of that class by declaring the |
| // ctor/dtor as private. |
| DISALLOW_IMPLICIT_CONSTRUCTORS(IconUtil); |
| }; |
| |
| #endif // UI_GFX_ICON_UTIL_H_ |