// BitmapFontEd
// Copyright (C) 2005  Ian Cowburn
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// $Id$
//
using System;
using System.Drawing;
using System.IO;
using System.Collections;

namespace BitmapFontEd
{
	/// <summary>
	/// Description of BitmapChar.
	/// </summary>
	public class BitmapChar
	{
		public BitmapChar(int width, int height)
		{
			CheckSize(width,height);
			m_width=width;
			m_height=height;
			m_data=new Color[m_width,m_height];
			Clear(Color.Transparent);
			m_changed=false;
		}
		
		public BitmapChar() : this(16,16)
		{
		}
		
		public BitmapChar(BitmapChar old)
		{
			m_width=old.m_width;
			m_height=old.m_height;
			m_data=new Color[m_width,m_height];
			
			for(int x=0;x<m_width;x++)
				for(int y=0;y<m_height;y++)
					m_data[x,y]=old.m_data[x,y];
			
			m_changed=old.m_changed;
		}
		
		public int Width
		{
			get {return m_width;}
		}
		
		public int Height
		{
			get {return m_height;}
		}
		
		public bool Changed
		{
			get {return m_changed;}
		}
		
		public void Resize(int width, int height)
		{
			CheckSize(width,height);
			
			if (width==m_width && height==m_height)
			{
				return;
			}
			
			Color[,] data=new Color[width,height];

			for(int y=0;y<height;y++)
				for(int x=0;x<width;x++)
					data[x,y]=Color.Transparent;

			int mx=Math.Min(width,m_width);
			int my=Math.Min(height,m_height);
			
			for(int x=0;x<mx;x++)
				for(int y=0;y<my;y++)
					data[x,y]=m_data[x,y];
			
			m_width=width;
			m_height=height;
			m_data=data;
			m_changed=true;
		}
		
		public Color this [int x, int y]
		{
			set
			{
				m_data[x,y]=value;
				m_changed=true;
			}
			get {return m_data[x,y];}
		}
		
		public void Clear(Color c)
		{
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					m_data[x,y]=c;

			m_changed=true;
		}
		
		public void MirrorHorizontal()
		{
			Color[,] d=new Color[m_width,m_height];
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					d[x,y]=m_data[m_width-x-1,y];
			
			m_data=d;
			m_changed=true;
		}

		public void MirrorVertical()
		{
			Color[,] d=new Color[m_width,m_height];
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					d[x,y]=m_data[x,m_height-y-1];
			
			m_data=d;
			m_changed=true;
		}
		
		public void Scroll(int dx, int dy)
		{
			Color[,] d=new Color[m_width,m_height];
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					d[Mod(x+dx,m_width),Mod(y+dy,m_height)]=m_data[x,y];
			
			m_data=d;
			m_changed=true;
		}
		
		public void RotateRight()
		{
			Color[,] d=new Color[m_width,m_height];
			int min=Math.Min(m_width,m_height);
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
				{
					long nx=min-y-1;
					long ny=x;
					
					if (nx>=0 && nx<m_width && ny>=0 && ny<m_height)
					{
						d[nx,ny]=m_data[x,y];
					}
				}
			
			m_data=d;
			m_changed=true;
		}

		public void RotateLeft()
		{
			Color[,] d=new Color[m_width,m_height];
			int min=Math.Min(m_width,m_height);
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
				{
					long nx=y;
					long ny=min-x-1;
					
					if (nx>=0 && nx<m_width && ny>=0 && ny<m_height)
					{
						d[nx,ny]=m_data[x,y];
					}
				}
			
			m_data=d;
			m_changed=true;
		}
		
		public void DropShadow(int dx, int dy, Color col)
		{
			Color[,] d=new Color[m_width,m_height];
			
			// I'm sure this is too convoluted...
			//
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					d[x,y]=Color.Transparent;
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					if (m_data[x,y].A!=0)
					{
						int nx=x+dx;
						int ny=y+dy;
						
						if (nx>=0 && nx<m_width && ny>=0 && ny<m_height &&
						    m_data[nx,ny].A==0)
						{
							d[nx,ny]=col;
						}
					}
			
			Util.DumpAlpha("Shadow Overlay",d);

			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					if (d[x,y].A!=0)
					{
						m_data[x,y]=d[x,y];
					}

			m_changed=true;
		}

		public void Edge(Color col)
		{
			Color[,] d=new Color[m_width,m_height];
			
			// I'm sure this is too convoluted...
			//
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					d[x,y]=Color.Transparent;
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					if (m_data[x,y].A!=0)
					{
						for(int dx=-1;dx<2;dx++)
							for(int dy=-1;dy<2;dy++)
						{
							int nx=x+dx;
							int ny=y+dy;
							
							if (nx>=0 && nx<m_width && ny>=0 && ny<m_height &&
							    m_data[nx,ny].A==0)
							{
								d[nx,ny]=col;
							}
						}
					}
			
			Util.DumpAlpha("Edge Overlay",d);
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					if (d[x,y].A!=0)
					{
						m_data[x,y]=d[x,y];
					}

			m_changed=true;
		}

		public void Output(Stream stream)
		{
			Util.WriteInt(stream,m_width);
			Util.WriteInt(stream,m_height);

			for(int x=0;x<m_width;x++)
			{
				for(int y=0;y<m_height;y++)
				{
					stream.WriteByte(m_data[x,y].B);
					stream.WriteByte(m_data[x,y].G);
					stream.WriteByte(m_data[x,y].R);
					stream.WriteByte(m_data[x,y].A);
				}
			}
		}
		
		public static BitmapChar Input(Stream stream)
		{
			int width=Util.ReadInt(stream);
			int height=Util.ReadInt(stream);
			
			BitmapChar s=new BitmapChar(width,height);
			
			for(int x=0;x<width;x++)
			{
				for(int y=0;y<height;y++)
				{
					int B=stream.ReadByte();
					int G=stream.ReadByte();
					int R=stream.ReadByte();
					int A=stream.ReadByte();

					s[x,y]=Color.FromArgb(A,R,G,B);
				}
			}
			
			s.m_changed=false;
			
			return s;
		}
		
		// ------------------------------------------------
		// PRIVATE
		//
		private int			m_width;
		private int			m_height;
		private Color[,]	m_data;
		private bool		m_changed;
		
		private void CheckSize(int width, int height)
		{
			if (width<0 || height<0)
			{
				throw new ArgumentException("Cannot use negative sizes");
			}
		}
		
		private int Mod(int v, int m)
		{
			while (v<0)
			{
				v+=m;
			}
			
			return v%m;
		}
	}
	
	/// <summary>
	/// Describes a list of bitmap characters
	/// </summary>
	public class BitmapCharList : IEnumerable
	{
		private const int CHARS=95;
		
		public BitmapCharList()
		{
			m_list=new BitmapChar[CHARS];
			
			for(int f=0;f<CHARS;f++)
			{
				m_list[f]=new BitmapChar();
			}
			
			m_changed=false;
		}
		
		public BitmapChar this [int i]
		{
			get {return m_list[i];}
			set
			{
				m_list[i]=value;
				m_changed=true;
			}
		}
		
		public bool Changed
		{
			get {return m_changed;}
			set {m_changed=value;}
		}
		
		public bool IsFixedWidth
		{
			get
			{
				int w=m_list[0].Width;
				
				foreach (BitmapChar c in m_list)
				{
					if (c.Width!=w)
					{
						return false;
					}
				}
				
				return true;
			}
		}
		
		public IEnumerator GetEnumerator()
		{
			return m_list.GetEnumerator();
		}
		
		public void Output(Stream stream)
		{
			Util.WriteString(stream,MAGIC);
			
			if (IsFixedWidth)
			{
				Util.WriteInt(stream,1);
			}
			else
			{
				Util.WriteInt(stream,0);
			}
			
			foreach (BitmapChar c in m_list)
			{
				c.Output(stream);
			}
		}
		
		public static BitmapCharList Input(Stream stream)
		{
			BitmapCharList l=new BitmapCharList();
			
			string magic=Util.ReadString(stream,4);
			
			if (magic!=MAGIC)
			{
				throw new Exception("Not a recognised BMF file");
			}
			
			Util.ReadInt(stream);
			
			for(int f=0;f<CHARS;f++)
			{
				l.m_list[f]=BitmapChar.Input(stream);
			}
			
			l.Changed=false;
			
			return l;
		}
		
		// ------------------------------------------------
		// PRIVATE
		//
		private const string	MAGIC="BMF1";
		
		private BitmapChar[]	m_list;
		private bool			m_changed;
	}
}