Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / WinForms / Managed / System / WinForms / ImageList.cs / 1 / ImageList.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Windows.Forms {
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System;
using System.Collections.Specialized;
using System.Collections;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using System.IO;
using System.ComponentModel.Design.Serialization;
using System.Runtime.Versioning;
using Microsoft.Win32;
using System.Security;
using System.Security.Permissions;
using System.Globalization;
///
/// The ImageList is an object that stores a collection of Images, most
/// commonly used by other controls, such as the ListView, TreeView, or
/// Toolbar. You can add either bitmaps or Icons to the ImageList, and the
/// other controls will be able to use the Images as they desire.
///
[
Designer("System.Windows.Forms.Design.ImageListDesigner, " + AssemblyRef.SystemDesign),
ToolboxItemFilter("System.Windows.Forms"),
DefaultProperty("Images"),
TypeConverter(typeof(ImageListConverter)),
DesignerSerializer("System.Windows.Forms.Design.ImageListCodeDomSerializer, " + AssemblyRef.SystemDesign, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + AssemblyRef.SystemDesign),
SRDescription(SR.DescriptionImageList)
]
public sealed class ImageList : Component {
// gpr: Copied from Icon
private static Color fakeTransparencyColor = Color.FromArgb(0x0d, 0x0b, 0x0c);
private static Size DefaultImageSize = new Size(16, 16);
private const int INITIAL_CAPACITY = 4;
private const int GROWBY = 4;
private NativeImageList nativeImageList;
// private int himlTemp;
// private Bitmap temp = null; // Used for drawing
private ColorDepth colorDepth = System.Windows.Forms.ColorDepth.Depth8Bit;
private Color transparentColor = Color.Transparent;
private Size imageSize = DefaultImageSize;
private ImageCollection imageCollection;
private object userData;
// The usual handle virtualization problem, with a new twist: image
// lists are lossy. At runtime, we delay handle creation as long as possible, and store
// away the original images until handle creation (and hope no one disposes of the images!). At design time, we keep the originals around indefinitely.
// This variable will become null when the original images are lost. See ASURT 65162.
private IList /* of Original */ originals = new ArrayList();
private EventHandler recreateHandler = null;
private EventHandler changeHandler = null;
private bool inAddRange = false;
///
/// Creates a new ImageList Control with a default image size of 16x16
/// pixels
///
public ImageList() { // DO NOT DELETE -- AUTOMATION BP 1
}
///
/// Creates a new ImageList Control with a default image size of 16x16
/// pixels and adds the ImageList to the passed in container.
///
public ImageList(IContainer container) {
container.Add(this);
}
// This class is for classes that want to support both an ImageIndex
// and ImageKey. We want to toggle between using keys or indexes.
// Default is to use the integer index.
internal class Indexer {
private string key = String.Empty;
private int index = -1;
private bool useIntegerIndex = true;
private ImageList imageList = null;
public virtual ImageList ImageList {
get { return imageList; }
set { imageList = value; }
}
public virtual string Key {
get { return key; }
set {
index = -1;
key = (value == null ? String.Empty : value);
useIntegerIndex = false;
}
}
public virtual int Index {
get { return index; }
set {
key = String.Empty;
index = value;
useIntegerIndex = true;
}
}
public virtual int ActualIndex {
get {
if (useIntegerIndex) {
return Index;
}
else if (ImageList != null) {
return ImageList.Images.IndexOfKey(Key);
}
return -1;
}
}
}
///
/// Retrieves the color depth of the imagelist.
///
[
SRCategory(SR.CatAppearance),
SRDescription(SR.ImageListColorDepthDescr)
]
public ColorDepth ColorDepth {
get {
return colorDepth;
}
set {
// ColorDepth is not conitguous - list the members instead.
if (!ClientUtils.IsEnumValid_NotSequential(value,
(int)value,
(int)ColorDepth.Depth4Bit,
(int)ColorDepth.Depth8Bit,
(int)ColorDepth.Depth16Bit,
(int)ColorDepth.Depth24Bit,
(int)ColorDepth.Depth32Bit)) {
throw new InvalidEnumArgumentException("value", (int)value, typeof(ColorDepth));
}
if (colorDepth != value) {
colorDepth = value;
PerformRecreateHandle("ColorDepth");
}
}
}
private bool ShouldSerializeColorDepth() {
return (Images.Count==0);
}
private void ResetColorDepth() {
ColorDepth = ColorDepth.Depth8Bit;
}
///
/// The handle of the ImageList object. This corresponds to a win32
/// HIMAGELIST Handle.
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ImageListHandleDescr)
]
public IntPtr Handle {
get {
if (nativeImageList == null) {
CreateHandle();
}
return nativeImageList.Handle;
}
}
///
/// Whether or not the underlying Win32 handle has been created.
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ImageListHandleCreatedDescr)
]
public bool HandleCreated {
get { return nativeImageList != null; }
}
///
/// [To be supplied.]
///
[
SRCategory(SR.CatAppearance),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ImageListImagesDescr),
MergableProperty(false)
]
public ImageCollection Images {
get {
if (imageCollection == null)
imageCollection = new ImageCollection(this);
return imageCollection;
}
}
///
/// Returns the size of the images in the ImageList
///
[
SRCategory(SR.CatBehavior),
Localizable(true),
SRDescription(SR.ImageListSizeDescr)
]
public Size ImageSize {
get {
return imageSize;
}
set {
if (value.IsEmpty) {
throw new ArgumentException(SR.GetString(SR.InvalidArgument, "ImageSize", "Size.Empty"));
}
// ImageList appears to consume an exponential amount of memory
// based on image size x bpp. Restrict this to a reasonable maximum
// to keep people's systems from crashing.
//
if (value.Width <= 0 || value.Width > 256) {
throw new ArgumentOutOfRangeException("ImageSize", SR.GetString(SR.InvalidBoundArgument, "ImageSize.Width", value.Width.ToString(CultureInfo.CurrentCulture), (1).ToString(CultureInfo.CurrentCulture), "256"));
}
if (value.Height <= 0 || value.Height > 256) {
throw new ArgumentOutOfRangeException("ImageSize", SR.GetString(SR.InvalidBoundArgument, "ImageSize.Height", value.Height.ToString(CultureInfo.CurrentCulture), (1).ToString(CultureInfo.CurrentCulture), "256"));
}
if (imageSize.Width != value.Width || imageSize.Height != value.Height) {
imageSize = new Size(value.Width, value.Height);
PerformRecreateHandle("ImageSize");
}
}
}
private bool ShouldSerializeImageSize() {
return (Images.Count==0);
}
///
/// Returns an ImageListStreamer, or null if the image list is empty.
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DefaultValue(null),
SRDescription(SR.ImageListImageStreamDescr)
]
public ImageListStreamer ImageStream {
get {
if (Images.Empty)
return null;
// No need for us to create the handle, because any serious attempts to use the
// ImageListStreamer will do it for us.
return new ImageListStreamer(this);
}
set {
if (value != null) {
NativeImageList himl = value.GetNativeImageList();
if (himl != null && himl != this.nativeImageList) {
DestroyHandle();
originals = null;
this.nativeImageList = new NativeImageList(SafeNativeMethods.ImageList_Duplicate(new HandleRef(himl, himl.Handle)));
int x, y;
if(SafeNativeMethods.ImageList_GetIconSize(new HandleRef(this, this.nativeImageList.Handle), out x, out y)) {
imageSize = new Size(x,y);
}
// need to get the image bpp
NativeMethods.IMAGEINFO imageInfo = new NativeMethods.IMAGEINFO(); // review? do I need to delete the mask and image?
if(SafeNativeMethods.ImageList_GetImageInfo(new HandleRef(this, this.nativeImageList.Handle), 0, imageInfo)) {
NativeMethods.BITMAP bmp = new NativeMethods.BITMAP();
UnsafeNativeMethods.GetObject(new HandleRef(null, imageInfo.hbmImage), Marshal.SizeOf(bmp), bmp);
switch(bmp.bmBitsPixel) {
case 4:
colorDepth = ColorDepth.Depth4Bit;
break;
case 8:
colorDepth = ColorDepth.Depth8Bit;
break;
case 16:
colorDepth = ColorDepth.Depth16Bit;
break;
case 24:
colorDepth = ColorDepth.Depth24Bit;
break;
case 32:
colorDepth = ColorDepth.Depth32Bit;
break;
default:
Debug.Fail("Unknown color depth");
break;
}
}
Images.ResetKeys();
OnRecreateHandle(new EventArgs());
}
}
else
{
DestroyHandle();
Images.Clear();
}
}
}
///
/// The color to treat as transparent.
///
[
SRCategory(SR.CatBehavior),
SRDescription(SR.ImageListTransparentColorDescr)
]
public Color TransparentColor {
get {
return transparentColor;
}
set {
transparentColor = value;
}
}
// Whether to use the transparent color, or rely on alpha instead
private bool UseTransparentColor {
get { return TransparentColor.A > 0;}
}
///
/// [To be supplied.]
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
SRDescription(SR.ImageListOnRecreateHandleDescr)
]
public event EventHandler RecreateHandle {
add {
recreateHandler += value;
}
remove {
recreateHandler -= value;
}
}
internal event EventHandler ChangeHandle {
add {
changeHandler += value;
}
remove {
changeHandler -= value;
}
}
//Creates a bitmap from the original image source..
//
private Bitmap CreateBitmap(Original original, out bool ownsBitmap) {
Color transparent = transparentColor;
ownsBitmap = false;
if ((original.options & OriginalOptions.CustomTransparentColor) != 0)
transparent = original.customTransparentColor;
Bitmap bitmap;
if (original.image is Bitmap) {
bitmap = (Bitmap) original.image;
}
else if (original.image is Icon) {
bitmap = ((Icon)original.image).ToBitmap();
ownsBitmap = true;
}
else {
bitmap = new Bitmap((Image)original.image);
ownsBitmap = true;
}
if (transparent.A > 0) {
// ImageList_AddMasked doesn't work on high color bitmaps,
// so we always create the mask ourselves
Bitmap source = bitmap;
bitmap = (Bitmap) bitmap.Clone();
bitmap.MakeTransparent(transparent);
if(ownsBitmap)
source.Dispose();
ownsBitmap = true;
}
Size size = bitmap.Size;
if ((original.options & OriginalOptions.ImageStrip) != 0) {
// strip width must be a positive multiple of image list width
if (size.Width == 0 || (size.Width % imageSize.Width) != 0)
throw new ArgumentException(SR.GetString(SR.ImageListStripBadWidth), "original");
if (size.Height != imageSize.Height)
throw new ArgumentException(SR.GetString(SR.ImageListImageTooShort), "original");
}
else if (!size.Equals(ImageSize)) {
Bitmap source = bitmap;
bitmap = new Bitmap(source, ImageSize);
if(ownsBitmap)
source.Dispose();
ownsBitmap = true;
}
return bitmap;
}
private int AddIconToHandle(Original original, Icon icon) {
try {
Debug.Assert(HandleCreated, "Calling AddIconToHandle when there is no handle");
int index = SafeNativeMethods.ImageList_ReplaceIcon(new HandleRef(this, Handle), -1, new HandleRef(icon, icon.Handle));
if (index == -1) throw new InvalidOperationException(SR.GetString(SR.ImageListAddFailed));
return index;
} finally {
if((original.options & OriginalOptions.OwnsImage) != 0) { /// this is to handle the case were we clone the icon (see WHY WHY WHY below)
icon.Dispose();
}
}
}
// Adds bitmap to the Imagelist handle...
//
private int AddToHandle(Original original, Bitmap bitmap) {
Debug.Assert(HandleCreated, "Calling AddToHandle when there is no handle");
IntPtr hMask = ControlPaint.CreateHBitmapTransparencyMask(bitmap); // Calls GDI to create Bitmap.
IntPtr hBitmap = ControlPaint.CreateHBitmapColorMask(bitmap, hMask); // Calls GDI+ to create Bitmap. Need to add handle to HandleCollector.
int index = SafeNativeMethods.ImageList_Add(new HandleRef(this, Handle), new HandleRef(null, hBitmap), new HandleRef(null, hMask));
SafeNativeMethods.DeleteObject(new HandleRef(null, hBitmap));
SafeNativeMethods.DeleteObject(new HandleRef(null, hMask));
if (index == -1) throw new InvalidOperationException(SR.GetString(SR.ImageListAddFailed));
return index;
}
///
/// Creates the underlying HIMAGELIST handle, and sets up all the
/// appropriate values with it. Inheriting classes overriding this method
/// should not forget to call base.createHandle();
///
private void CreateHandle() {
// so we don't reinit while we're doing this...
nativeImageList = null;
int flags = NativeMethods.ILC_MASK;
switch (colorDepth) {
case ColorDepth.Depth4Bit:
flags |= NativeMethods.ILC_COLOR4;
break;
case ColorDepth.Depth8Bit:
flags |= NativeMethods.ILC_COLOR8;
break;
case ColorDepth.Depth16Bit:
flags |= NativeMethods.ILC_COLOR16;
break;
case ColorDepth.Depth24Bit:
flags |= NativeMethods.ILC_COLOR24;
break;
case ColorDepth.Depth32Bit:
flags |= NativeMethods.ILC_COLOR32;
break;
default:
Debug.Fail("Unknown color depth in ImageList");
break;
}
//VSW #123063: We enclose the imagelist handle create in a theming scope. This is a temporary solution
// till we tackle the bigger issue tracked by VSW #95247
IntPtr userCookie = UnsafeNativeMethods.ThemingScope.Activate();
try {
SafeNativeMethods.InitCommonControls();
nativeImageList = new NativeImageList(SafeNativeMethods.ImageList_Create(imageSize.Width, imageSize.Height, flags, INITIAL_CAPACITY, GROWBY));
}
finally {
UnsafeNativeMethods.ThemingScope.Deactivate(userCookie);
}
if (Handle == IntPtr.Zero) throw new InvalidOperationException(SR.GetString(SR.ImageListCreateFailed));
SafeNativeMethods.ImageList_SetBkColor(new HandleRef(this, Handle), NativeMethods.CLR_NONE);
Debug.Assert(originals != null, "Handle not yet created, yet original images are gone");
for (int i = 0; i < originals.Count; i++) {
Original original = (Original) originals[i];
if (original.image is Icon) {
AddIconToHandle(original, (Icon)original.image);
// NOTE: if we own the icon (it's been created by us) this WILL dispose the icon to avoid a GDI leak
// **** original.image is NOT LONGER VALID AFTER THIS POINT ***
}
else {
bool ownsBitmap = false;
Bitmap bitmapValue = CreateBitmap(original, out ownsBitmap);
AddToHandle(original, bitmapValue);
if(ownsBitmap)
bitmapValue.Dispose();
}
}
originals = null;
}
// Don't merge this function into Dispose() -- that base.Dispose() will damage the design time experience
private void DestroyHandle() {
if (HandleCreated) {
// NOTE! No need to call ImageList_Destroy. It will be called in the NativeImageList finalizer.
nativeImageList = null;
originals = new ArrayList();
}
}
///
/// Frees all resources assocaited with this component.
///
protected override void Dispose(bool disposing) {
// NOTE! No need to call ImageList_Destroy. It will be called in the NativeImageList finalizer.
if (disposing) {
if(originals != null) { // we might own some of the stuff that's not been created yet
foreach(Original original in originals) {
if((original.options & OriginalOptions.OwnsImage) != 0) {
((IDisposable)original.image).Dispose();
}
}
}
DestroyHandle();
}
base.Dispose(disposing);
}
///
/// Draw the image indicated by the given index on the given Graphics
/// at the given location.
///
public void Draw(Graphics g, Point pt, int index) {
Draw(g, pt.X, pt.Y, index);
}
///
/// Draw the image indicated by the given index on the given Graphics
/// at the given location.
///
public void Draw(Graphics g, int x, int y, int index) {
Draw(g, x, y, imageSize.Width, imageSize.Height, index);
}
///
/// Draw the image indicated by the given index using the location, size
/// and raster op code specified. The image is stretched or compressed as
/// necessary to fit the bounds provided.
///
public void Draw(Graphics g, int x, int y, int width, int height, int index) {
if (index < 0 || index >= Images.Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
IntPtr dc = g.GetHdc();
try {
SafeNativeMethods.ImageList_DrawEx(new HandleRef(this, Handle), index, new HandleRef(g, dc), x, y,
width, height, NativeMethods.CLR_NONE, NativeMethods.CLR_NONE, NativeMethods.ILD_TRANSPARENT);
}
finally {
g.ReleaseHdcInternal(dc);
}
}
private void CopyBitmapData(BitmapData sourceData, BitmapData targetData) {
// do the actual copy
int offsetSrc = 0;
int offsetDest = 0;
unsafe {
for (int i = 0; i < targetData.Height; i++)
{
IntPtr srcPtr, destPtr;
if (IntPtr.Size == 4) {
srcPtr = new IntPtr(sourceData.Scan0.ToInt32() + offsetSrc);
destPtr = new IntPtr(targetData.Scan0.ToInt32() + offsetDest);
} else {
srcPtr = new IntPtr(sourceData.Scan0.ToInt64() + offsetSrc);
destPtr = new IntPtr(targetData.Scan0.ToInt64() + offsetDest);
}
UnsafeNativeMethods.CopyMemory(new HandleRef(this, destPtr), new HandleRef(this, srcPtr), Math.Abs(targetData.Stride));
offsetSrc += sourceData.Stride;
offsetDest += targetData.Stride;
}
}
}
private static bool BitmapHasAlpha(BitmapData bmpData) {
if(bmpData.PixelFormat != PixelFormat.Format32bppArgb && bmpData.PixelFormat != PixelFormat.Format32bppRgb) {
return false;
}
bool hasAlpha = false;
unsafe {
for (int i = 0; i < bmpData.Height; i++) {
int offsetRow = i * bmpData.Stride;
for (int j = 3; j < bmpData.Width*4; j += 4) { // *4 is safe since we know PixelFormat is ARGB
unsafe {
byte* candidate = ((byte*)bmpData.Scan0.ToPointer()) + offsetRow + j;
if (*candidate != 0) {
hasAlpha = true;
goto Found; // gotos are fugly but it's the best thing here...
}
}
}
}
Found:
return hasAlpha;
}
}
///
/// Returns the image specified by the given index. The bitmap returned is a
/// copy of the original image.
///
// NOTE: forces handle creation, so doesn't return things from the original list
private Bitmap GetBitmap(int index) {
if (index < 0 || index >= Images.Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
Bitmap result=null;
// if the imagelist is 32bpp, if the image slot at index
// has valid alpha information (not all zero... which is cause by windows just painting RGB values
// and not touching the alpha byte for images < 32bpp painted to a 32bpp imagelist)
// we're not using the mask. That means that
// we can just get the whole image strip, cut out the piece that we want
// and return that, that way we don't flatten the alpha by painting the value with the alpha... (ie using the alpha)
if(ColorDepth == ColorDepth.Depth32Bit) {
NativeMethods.IMAGEINFO imageInfo = new NativeMethods.IMAGEINFO(); // review? do I need to delete the mask and image inside of imageinfo?
if(SafeNativeMethods.ImageList_GetImageInfo(new HandleRef(this, this.Handle), index, imageInfo)) {
Bitmap tmpBitmap = null;
BitmapData bmpData = null;
BitmapData targetData = null;
IntSecurity.ObjectFromWin32Handle.Assert();
try {
tmpBitmap = Bitmap.FromHbitmap(imageInfo.hbmImage);
//
bmpData = tmpBitmap.LockBits(new Rectangle(imageInfo.rcImage_left,imageInfo.rcImage_top, imageInfo.rcImage_right-imageInfo.rcImage_left, imageInfo.rcImage_bottom-imageInfo.rcImage_top), ImageLockMode.ReadOnly, tmpBitmap.PixelFormat);
int offset = bmpData.Stride * imageSize.Height * index;
// we need do the following if the image has alpha because otherwise the image is fully transparent even though it has data
if(BitmapHasAlpha(bmpData)) {
result = new Bitmap(imageSize.Width, imageSize.Height, PixelFormat.Format32bppArgb);
targetData = result.LockBits(new Rectangle(0, 0, imageSize.Width, imageSize.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
CopyBitmapData(bmpData, targetData);
}
} finally {
CodeAccessPermission.RevertAssert();
if(tmpBitmap != null && bmpData != null) {
tmpBitmap.UnlockBits(bmpData);
}
if(result != null && targetData != null) {
result.UnlockBits(targetData);
}
}
}
}
if(result == null) { // paint with the mask but no alpha...
result = new Bitmap(imageSize.Width, imageSize.Height);
Graphics graphics = Graphics.FromImage(result);
try {
IntPtr dc = graphics.GetHdc();
try {
SafeNativeMethods.ImageList_DrawEx(new HandleRef(this, Handle), index, new HandleRef(graphics, dc), 0, 0,
imageSize.Width, imageSize.Height, NativeMethods.CLR_NONE, NativeMethods.CLR_NONE, NativeMethods.ILD_TRANSPARENT);
}
finally {
graphics.ReleaseHdcInternal(dc);
}
}
finally {
graphics.Dispose();
}
}
// gpr: See Icon for description of fakeTransparencyColor
result.MakeTransparent(fakeTransparencyColor);
return result;
}
#if DEBUG_ONLY_APIS
///
/// [To be supplied.]
///
public Bitmap DebugOnly_GetMasterImage() {
if (Images.Empty)
return null;
return Image.FromHBITMAP(GetImageInfo(0).hbmImage);
}
///
/// [To be supplied.]
///
public Bitmap DebugOnly_GetMasterMask() {
if (Images.Empty)
return null;
return Image.FromHBITMAP(GetImageInfo(0).hbmMask);
}
#endif // DEBUG_ONLY_APIS
///
/// Called when the Handle property changes.
///
private void OnRecreateHandle(EventArgs eventargs) {
if (recreateHandler != null) {
recreateHandler(this, eventargs);
}
}
private void OnChangeHandle(EventArgs eventargs) {
if (changeHandler != null) {
changeHandler(this, eventargs);
}
}
#if false
///
/// Copies the image at the specified index into the temporary Bitmap object.
/// The temporary Bitmap object is used for stuff that the Windows ImageList
/// control doesn't support, such as stretching images or copying images from
/// different image lists. Since bitmap creation is expensive, the same instance
/// of the temporary Bitmap is reused.
///
private void PutImageInTempBitmap(int index, bool useSnapshot) {
Debug.Assert(!useSnapshot || himlTemp != 0, "Where's himlTemp?");
IntPtr handleUse = (useSnapshot ? himlTemp : Handle);
int count = SafeNativeMethods.ImageList_GetImageCount(handleUse);
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", (index).ToString()));
if (temp != null) {
Size size = temp.Size;
if (!temp.Size.Equals(imageSize)) {
temp.Dispose();
temp = null;
}
}
if (temp == null) {
temp = new Bitmap(imageSize.Width, imageSize.Height);
}
temp.Transparent = useMask;
// OldGraphics gTemp = /*gpr useMask ? temp.ColorMask.GetGraphics() :*/ temp.GetGraphics();
SafeNativeMethods.ImageList_DrawEx(handleUse, index, gTemp.Handle, 0, 0,
imageSize.Width, imageSize.Height, useMask ? 0 : NativeMethods.CLR_DEFAULT, NativeMethods.CLR_NONE, NativeMethods.ILD_NORMAL);
if (useMask) {
gTemp = temp/*gpr .MonochromeMask*/.GetGraphics();
SafeNativeMethods.ImageList_DrawEx(handleUse, index, gTemp.Handle, 0, 0, imageSize.Width, imageSize.Height, NativeMethods.CLR_DEFAULT, NativeMethods.CLR_NONE, NativeMethods.ILD_MASK);
}
}
#endif
// PerformRecreateHandle doesn't quite do what you would suspect.
// Any existing images in the imagelist will NOT be copied to the
// new image list -- they really should. This bug has existed for a
// loooong time.
// The net effect is that if you add images to an imagelist, and
// then e.g. change the ImageSize any existing images will be lost
// and you will have to add them back. This is probably a corner case
// but it should be mentioned.
//
// The fix isn't as straightforward as you might think, i.e. we
// cannot just blindly store off the images and copy them into
// the newly created imagelist. E.g. say you change the ColorDepth
// from 8-bit to 32-bit. Just copying the 8-bit images would be wrong.
// Therefore we are going to leave this as is. Users should make sure
// to set these properties before actually adding the images.
// The Designer works around this by shadowing any Property that ends
// up calling PerformRecreateHandle (ImageSize, ColorDepth, ImageStream).
// Thus, if you add a new Property to ImageList which ends up calling
// PerformRecreateHandle, you must shadow the property in ImageListDesigner.
private void PerformRecreateHandle(string reason) {
if (!HandleCreated) return;
if (originals == null || Images.Empty)
originals = new ArrayList(); // spoof it into thinking this is the first CreateHandle
if (originals == null)
throw new InvalidOperationException(SR.GetString(SR.ImageListCantRecreate, reason));
DestroyHandle();
CreateHandle();
OnRecreateHandle(new EventArgs());
}
private void ResetImageSize() {
ImageSize = DefaultImageSize;
}
private void ResetTransparentColor() {
TransparentColor = Color.LightGray;
}
private bool ShouldSerializeTransparentColor() {
return !TransparentColor.Equals(Color.LightGray);
}
///
/// Returns a string representation for this control.
///
///
/// [To be supplied.]
///
[
Editor("System.Windows.Forms.Design.ImageCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))
]
public sealed class ImageCollection : IList {
private ImageList owner;
private ArrayList imageInfoCollection = new ArrayList();
/// A caching mechanism for key accessor
/// We use an index here rather than control so that we don't have lifetime
/// issues by holding on to extra references.
private int lastAccessedIndex = -1;
///
/// Returns the keys in the image list - images without keys return String.Empty.
///
///
public StringCollection Keys {
get {
// pass back a copy of the current state.
StringCollection keysCollection = new StringCollection();
for (int i = 0; i < imageInfoCollection.Count; i++) {
ImageInfo image = imageInfoCollection[i] as ImageInfo;
if ((image != null) && (image.Name != null) && (image.Name.Length != 0)) {
keysCollection.Add(image.Name);
} else {
keysCollection.Add(string.Empty);
}
}
return keysCollection;
}
}
internal ImageCollection(ImageList owner) {
this.owner = owner;
}
internal void ResetKeys() {
if (imageInfoCollection!= null)
imageInfoCollection.Clear();
for (int i = 0; i < this.Count; i++) {
imageInfoCollection.Add(new ImageCollection.ImageInfo());
}
}
[Conditional("DEBUG")]
private void AssertInvariant() {
Debug.Assert(owner != null, "ImageCollection has no owner (ImageList)");
Debug.Assert( (owner.originals == null) == (owner.HandleCreated), " Either we should have the original images, or the handle should be created");
}
///
/// [To be supplied.]
///
[Browsable(false)]
public int Count {
[ResourceExposure(ResourceScope.None)]
get {
AssertInvariant();
if (owner.HandleCreated) {
return SafeNativeMethods.ImageList_GetImageCount(new HandleRef(owner, owner.Handle));
}
else {
int count = 0;
foreach(Original original in owner.originals) {
if (original != null) {
count += original.nImages;
}
}
return count;
}
}
}
///
/// [To be supplied.]
///
public bool IsReadOnly {
get {
return false;
}
}
///
/// Determines if the ImageList has any images, without forcing a handle creation.
///
public bool Empty {
get {
return Count == 0;
}
}
///
/// [To be supplied.]
///
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Image this[int index] {
get {
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
return owner.GetBitmap(index);
}
set {
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
if (value == null) {
throw new ArgumentNullException("value");
}
if (!(value is Bitmap))
throw new ArgumentException(SR.GetString(SR.ImageListBitmap));
AssertInvariant();
Bitmap bitmap = (Bitmap)value;
bool ownsImage = false;
if (owner.UseTransparentColor) {
// Since there's no ImageList_ReplaceMasked, we need to generate
// a transparent bitmap
Bitmap source = bitmap;
bitmap = (Bitmap) bitmap.Clone();
bitmap.MakeTransparent(owner.transparentColor);
ownsImage = true;
}
try {
IntPtr hMask = ControlPaint.CreateHBitmapTransparencyMask(bitmap);
IntPtr hBitmap = ControlPaint.CreateHBitmapColorMask(bitmap, hMask);
bool ok = SafeNativeMethods.ImageList_Replace(new HandleRef(owner, owner.Handle), index, new HandleRef(null, hBitmap), new HandleRef(null, hMask));
SafeNativeMethods.DeleteObject(new HandleRef(null, hBitmap));
SafeNativeMethods.DeleteObject(new HandleRef(null, hMask));
if (!ok)
throw new InvalidOperationException(SR.GetString(SR.ImageListReplaceFailed));
} finally {
if(ownsImage) {
bitmap.Dispose();
}
}
}
}
///
/// Retrieves the child control with the specified key.
///
public Image this[string key] {
get {
// We do not support null and empty string as valid keys.
if ((key == null) || (key.Length == 0)){
return null;
}
// Search for the key in our collection
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
return this[index];
}
else {
return null;
}
}
}
///
/// Adds an image to the end of the image list with a key accessor.
///
public void Add(string key, Image image) {
Debug.Assert((this.Count == imageInfoCollection.Count), "The count of these two collections should be equal.");
// Store off the name.
ImageInfo imageInfo = new ImageInfo();
imageInfo.Name = key;
// Add the image to the IList
Original original = new Original(image, OriginalOptions.Default);
Add(original, imageInfo);
}
///
/// Adds an icon to the end of the image list with a key accessor.
///
public void Add(string key, Icon icon) {
Debug.Assert((this.Count == imageInfoCollection.Count), "The count of these two collections should be equal.");
// Store off the name.
ImageInfo imageInfo = new ImageInfo();
imageInfo.Name = key;
// Add the image to the IList
Original original = new Original(icon, OriginalOptions.Default);
Add(original, imageInfo);
}
///
/// [To be supplied.]
///
public void Add(Icon value) {
if (value == null) {
throw new ArgumentNullException("value");
}
Add(new Original(value.Clone(), OriginalOptions.OwnsImage), null); // WHY WHY WHY do we clone here...
// changing it now is a breaking change, so we have to keep track of this specific icon and dispose that
}
///
/// Add the given image to the ImageList.
///
public void Add(Image value) {
if (value == null) {
throw new ArgumentNullException("value");
}
Original original = new Original(value, OriginalOptions.Default);
Add(original, null);
}
///
/// Add the given image to the ImageList, using the given color
/// to generate the mask. The number of images to add is inferred from
/// the width of the given image.
///
public int Add(Image value, Color transparentColor) {
if (value == null) {
throw new ArgumentNullException("value");
}
Original original = new Original(value, OriginalOptions.CustomTransparentColor,
transparentColor);
return Add(original, null);
}
private int Add(Original original, ImageInfo imageInfo) {
if (original == null || original.image == null) {
throw new ArgumentNullException("value");
}
int index = -1;
AssertInvariant();
if (original.image is Bitmap) {
if (owner.originals != null) {
index = owner.originals.Add(original);
}
if (owner.HandleCreated) {
bool ownsBitmap = false;
Bitmap bitmapValue = owner.CreateBitmap(original, out ownsBitmap);
index = owner.AddToHandle(original, bitmapValue);
if(ownsBitmap)
bitmapValue.Dispose();
}
}
else if (original.image is Icon) {
if (owner.originals != null) {
index = owner.originals.Add(original);
}
if (owner.HandleCreated) {
index = owner.AddIconToHandle(original, (Icon)original.image);
// NOTE: if we own the icon (it's been created by us) this WILL dispose the icon to avoid a GDI leak
// **** original.image is NOT LONGER VALID AFTER THIS POINT ***
}
}
else {
throw new ArgumentException(SR.GetString(SR.ImageListBitmap));
}
// update the imageInfoCollection
// support AddStrip
if ((original.options & OriginalOptions.ImageStrip) != 0) {
for (int i = 0; i < original.nImages; i++) {
imageInfoCollection.Add(new ImageInfo());
}
} else {
if (imageInfo == null)
imageInfo = new ImageInfo();
imageInfoCollection.Add(imageInfo);
}
if (!owner.inAddRange)
owner.OnChangeHandle(new EventArgs());
return index;
}
///
/// [To be supplied.]
///
public void AddRange(Image[] images) {
if (images == null) {
throw new ArgumentNullException("images");
}
owner.inAddRange = true;
foreach(Image image in images) {
Add(image);
}
owner.inAddRange = false;
owner.OnChangeHandle(new EventArgs());
}
///
/// Add an image strip the given image to the ImageList. A strip is a single Image
/// which is treated as multiple images arranged side-by-side.
///
public int AddStrip(Image value) {
if (value == null) {
throw new ArgumentNullException("value");
}
// strip width must be a positive multiple of image list width
//
if (value.Width == 0 || (value.Width % owner.ImageSize.Width) != 0)
throw new ArgumentException(SR.GetString(SR.ImageListStripBadWidth), "value");
if (value.Height != owner.ImageSize.Height)
throw new ArgumentException(SR.GetString(SR.ImageListImageTooShort), "value");
int nImages = value.Width / owner.ImageSize.Width;
Original original = new Original(value, OriginalOptions.ImageStrip, nImages);
return Add(original, null);
}
///
/// Remove all images and masks from the ImageList.
///
public void Clear() {
AssertInvariant();
if (owner.originals != null)
owner.originals.Clear();
imageInfoCollection.Clear();
if (owner.HandleCreated)
SafeNativeMethods.ImageList_Remove(new HandleRef(owner, owner.Handle), -1);
owner.OnChangeHandle(new EventArgs());
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public bool Contains(Image image) {
throw new NotSupportedException();
}
///
/// Returns true if the collection contains an item with the specified key, false otherwise.
///
public bool ContainsKey(string key) {
return IsValidIndex(IndexOfKey(key));
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public int IndexOf(Image image) {
throw new NotSupportedException();
}
///
/// The zero-based index of the first occurrence of value within the entire CollectionBase,
/// if found; otherwise, -1.
///
public int IndexOfKey(String key) {
// Step 0 - Arg validation
if ((key == null) || (key.Length == 0)){
return -1; // we dont support empty or null keys.
}
// step 1 - check the last cached item
if (IsValidIndex(lastAccessedIndex))
{
if ((imageInfoCollection[lastAccessedIndex] != null) &&
(WindowsFormsUtils.SafeCompareStrings(((ImageInfo)imageInfoCollection[lastAccessedIndex]).Name, key, /* ignoreCase = */ true))) {
return lastAccessedIndex;
}
}
// step 2 - search for the item
for (int i = 0; i < this.Count; i ++) {
if ((imageInfoCollection[i] != null) &&
(WindowsFormsUtils.SafeCompareStrings(((ImageInfo)imageInfoCollection[i]).Name, key, /* ignoreCase = */ true))) {
lastAccessedIndex = i;
return i;
}
}
// step 3 - we didn't find it. Invalidate the last accessed index and return -1.
lastAccessedIndex = -1;
return -1;
}
///
/// Determines if the index is valid for the collection.
///
///
/// [To be supplied.]
///
public IEnumerator GetEnumerator() {
// Forces handle creation
AssertInvariant();
Image[] images = new Image[Count];
for (int i = 0; i < images.Length; ++i)
images[i] = owner.GetBitmap(i);
return images.GetEnumerator();
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void Remove(Image image) {
throw new NotSupportedException();
}
///
/// [To be supplied.]
///
public void RemoveAt(int index) {
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
AssertInvariant();
bool ok = SafeNativeMethods.ImageList_Remove(new HandleRef(owner, owner.Handle), index);
if (!ok) {
throw new InvalidOperationException(SR.GetString(SR.ImageListRemoveFailed));
} else {
if ((imageInfoCollection != null) && (index >= 0 && index < imageInfoCollection.Count)) {
imageInfoCollection.RemoveAt(index);
owner.OnChangeHandle(new EventArgs());
}
}
}
///
/// Removes the child control with the specified key.
///
public void RemoveByKey(string key) {
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
RemoveAt(index);
}
}
///
/// Sets/Resets the key accessor for an image already in the image list.
///
public void SetKeyName(int index, string name) {
if (!IsValidIndex(index)) {
throw new IndexOutOfRangeException(); //
}
if (imageInfoCollection[index] == null) {
imageInfoCollection[index] = new ImageInfo();
}
((ImageInfo)imageInfoCollection[index]).Name = name;
}
///
/// Gets a value indicating
/// whether this object supports properties using the
/// specified context.
///
public override bool GetPropertiesSupported(ITypeDescriptorContext context) {
return true;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Windows.Forms {
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System;
using System.Collections.Specialized;
using System.Collections;
using System.Drawing;
using System.Drawing.Imaging;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using System.IO;
using System.ComponentModel.Design.Serialization;
using System.Runtime.Versioning;
using Microsoft.Win32;
using System.Security;
using System.Security.Permissions;
using System.Globalization;
///
/// The ImageList is an object that stores a collection of Images, most
/// commonly used by other controls, such as the ListView, TreeView, or
/// Toolbar. You can add either bitmaps or Icons to the ImageList, and the
/// other controls will be able to use the Images as they desire.
///
[
Designer("System.Windows.Forms.Design.ImageListDesigner, " + AssemblyRef.SystemDesign),
ToolboxItemFilter("System.Windows.Forms"),
DefaultProperty("Images"),
TypeConverter(typeof(ImageListConverter)),
DesignerSerializer("System.Windows.Forms.Design.ImageListCodeDomSerializer, " + AssemblyRef.SystemDesign, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + AssemblyRef.SystemDesign),
SRDescription(SR.DescriptionImageList)
]
public sealed class ImageList : Component {
// gpr: Copied from Icon
private static Color fakeTransparencyColor = Color.FromArgb(0x0d, 0x0b, 0x0c);
private static Size DefaultImageSize = new Size(16, 16);
private const int INITIAL_CAPACITY = 4;
private const int GROWBY = 4;
private NativeImageList nativeImageList;
// private int himlTemp;
// private Bitmap temp = null; // Used for drawing
private ColorDepth colorDepth = System.Windows.Forms.ColorDepth.Depth8Bit;
private Color transparentColor = Color.Transparent;
private Size imageSize = DefaultImageSize;
private ImageCollection imageCollection;
private object userData;
// The usual handle virtualization problem, with a new twist: image
// lists are lossy. At runtime, we delay handle creation as long as possible, and store
// away the original images until handle creation (and hope no one disposes of the images!). At design time, we keep the originals around indefinitely.
// This variable will become null when the original images are lost. See ASURT 65162.
private IList /* of Original */ originals = new ArrayList();
private EventHandler recreateHandler = null;
private EventHandler changeHandler = null;
private bool inAddRange = false;
///
/// Creates a new ImageList Control with a default image size of 16x16
/// pixels
///
public ImageList() { // DO NOT DELETE -- AUTOMATION BP 1
}
///
/// Creates a new ImageList Control with a default image size of 16x16
/// pixels and adds the ImageList to the passed in container.
///
public ImageList(IContainer container) {
container.Add(this);
}
// This class is for classes that want to support both an ImageIndex
// and ImageKey. We want to toggle between using keys or indexes.
// Default is to use the integer index.
internal class Indexer {
private string key = String.Empty;
private int index = -1;
private bool useIntegerIndex = true;
private ImageList imageList = null;
public virtual ImageList ImageList {
get { return imageList; }
set { imageList = value; }
}
public virtual string Key {
get { return key; }
set {
index = -1;
key = (value == null ? String.Empty : value);
useIntegerIndex = false;
}
}
public virtual int Index {
get { return index; }
set {
key = String.Empty;
index = value;
useIntegerIndex = true;
}
}
public virtual int ActualIndex {
get {
if (useIntegerIndex) {
return Index;
}
else if (ImageList != null) {
return ImageList.Images.IndexOfKey(Key);
}
return -1;
}
}
}
///
/// Retrieves the color depth of the imagelist.
///
[
SRCategory(SR.CatAppearance),
SRDescription(SR.ImageListColorDepthDescr)
]
public ColorDepth ColorDepth {
get {
return colorDepth;
}
set {
// ColorDepth is not conitguous - list the members instead.
if (!ClientUtils.IsEnumValid_NotSequential(value,
(int)value,
(int)ColorDepth.Depth4Bit,
(int)ColorDepth.Depth8Bit,
(int)ColorDepth.Depth16Bit,
(int)ColorDepth.Depth24Bit,
(int)ColorDepth.Depth32Bit)) {
throw new InvalidEnumArgumentException("value", (int)value, typeof(ColorDepth));
}
if (colorDepth != value) {
colorDepth = value;
PerformRecreateHandle("ColorDepth");
}
}
}
private bool ShouldSerializeColorDepth() {
return (Images.Count==0);
}
private void ResetColorDepth() {
ColorDepth = ColorDepth.Depth8Bit;
}
///
/// The handle of the ImageList object. This corresponds to a win32
/// HIMAGELIST Handle.
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ImageListHandleDescr)
]
public IntPtr Handle {
get {
if (nativeImageList == null) {
CreateHandle();
}
return nativeImageList.Handle;
}
}
///
/// Whether or not the underlying Win32 handle has been created.
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ImageListHandleCreatedDescr)
]
public bool HandleCreated {
get { return nativeImageList != null; }
}
///
/// [To be supplied.]
///
[
SRCategory(SR.CatAppearance),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
SRDescription(SR.ImageListImagesDescr),
MergableProperty(false)
]
public ImageCollection Images {
get {
if (imageCollection == null)
imageCollection = new ImageCollection(this);
return imageCollection;
}
}
///
/// Returns the size of the images in the ImageList
///
[
SRCategory(SR.CatBehavior),
Localizable(true),
SRDescription(SR.ImageListSizeDescr)
]
public Size ImageSize {
get {
return imageSize;
}
set {
if (value.IsEmpty) {
throw new ArgumentException(SR.GetString(SR.InvalidArgument, "ImageSize", "Size.Empty"));
}
// ImageList appears to consume an exponential amount of memory
// based on image size x bpp. Restrict this to a reasonable maximum
// to keep people's systems from crashing.
//
if (value.Width <= 0 || value.Width > 256) {
throw new ArgumentOutOfRangeException("ImageSize", SR.GetString(SR.InvalidBoundArgument, "ImageSize.Width", value.Width.ToString(CultureInfo.CurrentCulture), (1).ToString(CultureInfo.CurrentCulture), "256"));
}
if (value.Height <= 0 || value.Height > 256) {
throw new ArgumentOutOfRangeException("ImageSize", SR.GetString(SR.InvalidBoundArgument, "ImageSize.Height", value.Height.ToString(CultureInfo.CurrentCulture), (1).ToString(CultureInfo.CurrentCulture), "256"));
}
if (imageSize.Width != value.Width || imageSize.Height != value.Height) {
imageSize = new Size(value.Width, value.Height);
PerformRecreateHandle("ImageSize");
}
}
}
private bool ShouldSerializeImageSize() {
return (Images.Count==0);
}
///
/// Returns an ImageListStreamer, or null if the image list is empty.
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
DefaultValue(null),
SRDescription(SR.ImageListImageStreamDescr)
]
public ImageListStreamer ImageStream {
get {
if (Images.Empty)
return null;
// No need for us to create the handle, because any serious attempts to use the
// ImageListStreamer will do it for us.
return new ImageListStreamer(this);
}
set {
if (value != null) {
NativeImageList himl = value.GetNativeImageList();
if (himl != null && himl != this.nativeImageList) {
DestroyHandle();
originals = null;
this.nativeImageList = new NativeImageList(SafeNativeMethods.ImageList_Duplicate(new HandleRef(himl, himl.Handle)));
int x, y;
if(SafeNativeMethods.ImageList_GetIconSize(new HandleRef(this, this.nativeImageList.Handle), out x, out y)) {
imageSize = new Size(x,y);
}
// need to get the image bpp
NativeMethods.IMAGEINFO imageInfo = new NativeMethods.IMAGEINFO(); // review? do I need to delete the mask and image?
if(SafeNativeMethods.ImageList_GetImageInfo(new HandleRef(this, this.nativeImageList.Handle), 0, imageInfo)) {
NativeMethods.BITMAP bmp = new NativeMethods.BITMAP();
UnsafeNativeMethods.GetObject(new HandleRef(null, imageInfo.hbmImage), Marshal.SizeOf(bmp), bmp);
switch(bmp.bmBitsPixel) {
case 4:
colorDepth = ColorDepth.Depth4Bit;
break;
case 8:
colorDepth = ColorDepth.Depth8Bit;
break;
case 16:
colorDepth = ColorDepth.Depth16Bit;
break;
case 24:
colorDepth = ColorDepth.Depth24Bit;
break;
case 32:
colorDepth = ColorDepth.Depth32Bit;
break;
default:
Debug.Fail("Unknown color depth");
break;
}
}
Images.ResetKeys();
OnRecreateHandle(new EventArgs());
}
}
else
{
DestroyHandle();
Images.Clear();
}
}
}
///
/// The color to treat as transparent.
///
[
SRCategory(SR.CatBehavior),
SRDescription(SR.ImageListTransparentColorDescr)
]
public Color TransparentColor {
get {
return transparentColor;
}
set {
transparentColor = value;
}
}
// Whether to use the transparent color, or rely on alpha instead
private bool UseTransparentColor {
get { return TransparentColor.A > 0;}
}
///
/// [To be supplied.]
///
[
Browsable(false), EditorBrowsable(EditorBrowsableState.Advanced),
SRDescription(SR.ImageListOnRecreateHandleDescr)
]
public event EventHandler RecreateHandle {
add {
recreateHandler += value;
}
remove {
recreateHandler -= value;
}
}
internal event EventHandler ChangeHandle {
add {
changeHandler += value;
}
remove {
changeHandler -= value;
}
}
//Creates a bitmap from the original image source..
//
private Bitmap CreateBitmap(Original original, out bool ownsBitmap) {
Color transparent = transparentColor;
ownsBitmap = false;
if ((original.options & OriginalOptions.CustomTransparentColor) != 0)
transparent = original.customTransparentColor;
Bitmap bitmap;
if (original.image is Bitmap) {
bitmap = (Bitmap) original.image;
}
else if (original.image is Icon) {
bitmap = ((Icon)original.image).ToBitmap();
ownsBitmap = true;
}
else {
bitmap = new Bitmap((Image)original.image);
ownsBitmap = true;
}
if (transparent.A > 0) {
// ImageList_AddMasked doesn't work on high color bitmaps,
// so we always create the mask ourselves
Bitmap source = bitmap;
bitmap = (Bitmap) bitmap.Clone();
bitmap.MakeTransparent(transparent);
if(ownsBitmap)
source.Dispose();
ownsBitmap = true;
}
Size size = bitmap.Size;
if ((original.options & OriginalOptions.ImageStrip) != 0) {
// strip width must be a positive multiple of image list width
if (size.Width == 0 || (size.Width % imageSize.Width) != 0)
throw new ArgumentException(SR.GetString(SR.ImageListStripBadWidth), "original");
if (size.Height != imageSize.Height)
throw new ArgumentException(SR.GetString(SR.ImageListImageTooShort), "original");
}
else if (!size.Equals(ImageSize)) {
Bitmap source = bitmap;
bitmap = new Bitmap(source, ImageSize);
if(ownsBitmap)
source.Dispose();
ownsBitmap = true;
}
return bitmap;
}
private int AddIconToHandle(Original original, Icon icon) {
try {
Debug.Assert(HandleCreated, "Calling AddIconToHandle when there is no handle");
int index = SafeNativeMethods.ImageList_ReplaceIcon(new HandleRef(this, Handle), -1, new HandleRef(icon, icon.Handle));
if (index == -1) throw new InvalidOperationException(SR.GetString(SR.ImageListAddFailed));
return index;
} finally {
if((original.options & OriginalOptions.OwnsImage) != 0) { /// this is to handle the case were we clone the icon (see WHY WHY WHY below)
icon.Dispose();
}
}
}
// Adds bitmap to the Imagelist handle...
//
private int AddToHandle(Original original, Bitmap bitmap) {
Debug.Assert(HandleCreated, "Calling AddToHandle when there is no handle");
IntPtr hMask = ControlPaint.CreateHBitmapTransparencyMask(bitmap); // Calls GDI to create Bitmap.
IntPtr hBitmap = ControlPaint.CreateHBitmapColorMask(bitmap, hMask); // Calls GDI+ to create Bitmap. Need to add handle to HandleCollector.
int index = SafeNativeMethods.ImageList_Add(new HandleRef(this, Handle), new HandleRef(null, hBitmap), new HandleRef(null, hMask));
SafeNativeMethods.DeleteObject(new HandleRef(null, hBitmap));
SafeNativeMethods.DeleteObject(new HandleRef(null, hMask));
if (index == -1) throw new InvalidOperationException(SR.GetString(SR.ImageListAddFailed));
return index;
}
///
/// Creates the underlying HIMAGELIST handle, and sets up all the
/// appropriate values with it. Inheriting classes overriding this method
/// should not forget to call base.createHandle();
///
private void CreateHandle() {
// so we don't reinit while we're doing this...
nativeImageList = null;
int flags = NativeMethods.ILC_MASK;
switch (colorDepth) {
case ColorDepth.Depth4Bit:
flags |= NativeMethods.ILC_COLOR4;
break;
case ColorDepth.Depth8Bit:
flags |= NativeMethods.ILC_COLOR8;
break;
case ColorDepth.Depth16Bit:
flags |= NativeMethods.ILC_COLOR16;
break;
case ColorDepth.Depth24Bit:
flags |= NativeMethods.ILC_COLOR24;
break;
case ColorDepth.Depth32Bit:
flags |= NativeMethods.ILC_COLOR32;
break;
default:
Debug.Fail("Unknown color depth in ImageList");
break;
}
//VSW #123063: We enclose the imagelist handle create in a theming scope. This is a temporary solution
// till we tackle the bigger issue tracked by VSW #95247
IntPtr userCookie = UnsafeNativeMethods.ThemingScope.Activate();
try {
SafeNativeMethods.InitCommonControls();
nativeImageList = new NativeImageList(SafeNativeMethods.ImageList_Create(imageSize.Width, imageSize.Height, flags, INITIAL_CAPACITY, GROWBY));
}
finally {
UnsafeNativeMethods.ThemingScope.Deactivate(userCookie);
}
if (Handle == IntPtr.Zero) throw new InvalidOperationException(SR.GetString(SR.ImageListCreateFailed));
SafeNativeMethods.ImageList_SetBkColor(new HandleRef(this, Handle), NativeMethods.CLR_NONE);
Debug.Assert(originals != null, "Handle not yet created, yet original images are gone");
for (int i = 0; i < originals.Count; i++) {
Original original = (Original) originals[i];
if (original.image is Icon) {
AddIconToHandle(original, (Icon)original.image);
// NOTE: if we own the icon (it's been created by us) this WILL dispose the icon to avoid a GDI leak
// **** original.image is NOT LONGER VALID AFTER THIS POINT ***
}
else {
bool ownsBitmap = false;
Bitmap bitmapValue = CreateBitmap(original, out ownsBitmap);
AddToHandle(original, bitmapValue);
if(ownsBitmap)
bitmapValue.Dispose();
}
}
originals = null;
}
// Don't merge this function into Dispose() -- that base.Dispose() will damage the design time experience
private void DestroyHandle() {
if (HandleCreated) {
// NOTE! No need to call ImageList_Destroy. It will be called in the NativeImageList finalizer.
nativeImageList = null;
originals = new ArrayList();
}
}
///
/// Frees all resources assocaited with this component.
///
protected override void Dispose(bool disposing) {
// NOTE! No need to call ImageList_Destroy. It will be called in the NativeImageList finalizer.
if (disposing) {
if(originals != null) { // we might own some of the stuff that's not been created yet
foreach(Original original in originals) {
if((original.options & OriginalOptions.OwnsImage) != 0) {
((IDisposable)original.image).Dispose();
}
}
}
DestroyHandle();
}
base.Dispose(disposing);
}
///
/// Draw the image indicated by the given index on the given Graphics
/// at the given location.
///
public void Draw(Graphics g, Point pt, int index) {
Draw(g, pt.X, pt.Y, index);
}
///
/// Draw the image indicated by the given index on the given Graphics
/// at the given location.
///
public void Draw(Graphics g, int x, int y, int index) {
Draw(g, x, y, imageSize.Width, imageSize.Height, index);
}
///
/// Draw the image indicated by the given index using the location, size
/// and raster op code specified. The image is stretched or compressed as
/// necessary to fit the bounds provided.
///
public void Draw(Graphics g, int x, int y, int width, int height, int index) {
if (index < 0 || index >= Images.Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
IntPtr dc = g.GetHdc();
try {
SafeNativeMethods.ImageList_DrawEx(new HandleRef(this, Handle), index, new HandleRef(g, dc), x, y,
width, height, NativeMethods.CLR_NONE, NativeMethods.CLR_NONE, NativeMethods.ILD_TRANSPARENT);
}
finally {
g.ReleaseHdcInternal(dc);
}
}
private void CopyBitmapData(BitmapData sourceData, BitmapData targetData) {
// do the actual copy
int offsetSrc = 0;
int offsetDest = 0;
unsafe {
for (int i = 0; i < targetData.Height; i++)
{
IntPtr srcPtr, destPtr;
if (IntPtr.Size == 4) {
srcPtr = new IntPtr(sourceData.Scan0.ToInt32() + offsetSrc);
destPtr = new IntPtr(targetData.Scan0.ToInt32() + offsetDest);
} else {
srcPtr = new IntPtr(sourceData.Scan0.ToInt64() + offsetSrc);
destPtr = new IntPtr(targetData.Scan0.ToInt64() + offsetDest);
}
UnsafeNativeMethods.CopyMemory(new HandleRef(this, destPtr), new HandleRef(this, srcPtr), Math.Abs(targetData.Stride));
offsetSrc += sourceData.Stride;
offsetDest += targetData.Stride;
}
}
}
private static bool BitmapHasAlpha(BitmapData bmpData) {
if(bmpData.PixelFormat != PixelFormat.Format32bppArgb && bmpData.PixelFormat != PixelFormat.Format32bppRgb) {
return false;
}
bool hasAlpha = false;
unsafe {
for (int i = 0; i < bmpData.Height; i++) {
int offsetRow = i * bmpData.Stride;
for (int j = 3; j < bmpData.Width*4; j += 4) { // *4 is safe since we know PixelFormat is ARGB
unsafe {
byte* candidate = ((byte*)bmpData.Scan0.ToPointer()) + offsetRow + j;
if (*candidate != 0) {
hasAlpha = true;
goto Found; // gotos are fugly but it's the best thing here...
}
}
}
}
Found:
return hasAlpha;
}
}
///
/// Returns the image specified by the given index. The bitmap returned is a
/// copy of the original image.
///
// NOTE: forces handle creation, so doesn't return things from the original list
private Bitmap GetBitmap(int index) {
if (index < 0 || index >= Images.Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
Bitmap result=null;
// if the imagelist is 32bpp, if the image slot at index
// has valid alpha information (not all zero... which is cause by windows just painting RGB values
// and not touching the alpha byte for images < 32bpp painted to a 32bpp imagelist)
// we're not using the mask. That means that
// we can just get the whole image strip, cut out the piece that we want
// and return that, that way we don't flatten the alpha by painting the value with the alpha... (ie using the alpha)
if(ColorDepth == ColorDepth.Depth32Bit) {
NativeMethods.IMAGEINFO imageInfo = new NativeMethods.IMAGEINFO(); // review? do I need to delete the mask and image inside of imageinfo?
if(SafeNativeMethods.ImageList_GetImageInfo(new HandleRef(this, this.Handle), index, imageInfo)) {
Bitmap tmpBitmap = null;
BitmapData bmpData = null;
BitmapData targetData = null;
IntSecurity.ObjectFromWin32Handle.Assert();
try {
tmpBitmap = Bitmap.FromHbitmap(imageInfo.hbmImage);
//
bmpData = tmpBitmap.LockBits(new Rectangle(imageInfo.rcImage_left,imageInfo.rcImage_top, imageInfo.rcImage_right-imageInfo.rcImage_left, imageInfo.rcImage_bottom-imageInfo.rcImage_top), ImageLockMode.ReadOnly, tmpBitmap.PixelFormat);
int offset = bmpData.Stride * imageSize.Height * index;
// we need do the following if the image has alpha because otherwise the image is fully transparent even though it has data
if(BitmapHasAlpha(bmpData)) {
result = new Bitmap(imageSize.Width, imageSize.Height, PixelFormat.Format32bppArgb);
targetData = result.LockBits(new Rectangle(0, 0, imageSize.Width, imageSize.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
CopyBitmapData(bmpData, targetData);
}
} finally {
CodeAccessPermission.RevertAssert();
if(tmpBitmap != null && bmpData != null) {
tmpBitmap.UnlockBits(bmpData);
}
if(result != null && targetData != null) {
result.UnlockBits(targetData);
}
}
}
}
if(result == null) { // paint with the mask but no alpha...
result = new Bitmap(imageSize.Width, imageSize.Height);
Graphics graphics = Graphics.FromImage(result);
try {
IntPtr dc = graphics.GetHdc();
try {
SafeNativeMethods.ImageList_DrawEx(new HandleRef(this, Handle), index, new HandleRef(graphics, dc), 0, 0,
imageSize.Width, imageSize.Height, NativeMethods.CLR_NONE, NativeMethods.CLR_NONE, NativeMethods.ILD_TRANSPARENT);
}
finally {
graphics.ReleaseHdcInternal(dc);
}
}
finally {
graphics.Dispose();
}
}
// gpr: See Icon for description of fakeTransparencyColor
result.MakeTransparent(fakeTransparencyColor);
return result;
}
#if DEBUG_ONLY_APIS
///
/// [To be supplied.]
///
public Bitmap DebugOnly_GetMasterImage() {
if (Images.Empty)
return null;
return Image.FromHBITMAP(GetImageInfo(0).hbmImage);
}
///
/// [To be supplied.]
///
public Bitmap DebugOnly_GetMasterMask() {
if (Images.Empty)
return null;
return Image.FromHBITMAP(GetImageInfo(0).hbmMask);
}
#endif // DEBUG_ONLY_APIS
///
/// Called when the Handle property changes.
///
private void OnRecreateHandle(EventArgs eventargs) {
if (recreateHandler != null) {
recreateHandler(this, eventargs);
}
}
private void OnChangeHandle(EventArgs eventargs) {
if (changeHandler != null) {
changeHandler(this, eventargs);
}
}
#if false
///
/// Copies the image at the specified index into the temporary Bitmap object.
/// The temporary Bitmap object is used for stuff that the Windows ImageList
/// control doesn't support, such as stretching images or copying images from
/// different image lists. Since bitmap creation is expensive, the same instance
/// of the temporary Bitmap is reused.
///
private void PutImageInTempBitmap(int index, bool useSnapshot) {
Debug.Assert(!useSnapshot || himlTemp != 0, "Where's himlTemp?");
IntPtr handleUse = (useSnapshot ? himlTemp : Handle);
int count = SafeNativeMethods.ImageList_GetImageCount(handleUse);
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", (index).ToString()));
if (temp != null) {
Size size = temp.Size;
if (!temp.Size.Equals(imageSize)) {
temp.Dispose();
temp = null;
}
}
if (temp == null) {
temp = new Bitmap(imageSize.Width, imageSize.Height);
}
temp.Transparent = useMask;
// OldGraphics gTemp = /*gpr useMask ? temp.ColorMask.GetGraphics() :*/ temp.GetGraphics();
SafeNativeMethods.ImageList_DrawEx(handleUse, index, gTemp.Handle, 0, 0,
imageSize.Width, imageSize.Height, useMask ? 0 : NativeMethods.CLR_DEFAULT, NativeMethods.CLR_NONE, NativeMethods.ILD_NORMAL);
if (useMask) {
gTemp = temp/*gpr .MonochromeMask*/.GetGraphics();
SafeNativeMethods.ImageList_DrawEx(handleUse, index, gTemp.Handle, 0, 0, imageSize.Width, imageSize.Height, NativeMethods.CLR_DEFAULT, NativeMethods.CLR_NONE, NativeMethods.ILD_MASK);
}
}
#endif
// PerformRecreateHandle doesn't quite do what you would suspect.
// Any existing images in the imagelist will NOT be copied to the
// new image list -- they really should. This bug has existed for a
// loooong time.
// The net effect is that if you add images to an imagelist, and
// then e.g. change the ImageSize any existing images will be lost
// and you will have to add them back. This is probably a corner case
// but it should be mentioned.
//
// The fix isn't as straightforward as you might think, i.e. we
// cannot just blindly store off the images and copy them into
// the newly created imagelist. E.g. say you change the ColorDepth
// from 8-bit to 32-bit. Just copying the 8-bit images would be wrong.
// Therefore we are going to leave this as is. Users should make sure
// to set these properties before actually adding the images.
// The Designer works around this by shadowing any Property that ends
// up calling PerformRecreateHandle (ImageSize, ColorDepth, ImageStream).
// Thus, if you add a new Property to ImageList which ends up calling
// PerformRecreateHandle, you must shadow the property in ImageListDesigner.
private void PerformRecreateHandle(string reason) {
if (!HandleCreated) return;
if (originals == null || Images.Empty)
originals = new ArrayList(); // spoof it into thinking this is the first CreateHandle
if (originals == null)
throw new InvalidOperationException(SR.GetString(SR.ImageListCantRecreate, reason));
DestroyHandle();
CreateHandle();
OnRecreateHandle(new EventArgs());
}
private void ResetImageSize() {
ImageSize = DefaultImageSize;
}
private void ResetTransparentColor() {
TransparentColor = Color.LightGray;
}
private bool ShouldSerializeTransparentColor() {
return !TransparentColor.Equals(Color.LightGray);
}
///
/// Returns a string representation for this control.
///
///
/// [To be supplied.]
///
[
Editor("System.Windows.Forms.Design.ImageCollectionEditor, " + AssemblyRef.SystemDesign, typeof(UITypeEditor))
]
public sealed class ImageCollection : IList {
private ImageList owner;
private ArrayList imageInfoCollection = new ArrayList();
/// A caching mechanism for key accessor
/// We use an index here rather than control so that we don't have lifetime
/// issues by holding on to extra references.
private int lastAccessedIndex = -1;
///
/// Returns the keys in the image list - images without keys return String.Empty.
///
///
public StringCollection Keys {
get {
// pass back a copy of the current state.
StringCollection keysCollection = new StringCollection();
for (int i = 0; i < imageInfoCollection.Count; i++) {
ImageInfo image = imageInfoCollection[i] as ImageInfo;
if ((image != null) && (image.Name != null) && (image.Name.Length != 0)) {
keysCollection.Add(image.Name);
} else {
keysCollection.Add(string.Empty);
}
}
return keysCollection;
}
}
internal ImageCollection(ImageList owner) {
this.owner = owner;
}
internal void ResetKeys() {
if (imageInfoCollection!= null)
imageInfoCollection.Clear();
for (int i = 0; i < this.Count; i++) {
imageInfoCollection.Add(new ImageCollection.ImageInfo());
}
}
[Conditional("DEBUG")]
private void AssertInvariant() {
Debug.Assert(owner != null, "ImageCollection has no owner (ImageList)");
Debug.Assert( (owner.originals == null) == (owner.HandleCreated), " Either we should have the original images, or the handle should be created");
}
///
/// [To be supplied.]
///
[Browsable(false)]
public int Count {
[ResourceExposure(ResourceScope.None)]
get {
AssertInvariant();
if (owner.HandleCreated) {
return SafeNativeMethods.ImageList_GetImageCount(new HandleRef(owner, owner.Handle));
}
else {
int count = 0;
foreach(Original original in owner.originals) {
if (original != null) {
count += original.nImages;
}
}
return count;
}
}
}
///
/// [To be supplied.]
///
public bool IsReadOnly {
get {
return false;
}
}
///
/// Determines if the ImageList has any images, without forcing a handle creation.
///
public bool Empty {
get {
return Count == 0;
}
}
///
/// [To be supplied.]
///
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Image this[int index] {
get {
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
return owner.GetBitmap(index);
}
set {
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
if (value == null) {
throw new ArgumentNullException("value");
}
if (!(value is Bitmap))
throw new ArgumentException(SR.GetString(SR.ImageListBitmap));
AssertInvariant();
Bitmap bitmap = (Bitmap)value;
bool ownsImage = false;
if (owner.UseTransparentColor) {
// Since there's no ImageList_ReplaceMasked, we need to generate
// a transparent bitmap
Bitmap source = bitmap;
bitmap = (Bitmap) bitmap.Clone();
bitmap.MakeTransparent(owner.transparentColor);
ownsImage = true;
}
try {
IntPtr hMask = ControlPaint.CreateHBitmapTransparencyMask(bitmap);
IntPtr hBitmap = ControlPaint.CreateHBitmapColorMask(bitmap, hMask);
bool ok = SafeNativeMethods.ImageList_Replace(new HandleRef(owner, owner.Handle), index, new HandleRef(null, hBitmap), new HandleRef(null, hMask));
SafeNativeMethods.DeleteObject(new HandleRef(null, hBitmap));
SafeNativeMethods.DeleteObject(new HandleRef(null, hMask));
if (!ok)
throw new InvalidOperationException(SR.GetString(SR.ImageListReplaceFailed));
} finally {
if(ownsImage) {
bitmap.Dispose();
}
}
}
}
///
/// Retrieves the child control with the specified key.
///
public Image this[string key] {
get {
// We do not support null and empty string as valid keys.
if ((key == null) || (key.Length == 0)){
return null;
}
// Search for the key in our collection
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
return this[index];
}
else {
return null;
}
}
}
///
/// Adds an image to the end of the image list with a key accessor.
///
public void Add(string key, Image image) {
Debug.Assert((this.Count == imageInfoCollection.Count), "The count of these two collections should be equal.");
// Store off the name.
ImageInfo imageInfo = new ImageInfo();
imageInfo.Name = key;
// Add the image to the IList
Original original = new Original(image, OriginalOptions.Default);
Add(original, imageInfo);
}
///
/// Adds an icon to the end of the image list with a key accessor.
///
public void Add(string key, Icon icon) {
Debug.Assert((this.Count == imageInfoCollection.Count), "The count of these two collections should be equal.");
// Store off the name.
ImageInfo imageInfo = new ImageInfo();
imageInfo.Name = key;
// Add the image to the IList
Original original = new Original(icon, OriginalOptions.Default);
Add(original, imageInfo);
}
///
/// [To be supplied.]
///
public void Add(Icon value) {
if (value == null) {
throw new ArgumentNullException("value");
}
Add(new Original(value.Clone(), OriginalOptions.OwnsImage), null); // WHY WHY WHY do we clone here...
// changing it now is a breaking change, so we have to keep track of this specific icon and dispose that
}
///
/// Add the given image to the ImageList.
///
public void Add(Image value) {
if (value == null) {
throw new ArgumentNullException("value");
}
Original original = new Original(value, OriginalOptions.Default);
Add(original, null);
}
///
/// Add the given image to the ImageList, using the given color
/// to generate the mask. The number of images to add is inferred from
/// the width of the given image.
///
public int Add(Image value, Color transparentColor) {
if (value == null) {
throw new ArgumentNullException("value");
}
Original original = new Original(value, OriginalOptions.CustomTransparentColor,
transparentColor);
return Add(original, null);
}
private int Add(Original original, ImageInfo imageInfo) {
if (original == null || original.image == null) {
throw new ArgumentNullException("value");
}
int index = -1;
AssertInvariant();
if (original.image is Bitmap) {
if (owner.originals != null) {
index = owner.originals.Add(original);
}
if (owner.HandleCreated) {
bool ownsBitmap = false;
Bitmap bitmapValue = owner.CreateBitmap(original, out ownsBitmap);
index = owner.AddToHandle(original, bitmapValue);
if(ownsBitmap)
bitmapValue.Dispose();
}
}
else if (original.image is Icon) {
if (owner.originals != null) {
index = owner.originals.Add(original);
}
if (owner.HandleCreated) {
index = owner.AddIconToHandle(original, (Icon)original.image);
// NOTE: if we own the icon (it's been created by us) this WILL dispose the icon to avoid a GDI leak
// **** original.image is NOT LONGER VALID AFTER THIS POINT ***
}
}
else {
throw new ArgumentException(SR.GetString(SR.ImageListBitmap));
}
// update the imageInfoCollection
// support AddStrip
if ((original.options & OriginalOptions.ImageStrip) != 0) {
for (int i = 0; i < original.nImages; i++) {
imageInfoCollection.Add(new ImageInfo());
}
} else {
if (imageInfo == null)
imageInfo = new ImageInfo();
imageInfoCollection.Add(imageInfo);
}
if (!owner.inAddRange)
owner.OnChangeHandle(new EventArgs());
return index;
}
///
/// [To be supplied.]
///
public void AddRange(Image[] images) {
if (images == null) {
throw new ArgumentNullException("images");
}
owner.inAddRange = true;
foreach(Image image in images) {
Add(image);
}
owner.inAddRange = false;
owner.OnChangeHandle(new EventArgs());
}
///
/// Add an image strip the given image to the ImageList. A strip is a single Image
/// which is treated as multiple images arranged side-by-side.
///
public int AddStrip(Image value) {
if (value == null) {
throw new ArgumentNullException("value");
}
// strip width must be a positive multiple of image list width
//
if (value.Width == 0 || (value.Width % owner.ImageSize.Width) != 0)
throw new ArgumentException(SR.GetString(SR.ImageListStripBadWidth), "value");
if (value.Height != owner.ImageSize.Height)
throw new ArgumentException(SR.GetString(SR.ImageListImageTooShort), "value");
int nImages = value.Width / owner.ImageSize.Width;
Original original = new Original(value, OriginalOptions.ImageStrip, nImages);
return Add(original, null);
}
///
/// Remove all images and masks from the ImageList.
///
public void Clear() {
AssertInvariant();
if (owner.originals != null)
owner.originals.Clear();
imageInfoCollection.Clear();
if (owner.HandleCreated)
SafeNativeMethods.ImageList_Remove(new HandleRef(owner, owner.Handle), -1);
owner.OnChangeHandle(new EventArgs());
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public bool Contains(Image image) {
throw new NotSupportedException();
}
///
/// Returns true if the collection contains an item with the specified key, false otherwise.
///
public bool ContainsKey(string key) {
return IsValidIndex(IndexOfKey(key));
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public int IndexOf(Image image) {
throw new NotSupportedException();
}
///
/// The zero-based index of the first occurrence of value within the entire CollectionBase,
/// if found; otherwise, -1.
///
public int IndexOfKey(String key) {
// Step 0 - Arg validation
if ((key == null) || (key.Length == 0)){
return -1; // we dont support empty or null keys.
}
// step 1 - check the last cached item
if (IsValidIndex(lastAccessedIndex))
{
if ((imageInfoCollection[lastAccessedIndex] != null) &&
(WindowsFormsUtils.SafeCompareStrings(((ImageInfo)imageInfoCollection[lastAccessedIndex]).Name, key, /* ignoreCase = */ true))) {
return lastAccessedIndex;
}
}
// step 2 - search for the item
for (int i = 0; i < this.Count; i ++) {
if ((imageInfoCollection[i] != null) &&
(WindowsFormsUtils.SafeCompareStrings(((ImageInfo)imageInfoCollection[i]).Name, key, /* ignoreCase = */ true))) {
lastAccessedIndex = i;
return i;
}
}
// step 3 - we didn't find it. Invalidate the last accessed index and return -1.
lastAccessedIndex = -1;
return -1;
}
///
/// Determines if the index is valid for the collection.
///
///
/// [To be supplied.]
///
public IEnumerator GetEnumerator() {
// Forces handle creation
AssertInvariant();
Image[] images = new Image[Count];
for (int i = 0; i < images.Length; ++i)
images[i] = owner.GetBitmap(i);
return images.GetEnumerator();
}
///
/// [To be supplied.]
///
[EditorBrowsable(EditorBrowsableState.Never)]
public void Remove(Image image) {
throw new NotSupportedException();
}
///
/// [To be supplied.]
///
public void RemoveAt(int index) {
if (index < 0 || index >= Count)
throw new ArgumentOutOfRangeException("index", SR.GetString(SR.InvalidArgument, "index", index.ToString(CultureInfo.CurrentCulture)));
AssertInvariant();
bool ok = SafeNativeMethods.ImageList_Remove(new HandleRef(owner, owner.Handle), index);
if (!ok) {
throw new InvalidOperationException(SR.GetString(SR.ImageListRemoveFailed));
} else {
if ((imageInfoCollection != null) && (index >= 0 && index < imageInfoCollection.Count)) {
imageInfoCollection.RemoveAt(index);
owner.OnChangeHandle(new EventArgs());
}
}
}
///
/// Removes the child control with the specified key.
///
public void RemoveByKey(string key) {
int index = IndexOfKey(key);
if (IsValidIndex(index)) {
RemoveAt(index);
}
}
///
/// Sets/Resets the key accessor for an image already in the image list.
///
public void SetKeyName(int index, string name) {
if (!IsValidIndex(index)) {
throw new IndexOutOfRangeException(); //
}
if (imageInfoCollection[index] == null) {
imageInfoCollection[index] = new ImageInfo();
}
((ImageInfo)imageInfoCollection[index]).Name = name;
}
///
/// Gets a value indicating
/// whether this object supports properties using the
/// specified context.
///
public override bool GetPropertiesSupported(ITypeDescriptorContext context) {
return true;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- BooleanConverter.cs
- XsdCachingReader.cs
- ProcessHost.cs
- ClusterSafeNativeMethods.cs
- HorizontalAlignConverter.cs
- GridViewSortEventArgs.cs
- TitleStyle.cs
- PerformanceCountersElement.cs
- SqlResolver.cs
- StylusCaptureWithinProperty.cs
- GridViewColumnHeaderAutomationPeer.cs
- InteropBitmapSource.cs
- SortedDictionary.cs
- PrincipalPermission.cs
- LowerCaseStringConverter.cs
- FontStretches.cs
- TransactionalPackage.cs
- VectorKeyFrameCollection.cs
- CreatingCookieEventArgs.cs
- BufferedStream.cs
- Int32Collection.cs
- LineGeometry.cs
- ConnectionStringsExpressionBuilder.cs
- DiagnosticsConfigurationHandler.cs
- TextWriterTraceListener.cs
- SvcMapFile.cs
- CommandBindingCollection.cs
- DataColumnSelectionConverter.cs
- ComponentRenameEvent.cs
- IncomingWebRequestContext.cs
- SoapFormatterSinks.cs
- ToolBarButton.cs
- CopyAttributesAction.cs
- ImageSourceValueSerializer.cs
- BaseDataBoundControl.cs
- CodeArgumentReferenceExpression.cs
- UIElementParagraph.cs
- DateTimeUtil.cs
- FreezableCollection.cs
- ConsumerConnectionPoint.cs
- MenuBase.cs
- InputLanguageManager.cs
- WorkflowOwnerAsyncResult.cs
- UxThemeWrapper.cs
- DesignTimeResourceProviderFactoryAttribute.cs
- ExpressionNormalizer.cs
- __Error.cs
- SignedXml.cs
- BitmapEffectState.cs
- GetReadStreamResult.cs
- ScrollChrome.cs
- GridErrorDlg.cs
- UTF8Encoding.cs
- StreamWriter.cs
- GenericTypeParameterBuilder.cs
- _SslStream.cs
- ExpressionBuilder.cs
- AppDomainResourcePerfCounters.cs
- LocalValueEnumerator.cs
- System.Data_BID.cs
- StateMachine.cs
- SQLGuid.cs
- TypeUnloadedException.cs
- EntityDataSourceSelectingEventArgs.cs
- TypeBuilder.cs
- TargetParameterCountException.cs
- DispatcherHookEventArgs.cs
- MetadataItemEmitter.cs
- CodeThrowExceptionStatement.cs
- DataGridHeaderBorder.cs
- CopyAttributesAction.cs
- ExpressionPrinter.cs
- CodeTypeParameter.cs
- ICspAsymmetricAlgorithm.cs
- Cursor.cs
- GetLedgerEntryForRecipientRequest.cs
- SizeFConverter.cs
- AttributeEmitter.cs
- RequestCacheManager.cs
- StrongNameIdentityPermission.cs
- AspNetPartialTrustHelpers.cs
- Compress.cs
- MetadataException.cs
- UIElementCollection.cs
- NativeWindow.cs
- Script.cs
- TraceSection.cs
- FontStyles.cs
- _NegotiateClient.cs
- SwitchElementsCollection.cs
- DropDownList.cs
- PersonalizationStateInfo.cs
- XmlSerializableWriter.cs
- ContextMarshalException.cs
- PersonalizationDictionary.cs
- EntitySqlQueryBuilder.cs
- invalidudtexception.cs
- XamlSerializer.cs
- Bitmap.cs
- oledbmetadatacolumnnames.cs