ImageBox Control with Zoom/Pan Capability

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace Application
{
	/// <summary>
	/// Image Viewer
	/// 
	/// This application displays image files.  
	/// 
	/// This biggest trick involved
	/// with this is the creation of a zero sized text box that is used to
	/// capture keystrokes.  It may be possible to set the focus always to
	/// the form, but this was not tried.  The form is configured so that the
	/// only control able to receive focus is this text box.  In this way, 
	/// keystrokes can be captured within the key down event.
	/// 

	public partial class ImageViewer : Form
	{
		// the 100% zoom values is at array index 7
		private const int FullZoomIndex = 7;

		private int originalImageHeight;
		private int originalImageWidth;
		private int zoomIndex;
		private int hScrollIncrement;
		private int vScrollIncrement;
		private int hScrollPosition;
		private int vScrollPosition;
		private int hCenter;
		private int vCenter;
		private Point imageCenter;
		private string imageFile;

		// define the available zoom levels
		private double[] zoomFactor = { 0.10, 0.15, 0.20, 0.25, 0.33, 0.50, 0.75, 1.00, 1.25, 1.50 };

		// this method seemed to work best when telling the panel to scroll.
		[DllImport("user32.dll")]
		static extern int SendMessage(IntPtr hWnd, int wMsg, int wParam, int lParam);

		public ImageViewer()
		{
			InitializeComponent();
		}

		public ImageViewer(string fileName)
		{
			InitializeComponent();

			// strip out the name of the file for display in the window title.
			string[] s = fileName.Split(new char[] { '\\', '.' });
			imageFile = s[s.Length - 2];

			// Hook into the focus event of the text box used to
			// capture kestrokes.
			KeystrokeCaptureTextBox.GotFocus += new EventHandler(KeystrokeCaptureTextBox_GotFocus);

			// Load the image file
			ImagePictureBox.Load(fileName);

			// save the original size of the image.  These values are used to 
			// calculate the zoomed image size.
			originalImageHeight = ImagePictureBox.Image.Height - 1;
			originalImageWidth = ImagePictureBox.Image.Width - 1;

			// initialize the horizontal and vertical scroll position values.
			hScrollPosition = 0;
			vScrollPosition = 0;

			// set the scroll increment.  In this case 1% of the original image size.
			hScrollIncrement = ImagePictureBox.Image.Width / 100;
			vScrollIncrement = ImagePictureBox.Image.Height / 100;
			ScrollPanel.HorizontalScroll.SmallChange = hScrollIncrement;
			ScrollPanel.VerticalScroll.SmallChange = vScrollIncrement;

			// set the size of the picture box.  Initially this will be at 100% zoom
			ImagePictureBox.Width = originalImageWidth;
			ImagePictureBox.Height = originalImageHeight;

			// calculate the image center.  This is used during the zoom processes.
			// In the case of this code, these values could be constant.  But, in
			// the interest of flexibility, they are calculated.
			imageCenter = CalculateImageCenter();

			// set the initial zoom to 100%
			zoomIndex = FullZoomIndex;

			// set the title text of the image display form.
			SetWindowTitle();
		}

		private Point CalculateImageCenter()
		{
			int x, y;

			x = (int)(ScrollPanel.Width / 2 + 0.5);
			y = (int)(ScrollPanel.Height / 2 + 0.5);

			return new Point(x, y);
		}

		private void SetWindowTitle()
		{
			// show the file name and zoom factor in the window title.
			this.Text = imageFile + " : " + "Zoom " + (zoomFactor[zoomIndex] * 100).ToString() + "%";
		}

		#region Zoom and Scroll

		private void ScrollRight()
		{
			// Tell the panel to scroll right
			SendMessage(
				ScrollPanel.Handle, 
				WindowsMessages.WM_HSCROLL, 
				WindowsMessages.SB_LINERIGHT, 
				0);
		}

		private void ScrollLeft()
		{
			// Tell the panel to scroll left
			SendMessage(
				ScrollPanel.Handle, 
				WindowsMessages.WM_HSCROLL, 
				WindowsMessages.SB_LINELEFT, 
				0); 
		}

		private void ScrollUp()
		{
			// Tell the panel to scroll up
			SendMessage(
				ScrollPanel.Handle,
				WindowsMessages.WM_VSCROLL,
				WindowsMessages.SB_LINEUP,
				0);
		}

		private void ScrollDown()
		{
			// Tell the panel to scroll down
			SendMessage(
				ScrollPanel.Handle,
				WindowsMessages.WM_VSCROLL,
				WindowsMessages.SB_LINEDOWN,
				0);
		}

		private void Zoom(string InOut)
		{
			// The center position calculation (not scroll bar position) is as follows:
			// newCenterX = newWidth * oldCenterX / oldWidth
			// newCenterY = newHeight * oldCenterY / oldHeight
			// these values need to have the scroll panel height and width subtracted from them

			// Calculate the center of the displayed image.
			Point p = CalculateImageCenter();

			// Get the coordinates of the center of the image.  
			// This is the old position.
			int oldCenterX = hCenter;
			int oldCenterY = vCenter;

			// get the current image size.
			int oldImageWidth = ImagePictureBox.Width;
			int oldImageHeight = ImagePictureBox.Height;

			// move the the previous zoom factor, if not zoomed all the way in.
			if (InOut == "In") 
			{
				if (zoomIndex < zoomFactor.Length - 1) zoomIndex++;
			}

			// move the the previous zoom factor, if not zoomed all the way out.
			if (InOut == "Out") 
			{
				if (zoomIndex > 0) zoomIndex--;
			}

			// calculate the new image size in accordance with the zoom factor.
			int newImageWidth = (int)(originalImageWidth * zoomFactor[zoomIndex] + 0.5);
			int newImageHeight = (int)(originalImageHeight * zoomFactor[zoomIndex] + 0.5);

			// set the picture box dimensions 
			// The picture box is set to stretch the image to fit the size of the box.
			// Altering those dimensions has the effect of zooming.
			ImagePictureBox.Width = newImageWidth;
			ImagePictureBox.Height = newImageHeight;

			// calculate and save the new center position
			hCenter = (int)(newImageWidth * oldCenterX / oldImageWidth + 0.5);
			vCenter = (int)(newImageHeight * oldCenterY / oldImageHeight + 0.5);
	
			// reset the scroll position and adjust for center
			int scrollX = hCenter - p.X;
			int scrollY = vCenter - p.Y;

			// A negative scroll position generates an error.  
			// So, set it to zero if it is negative.
			if (scrollX < 0) scrollX = 0;
			if (scrollY < 0) scrollY = 0;

			hScrollPosition = scrollX;
			vScrollPosition = scrollY;

			ScrollPanel.HorizontalScroll.Value = scrollX;
			ScrollPanel.VerticalScroll.Value = scrollY;

			SetWindowTitle();

		}

		#endregion

		#region Event Handlers

		private void KeystrokeCaptureTextBox_KeyDown(object sender, KeyEventArgs e)
		{
			if (e.KeyCode == Keys.Left) ScrollLeft();
			if (e.KeyCode == Keys.Right) ScrollRight();
			if (e.KeyCode == Keys.Up) ScrollUp();
			if (e.KeyCode == Keys.Down) ScrollDown();

			if (e.KeyCode == Keys.Add) Zoom("In");
			if (e.KeyCode == Keys.Subtract) Zoom("Out");

			if (e.KeyCode == Keys.Left | e.KeyCode == Keys.Right | 
				e.KeyCode == Keys.Up | e.KeyCode == Keys.Down |
				e.KeyCode == Keys.Add | e.KeyCode == Keys.Subtract)
			{
				e.Handled = true;
			}
		}

		private void ScrollPanel_Scroll(object sender, ScrollEventArgs e)
		{
			int oldValue = e.OldValue;
			int newValue = e.NewValue;
			ScrollEventType set = e.Type;
			ScrollOrientation so = e.ScrollOrientation;

			Point p = CalculateImageCenter();

			if (e.ScrollOrientation == ScrollOrientation.HorizontalScroll)
			{
				hScrollPosition = e.NewValue;
				hCenter = e.NewValue + p.X;
			}

			if (e.ScrollOrientation == ScrollOrientation.VerticalScroll)
			{
				vScrollPosition = e.NewValue;
				vCenter = e.NewValue + p.Y;
			}
		}

		private void KeystrokeCaptureTextBox_GotFocus(object sender, EventArgs e)
		{
			ScrollPanel.HorizontalScroll.Value = hScrollPosition;
			ScrollPanel.VerticalScroll.Value = vScrollPosition;
		}

		#endregion
	}
}