#region Copyright (c) 2007, PP4L Software
/************************************************************************************

Copyright  2007, PP4L Software
Author:	Lampiasis <lampiasis@dvolker.com>

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

'***********************************************************************************/
#endregion

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Text.RegularExpressions;
using System.Drawing.Printing;


namespace AsciiPumper
{
	public partial class PaintCanvas : UserControl
	{
		public PaintCanvas()
		{
			InitializeComponent();

			CellRows = new List<List<CellInfo>>();
			ResizeCellRows();


			UpdateSeperatorPen();
			PaintCanvas_SizeChanged(this, EventArgs.Empty);
			PaintIntoBackground();
			Program.Settings.PropertyChanged += new PropertyChangedEventHandler(Settings_PropertyChanged);

		}


		public Stack<IUndoableAction> UndoList = new Stack<IUndoableAction>();
		public Stack<IUndoableAction> RedoList = new Stack<IUndoableAction>();
		public IUndoableAction CurrentAction;

		private bool m_Modified;

		/// <summary>
		/// Gets or sets the Modified.
		/// </summary>
		public bool Modified
		{
			get { return m_Modified; }
			set
			{
				if (m_Modified != value)
				{
					if (value == true)
						OnCanvasModified(CanvasModifiedEventArgs.Empty);
					m_Modified = value;
				}
			}
		}

		public class CanvasModifiedEventArgs : EventArgs
		{
			public static readonly new CanvasModifiedEventArgs Empty = new CanvasModifiedEventArgs();
		}

		public event EventHandler<CanvasModifiedEventArgs> CanvasModified;

		protected virtual void OnCanvasModified(CanvasModifiedEventArgs e)
		{
			EventHandler<CanvasModifiedEventArgs> handler = CanvasModified;
			if (handler != null)
			{
				handler(this, e);
			}
		}

		public void CompleteRepaint()
		{
			this.PaintIntoBackground();
			this.Invalidate();
		}

		void Settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
		{
			bool invalidate = false;

			if ( e.PropertyName == "PaintFontName" )
			{
				this.Font = new Font((string) Program.Settings["PaintFontName"], (float) Program.Settings["PaintFontSize"]);
				invalidate = true;
			}
			if (e.PropertyName == "PaintFontSize")
			{
				this.Font = new Font((string) Program.Settings["PaintFontName"], (float) Program.Settings["PaintFontSize"]);
				invalidate = true;
			}
			if (e.PropertyName == "CellWidth")
			{
				this.CellWidth = Program.Settings.CellWidth;
				invalidate = true;
			}
			if (e.PropertyName == "CellHeight")
			{
				this.CellHeight = Program.Settings.CellHeight;
				invalidate = true;
			}
			if (e.PropertyName == "SeperatorColor")
				this.SeperatorColor = Program.Settings.SeperatorColor;
			if (e.PropertyName == "HighlightColor")
				this.HighlightColor = Program.Settings.HighlightColor;

			if (invalidate)
			{
			//	this.PaintIntoBackground();
			//	this.Invalidate();
			}
		}

		private void ResizeCellRows( )
		{
			for (int rows = 0; rows < this.Rows; rows++)
			{
				if ( CellRows.Count < rows + 1 ) 
					CellRows.Add(new List<CellInfo>(this.Columns));
				for (int cols = 0; cols < this.Columns; cols++)
				{
					if ( CellRows[rows].Count < cols + 1 )
						CellRows[rows].Add( new CellInfo() );
				}
			}
		}
    

		private void PaintCanvas_Paint(object sender, PaintEventArgs e)
		{
#if false
			// test
			Font consolas = new Font("Consolas", 18);
			m_PaintBuffer.DrawString("Test", consolas, Brushes.BlueViolet, 10, consolas.Height);
			SizeF size = m_PaintBuffer.MeasureString("Test", consolas);
			m_PaintBuffer.DrawString(size.Width.ToString(), consolas, Brushes.Blue, size.Width + 10, consolas.Height);
			// test
			Font arial = new Font("Arial", 10);
			m_PaintBuffer.DrawString("Test", arial, Brushes.BlueViolet, 10, 40);
			size = m_PaintBuffer.MeasureString("Test", arial);
			m_PaintBuffer.DrawString(size.Width.ToString(), arial, Brushes.Blue, size.Width + 10, 40);
#endif
		}

		private Image m_PaintImage;

		private Graphics m_PaintBuffer;


		protected override void OnPaint(PaintEventArgs e)
		{
			base.OnPaint(e);
			// PaintIntoBackground();
			e.Graphics.DrawImage(m_PaintImage, e.ClipRectangle, e.ClipRectangle, GraphicsUnit.Pixel); // DrawImageUnscaledAndClipped(m_PaintImage., e.ClipRectangle);


		}

		public void PrintToGraphicDevice(Graphics graphics, PrintPageEventArgs e )
		{
			Rectangle printRect = new Rectangle(
				e.MarginBounds.Top, e.MarginBounds.Left ,
				Math.Min(m_PaintImage.Width, e.MarginBounds.Right - e.MarginBounds.Left),
				Math.Min(m_PaintImage.Height, e.MarginBounds.Bottom - e.MarginBounds.Top)
				);
			
			graphics.DrawImage(m_PaintImage, printRect, new Rectangle(0, 0, m_PaintImage.Width, m_PaintImage.Height), GraphicsUnit.Pixel);
		}

		private void ResizeByCellSize()
		{
			this.Height = /*(m_Rows * ( m_SeperatorWidth / 2)) +*/ (m_Rows * m_CellHeight);
			this.Width = (m_Columns * (m_SeperatorWidth / 2)) + (m_Columns * m_CellWidth);

		} 

		private Point m_SelectedCellPosition = new Point(0,0);

		/// <summary>
		/// Gets or sets the SelectedCellPosition.
		/// </summary>
		public Point SelectedCellPosition
		{
			get { return m_SelectedCellPosition; }
			set { RepaintSingleCell(m_SelectedCellPosition); m_SelectedCellPosition = value; RepaintSingleCell(m_SelectedCellPosition); }
		}

		#region Highlight Properties and methods
		private void UpdateHighlightPen()
		{
			m_HighlightPen = new Pen(m_HighlightColor, m_HighlightWidth);
			
		}

		private Pen m_HighlightPen = Pens.OldLace;

		private Color m_HighlightColor = Color.OldLace;

		/// <summary>
		/// Gets or sets the HighlightColor.
		/// </summary>
		public Color HighlightColor
		{
			get { return m_HighlightColor; }
			set { m_HighlightColor = value; UpdateHighlightPen(); PaintIntoBackground();  this.Invalidate(); }
		}

		private int m_HighlightWidth = 2;

		/// <summary>
		/// Gets or sets the HighlightWidth.
		/// </summary>
		public int HighlightWidth
		{
			get { return m_HighlightWidth; }
			set { m_HighlightWidth = value; UpdateHighlightPen(); PaintIntoBackground(); this.Invalidate(); }
		}
		#endregion

		private int m_SeperatorWidth = 1;

		/// <summary>
		/// Gets or sets the SeperatorWidth.
		/// </summary>
		public int SeperatorWidth
		{
			get { return m_SeperatorWidth; }
			set { m_SeperatorWidth = value; UpdateSeperatorPen(); ResizeByCellSize(); PaintIntoBackground();  this.Invalidate(); }
		}

		private int m_CellWidth = 5;

		/// <summary>
		/// Gets or sets the CellWidth.
		/// </summary>
		public int CellWidth
		{
			get { return m_CellWidth; }
			set { m_CellWidth = value; ResizeByCellSize(); PaintIntoBackground(); this.Invalidate(); }
		}

		private int m_CellHeight = 10;

		/// <summary>
		/// Gets or sets the CellHeight.
		/// </summary>
		public int CellHeight
		{
			get { return m_CellHeight; }
			set { m_CellHeight = value; ResizeByCellSize(); PaintIntoBackground(); this.Invalidate(); }
		}

		private int m_Columns = 60;

		/// <summary>
		/// Gets or sets the Columns.
		/// </summary>
		public int Columns 
		{
			get { return m_Columns; }
			set { m_Columns = value; ResizeCellRows(); ResizeByCellSize(); PaintIntoBackground(); this.Invalidate(); }
		}

		private int m_Rows = 20;

		/// <summary>
		/// Gets or sets the Rows.
		/// </summary>
		public int Rows
		{
			get { return m_Rows; }
			set { m_Rows = value; ResizeCellRows(); ResizeByCellSize(); PaintIntoBackground();  this.Invalidate(); }
		}


		private Color m_SeperatorColor = Color.DarkGray;

		/// <summary>
		/// Gets or sets the SeperatorColor.
		/// </summary>
		public Color SeperatorColor
		{
			get { return m_SeperatorColor; }
			set { m_SeperatorColor = value; UpdateSeperatorPen(); this.Invalidate(); }
		}

		private Pen m_SeperatorPen;

		private void UpdateSeperatorPen()
		{
			m_SeperatorPen = new Pen(m_SeperatorColor, m_SeperatorWidth);
		}

		private void RepaintSingleCell(Point cellpos)
		{
			if ( m_DontRepaint )
				return;

			if (cellpos.X < 0 || cellpos.Y < 0 || cellpos.Y >= CellRows.Count || cellpos.X >= CellRows[0].Count)
				return;

			
			
			/* int max_x = cellpos.X + 1;
			int max_y = cellpos.Y + 1;
			for (cellpos.X--; cellpos.X < max_x; cellpos.X++)
			{
				for (cellpos.Y--; cellpos.Y < max_y; cellpos.Y++)
				{
					if (cellpos.Y < 0 || cellpos.X < 0)
						continue;
			 */
		
					CellInfo ci = CellRows[cellpos.Y][cellpos.X];
					//m_PaintBuffer.FillRectangle(new SolidBrush(this.BackColor), cellpos.X * m_CellWidth, cellpos.Y * m_CellHeight, m_CellWidth, m_CellHeight);
					m_PaintBuffer.FillRectangle(this.Colors.SolidBrushes[ci.BackColor], cellpos.X * m_CellWidth, cellpos.Y * m_CellHeight, m_CellWidth, m_CellHeight);
					if (CellRows[cellpos.Y][cellpos.X].Character != ' ')
					{
						FontStyle styles = new FontStyle();
						if (ci.Bold)
							styles |= FontStyle.Bold;
						if (ci.Underlined)
							styles |= FontStyle.Underline;
						Font font = new Font(this.Font, styles);
						m_PaintBuffer.DrawString(ci.Character.ToString(), font,this.Colors.SolidBrushes[ci.ForeColor], cellpos.X * m_CellWidth, cellpos.Y * m_CellHeight);

					}
					m_PaintBuffer.DrawLine(m_SeperatorPen, cellpos.X * m_CellWidth, (1 + cellpos.Y) * m_CellHeight, (1 + cellpos.X) * m_CellWidth, (1 + cellpos.Y) * m_CellHeight);
					m_PaintBuffer.DrawLine(m_SeperatorPen, (1 + cellpos.X) * m_CellWidth, (cellpos.Y) * m_CellHeight, (1 + cellpos.X) * m_CellWidth, (1 + cellpos.Y) * m_CellHeight);
					m_PaintBuffer.DrawLine(m_SeperatorPen, (cellpos.X) * m_CellWidth, (cellpos.Y) * m_CellHeight, (1 + cellpos.X) * m_CellWidth, (cellpos.Y) * m_CellHeight);
					m_PaintBuffer.DrawLine(m_SeperatorPen, (cellpos.X) * m_CellWidth, (cellpos.Y) * m_CellHeight, (cellpos.X) * m_CellWidth, (1 + cellpos.Y) * m_CellHeight);
					if (m_SelectedCellPosition.X == cellpos.X && m_SelectedCellPosition.Y == cellpos.Y)
					{
						m_PaintBuffer.DrawRectangle(m_HighlightPen, 1 + (m_SelectedCellPosition.X * (m_CellWidth + (m_SeperatorWidth / 2))), 1 + ( m_SelectedCellPosition.Y * (m_CellHeight + (m_SeperatorWidth / 2)) ),
										 m_CellWidth - 2, m_CellHeight - 2);
					}
			//	}
			//}
			int xpos = (cellpos.X * m_CellWidth) - 5;
			int ypos = (cellpos.Y * m_CellHeight) - 5;
			if ( xpos < 0 ) 
				xpos = 0;
			if ( ypos < 0 )
				ypos = 0;
			this.Invalidate(new Rectangle(new Point(xpos, ypos), new Size(m_CellWidth + 5, m_CellHeight + 5)));
		}

		private void PaintIntoBackground()
		{
			if ( m_DontRepaint )
				return;
			//m_PaintBuffer.FillRectangle(new SolidBrush(this.BackColor), 0, 0, this.Width, this.Height);

			Font boldfont = new Font(this.Font, FontStyle.Bold);
			Font underlinedfont = new Font(this.Font, FontStyle.Underline);
			Font bold_underlined_font = new Font(this.Font, FontStyle.Underline | FontStyle.Bold);

			CellInfo ci;
			for (int row = 0; row < m_Rows; row++)
			{
				for (int col = 0; col < m_Columns; col++)
				{
					ci = CellRows[row][col];
					m_PaintBuffer.FillRectangle(this.Colors.SolidBrushes[ci.BackColor], col * m_CellWidth, row * m_CellHeight, m_CellWidth, m_CellHeight);
					if (CellRows[row][col].Character != ' ')
					{
						Font font;
						if (ci.Bold && ci.Underlined)
							font = bold_underlined_font;
						else if (ci.Bold)
							font = boldfont;
						else if (ci.Underlined)
							font = underlinedfont;
						else
							font = this.Font;
						m_PaintBuffer.DrawString(ci.Character.ToString(), font, this.Colors.SolidBrushes[ci.ForeColor], col * m_CellWidth, row * m_CellHeight);

					}
				}
			}
			for (int i = 0; i < m_Rows; i++)
			{
				int ypos = (m_SeperatorWidth / 2) + i * m_CellHeight;
				m_PaintBuffer.DrawLine(m_SeperatorPen, 0, ypos, this.Width, ypos);

			}
			for (int i = 0; i < m_Columns; i++)
			{
				int xpos = (m_SeperatorWidth / 2) + i * m_CellWidth;
				m_PaintBuffer.DrawLine(m_SeperatorPen, xpos, 0, xpos, this.Height);

			}

			m_PaintBuffer.DrawRectangle(m_HighlightPen, m_SelectedCellPosition.X * (m_CellWidth + (m_SeperatorWidth / 2)), m_SelectedCellPosition.Y * (m_CellHeight + (m_SeperatorWidth / 2)),
				 m_CellWidth, m_CellHeight);

			
#if false
			// test
			Font consolas = new Font("Consolas", 18, GraphicsUnit.Pixel);
			m_PaintBuffer.DrawString("Test", consolas, Brushes.BlueViolet, 10, 0);
			SizeF size = m_PaintBuffer.MeasureString("Test", consolas);
			m_PaintBuffer.DrawString(size.Width.ToString(), consolas, Brushes.Blue, size.Width + 10, 0);
			m_PaintBuffer.DrawLine(new Pen(Brushes.AliceBlue), new Point(0, consolas.Height), new Point(this.Width, consolas.Height));
			// test
			Font arial = new Font("Arial", 10, GraphicsUnit.Pixel);
			
			m_PaintBuffer.DrawString("Test", arial, Brushes.BlueViolet, 10, consolas.Height);
			size = m_PaintBuffer.MeasureString("Test", arial);
			m_PaintBuffer.DrawString(size.Width.ToString(), arial, Brushes.Blue, size.Width + 10, consolas.Height);
			m_PaintBuffer.DrawLine(new Pen(Brushes.Peru), new Point(0, consolas.Height + arial.Height), new Point(this.Width, consolas.Height + arial.Height));
#endif
		}

		private void PaintCanvas_SizeChanged(object sender, EventArgs e)
		{
			m_PaintImage = new Bitmap(this.Width, this.Height, System.Drawing.Imaging.PixelFormat.Format16bppRgb565); //.Format32bppRgb);
			m_PaintBuffer = Graphics.FromImage(m_PaintImage);
			PaintIntoBackground();
		}

		public enum PaintModes
		{
			PaintBrush,
			Fill,
			Bold,
			Underline,
			RemoveFormatting
		};

		private PaintModes m_PaintMode;

		/// <summary>
		/// Gets or sets the PaintMode.
		/// </summary>
		public PaintModes PaintMode
		{
			get { return m_PaintMode; }
			set { m_PaintMode = value; }
		}

		private void PaintCanvas_MouseDown(object sender, MouseEventArgs e)
		{
			if (CurrentAction is KeypressAction)
			{
				CurrentAction = null;
			}

			if (CurrentAction == null)
			{
				if ( m_PaintMode == PaintModes.PaintBrush || m_PaintMode == PaintModes.Fill )
					CurrentAction = new PaintAction();
			}
			SelectAppropriateCell(e.X, e.Y);
			if (m_PaintMode == PaintModes.PaintBrush || m_PaintMode == PaintModes.Fill)
				PaintCellByMouseArgs(this.m_SelectedCellPosition, e);
			else if (m_PaintMode == PaintModes.Bold)
			{
				BoldSelectedCell();
			}
			else if (m_PaintMode == PaintModes.Underline)
			{
				UnderlineSelectedCell();
			}
			else if (m_PaintMode == PaintModes.RemoveFormatting)
			{
				RemoveFormattingSelectedCell();
			}
		}

		private void RemoveFormattingSelectedCell()
		{
			SelectedCell.Underlined = false;
			SelectedCell.Bold = false;
			RepaintSingleCell(SelectedCellPosition);
		}

		public void UnderlineSelectedCell()
		{
			SelectedCell.Underlined = true;
			RepaintSingleCell(SelectedCellPosition);
		}

		public void BoldSelectedCell()
		{
			SelectedCell.Bold = true; //  (SelectedCell.Bold ? false : true); 
			RepaintSingleCell(SelectedCellPosition);
		}

		private void StartFillCell( Point point, byte origcolor, byte color, bool foreground)
		{
			if (CurrentAction is PaintAction)
			{
				//CurrentAction = new PaintAction();
				((PaintAction)CurrentAction).IsForeground = foreground;
				((PaintAction)CurrentAction).NewPaintColor = color;
				((PaintAction)CurrentAction).OldPaintColor = origcolor;
			}
			FillCell(  point,  origcolor,  color,  foreground);
			if (CurrentAction is PaintAction)
			{
				AddUndoAction(CurrentAction);
				CurrentAction = null;
			}
		}

		private void PaintCellByMouseArgs(Point point, MouseEventArgs e)
		{


			switch (e.Button)
			{
				case MouseButtons.Left:
					if ( m_PaintMode == PaintModes.Fill )
					{
						if ( m_LeftMouseIsForeground )
							StartFillCell(point, CellRows[point.Y][point.X].ForeColor, m_LeftMouseColor, m_LeftMouseIsForeground);
						else
							StartFillCell(point, CellRows[point.Y][point.X].BackColor, m_LeftMouseColor, m_LeftMouseIsForeground);
						this.Invalidate();
					}
					else
						PaintCell(point, m_LeftMouseColor, m_LeftMouseIsForeground);
					if (m_LeftMouseIsForeground)
						this.MostRecentForegroundColor = m_LeftMouseColor;
					break;
				case MouseButtons.Right:
					if (m_PaintMode == PaintModes.Fill)
					{
						if (m_RightMouseIsForeground)
							StartFillCell(point, CellRows[point.Y][point.X].ForeColor, m_RightMouseColor, m_RightMouseIsForeground);
						else
							StartFillCell(point, CellRows[point.Y][point.X].BackColor, m_RightMouseColor, m_RightMouseIsForeground);
						this.Invalidate();
					}
					else
						PaintCell(point, m_RightMouseColor, m_RightMouseIsForeground);
					if (m_RightMouseIsForeground)
						this.MostRecentForegroundColor = m_RightMouseColor;
					break;
				case MouseButtons.Middle:
					if (m_PaintMode == PaintModes.Fill)
					{
						if (m_MiddleMouseIsForeground)
							StartFillCell(point, CellRows[point.Y][point.X].ForeColor, m_MiddleMouseColor, m_MiddleMouseIsForeground);
						else
							StartFillCell(point, CellRows[point.Y][point.X].BackColor, m_MiddleMouseColor, m_MiddleMouseIsForeground);
						this.Invalidate();
					}
					else
						PaintCell(point, m_MiddleMouseColor, m_MiddleMouseIsForeground);
					if (m_MiddleMouseIsForeground)
						this.MostRecentForegroundColor = m_MiddleMouseColor;
					break;
				default:
					break;
			}
		}

		private bool m_DontRepaint = false;

		/// <summary>
		/// Gets or sets the DontRepaint = false.
		/// </summary>
		public bool DontRepaint 
		{
			get { return m_DontRepaint; }
			set { m_DontRepaint = value; }
		}

		private void FillCell(Point point, byte origcolor, byte color, bool foreground)
		{

			Point curpoint = new Point();
			if (foreground)
			{
				if (CellRows[point.Y][point.X].ForeColor == color)
					return;
				CellRows[point.Y][point.X].ForeColor = color;
			}
			else
			{
				if (CellRows[point.Y][point.X].BackColor == color)
					return;
				CellRows[point.Y][point.X].BackColor = color;
			}



			if (CurrentAction is PaintAction)
			{
				((PaintAction)CurrentAction).PaintedPoints.Add(point);
			}
		

			RepaintSingleCell(point);
			

			if (point.Y - 1 >= 0) // up
			{
				curpoint.Y = point.Y - 1;
				curpoint.X = point.X;
				if (foreground)
				{
					if (CellRows[curpoint.Y][curpoint.X].ForeColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
				}
				else
					if (CellRows[curpoint.Y][curpoint.X].BackColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
			}
			if ( point.X + 1 < m_Columns ) // right
			{
				curpoint.Y = point.Y;
				curpoint.X = point.X + 1;
				if (foreground)
				{
					if (CellRows[curpoint.Y][curpoint.X].ForeColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
				}
				else
					if (CellRows[curpoint.Y][curpoint.X].BackColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
			}

			if (point.X - 1 >= 0) // left
			{
				curpoint.Y = point.Y;
				curpoint.X = point.X - 1;
				if (foreground)
				{
					if (CellRows[curpoint.Y][curpoint.X].ForeColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
				}
				else
					if (CellRows[curpoint.Y][curpoint.X].BackColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
			}
			if (point.Y + 1 < m_Rows)	// down
			{
				curpoint.Y = point.Y + 1;
				curpoint.X = point.X;
				if (foreground)
				{
					if (CellRows[curpoint.Y][curpoint.X].ForeColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
				}
				else
					if (CellRows[curpoint.Y][curpoint.X].BackColor == origcolor)
						FillCell(curpoint, origcolor, color, foreground);
			}

			if ( m_Modified == false )
				Modified = true;


		}

		private void PaintCell(Point point, byte color, bool foreground)
		{
			if (CurrentAction is PaintAction)
			{
				PaintAction act = (PaintAction)CurrentAction;
				act.IsForeground = foreground;
				act.NewPaintColor = color;
				if (foreground)
					act.OldPaintColor = CellRows[point.Y][point.X].ForeColor;
				else
					act.OldPaintColor = CellRows[point.Y][point.X].BackColor;
				act.PaintedPoints.Add(new Point(point.X, point.Y));
			}


			if ( foreground )
				CellRows[point.Y][point.X].ForeColor = color;
			else
				CellRows[point.Y][point.X].BackColor = color;
			RepaintSingleCell(point);
	
			if (m_Modified == false)
				Modified = true;


		}

		private void PaintCanvas_MouseMove(object sender, MouseEventArgs e)
		{
			if (e.Button != MouseButtons.None )
			{
				Point newpos = FindCellCoords(e.X, e.Y);
				if ( newpos.X != SelectedCellPosition.X || newpos.Y != SelectedCellPosition.Y)
				{
					SelectAppropriateCell(e.X, e.Y);
					if (m_PaintMode == PaintModes.Bold)
					{
						BoldSelectedCell();
						RepaintSingleCell(newpos);
					}
					else if (m_PaintMode == PaintModes.Underline)
					{
						UnderlineSelectedCell();
						RepaintSingleCell(newpos);
					}
					else if (m_PaintMode == PaintModes.RemoveFormatting)
					{
						RemoveFormattingSelectedCell();
						RepaintSingleCell(newpos);
					}
					else if (CurrentAction is PaintAction)			
					{
						if (!((PaintAction)CurrentAction).PointExists(m_SelectedCellPosition))
							PaintCellByMouseArgs(this.m_SelectedCellPosition, e);
					}
				}
			}

		}

		private Point FindCellCoords(int x, int y)
		{
			// Find the cell we need to highlight.
			int xpos = x / this.m_CellWidth;
			int ypos = y / this.m_CellHeight;
			if (xpos < 0)
				xpos = 0;
			if (ypos < 0)
				ypos = 0;
			if (ypos >= CellRows.Count)
				ypos = CellRows.Count - 1;
			if (xpos >= CellRows[ypos].Count)
				xpos = CellRows[ypos].Count - 1;
			return new Point(xpos, ypos);
		}

		private void SelectAppropriateCell(int x, int y)
		{
			Point oldpos = m_SelectedCellPosition;

			SelectedCellPosition = FindCellCoords(x, y);
			
			RepaintSingleCell(oldpos); 
			RepaintSingleCell(m_SelectedCellPosition); 
		} 

		private ColorPalette m_Colors = new ColorPalette(); 

		/// <summary> 
		/// Gets or sets the Colors.
		/// </summary>
		public ColorPalette Colors
		{
			get { return m_Colors; }
			set { m_Colors = value; this.Invalidate(); }
		}

		public List<List<CellInfo>> CellRows;
		 
		private byte m_LeftMouseColor = 0;

		/// <summary>
		/// Gets or sets the LeftMouseColor .
		/// </summary>
		public byte LeftMouseColor 
		{
			get { return m_LeftMouseColor ; }
			set { m_LeftMouseColor  = value; }
		}

		private byte m_MiddleMouseColor = 4;

		/// <summary>
		/// Gets or sets the MiddleMouseColor.
		/// </summary>
		public byte MiddleMouseColor
		{
			get { return m_MiddleMouseColor; }
			set { m_MiddleMouseColor = value; }
		}

		private byte m_RightMouseColor = 1;

		/// <summary>
		/// Gets or sets the RightMouseColor.
		/// </summary>
		public byte RightMouseColor
		{
			get { return m_RightMouseColor; }
			set { m_RightMouseColor = value; }
		}
		 
		private bool m_LeftMouseIsForeground = true;

		/// <summary>
		/// Gets or sets the LeftMouseIsForeground.
		/// </summary>
		public bool LeftMouseIsForeground
		{
			get { return m_LeftMouseIsForeground; }
			set { m_LeftMouseIsForeground = value; }
		} 

		private bool m_MiddleMouseIsForeground = false;

		/// <summary>
		/// Gets or sets the MiddleMouseIsForeground.
		/// </summary>
		public bool MiddleMouseIsForeground
		{
			get { return m_MiddleMouseIsForeground; }
			set { m_MiddleMouseIsForeground = value; }
		} 

		private bool m_RightMouseIsForeground = false;

		/// <summary>
		/// Gets or sets the RightMouseIsForeground.
		/// </summary>
		public bool RightMouseIsForeground
		{
			get { return m_RightMouseIsForeground; }
			set { m_RightMouseIsForeground = value; }
		}

		public CellInfo SelectedCell
		{
			get { return CellRows[m_SelectedCellPosition.Y][m_SelectedCellPosition.X]; }
		}
	

		private void PaintCanvas_KeyPress(object sender, KeyPressEventArgs e)
		{
			e.Handled = true;
			Point oldpos = m_SelectedCellPosition;
			if (!char.IsControl((char)e.KeyChar) ) // && e.KeyChar != (char)Keys.Up && e.KeyChar != (char)Keys.Down && e.KeyChar != (char)Keys.Left && e.KeyChar != (char)Keys.Right && e.KeyChar != (char)Keys.Return)
			{
				AddCharacterChangeToKeypressAction(m_SelectedCellPosition.X, m_SelectedCellPosition.Y, SelectedCell.Character, (char)e.KeyChar);
				SelectedCell.Character = (char)e.KeyChar;
				SelectedCell.ForeColor = m_MostRecentForegroundColor;

				if (m_SelectedCellPosition.X + 1 < m_Columns)
					m_SelectedCellPosition.X++;
				else
				{
					m_SelectedCellPosition.X = 0;
					m_SelectedCellPosition.Y++;
				}
				RepaintSingleCell(oldpos);
				RepaintSingleCell(m_SelectedCellPosition);

			}
			
		}


		private int ParseChar(char c)
		{
			return (int)(c - 0x30);
		}

		private const char ColorControl = '\x0003';
		private const char UnderlineControl = '\x001F';
		private const char BoldControl = '\x0002';
		private const char PlainControl = '\x000F';
		private const char ReverseControl = '\x0016';

		internal void LoadStream(System.IO.Stream stream)
		{

			StreamReader reader = new StreamReader(stream);

			CellRows.Clear();
			CellRows = new List<List<CellInfo>>();


			//int col = 0;
			int row = 0;
			while(reader.Peek() >= 0 )
			{
				int bc = 100;
				int fc = 100;
				CellRows.Add(new List<CellInfo>());
				string strline = reader.ReadLine();
				char[] str = strline.ToCharArray();
				bool bold = false;
				bool underlined = false;
				for(int i = 0; i < str.Length; i++)
				{
					
					if (IsControlCode(str[i]))
					{
						if (str[i] == BoldControl)
						{
							bold = (bold ? false : true);
							continue;
						}
						else if (str[i] == UnderlineControl)
						{
							underlined = (underlined ? false : true);
							continue;
						}
						else if (str[i] == ReverseControl)
						{
							continue;
						}
						else if (str[i] == PlainControl)
						{
							bold = false;
							underlined = false;
							continue;
						}
						else if (str[i] == ColorControl)
						{
							//bc = 100;
							fc = 100;


							if (i + 1 == str.Length)
								break;
							i++;

							if (Char.IsDigit(str[i]))
							{
								// forecolor += str[i];
								fc = ParseChar(str[i]);

								if (i + 1 == str.Length)
									break;
								i++;
								if (Char.IsDigit(str[i]))
								{
									fc = ((fc * 10)) + ParseChar(str[i]);

									if (i + 1 == str.Length)
										break;
									i++;

								}

							}

							if (fc > 15 && fc != 100)
								fc = 0;

							if (str[i] == ',')
							{
								if (++i == str.Length)
									break;

								if (Char.IsDigit(str[i]))
								{
									bc = ParseChar(str[i]);
									if (++i == str.Length)
										break;

									if (Char.IsDigit(str[i]))
									{
										bc = (bc * 10) + ParseChar(str[i]);
										if (++i == str.Length)
											break;
									}
								}
							}

							if (bc > 15 && bc != 100)
								bc = 1;


							/*for (; i < str.Length && IsControlCode(str[i]); i++)
							{
							}
							 */

						}
					}
					CellInfo ci = new CellInfo();
					ci.Character = str[i];
					if (fc != 100)
						ci.ForeColor = (byte)fc;
					if (bc != 100)
						ci.BackColor = (byte)bc;
					ci.Bold = bold;
					ci.Underlined = underlined;
					CellRows[row].Add(ci);


				}
				row++;
				
			}


			// find longest row.
			int longest = 0;
			foreach (List<CellInfo> cellrow in CellRows)
			{
				if (cellrow.Count > longest)
					longest = cellrow.Count;
			}
			this.m_Columns = longest;
			this.m_Rows = CellRows.Count;
			ResizeCellRows(); 
			ResizeByCellSize(); 
			PaintIntoBackground();
		}

		private bool IsControlCode(char c)
		{
			return
				c == '\x0003' ||
				c == '\x001F' ||
				c == '\x0002' ||
				c == '\x000F' ||
				c == '\x0016';
		}

		private void PaintCanvas_Load(object sender, EventArgs e)
		{
			this.Font = new Font(Program.Settings.PaintFontName, Program.Settings.PaintFontSize);
			this.CellHeight = Program.Settings.CellHeight;
			this.CellWidth = Program.Settings.CellWidth;
			this.HighlightColor = Program.Settings.HighlightColor;
			this.LeftMouseColor = Program.Settings.LMBColor;
			this.LeftMouseIsForeground = Program.Settings.LMBIsForeground;
			
			this.RightMouseColor = Program.Settings.RMBColor;
			this.RightMouseIsForeground = Program.Settings.RMBIsForeground;
			this.MiddleMouseColor = Program.Settings.MMBColor;
			this.MiddleMouseIsForeground = Program.Settings.MMBIsForeground;
			this.SeperatorColor = Program.Settings.SeperatorColor;
			this.HighlightColor = Program.Settings.HighlightColor;

			if (this.RightMouseIsForeground)
				this.MostRecentForegroundColor = this.RightMouseColor;
			if (this.MiddleMouseIsForeground)
				this.MostRecentForegroundColor = this.MiddleMouseColor;
			if (this.LeftMouseIsForeground)
				this.MostRecentForegroundColor = this.LeftMouseColor;
			
		}

		private byte m_MostRecentForegroundColor = 0;

		/// <summary>
		/// Gets or sets the MostRecentForegroundColor.
		/// </summary>
		public byte MostRecentForegroundColor
		{
			get { return m_MostRecentForegroundColor; }
			set { m_MostRecentForegroundColor = value; }
		}

		private void PaintCanvas_KeyDown(object sender, KeyEventArgs e)
		{
			
		}

		public void ImportImage(string filename)
		{
			Bitmap bmp = new Bitmap(filename);

			this.Columns = bmp.Width * 2;
			this.Rows = bmp.Height;
			for (int y = 0; y < bmp.Height; y++)
			{
				for (int x = 0; x < bmp.Width * 2; x++)
				{
					byte newcolor = this.Colors.FindClosestColor(bmp.GetPixel(x/2, y));
					this.CellRows[y][x++].BackColor = newcolor;
					this.CellRows[y][x].BackColor = newcolor;
				}
			}
			this.PaintIntoBackground();
			this.Invalidate();
		}

		private void PaintCanvas_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
		{
			//e.Handled = true;
			bool repaint = false;
			Point oldpos = m_SelectedCellPosition;

			if (e.KeyCode == Keys.Up)
			{
				if (m_SelectedCellPosition.Y > 0)
				{
					m_SelectedCellPosition.Y--;
				}
				repaint = true;
			}
			else if (e.KeyCode == Keys.Right)
			{
				if (m_SelectedCellPosition.X < CellRows[0].Count)
					m_SelectedCellPosition.X++;
				repaint = true;
			}
			else if (e.KeyCode == Keys.Down)
			{
				if (m_SelectedCellPosition.Y < CellRows.Count)
					m_SelectedCellPosition.Y++;
				repaint = true;
			}
			else if (e.KeyCode == Keys.Left)
			{
				if (m_SelectedCellPosition.X > 0)
					m_SelectedCellPosition.X--;
				repaint = true;
			}
			else if (e.KeyCode == Keys.Return)
			{
				if (m_SelectedCellPosition.Y < CellRows.Count)
					m_SelectedCellPosition.Y++;
				m_SelectedCellPosition.X = 0;
				repaint = true;
			}
			else if (e.KeyCode == Keys.Back)
			{
				if (m_SelectedCellPosition.X > 0)
					m_SelectedCellPosition.X--;
				AddCharacterChangeToKeypressAction(m_SelectedCellPosition.X, m_SelectedCellPosition.Y, SelectedCell.Character, ' ');
				SelectedCell.Character = ' ';
				
				repaint = true;
			}
			else if (e.KeyCode == Keys.Delete)
			{
				AddCharacterChangeToKeypressAction(m_SelectedCellPosition.X, m_SelectedCellPosition.Y, SelectedCell.Character, ' ');
				SelectedCell.Character = ' ';
				repaint = true;
			}

			if (repaint)
			{
				RepaintSingleCell(oldpos);
				RepaintSingleCell(m_SelectedCellPosition);
			}
		}

		public void AddCharacterChangeToKeypressAction(int x, int y, char origchar, char newchar)
		{
			if (CurrentAction == null)
			{
				CurrentAction = new KeypressAction();
				AddUndoAction(CurrentAction);
			}

			if (CurrentAction is KeypressAction)
			{
				((KeypressAction)CurrentAction).AddCharacter(x, y, origchar, newchar);
			}
		}

		public class UndoChangedEventArgs : EventArgs
		{
			public static readonly new UndoChangedEventArgs Empty = new UndoChangedEventArgs();
		}

		public event EventHandler<UndoChangedEventArgs> UndoChanged;

		protected virtual void OnUndoChanged(UndoChangedEventArgs e)
		{
			EventHandler<UndoChangedEventArgs> handler = UndoChanged;
			if (handler != null)
			{
				handler(this, e);
			}
		}

		public class RedoChangedEventArgs : EventArgs
		{
			public static readonly new RedoChangedEventArgs Empty = new RedoChangedEventArgs();
		}

		public event EventHandler<RedoChangedEventArgs> RedoChanged;

		protected virtual void OnRedoChanged(RedoChangedEventArgs e)
		{
			EventHandler<RedoChangedEventArgs> handler = RedoChanged;
			if (handler != null)
			{
				handler(this, e);
			}
		}

		public void AddUndoAction(IUndoableAction action)
		{
			UndoList.Push(action);
			if (RedoList.Count > 0)
			{
				RedoList.Clear();
				OnRedoChanged(RedoChangedEventArgs.Empty);
			}
			OnUndoChanged(UndoChangedEventArgs.Empty);
		}

		public void AddRedoAction(IUndoableAction action)
		{
			RedoList.Push(action);
			OnRedoChanged(RedoChangedEventArgs.Empty);
		}

		public void Undo()
		{
			if (UndoList.Count > 0)
			{
				IUndoableAction act = UndoList.Pop();
				act.Undo(this);
				OnUndoChanged(UndoChangedEventArgs.Empty);
				RedoList.Push(act);
				OnRedoChanged(RedoChangedEventArgs.Empty);
			}
		}

		public void Redo()
		{
			if (RedoList.Count > 0)
			{
				IUndoableAction act = RedoList.Pop();
				act.Redo(this);
				OnRedoChanged(RedoChangedEventArgs.Empty);
				//UndoList.Clear();
				UndoList.Push(act);
				OnUndoChanged(UndoChangedEventArgs.Empty);
			}
		}

		private void PaintCanvas_MouseUp(object sender, MouseEventArgs e)
		{
			if (CurrentAction is PaintAction)
			{
				AddUndoAction(CurrentAction);
				CurrentAction = null;
				
			}
		}

		public void RepaintAll()
		{
			this.PaintIntoBackground();
			this.Invalidate();
		}
	}
}