summaryrefslogtreecommitdiffstats
path: root/gfx/icon_util.cc
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/icon_util.cc')
-rw-r--r--gfx/icon_util.cc457
1 files changed, 0 insertions, 457 deletions
diff --git a/gfx/icon_util.cc b/gfx/icon_util.cc
deleted file mode 100644
index cabc505..0000000
--- a/gfx/icon_util.cc
+++ /dev/null
@@ -1,457 +0,0 @@
-// Copyright (c) 2011 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.
-
-#include "gfx/icon_util.h"
-
-#include "base/file_util.h"
-#include "base/logging.h"
-#include "base/scoped_ptr.h"
-#include "base/win/scoped_handle.h"
-#include "gfx/size.h"
-#include "skia/ext/image_operations.h"
-#include "third_party/skia/include/core/SkBitmap.h"
-
-// Defining the dimensions for the icon images. We store only one value because
-// we always resize to a square image; that is, the value 48 means that we are
-// going to resize the given bitmap to a 48 by 48 pixels bitmap.
-//
-// The icon images appear in the icon file in same order in which their
-// corresponding dimensions appear in the |icon_dimensions_| array, so it is
-// important to keep this array sorted. Also note that the maximum icon image
-// size we can handle is 255 by 255.
-const int IconUtil::icon_dimensions_[] = {
- 8, // Recommended by the MSDN as a nice to have icon size.
- 10, // Used by the Shell (e.g. for shortcuts).
- 14, // Recommended by the MSDN as a nice to have icon size.
- 16, // Toolbar, Application and Shell icon sizes.
- 22, // Recommended by the MSDN as a nice to have icon size.
- 24, // Used by the Shell (e.g. for shortcuts).
- 32, // Toolbar, Dialog and Wizard icon size.
- 40, // Quick Launch.
- 48, // Alt+Tab icon size.
- 64, // Recommended by the MSDN as a nice to have icon size.
- 96, // Recommended by the MSDN as a nice to have icon size.
- 128 // Used by the Shell (e.g. for shortcuts).
-};
-
-HICON IconUtil::CreateHICONFromSkBitmap(const SkBitmap& bitmap) {
- // Only 32 bit ARGB bitmaps are supported. We also try to perform as many
- // validations as we can on the bitmap.
- SkAutoLockPixels bitmap_lock(bitmap);
- if ((bitmap.getConfig() != SkBitmap::kARGB_8888_Config) ||
- (bitmap.width() <= 0) || (bitmap.height() <= 0) ||
- (bitmap.getPixels() == NULL))
- return NULL;
-
- // We start by creating a DIB which we'll use later on in order to create
- // the HICON. We use BITMAPV5HEADER since the bitmap we are about to convert
- // may contain an alpha channel and the V5 header allows us to specify the
- // alpha mask for the DIB.
- BITMAPV5HEADER bitmap_header;
- InitializeBitmapHeader(&bitmap_header, bitmap.width(), bitmap.height());
- void* bits;
- HDC hdc = ::GetDC(NULL);
- HBITMAP dib;
- dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&bitmap_header),
- DIB_RGB_COLORS, &bits, NULL, 0);
- DCHECK(dib);
- ::ReleaseDC(NULL, hdc);
- memcpy(bits, bitmap.getPixels(), bitmap.width() * bitmap.height() * 4);
-
- // Icons are generally created using an AND and XOR masks where the AND
- // specifies boolean transparency (the pixel is either opaque or
- // transparent) and the XOR mask contains the actual image pixels. If the XOR
- // mask bitmap has an alpha channel, the AND monochrome bitmap won't
- // actually be used for computing the pixel transparency. Even though all our
- // bitmap has an alpha channel, Windows might not agree when all alpha values
- // are zero. So the monochrome bitmap is created with all pixels transparent
- // for this case. Otherwise, it is created with all pixels opaque.
- bool bitmap_has_alpha_channel = PixelsHaveAlpha(
- static_cast<const uint32*>(bitmap.getPixels()),
- bitmap.width() * bitmap.height());
-
- scoped_array<uint8> mask_bits;
- if (!bitmap_has_alpha_channel) {
- // Bytes per line with paddings to make it word alignment.
- size_t bytes_per_line = (bitmap.width() + 0xF) / 16 * 2;
- size_t mask_bits_size = bytes_per_line * bitmap.height();
-
- mask_bits.reset(new uint8[mask_bits_size]);
- DCHECK(mask_bits.get());
-
- // Make all pixels transparent.
- memset(mask_bits.get(), 0xFF, mask_bits_size);
- }
-
- HBITMAP mono_bitmap = ::CreateBitmap(bitmap.width(), bitmap.height(), 1, 1,
- reinterpret_cast<LPVOID>(mask_bits.get()));
- DCHECK(mono_bitmap);
-
- ICONINFO icon_info;
- icon_info.fIcon = TRUE;
- icon_info.xHotspot = 0;
- icon_info.yHotspot = 0;
- icon_info.hbmMask = mono_bitmap;
- icon_info.hbmColor = dib;
- HICON icon = ::CreateIconIndirect(&icon_info);
- ::DeleteObject(dib);
- ::DeleteObject(mono_bitmap);
- return icon;
-}
-
-SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s) {
- // We start with validating parameters.
- ICONINFO icon_info;
- if (!icon || !(::GetIconInfo(icon, &icon_info)) ||
- !icon_info.fIcon || s.IsEmpty())
- return NULL;
-
- // Allocating memory for the SkBitmap object. We are going to create an ARGB
- // bitmap so we should set the configuration appropriately.
- SkBitmap* bitmap = new SkBitmap;
- DCHECK(bitmap);
- bitmap->setConfig(SkBitmap::kARGB_8888_Config, s.width(), s.height());
- bitmap->allocPixels();
- bitmap->eraseARGB(0, 0, 0, 0);
- SkAutoLockPixels bitmap_lock(*bitmap);
-
- // Now we should create a DIB so that we can use ::DrawIconEx in order to
- // obtain the icon's image.
- BITMAPV5HEADER h;
- InitializeBitmapHeader(&h, s.width(), s.height());
- HDC dc = ::GetDC(NULL);
- uint32* bits;
- HBITMAP dib = ::CreateDIBSection(dc, reinterpret_cast<BITMAPINFO*>(&h),
- DIB_RGB_COLORS, reinterpret_cast<void**>(&bits), NULL, 0);
- DCHECK(dib);
- HDC dib_dc = CreateCompatibleDC(dc);
- DCHECK(dib_dc);
- ::SelectObject(dib_dc, dib);
-
- // Windows icons are defined using two different masks. The XOR mask, which
- // represents the icon image and an AND mask which is a monochrome bitmap
- // which indicates the transparency of each pixel.
- //
- // To make things more complex, the icon image itself can be an ARGB bitmap
- // and therefore contain an alpha channel which specifies the transparency
- // for each pixel. Unfortunately, there is no easy way to determine whether
- // or not a bitmap has an alpha channel and therefore constructing the bitmap
- // for the icon is nothing but straightforward.
- //
- // The idea is to read the AND mask but use it only if we know for sure that
- // the icon image does not have an alpha channel. The only way to tell if the
- // bitmap has an alpha channel is by looking through the pixels and checking
- // whether there are non-zero alpha bytes.
- //
- // We start by drawing the AND mask into our DIB.
- size_t num_pixels = s.GetArea();
- memset(bits, 0, num_pixels * 4);
- ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_MASK);
-
- // Capture boolean opacity. We may not use it if we find out the bitmap has
- // an alpha channel.
- bool* opaque = new bool[num_pixels];
- DCHECK(opaque);
- for (size_t i = 0; i < num_pixels; ++i)
- opaque[i] = !bits[i];
-
- // Then draw the image itself which is really the XOR mask.
- memset(bits, 0, num_pixels * 4);
- ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_NORMAL);
- memcpy(bitmap->getPixels(), static_cast<void*>(bits), num_pixels * 4);
-
- // Finding out whether the bitmap has an alpha channel.
- bool bitmap_has_alpha_channel = PixelsHaveAlpha(
- static_cast<const uint32*>(bitmap->getPixels()), num_pixels);
-
- // If the bitmap does not have an alpha channel, we need to build it using
- // the previously captured AND mask. Otherwise, we are done.
- if (!bitmap_has_alpha_channel) {
- uint32* p = static_cast<uint32*>(bitmap->getPixels());
- for (size_t i = 0; i < num_pixels; ++p, ++i) {
- DCHECK_EQ((*p & 0xff000000), 0u);
- if (opaque[i])
- *p |= 0xff000000;
- else
- *p &= 0x00ffffff;
- }
- }
-
- delete [] opaque;
- ::DeleteDC(dib_dc);
- ::DeleteObject(dib);
- ::ReleaseDC(NULL, dc);
-
- return bitmap;
-}
-
-bool IconUtil::CreateIconFileFromSkBitmap(const SkBitmap& bitmap,
- const FilePath& icon_path) {
- // Only 32 bit ARGB bitmaps are supported. We also make sure the bitmap has
- // been properly initialized.
- SkAutoLockPixels bitmap_lock(bitmap);
- if ((bitmap.getConfig() != SkBitmap::kARGB_8888_Config) ||
- (bitmap.height() <= 0) || (bitmap.width() <= 0) ||
- (bitmap.getPixels() == NULL))
- return false;
-
- // We start by creating the file.
- base::win::ScopedHandle icon_file(::CreateFile(icon_path.value().c_str(),
- GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL));
-
- if (icon_file.Get() == INVALID_HANDLE_VALUE)
- return false;
-
- // Creating a set of bitmaps corresponding to the icon images we'll end up
- // storing in the icon file. Each bitmap is created by resizing the given
- // bitmap to the desired size.
- std::vector<SkBitmap> bitmaps;
- CreateResizedBitmapSet(bitmap, &bitmaps);
- DCHECK(!bitmaps.empty());
- size_t bitmap_count = bitmaps.size();
-
- // Computing the total size of the buffer we need in order to store the
- // images in the desired icon format.
- size_t buffer_size = ComputeIconFileBufferSize(bitmaps);
- unsigned char* buffer = new unsigned char[buffer_size];
- DCHECK(buffer != NULL);
- memset(buffer, 0, buffer_size);
-
- // Setting the information in the structures residing within the buffer.
- // First, we set the information which doesn't require iterating through the
- // bitmap set and then we set the bitmap specific structures. In the latter
- // step we also copy the actual bits.
- ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(buffer);
- icon_dir->idType = kResourceTypeIcon;
- icon_dir->idCount = bitmap_count;
- size_t icon_dir_count = bitmap_count - 1; // Note DCHECK(!bitmaps.empty())!
- size_t offset = sizeof(ICONDIR) + (sizeof(ICONDIRENTRY) * icon_dir_count);
- for (size_t i = 0; i < bitmap_count; i++) {
- ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(buffer + offset);
- DCHECK_LT(offset, buffer_size);
- size_t icon_image_size = 0;
- SetSingleIconImageInformation(bitmaps[i], i, icon_dir, image, offset,
- &icon_image_size);
- DCHECK_GT(icon_image_size, 0U);
- offset += icon_image_size;
- }
- DCHECK_EQ(offset, buffer_size);
-
- // Finally, writing the data info the file.
- DWORD bytes_written;
- bool delete_file = false;
- if (!WriteFile(icon_file.Get(), buffer, buffer_size, &bytes_written, NULL) ||
- bytes_written != buffer_size)
- delete_file = true;
-
- ::CloseHandle(icon_file.Take());
- delete [] buffer;
- if (delete_file) {
- bool success = file_util::Delete(icon_path, false);
- DCHECK(success);
- }
-
- return !delete_file;
-}
-
-bool IconUtil::PixelsHaveAlpha(const uint32* pixels, size_t num_pixels) {
- for (const uint32* end = pixels + num_pixels; pixels != end; ++pixels) {
- if ((*pixels & 0xff000000) != 0)
- return true;
- }
-
- return false;
-}
-
-void IconUtil::InitializeBitmapHeader(BITMAPV5HEADER* header, int width,
- int height) {
- DCHECK(header);
- memset(header, 0, sizeof(BITMAPV5HEADER));
- header->bV5Size = sizeof(BITMAPV5HEADER);
-
- // Note that icons are created using top-down DIBs so we must negate the
- // value used for the icon's height.
- header->bV5Width = width;
- header->bV5Height = -height;
- header->bV5Planes = 1;
- header->bV5Compression = BI_RGB;
-
- // Initializing the bitmap format to 32 bit ARGB.
- header->bV5BitCount = 32;
- header->bV5RedMask = 0x00FF0000;
- header->bV5GreenMask = 0x0000FF00;
- header->bV5BlueMask = 0x000000FF;
- header->bV5AlphaMask = 0xFF000000;
-
- // Use the system color space. The default value is LCS_CALIBRATED_RGB, which
- // causes us to crash if we don't specify the approprite gammas, etc. See
- // <http://msdn.microsoft.com/en-us/library/ms536531(VS.85).aspx> and
- // <http://b/1283121>.
- header->bV5CSType = LCS_WINDOWS_COLOR_SPACE;
-
- // Use a valid value for bV5Intent as 0 is not a valid one.
- // <http://msdn.microsoft.com/en-us/library/dd183381(VS.85).aspx>
- header->bV5Intent = LCS_GM_IMAGES;
-}
-
-void IconUtil::SetSingleIconImageInformation(const SkBitmap& bitmap,
- size_t index,
- ICONDIR* icon_dir,
- ICONIMAGE* icon_image,
- size_t image_offset,
- size_t* image_byte_count) {
- DCHECK(icon_dir != NULL);
- DCHECK(icon_image != NULL);
- DCHECK_GT(image_offset, 0U);
- DCHECK(image_byte_count != NULL);
-
- // We start by computing certain image values we'll use later on.
- size_t xor_mask_size, bytes_in_resource;
- ComputeBitmapSizeComponents(bitmap,
- &xor_mask_size,
- &bytes_in_resource);
-
- icon_dir->idEntries[index].bWidth = static_cast<BYTE>(bitmap.width());
- icon_dir->idEntries[index].bHeight = static_cast<BYTE>(bitmap.height());
- icon_dir->idEntries[index].wPlanes = 1;
- icon_dir->idEntries[index].wBitCount = 32;
- icon_dir->idEntries[index].dwBytesInRes = bytes_in_resource;
- icon_dir->idEntries[index].dwImageOffset = image_offset;
- icon_image->icHeader.biSize = sizeof(BITMAPINFOHEADER);
-
- // The width field in the BITMAPINFOHEADER structure accounts for the height
- // of both the AND mask and the XOR mask so we need to multiply the bitmap's
- // height by 2. The same does NOT apply to the width field.
- icon_image->icHeader.biHeight = bitmap.height() * 2;
- icon_image->icHeader.biWidth = bitmap.width();
- icon_image->icHeader.biPlanes = 1;
- icon_image->icHeader.biBitCount = 32;
-
- // We use a helper function for copying to actual bits from the SkBitmap
- // object into the appropriate space in the buffer. We use a helper function
- // (rather than just copying the bits) because there is no way to specify the
- // orientation (bottom-up vs. top-down) of a bitmap residing in a .ico file.
- // Thus, if we just copy the bits, we'll end up with a bottom up bitmap in
- // the .ico file which will result in the icon being displayed upside down.
- // The helper function copies the image into the buffer one scanline at a
- // time.
- //
- // Note that we don't need to initialize the AND mask since the memory
- // allocated for the icon data buffer was initialized to zero. The icon we
- // create will therefore use an AND mask containing only zeros, which is OK
- // because the underlying image has an alpha channel. An AND mask containing
- // only zeros essentially means we'll initially treat all the pixels as
- // opaque.
- unsigned char* image_addr = reinterpret_cast<unsigned char*>(icon_image);
- unsigned char* xor_mask_addr = image_addr + sizeof(BITMAPINFOHEADER);
- CopySkBitmapBitsIntoIconBuffer(bitmap, xor_mask_addr, xor_mask_size);
- *image_byte_count = bytes_in_resource;
-}
-
-void IconUtil::CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap,
- unsigned char* buffer,
- size_t buffer_size) {
- SkAutoLockPixels bitmap_lock(bitmap);
- unsigned char* bitmap_ptr = static_cast<unsigned char*>(bitmap.getPixels());
- size_t bitmap_size = bitmap.height() * bitmap.width() * 4;
- DCHECK_EQ(buffer_size, bitmap_size);
- for (size_t i = 0; i < bitmap_size; i += bitmap.width() * 4) {
- memcpy(buffer + bitmap_size - bitmap.width() * 4 - i,
- bitmap_ptr + i,
- bitmap.width() * 4);
- }
-}
-
-void IconUtil::CreateResizedBitmapSet(const SkBitmap& bitmap_to_resize,
- std::vector<SkBitmap>* bitmaps) {
- DCHECK(bitmaps != NULL);
- DCHECK(bitmaps->empty());
-
- bool inserted_original_bitmap = false;
- for (size_t i = 0; i < arraysize(icon_dimensions_); i++) {
- // If the dimensions of the bitmap we are resizing are the same as the
- // current dimensions, then we should insert the bitmap and not a resized
- // bitmap. If the bitmap's dimensions are smaller, we insert our bitmap
- // first so that the bitmaps we return in the vector are sorted based on
- // their dimensions.
- if (!inserted_original_bitmap) {
- if ((bitmap_to_resize.width() == icon_dimensions_[i]) &&
- (bitmap_to_resize.height() == icon_dimensions_[i])) {
- bitmaps->push_back(bitmap_to_resize);
- inserted_original_bitmap = true;
- continue;
- }
-
- if ((bitmap_to_resize.width() < icon_dimensions_[i]) &&
- (bitmap_to_resize.height() < icon_dimensions_[i])) {
- bitmaps->push_back(bitmap_to_resize);
- inserted_original_bitmap = true;
- }
- }
- bitmaps->push_back(skia::ImageOperations::Resize(
- bitmap_to_resize, skia::ImageOperations::RESIZE_LANCZOS3,
- icon_dimensions_[i], icon_dimensions_[i]));
- }
-
- if (!inserted_original_bitmap)
- bitmaps->push_back(bitmap_to_resize);
-}
-
-size_t IconUtil::ComputeIconFileBufferSize(const std::vector<SkBitmap>& set) {
- DCHECK(!set.empty());
-
- // We start by counting the bytes for the structures that don't depend on the
- // number of icon images. Note that sizeof(ICONDIR) already accounts for a
- // single ICONDIRENTRY structure, which is why we subtract one from the
- // number of bitmaps.
- size_t total_buffer_size = sizeof(ICONDIR);
- size_t bitmap_count = set.size();
- total_buffer_size += sizeof(ICONDIRENTRY) * (bitmap_count - 1);
- DCHECK_GE(bitmap_count, arraysize(icon_dimensions_));
-
- // Add the bitmap specific structure sizes.
- for (size_t i = 0; i < bitmap_count; i++) {
- size_t xor_mask_size, bytes_in_resource;
- ComputeBitmapSizeComponents(set[i],
- &xor_mask_size,
- &bytes_in_resource);
- total_buffer_size += bytes_in_resource;
- }
- return total_buffer_size;
-}
-
-void IconUtil::ComputeBitmapSizeComponents(const SkBitmap& bitmap,
- size_t* xor_mask_size,
- size_t* bytes_in_resource) {
- // The XOR mask size is easy to calculate since we only deal with 32bpp
- // images.
- *xor_mask_size = bitmap.width() * bitmap.height() * 4;
-
- // Computing the AND mask is a little trickier since it is a monochrome
- // bitmap (regardless of the number of bits per pixels used in the XOR mask).
- // There are two things we must make sure we do when computing the AND mask
- // size:
- //
- // 1. Make sure the right number of bytes is allocated for each AND mask
- // scan line in case the number of pixels in the image is not divisible by
- // 8. For example, in a 15X15 image, 15 / 8 is one byte short of
- // containing the number of bits we need in order to describe a single
- // image scan line so we need to add a byte. Thus, we need 2 bytes instead
- // of 1 for each scan line.
- //
- // 2. Make sure each scan line in the AND mask is 4 byte aligned (so that the
- // total icon image has a 4 byte alignment). In the 15X15 image example
- // above, we can not use 2 bytes so we increase it to the next multiple of
- // 4 which is 4.
- //
- // Once we compute the size for a singe AND mask scan line, we multiply that
- // number by the image height in order to get the total number of bytes for
- // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
- // for the monochrome bitmap representing the AND mask.
- size_t and_line_length = (bitmap.width() + 7) >> 3;
- and_line_length = (and_line_length + 3) & ~3;
- size_t and_mask_size = and_line_length * bitmap.height();
- size_t masks_size = *xor_mask_size + and_mask_size;
- *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER);
-}
generated by cgit v1.1 at 2025-01-31 16:15:44 +0000