using System;
using System.Drawing;
using System.ComponentModel;
using DevComponents.DotNetBar;

namespace DevComponents.AdvTree
{
	/// <summary>
	/// Represents class that holds images for a cell.
	/// </summary>
	/// <remarks>
	/// If you plan to use alpha-blended images we recommend using PNG-24 format which
	/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
	/// alpha-blending when used through Image class.
	/// </remarks>
	[ToolboxItem(false), TypeConverter(typeof(System.ComponentModel.ExpandableObjectConverter))]
	public class CellImages
	{
		// Image variables
		private System.Drawing.Image m_Image=null;
        private System.Drawing.Image m_DisabledImageGenerated = null;
		private int m_ImageIndex=-1; // Image index if image from ImageList is used
		private System.Drawing.Image m_ImageMouseOver=null;
		private int m_ImageMouseOverIndex=-1; // Image index if image from ImageList is used
		private System.Drawing.Image m_ImageDisabled=null;
//		private bool m_DisabledImageCustom=false;
		private int m_ImageDisabledIndex=-1; // Image index if image from ImageList is used
		private System.Drawing.Image m_ImageExpanded=null;
		private int m_ImageExpandedIndex=-1;
		private Cell m_ParentCell=null;
		private Size m_LargestImageSize=Size.Empty;

		/// <summary>
		/// Initializes new instance of CellImages class.
		/// </summary>
		/// <param name="parentCell">Reference to parent cell.</param>
		public CellImages(Cell parentCell)
		{
			m_ParentCell=parentCell;
		}

		#region Properties

        internal System.Drawing.Image DisabledImageGenerated
        {
            get { return m_DisabledImageGenerated; }
            set
            {
                m_DisabledImageGenerated = value;
            }
        }

		/// <summary>
		/// Gets or sets default cell image. Setting this property to valid image will
		/// override any setting of ImageIndex property.
		/// </summary>
		/// <remarks>
		/// 	<para>The image set through this property will be serialized with the cell. If you
		///     plan to use ImageList then use <see cref="ImageIndex">ImageIndex</see>
		///     property.</para>
		/// 	<para>
		/// 		<para>If you plan to use alpha-blended images we recommend using PNG-24 format
		///         which supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1
		///         do not support alpha-blending when used through Image class.</para>
		/// 	</para>
		/// </remarks>
		/// <value>Image object or <strong>null (Nothing)</strong> if no image is assigned.</value>
		[Browsable(true),DefaultValue(null),Category("Images"),Description("Indicates default cell image"), DevCoSerialize()]
		public System.Drawing.Image Image
		{
			get {return m_Image;}
			set
			{
				ChangeImage(ref m_Image, value);
			}
		}

		/// <summary>
		/// Resets Image property to it's default value (null, VB nothing).
		/// </summary>
		public void ResetImage()
		{
			TypeDescriptor.GetProperties(this)["Image"].SetValue(this, null);
		}

		/// <summary>
		/// Gets or sets the image that is displayed when mouse is over the cell. Setting
		/// this property to valid image will override any setting of ImageMouseOverIndex
		/// property.
		/// </summary>
		/// <remarks>
		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
		/// supports alpha-blending. As of this writting .NET Framework 1.0 and 1.1 do not support
		/// alpha-blending when used through Image class.
		/// </remarks>
		[Browsable(true),DefaultValue(null),Category("Images"),Description("Indicates cell image when mouse is over the cell"), DevCoSerialize()]
		public System.Drawing.Image ImageMouseOver
		{
			get {return m_ImageMouseOver;}
			set
			{
                ChangeImage(ref m_ImageMouseOver, value);
			}
		}

		/// <summary>
		/// Resets ImageMouseOver to it's default value (null, VB nothing).
		/// </summary>
		public void ResetImageMouseOver()
		{
			TypeDescriptor.GetProperties(this)["ImageMouseOver"].SetValue(this, null);
		}

        /// <summary>
        /// Gets or sets the image that is displayed when cell is disabled. If not assigned
        /// disabled image is created from default cell image. Setting this property to valid image
        /// will override any setting of ImageDisabledIndex property.
        /// </summary>
        /// <remarks>
        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
        /// alpha-blending when used through Image class.
        /// </remarks>
        [Browsable(true), DefaultValue(null), Category("Images"), Description("Indicates disabled cell image")]
        public System.Drawing.Image ImageDisabled
        {
            get { return m_ImageDisabled; }
            set
            {
                ChangeImage(ref m_ImageDisabled, value);
            }
        }

        /// <summary>
        /// Resets ImageDisabled to it's default value (null, VB nothing).
        /// </summary>
        public void ResetImageDisabled()
        {
            this.ImageDisabled = null;
        }

		/// <summary>
		/// Gets or sets image that is displayed when Node that this cell belongs to is
		/// expanded. Setting this property to valid image will override any setting of
		/// ImageExpandedIndex property.
		/// </summary>
		/// <remarks>
		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
		/// alpha-blending when used through Image class.
		/// </remarks>
        [Browsable(true),DefaultValue(null),Category("Images"),Description("Indicates cell image when node associtaed with this cell is expanded"), DevCoSerialize()]
		public System.Drawing.Image ImageExpanded
		{
			get {return m_ImageExpanded;}
			set
			{
                ChangeImage(ref m_ImageExpanded, value);
			}
		}

		/// <summary>
		/// Resets ImageExpanded to it's default value (null, VB nothing).
		/// </summary>
		public void ResetImageExpanded()
		{
			TypeDescriptor.GetProperties(this)["ImageExpanded"].SetValue(this, null);
		}

		/// <summary>
		/// Gets or sets the Index of default cell image from ImageList specified on AdvTree
		/// control.
		/// </summary>
		/// <remarks>
		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
		/// alpha-blending when used through Image class.
		/// </remarks>
		[Browsable(true),DefaultValue(-1),Category("ImageList Images"),Description("Indicates default cell image"), DevCoSerialize()]
		public int ImageIndex
		{
			get {return m_ImageIndex;}
			set
			{
				m_ImageIndex=value;
				this.OnImageChanged();
			}
		}

        private string _ImageKey = "";
        /// <summary>
        /// Gets or sets the key of the default cell image from ImageList specified on AdvTree control.
        /// </summary>
        [DefaultValue(""), Category("ImageList Images"), Description("Indicates the default cell image key"), DevCoSerialize()]
        public string ImageKey
        {
            get { return _ImageKey; }
            set
            {
                _ImageKey = value;
                this.OnImageChanged();
            }
        }
        

		/// <summary>
		/// Property Editor support for ImageIndex selection
		/// </summary>
		[System.ComponentModel.Browsable(false),System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
		public System.Windows.Forms.ImageList ImageList
		{
			get
			{
				if(this.Parent!=null)
				{
					AdvTree tree=this.Parent.TreeControl;
					if(tree!=null)
					{
						return tree.ImageList;
					}
				}

				return null;
			}
		}

		/// <remarks>
		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
		/// alpha-blending when used through Image class.
		/// </remarks>
		/// <summary>
		/// Gets or sets the Index of cell image when mouse is over the cell from ImageList
		/// specified on AdvTree control.
		/// </summary>
		[Browsable(true),DefaultValue(-1),Category("ImageList Images"),Description("Indicates cell image when mouse is over the cell"), DevCoSerialize()]
		public int ImageMouseOverIndex
		{
			get {return m_ImageMouseOverIndex;}
			set
			{
				m_ImageMouseOverIndex=value;
				this.OnImageChanged();
			}
		}

        private string _ImageMouseOverKey = "";
        /// <remarks>
        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
        /// alpha-blending when used through Image class.
        /// </remarks>
        /// <summary>
        /// Gets or sets the key of cell image when mouse is over the cell from ImageList
        /// specified on AdvTree control.
        /// </summary>
        [Browsable(true), DefaultValue(""), Category("ImageList Images"), Description("Indicates cell image when mouse is over the cell"), DevCoSerialize()]
        public string ImageMouseOverKey
        {
            get { return _ImageMouseOverKey; }
            set
            {
                _ImageMouseOverKey = value;
                this.OnImageChanged();
            }
        }

        /// <remarks>
        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
        /// alpha-blending when used through Image class.
        /// </remarks>
        /// <summary>
        /// Gets or sets the Index of disabled cell image from ImageList specified on AdvTree
        /// control.
        /// </summary>
        [Browsable(true), DefaultValue(-1), Category("ImageList Images"), Description("Indicates disabled cell image")]
        public int ImageDisabledIndex
        {
            get { return m_ImageDisabledIndex; }
            set
            {
                m_ImageDisabledIndex = value;
                this.OnImageChanged();
            }
        }

        private string _ImageDisabledKey = "";
        /// <remarks>
        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
        /// alpha-blending when used through Image class.
        /// </remarks>
        /// <summary>
        /// Gets or sets the key of disabled cell image from ImageList specified on AdvTree
        /// control.
        /// </summary>
        [Browsable(true), DefaultValue(""), Category("ImageList Images"), Description("Indicates disabled cell image")]
        public string ImageDisabledKey
        {
            get { return _ImageDisabledKey; }
            set
            {
                _ImageDisabledKey = value;
                this.OnImageChanged();
            }
        }

		/// <remarks>
		/// If you plan to use alpha-blended images we recommend using PNG-24 format which
		/// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
		/// alpha-blending when used through Image class.
		/// </remarks>
		/// <summary>
		/// Gets or sets the Index of cell image from ImageList specified on AdvTree control
		/// that is used when Node associated with this cell is expanded
		/// </summary>
		[Browsable(true),DefaultValue(-1),Category("ImageList Images"),Description("Indicates expanded cell image"), DevCoSerialize()]
		public int ImageExpandedIndex
		{
			get {return m_ImageExpandedIndex;}
			set
			{
				m_ImageExpandedIndex=value;
				this.OnImageChanged();
			}
		}

        private string _ImageExpandedKey = "";
        /// <remarks>
        /// If you plan to use alpha-blended images we recommend using PNG-24 format which
        /// supports alpha-blending. As of this writing .NET Framework 1.0 and 1.1 do not support
        /// alpha-blending when used through Image class.
        /// </remarks>
        /// <summary>
        /// Gets or sets the key of cell image from ImageList specified on AdvTree control
        /// that is used when Node associated with this cell is expanded
        /// </summary>
        [Browsable(true), DefaultValue(""), Category("ImageList Images"), Description("Indicates expanded cell image"), DevCoSerialize()]
        public string ImageExpandedKey
        {
            get { return _ImageExpandedKey; }
            set
            {
                _ImageExpandedKey = value;
                this.OnImageChanged();
            }
        }

		/// <summary>
		/// Gets or sets the parent node of the cell.
		/// </summary>
		[Browsable(false),DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public Cell Parent
		{
			get {return m_ParentCell;}
			set {m_ParentCell=value;}
		}

		/// <summary>
		/// Gets whether CellImages object should be serialized or not. If object has all
		/// default values then this property will return <strong>false</strong>.
		/// </summary>
		internal bool ShouldSerialize
		{
			get
			{
				if(m_Image==null && m_ImageDisabled==null && m_ImageDisabledIndex==-1 &&
					m_ImageExpanded==null && m_ImageExpandedIndex==-1 && m_ImageIndex==-1 &&
					m_ImageMouseOver==null && m_ImageMouseOverIndex==-1)
					return false;
				return true;
			}
		}

		/// <summary>
		/// Returns largest image size in this set of images.
		/// </summary>
		internal Size LargestImageSize
		{
			get
			{
				return m_LargestImageSize;
			}
		}

		#endregion

		#region Methods

		/// <summary>Makes a copy of a CellImages object.</summary>
		public virtual CellImages Copy()
		{
			CellImages ci=new CellImages(null);
			ci.Image=this.Image;
//			ci.ImageDisabled=this.ImageDisabled;
//			ci.ImageDisabledIndex=this.ImageDisabledIndex;
		    ci.ImageExpanded = this.ImageExpanded == null ? null : (Image) this.ImageExpanded.Clone();
			ci.ImageExpandedIndex=this.ImageExpandedIndex;
			ci.ImageIndex=this.ImageIndex;
			ci.ImageMouseOver=this.ImageMouseOver == null? null : (Image)this.ImageMouseOver.Clone();
			ci.ImageMouseOverIndex=this.ImageMouseOverIndex;
            ci.ImageDisabledKey = this.ImageDisabledKey;
            ci.ImageExpandedKey = this.ImageExpandedKey;
            ci.ImageKey = this.ImageKey;
            ci.ImageMouseOverKey = this.ImageMouseOverKey;
			return ci;
		}

		#endregion

		#region Internals
        /// <summary>
        /// Changes the image and invokes largest image size calculation if the
        /// image size truly changed.
        /// </summary>
        /// <param name="currentImage"></param>
        /// <param name="newImage"></param>
        private void ChangeImage(ref System.Drawing.Image currentImage, System.Drawing.Image newImage)
        {
            // Early out if no real change
            if (currentImage == newImage)
                return;

            // Hold onto previous image
            System.Drawing.Image previousImage = currentImage;

            // Assign new image
            currentImage = newImage;

            // If either current or previous is null, or the sizes don't match,
            // we need to resize ourselves and the parent.
            if (previousImage == null || currentImage == null || GetImageSize(previousImage) != GetImageSize(currentImage))
            {
                RefreshLargestImageSize();

                if (this.Parent != null)
                    this.Parent.OnImageChanged();
            }

            // Dispose the generated disabled image, if applicable.
            DisposeGeneratedDisabledImage();
        }
        private Size GetImageSize(Image image)
        {
            try
            {
                return image.Size;
            }
            catch
            {
                return Size.Empty;
            }
        }

        private void OnImageChanged()
        {
            RefreshLargestImageSize();
            if (this.Parent != null)
                this.Parent.OnImageChanged();
            DisposeGeneratedDisabledImage();
        }

        public void Dispose()
        {
            DisposeGeneratedDisabledImage();
            if (BarUtilities.DisposeItemImages || _AutoDispose)
            {
                BarUtilities.DisposeImage(ref m_Image);
                BarUtilities.DisposeImage(ref m_ImageDisabled);
                BarUtilities.DisposeImage(ref m_ImageExpanded);
                BarUtilities.DisposeImage(ref m_ImageMouseOver);
            }
        }

        internal void DisposeGeneratedDisabledImage()
        {
            if (m_DisabledImageGenerated != null)
            {
                m_DisabledImageGenerated.Dispose();
                m_DisabledImageGenerated = null;
            }
        }

		internal void RefreshLargestImageSize()
		{
			m_LargestImageSize=Size.Empty;
			AdjustSize(m_Image,ref m_LargestImageSize);
			AdjustSize(m_ImageDisabled,ref m_LargestImageSize);
			AdjustSize(m_ImageExpanded,ref m_LargestImageSize);
			AdjustSize(m_ImageMouseOver,ref m_LargestImageSize);
            
			AdjustSize(GetImageByIndex(m_ImageIndex),ref m_LargestImageSize);
			AdjustSize(GetImageByIndex(m_ImageDisabledIndex),ref m_LargestImageSize);
			AdjustSize(GetImageByIndex(m_ImageExpandedIndex),ref m_LargestImageSize);
			AdjustSize(GetImageByIndex(m_ImageMouseOverIndex),ref m_LargestImageSize);

            AdjustSize(GetImageByKey(_ImageKey), ref m_LargestImageSize);
            AdjustSize(GetImageByKey(_ImageDisabledKey), ref m_LargestImageSize);
            AdjustSize(GetImageByKey(_ImageExpandedKey), ref m_LargestImageSize);
            AdjustSize(GetImageByKey(_ImageMouseOverKey), ref m_LargestImageSize);
		}
		private void AdjustSize(System.Drawing.Image image, ref Size size)
		{
			if(image!=null)
			{
				if(image.Width>size.Width)
					size.Width=image.Width;
				if(image.Height>size.Height)
					size.Height=image.Height;
			}
		}
		/// <summary>
		/// Returns image from image list based on the image index.
		/// </summary>
		/// <param name="imageIndex">Index of the image to return.</param>
		/// <returns>Image object from image list.</returns>
		internal System.Drawing.Image GetImageByIndex(int imageIndex)
		{
            if (imageIndex >= 0 && this.Parent != null && this.Parent.TreeControl != null && this.Parent.TreeControl.ImageList != null && this.Parent.TreeControl.ImageList.Images.Count > 0)
            {
                try
                {
                    return this.Parent.TreeControl.ImageList.Images[imageIndex];
                }
                catch
                {
                    return null;
                }
                
            }
            else
                return null;
		}

        /// <summary>
        /// Returns image from image list based on the image key.
        /// </summary>
        /// <param name="key">Key of the image to return.</param>
        /// <returns>Image object from image list.</returns>
        internal System.Drawing.Image GetImageByKey(string key)
        {
            if (string.IsNullOrEmpty(key)) return null;

            Cell parent = this.Parent;
            if (parent == null) return null;

            AdvTree tree = parent.TreeControl;
            if (tree == null || tree.ImageList == null || !tree.ImageList.Images.ContainsKey(key)) return null;

            return tree.ImageList.Images[key];
        }

        private bool _AutoDispose = false;
        /// <summary>
        /// Indicates whether assigned images are automatically disposed when the cell and node are disposed. Default value is false.
        /// </summary>
        [Browsable(false), DefaultValue(false)]
        public bool AutoDispose
        {
            get { return _AutoDispose; }
            set
            {
                _AutoDispose = value;
            }
        }
        
		#endregion
	}
}