// Written by Christopher E. Miller
// See the included license.txt for copyright and license details.


///
module dfl.imagelist;

import dfl.base, dfl.drawing, dfl.internal.winapi;
import dfl.collections;


version(DFL_NO_IMAGELIST)
{
}
else
{
	///
	class ImageList // docmain
	{
		///
		class ImageCollection
		{
			protected this()
			{
			}
			
			
			void insert(int index, Image img)
			{
				if(index >= _images.length)
				{
					add(img);
				}
				else
				{
					assert(0, "Must add images to the end of the image list");
				}
			}
			
			
			final void addStrip(Image img)
			{
				HGDIOBJ hgo;
				if(1 != img._imgtype(&hgo))
				{
					debug
					{
						assert(0, "Image list: addStrip needs bitmap");
					}
					else
					{
						_unableimg();
					}
				}
				
				auto sz = imageSize;
				if(img.height != sz.height
					|| img.width % sz.width)
				{
					debug
					{
						assert(0, "Image list: invalid image size");
					}
					else
					{
						_unableimg();
					}
				}
				int num = img.width / sz.width;
				
				/+
				if(1 == num)
				{
					add(img);
					return;
				}
				+/
				
				auto _hdl = handle; // _addhbitmap needs the handle! Could avoid this in the future.
				_addhbitmap(hgo);
				
				int x = 0;
				for(; num; num--)
				{
					auto sp = new StripPart();
					sp.origImg = img;
					sp.hbm = hgo;
					sp.partBounds = Rect(x, 0, sz.width, sz.height);
					
					_images ~= sp;
					
					x += sz.width;
				}
			}
			
			
			package:
			
			Image[] _images;
			
			
			static class StripPart: Image
			{
				override @property Size size() // getter
				{
					return partBounds.size;
				}
				
				
				override void draw(Graphics g, Point pt)
				{
					HDC memdc;
					memdc = CreateCompatibleDC(g.handle);
					try
					{
						HGDIOBJ hgo;
						hgo = SelectObject(memdc, hbm);
						BitBlt(g.handle, pt.x, pt.y, partBounds.width, partBounds.height, memdc, partBounds.x, partBounds.y, SRCCOPY);
						SelectObject(memdc, hgo); // Old bitmap.
					}
					finally
					{
						DeleteDC(memdc);
					}
				}
				
				
				override void drawStretched(Graphics g, Rect r)
				{
					HDC memdc;
					memdc = CreateCompatibleDC(g.handle);
					try
					{
						HGDIOBJ hgo;
						int lstretch;
						hgo = SelectObject(memdc, hbm);
						lstretch = SetStretchBltMode(g.handle, COLORONCOLOR);
						StretchBlt(g.handle, r.x, r.y, r.width, r.height,
							memdc, partBounds.x, partBounds.y, partBounds.width, partBounds.height, SRCCOPY);
						SetStretchBltMode(g.handle, lstretch);
						SelectObject(memdc, hgo); // Old bitmap.
					}
					finally
					{
						DeleteDC(memdc);
					}
				}
				
				
				Image origImg; // Hold this so the HBITMAP doesn't get collected.
				HBITMAP hbm;
				Rect partBounds;
			}
			
			
			void _adding(size_t idx, Image val)
			{
				assert(val !is null);
				
				switch(val._imgtype(null))
				{
					case 1:
					case 2:
						break;
					default:
						debug
						{
							assert(0, "Image list: invalid image type");
						}
						else
						{
							_unableimg();
						}
				}
				
				if(val.size != imageSize)
				{
					debug
					{
						assert(0, "Image list: invalid image size");
					}
					else
					{
						_unableimg();
					}
				}
			}
			
			
			void _added(size_t idx, Image val)
			{
				if(isHandleCreated)
				{
					//if(idx >= _images.length) // Can't test for this here because -val- is already added to the array.
					_addimg(val);
				}
			}
			
			
			void _removed(size_t idx, Image val)
			{
				if(isHandleCreated)
				{
					if(size_t.max == idx) // Clear all.
					{
						imageListRemove(handle, -1);
					}
					else
					{
						imageListRemove(handle, idx);
					}
				}
			}
			
			
			public:
			
			mixin ListWrapArray!(Image, _images,
				_adding, _added,
				_blankListCallback!(Image), _removed,
				false, false, false);
		}
		
		
		this()
		{
			InitCommonControls();
			
			_cimages = new ImageCollection();
			_transcolor = Color.transparent;
		}
		
		
		///
		final @property void colorDepth(ColorDepth depth) // setter
		{
			assert(!isHandleCreated);
			
			this._depth = depth;
		}
		
		/// ditto
		final @property ColorDepth colorDepth() // getter
		{
			return _depth;
		}
		
		
		///
		final @property void transparentColor(Color tc) // setter
		{
			assert(!isHandleCreated);
			
			_transcolor = tc;
		}
		
		/// ditto
		final @property Color transparentColor() // getter
		{
			return _transcolor;
		}
		
		
		///
		final @property void imageSize(Size sz) // setter
		{
			assert(!isHandleCreated);
			
			assert(sz.width && sz.height);
			
			_w = sz.width;
			_h = sz.height;
		}
		
		/// ditto
		final @property Size imageSize() // getter
		{
			return Size(_w, _h);
		}
		
		
		///
		final @property ImageCollection images() // getter
		{
			return _cimages;
		}
		
		
		///
		final @property void tag(Object t) // setter
		{
			this._tag = t;
		}
		
		/// ditto
		final @property Object tag() // getter
		{
			return this._tag;
		}
		
		
		/+ // Actually, forget about these; just draw with the actual images.
		///
		final void draw(Graphics g, Point pt, int index)
		{
			return draw(g, pt.x, pt.y, index);
		}
		
		/// ditto
		final void draw(Graphics g, int x, int y, int index)
		{
			imageListDraw(handle, index, g.handle, x, y, ILD_NORMAL);
		}
		
		/// ditto
		// stretch
		final void draw(Graphics g, int x, int y, int width, int height, int index)
		{
			// ImageList_DrawEx operates differently if the width or height is zero
			// so bail out if zero and pretend the zero size image was drawn.
			if(!width)
				return;
			if(!height)
				return;
			
			imageListDrawEx(handle, index, g.handle, x, y, width, height,
				CLR_NONE, CLR_NONE, ILD_NORMAL); // ?
		}
		+/
		
		
		///
		final @property bool isHandleCreated() // getter
		{
			return HIMAGELIST.init != _hil;
		}
		
		deprecated alias isHandleCreated handleCreated;
		
		
		///
		final @property HIMAGELIST handle() // getter
		{
			if(!isHandleCreated)
				_createimagelist();
			return _hil;
		}
		
		
		///
		void dispose()
		{
			return dispose(true);
		}
		
		/// ditto
		void dispose(bool disposing)
		{
			if(isHandleCreated)
				imageListDestroy(_hil);
			_hil = HIMAGELIST.init;
			
			if(disposing)
			{
				//_cimages._images = null; // Not GC-safe in dtor.
				//_cimages = null; // Could cause bad things.
			}
		}
		
		
		~this()
		{
			dispose();
		}
		
		
		private:
		
		ColorDepth _depth = ColorDepth.DEPTH_8BIT;
		Color _transcolor;
		ImageCollection _cimages;
		HIMAGELIST _hil;
		int _w = 16, _h = 16;
		Object _tag;
		
		
		void _createimagelist()
		{
			if(isHandleCreated)
			{
				imageListDestroy(_hil);
				_hil = HIMAGELIST.init;
			}
			
			UINT flags = ILC_MASK;
			switch(_depth)
			{
				case ColorDepth.DEPTH_4BIT:          flags |= ILC_COLOR4;  break;
				default: case ColorDepth.DEPTH_8BIT: flags |= ILC_COLOR8;  break;
				case ColorDepth.DEPTH_16BIT:         flags |= ILC_COLOR16; break;
				case ColorDepth.DEPTH_24BIT:         flags |= ILC_COLOR24; break;
				case ColorDepth.DEPTH_32BIT:         flags |= ILC_COLOR32; break;
			}
			
			// Note: cGrow is not a limit, but how many images to preallocate each grow.
			_hil = imageListCreate(_w, _h, flags, _cimages._images.length, 4 + _cimages._images.length / 4);
			if(!_hil)
				throw new DflException("Unable to create image list");
			
			foreach(img; _cimages._images)
			{
				_addimg(img);
			}
		}
		
		
		void _unableimg()
		{
			throw new DflException("Unable to add image to image list");
		}
		
		
		int _addimg(Image img)
		{
			assert(isHandleCreated);
			
			HGDIOBJ hgo;
			int result;
			switch(img._imgtype(&hgo))
			{
				case 1:
					result = _addhbitmap(hgo);
					break;
				
				case 2:
					result = imageListAddIcon(_hil, cast(HICON)hgo);
					break;
				
				default:
					result = -1;
			}
			
			//if(-1 == result)
			//	_unableimg();
			return result;
		}
		
		int _addhbitmap(HBITMAP hbm)
		{
			assert(isHandleCreated);
			
			COLORREF cr;
			if(_transcolor == Color.empty
				|| _transcolor == Color.transparent)
			{
				cr = CLR_NONE; // ?
			}
			else
			{
				cr = _transcolor.toRgb();
			}
			return imageListAddMasked(_hil, cast(HBITMAP)hbm, cr);
		}
	}


	private extern(Windows)
	{
		// This was the only way I could figure out how to use the current actctx (Windows issue).
		
		HIMAGELIST imageListCreate(
			int cx, int cy, UINT flags, int cInitial, int cGrow)
		{
			alias typeof(&ImageList_Create) TProc;
			static TProc proc = null;
			if(!proc)
				proc = cast(typeof(proc))GetProcAddress(GetModuleHandleA("comctl32.dll"), "ImageList_Create");
			return proc(cx, cy, flags, cInitial, cGrow);
		}
		
		int imageListAddIcon(
			HIMAGELIST himl, HICON hicon)
		{
			alias typeof(&ImageList_AddIcon) TProc;
			static TProc proc = null;
			if(!proc)
				proc = cast(typeof(proc))GetProcAddress(GetModuleHandleA("comctl32.dll"), "ImageList_AddIcon");
			return proc(himl, hicon);
		}
		
		int imageListAddMasked(
			HIMAGELIST himl, HBITMAP hbmImage, COLORREF crMask)
		{
			alias typeof(&ImageList_AddMasked) TProc;
			static TProc proc = null;
			if(!proc)
				proc = cast(typeof(proc))GetProcAddress(GetModuleHandleA("comctl32.dll"), "ImageList_AddMasked");
			return proc(himl, hbmImage, crMask);
		}
		
		BOOL imageListRemove(
			HIMAGELIST himl, int i)
		{
			alias typeof(&ImageList_Remove) TProc;
			static TProc proc = null;
			if(!proc)
				proc = cast(typeof(proc))GetProcAddress(GetModuleHandleA("comctl32.dll"), "ImageList_Remove");
			return proc(himl, i);
		}
		
		BOOL imageListDestroy(
			HIMAGELIST himl)
		{
			alias typeof(&ImageList_Destroy) TProc;
			static TProc proc = null;
			if(!proc)
				proc = cast(typeof(proc))GetProcAddress(GetModuleHandleA("comctl32.dll"), "ImageList_Destroy");
			return proc(himl);
		}
	}
}