// 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. // An Image wraps an image any flavor, be it platform-native GdkBitmap/NSImage, // or a SkBitmap. This also provides easy conversion to other image types // through operator overloading. It will cache the converted representations // internally to prevent double-conversion. // // The lifetime of both the initial representation and any converted ones are // tied to the lifetime of the Image's internal storage. To allow Images to be // cheaply passed around by value, the actual image data is stored in a ref- // counted member. When all Images referencing this storage are deleted, the // actual representations are deleted, too. // // Images can be empty, in which case they have no backing representation. // Attempting to use an empty Image will result in a crash. #ifndef UI_GFX_IMAGE_IMAGE_H_ #define UI_GFX_IMAGE_IMAGE_H_ #include <map> #include <vector> #include "base/basictypes.h" #include "base/gtest_prod_util.h" #include "base/memory/ref_counted_memory.h" #include "ui/gfx/gfx_export.h" #include "ui/gfx/native_widget_types.h" #if defined(OS_MACOSX) && !defined(OS_IOS) typedef struct CGColorSpace* CGColorSpaceRef; #endif class SkBitmap; namespace { class ImageTest; class ImageMacTest; } namespace gfx { struct ImagePNGRep; class ImageSkia; class Size; #if defined(TOOLKIT_GTK) class CairoCachedSurface; #endif namespace internal { class ImageRep; class ImageStorage; } class GFX_EXPORT Image { public: enum RepresentationType { kImageRepGdk, kImageRepCocoa, kImageRepCocoaTouch, kImageRepCairo, kImageRepSkia, kImageRepPNG, }; typedef std::map<RepresentationType, internal::ImageRep*> RepresentationMap; // Creates an empty image with no representations. Image(); // Creates a new image by copying the raw PNG-encoded input for use as the // default representation. explicit Image(const std::vector<ImagePNGRep>& image_reps); // Creates a new image by copying the ImageSkia for use as the default // representation. explicit Image(const ImageSkia& image); #if defined(TOOLKIT_GTK) // Does not increase |pixbuf|'s reference count; expects to take ownership. explicit Image(GdkPixbuf* pixbuf); #elif defined(OS_IOS) // Does not retain |image|; expects to take ownership. explicit Image(UIImage* image); #elif defined(OS_MACOSX) // Does not retain |image|; expects to take ownership. // A single NSImage object can contain multiple bitmaps so there's no reason // to pass a vector of these. explicit Image(NSImage* image); #endif // Initializes a new Image by AddRef()ing |other|'s internal storage. Image(const Image& other); // Copies a reference to |other|'s storage. Image& operator=(const Image& other); // Deletes the image and, if the only owner of the storage, all of its cached // representations. ~Image(); // Creates an image from the passed in 1x bitmap. // WARNING: The resulting image will be pixelated when painted on a high // density display. static Image CreateFrom1xBitmap(const SkBitmap& bitmap); // Creates an image from the PNG encoded input. // For example (from an std::vector): // std::vector<unsigned char> png = ...; // gfx::Image image = // Image::CreateFrom1xPNGBytes(&png.front(), png.size()); static Image CreateFrom1xPNGBytes(const unsigned char* input, size_t input_size); // Creates an image from the PNG encoded input. static Image CreateFrom1xPNGBytes( const scoped_refptr<base::RefCountedMemory>& input); // Converts the Image to the desired representation and stores it internally. // The returned result is a weak pointer owned by and scoped to the life of // the Image. Must only be called if IsEmpty() is false. const SkBitmap* ToSkBitmap() const; const ImageSkia* ToImageSkia() const; #if defined(TOOLKIT_GTK) GdkPixbuf* ToGdkPixbuf() const; CairoCachedSurface* const ToCairo() const; #elif defined(OS_IOS) UIImage* ToUIImage() const; #elif defined(OS_MACOSX) NSImage* ToNSImage() const; #endif // Returns the raw PNG-encoded data for the bitmap at 1x. If the data is // unavailable, either because the image has no data for 1x or because it is // empty, an empty RefCountedBytes object is returned. NULL is never // returned. scoped_refptr<base::RefCountedMemory> As1xPNGBytes() const; // Same as ToSkBitmap(), but returns a null SkBitmap if this image is empty. SkBitmap AsBitmap() const; // Same as ToImageSkia(), but returns an empty ImageSkia if this // image is empty. ImageSkia AsImageSkia() const; #if defined(OS_MACOSX) && !defined(OS_IOS) // Same as ToSkBitmap(), but returns nil if this image is empty. NSImage* AsNSImage() const; #endif // Performs a conversion, like above, but returns a copy of the result rather // than a weak pointer. The caller is responsible for deleting the result. // Note that the result is only a copy in terms of memory management; the // backing pixels are shared amongst all copies (a fact of each of the // converted representations, rather than a limitation imposed by Image) and // so the result should be considered immutable. scoped_refptr<base::RefCountedMemory> Copy1xPNGBytes() const; ImageSkia* CopyImageSkia() const; SkBitmap* CopySkBitmap() const; #if defined(TOOLKIT_GTK) GdkPixbuf* CopyGdkPixbuf() const; #elif defined(OS_IOS) UIImage* CopyUIImage() const; #elif defined(OS_MACOSX) NSImage* CopyNSImage() const; #endif // Inspects the representations map to see if the given type exists. bool HasRepresentation(RepresentationType type) const; // Returns the number of representations. size_t RepresentationCount() const; // Returns true if this Image has no representations. bool IsEmpty() const; // Width and height of image in DIP coordinate system. int Width() const; int Height() const; gfx::Size Size() const; // Swaps this image's internal representations with |other|. void SwapRepresentations(gfx::Image* other); #if defined(OS_MACOSX) && !defined(OS_IOS) // Set the default representation's color space. This is used for converting // to NSImage. This is used to compensate for PNGCodec not writing or reading // colorspace ancillary chunks. (sRGB, iCCP). void SetSourceColorSpace(CGColorSpaceRef color_space); #endif // defined(OS_MACOSX) && !defined(OS_IOS) private: // Returns the type of the default representation. RepresentationType DefaultRepresentationType() const; // Returns the ImageRep of the appropriate type or NULL if there is no // representation of that type (and must_exist is false). internal::ImageRep* GetRepresentation( RepresentationType rep_type, bool must_exist) const; // Stores a representation into the map. void AddRepresentation(internal::ImageRep* rep) const; // Internal class that holds all the representations. This allows the Image to // be cheaply copied. scoped_refptr<internal::ImageStorage> storage_; friend class ::ImageTest; friend class ::ImageMacTest; }; } // namespace gfx #endif // UI_GFX_IMAGE_IMAGE_H_