// 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(uint width, uint height)
		{
			m_width=width;
			m_height=height;
			m_data=new Color[m_width,m_height];
			Clear(Color.Black);
			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 uint Width
		{
			get {return m_width;}
		}
		
		public uint Height
		{
			get {return m_height;}
		}
		
		public bool Changed
		{
			get {return m_changed;}
		}
		
		public void Resize(uint width, uint 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.Black;

			uint mx=Math.Min(width,m_width);
			uint 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 [uint x, uint 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];
			uint 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];
			uint 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.Black;
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					if (m_data[x,y]!=Color.Black)
					{
						int nx=x+dx;
						int ny=y+dy;
						
						if (nx>=0 && nx<m_width && ny>=0 && ny<m_height &&
						    m_data[nx,ny]==Color.Black)
						{
							d[nx,ny]=col;
						}
					}
			
			for(int y=0;y<m_height;y++)
				for(int x=0;x<m_width;x++)
					if (d[x,y]!=Color.Black)
					{
						m_data[x,y]=d[x,y];
					}

			m_changed=true;
		}

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

			for(uint x=0;x<m_width;x++)
			{
				for(uint y=0;y<m_height;y++)
				{
					if (m_data[x,y]!=Color.Black)
					{
						Util.WriteInt(stream,m_data[x,y].ToArgb());
					}
					else
					{
						Util.WriteInt(stream,0);
					}
				}
			}
		}
		
		public static BitmapChar Input(Stream stream)
		{
			uint width=Util.ReadUint(stream);
			uint height=Util.ReadUint(stream);
			
			BitmapChar s=new BitmapChar(width,height);
			
			for(uint x=0;x<width;x++)
			{
				for(uint y=0;y<height;y++)
				{
					int col=Util.ReadInt(stream);
					
					if (col==0)
					{
						s[x,y]=Color.Black;
					}
					else
					{
						s[x,y]=Color.FromArgb(255,(col&0xff0000)>>16,(col&0xff00)>>8,col&0xff);
					}
				}
			}
			
			s.m_changed=false;
			
			return s;
		}
		
		// ------------------------------------------------
		// PRIVATE
		//
		private uint		m_width;
		private uint		m_height;
		private Color[,]	m_data;
		private bool		m_changed;
		
		private int Mod(int v, uint max)
		{
			while(v<0)
				v+=(int)max;
			
			v=v%(int)max;
			
			return v;
		}
	}
	
	/// <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
			{
				uint 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;
	}
}