Oren's Folder: Paint Application [C#]

Greetings. I wrote a Paint Application in C#, here is a summary of it:

It is a Multiple-Document Interface application - The Image forms are MdiChildren of the Main application form.
According to this, the main menu is merged with a non-visible MenuStrip on the Image form.
The various tool windows are owned by the Main application form.

The featured tools are: Select, Pencil (1px free-draw), Brush, Eraser, Rectangle, Circle, Fill and Pipette (color picker).

The different parameters for each tool are displayed in the Tool Options window.
Each tool's options are arranged on a dedicated panel on this form. When a tool is chosen, its' options panel toggles to the only visible panel.

The edited image is displayed inside a PictureBox control.
All drawing actions are done in the course of the MouseDown, MouseMove and MouseUp events of that PictureBox.
A boolean named isDragging is turned true on MouseDown event, and false on MouseUp event, thus enabling continuous drawing actions.

Selection definition, dragging and dropping is done in a similar way, based on four selection states listed in an enum.

The algorithm for the flood fill tool is taken from this tutorial.

Two image filters are available from the Image menu - Brightness and Invert, and can also be applied to selections.
Brightness also features a dialog for setting the filter level, with a small preview of its' effect.

The data for the multiple undo and redo features is stored in Stacks.

Image files can be loaded and saved in the various ImageFormats provided by .NET.

Here are a couple of screenshots:

And here is the code for the Image form:

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

namespace PaintApp
{
    public partial class ImageForm : Form
    {
        public ImageForm()
        {
            InitializeComponent();

// Subscribe to event for PrintDocument page printing.
            myPrintDocument.PrintPage += new PrintPageEventHandler(myPrintDocument_PrintPage);
        }

private string fileName = "";
        private System.Drawing.Imaging.ImageFormat fileImageFormat;

private Stack<Bitmap> undoStack = new Stack<Bitmap>();
        private Stack<Bitmap> redoStack = new Stack<Bitmap>();

// Property for getting the image fileName by the main application form. 
        public string FileName
        {
            get { return fileName; } //
        }

// Property for getting myImage Bitmap by the BrightnessDialog.
        public Bitmap MyImage
        {
            get { return myImage; }
        }

// Property for getting the selection Bitmap by the BrightnessDialog.
        public Bitmap SelectBi
        {
            get { return selectBi; }
        }

// Property for getting the selection state by the BrightnessDialog.
        // If a selection exists, the brightness preview uses it.
        public string MySelectionState
        {
            get { return mySelectionState.ToString(); }
        }

private Bitmap myImage; // the image Bitmap
        private Bitmap tempBi; // for temporary changes in the image
        private Bitmap selectBi; // the selection bitmap
        
        private bool isDragging = false; // enables continuous drawing actions
        private bool selectPaste = false; // determines whether the selection origin is a clipboard paste
        private bool selectChanged = false; // determines if any change was applied on the selection
        
        private enum SelectionState { None, Define, Selected, Drag }; // the list of states for selections
        private SelectionState mySelectionState = SelectionState.None; // the current selection state
        
        private int lastX, lastY, // last mouse position for free drawing tools
            selectionStartX, selectionStartY, // the selection origin
            eFixX, eFixY, // calculated by the FixEValues method, to avoid selecting outside image boundaries
            selectionLocationX, selectionLocationY, // current selection location (upper-left corner)
            selectionDragOffsetX, selectionDragOffsetY, // the distances between SelectionLocation and where the mouse pressed inside the selection
            selectionWidth, selectionHeight, // selection measurements
            shapeStartX, shapeStartY; // shape origin
        private Rectangle mySelection; // Rectangle of the selection location and measurements
        
        private Pen selectPen = new Pen(Brushes.Blue, 1); // Pen for selection frame
        private Pen pencilPen, brushPen, eraserPen, rectanglePen, circlePen; // draw and shape tools Pens
        private SolidBrush selectionCutBrush, rectangleFillBrush, circleFillBrush; // Brushes for filling shapes and the original location of a selection

// The classes needed for printing.
        private PrintDocument myPrintDocument = new PrintDocument();
        private PageSettings myPageSettings = new PageSettings();
        private PageSetupDialog myPageSetupDialog = new PageSetupDialog();
        private PrintPreviewDialog myPrintPreviewDialog = new PrintPreviewDialog();
        private PrintDialog myPrintDialog = new PrintDialog();
        private Rectangle myPrintArea; // the image area on the printed page

/* The three methods below are for the MouseDown, MouseMove and MouseUp events 
           of pictureBox1. All drawing is done in the course of these three events. */

private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
        {
            if (ToolsWindow.MyTool == "select") // the selection tool is different from the rest, since it has four states
            {
                if (mySelectionState == SelectionState.None) // if there is no selection, start defining a new one
                {
                    selectionStartX = e.X;
                    selectionStartY = e.Y;
                    mySelectionState = SelectionState.Define;
                }
                else if (mySelectionState == SelectionState.Selected) // if a selection exists
                {
                    if ((e.X > selectionLocationX) && 
                        (e.X < selectionLocationX + selectionWidth) && 
                        (e.Y > selectionLocationY) && 
                        (e.Y < selectionLocationY + selectionHeight)) // if mouse pressed inside the selection, start dragging it
                    {
                        selectionDragOffsetX = e.X - selectionLocationX;
                        selectionDragOffsetY = e.Y - selectionLocationY;
                        mySelectionState = SelectionState.Drag;
                    }
                    else // if mouse pressed outside the selection, drop it down
                    {
                        DropSelection();

// Immediately after dropping a selection, a new one can be defined by dragging the mouse.
                        selectionStartX = e.X;
                        selectionStartY = e.Y;
                        mySelectionState = SelectionState.Define;
                    }
                }
            }
            else // for all tools other than select
            {
                // If a selection exists, drop it down.
                if (mySelectionState == SelectionState.Selected)
                {
                    DropSelection();
                }

// Before drawing, push the current image to the undoStack.
                PushEdit();

if ((ToolsWindow.MyTool == "pencil") || 
                    (ToolsWindow.MyTool == "brush") || 
                    (ToolsWindow.MyTool == "eraser")) // these tools draw the first 'dot' on MouseDown
                {
                    Graphics g = Graphics.FromImage(myImage);
                    if (ToolsWindow.MyTool == "pencil")
                    {
                        pencilPen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), 1);
                        myImage.SetPixel(e.X, e.Y, pencilPen.Color);
                    }
                    else if (ToolsWindow.MyTool == "brush")
                    {
                        brushPen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyBrushDiameter);
                        g.FillEllipse(brushPen.Brush, e.X - brushPen.Width / 2, e.Y - brushPen.Width / 2, brushPen.Width, brushPen.Width);
                    }
                    else if (ToolsWindow.MyTool == "eraser")
                    {
                        eraserPen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyEraserDiameter);
                        g.FillRectangle(eraserPen.Brush, e.X - eraserPen.Width / 2, e.Y - eraserPen.Width / 2, eraserPen.Width, eraserPen.Width);
                    }
                    // Storing the last mouse position is required on the free drawing tools,
                    // to draw a line between that position and the new one.
                    lastX = e.X;
                    lastY = e.Y;
                }
                else if ((ToolsWindow.MyTool == "rectangle") || 
                    (ToolsWindow.MyTool == "circle")) // the shape origin is defined on MouseDown
                {
                    shapeStartX = e.X;
                    shapeStartY = e.Y;
                }
                else if ((ToolsWindow.MyTool == "fill") || 
                    (ToolsWindow.MyTool == "pipette")) // these tools complete their tasks on MouseDown
                {
                    if (ToolsWindow.MyTool == "fill")
                    {
                        Color myReplacedColor = myImage.GetPixel(e.X, e.Y);
                        if (myReplacedColor != ColorsWindow.MyBackColor)
                        {
                            if (ToolOptionsWindow.MyFillContiguous == true) // flood fill
                            {
                                FillContiguously(e.X, e.Y, myImage.GetPixel(e.X, e.Y));
                            }
                            else // fill which replaces all pixels of the pressed pixel color
                            {
                                for (int x = 0; x < myImage.Width; x++)
                                {
                                    for (int y = 0; y < myImage.Height; y++)
                                    {
                                        if (myImage.GetPixel(x, y) == myReplacedColor)
                                        {
                                            myImage.SetPixel(x, y, ColorsWindow.MyBackColor);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else if (ToolsWindow.MyTool == "pipette")
                    {
                        // Calls a method on the Main form which calls a method on its' owned ColorsWindow form.
                        ((Main)(this.MdiParent)).SetPipetteColor(myImage.GetPixel(e.X, e.Y));
                    }
                }
                pictureBox1.Image = myImage;
                isDragging = true;
            }
        }

private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
            // Update the StatusStrip on the Main form.
            ((Main)(this.MdiParent)).StatusStripUpdate(e.Location);

if (ToolsWindow.MyTool == "select")
            {
                // When a selection is defined or dragged,
                // myImage is cloned to tempBi, for the temporary changes.
                if (mySelectionState == SelectionState.Define)
                {
                    tempBi = (Bitmap)myImage.Clone();
                    Graphics tempGr = Graphics.FromImage(tempBi);
                    FixEValues(e.X, e.Y);
                    tempGr.DrawRectangle(selectPen, (int)Math.Min(selectionStartX, eFixX), (int)Math.Min(selectionStartY, eFixY), Math.Abs(eFixX - selectionStartX), Math.Abs(eFixY - selectionStartY));
                    pictureBox1.Image = tempBi;
                }
                else if (mySelectionState == SelectionState.Drag)
                {
                    selectChanged = true;
                    tempBi = (Bitmap)myImage.Clone();
                    Graphics tempGr = Graphics.FromImage(tempBi);
                    if (selectPaste == false) // if true, the original location will not be erased
                    {
                        selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                        tempGr.FillRectangle(selectionCutBrush, mySelection);
                    }
                    tempGr.DrawImage(selectBi, e.X - selectionDragOffsetX, e.Y - selectionDragOffsetY);
                    tempGr.DrawRectangle(selectPen, e.X - selectionDragOffsetX, e.Y - selectionDragOffsetY, selectionWidth - 1, selectionHeight - 1);
                    pictureBox1.Image = tempBi;
                }
            }
            else // for all tools other than select
            {
                if (isDragging)
                {
                    if ((ToolsWindow.MyTool == "pencil") || 
                        (ToolsWindow.MyTool == "brush") || 
                        (ToolsWindow.MyTool == "eraser")) // these tools draw a line between the current and last mouse positions on MouseMove
                    {
                        Graphics g = Graphics.FromImage(myImage);
                        if (ToolsWindow.MyTool == "pencil")
                            g.DrawLine(pencilPen, lastX, lastY, e.X, e.Y);
                        else if (ToolsWindow.MyTool == "brush")
                        {
                            g.DrawLine(brushPen, lastX, lastY, e.X, e.Y);
                            g.FillEllipse(brushPen.Brush, e.X - brushPen.Width / 2, e.Y - brushPen.Width / 2, brushPen.Width, brushPen.Width);
                        }
                        else if (ToolsWindow.MyTool == "eraser")
                        {
                            g.DrawLine(eraserPen, lastX, lastY, e.X, e.Y);
                            g.FillRectangle(eraserPen.Brush, e.X - eraserPen.Width / 2, e.Y - eraserPen.Width / 2, eraserPen.Width, eraserPen.Width);
                        }
                        // Storing the last mouse position is required on the free drawing tools,
                        // to draw a line between that position and the new one.
                        lastX = e.X;
                        lastY = e.Y;
                        pictureBox1.Image = myImage;
                    }
                    else if ((ToolsWindow.MyTool == "rectangle") || 
                        (ToolsWindow.MyTool == "circle")) // shapes are previewed dynamically on tempBi on MouseMove
                    {
                        tempBi = (Bitmap)myImage.Clone();
                        Graphics tempGr = Graphics.FromImage(tempBi);
                        if (ToolsWindow.MyTool == "rectangle")
                        {
                            if (ToolOptionsWindow.MyRectangleFill == true) // fill the shape if checked to do so
                            {
                                rectangleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                                tempGr.FillRectangle(rectangleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                            }
                            rectanglePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyRectangleContour);
                            tempGr.DrawRectangle(rectanglePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        else if (ToolsWindow.MyTool == "circle")
                        {
                            if (ToolOptionsWindow.MyCircleFill == true) // fill the shape if checked to do so
                            {
                                circleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                                tempGr.FillEllipse(circleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                            }
                            circlePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyCircleContour);
                            tempGr.DrawEllipse(circlePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        pictureBox1.Image = tempBi;
                    }
                    else if (ToolsWindow.MyTool == "pipette") // the pipette tool will repeat its' task on MouseMove
                    {
                        ((Main)(this.MdiParent)).SetPipetteColor(myImage.GetPixel(e.X, e.Y));
                    }
                }
            }
        }

private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
        {
            if (ToolsWindow.MyTool == "select")
            {
                if (mySelectionState == SelectionState.Define) // definition of a selection ends on MouseUp
                {
                    FixEValues(e.X, e.Y);
                    selectionWidth = Math.Abs(eFixX - selectionStartX + 1);
                    selectionHeight = Math.Abs(eFixY - selectionStartY + 1);
                    if (selectionWidth > 0 && selectionHeight > 0)
                    {
                        if (eFixX < selectionStartX)
                        {
                            selectionStartX = eFixX;
                        }
                        if (eFixY < selectionStartY)
                        {
                            selectionStartY = eFixY;
                        }
                        mySelection = new Rectangle(selectionStartX, selectionStartY, selectionWidth, selectionHeight);
                        selectionLocationX = selectionStartX;
                        selectionLocationY = selectionStartY;

selectBi = new Bitmap(selectionWidth, selectionHeight);
                        Graphics selectGr = Graphics.FromImage(selectBi);
                        selectGr.DrawImage(myImage, 0, 0, mySelection, GraphicsUnit.Pixel);

mySelectionState = SelectionState.Selected;
                        selectChanged = false;
                        selectPaste = false;
                    }
                    else // if one of the measurements equals 0, no selection is done
                    {
                        mySelectionState = SelectionState.None;
                    }
                }
                else if (mySelectionState == SelectionState.Drag) // location of a dragged selection is updated on MouseUp
                {
                    selectionLocationX = e.X - selectionDragOffsetX;
                    selectionLocationY = e.Y - selectionDragOffsetY;
                    mySelectionState = SelectionState.Selected;
                }
            }
            else // for all tools other than select
            {
                if ((ToolsWindow.MyTool == "rectangle") || 
                    (ToolsWindow.MyTool == "circle")) // shapes are finalized and drawn to myImage on MouseUp
                {
                    Graphics g = Graphics.FromImage(myImage);
                    if (ToolsWindow.MyTool == "rectangle")
                    {
                        if (ToolOptionsWindow.MyRectangleFill == true)
                        {
                            rectangleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                            g.FillRectangle(rectangleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        rectanglePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyRectangleContour);
                        g.DrawRectangle(rectanglePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                    }
                    else if (ToolsWindow.MyTool == "circle")
                    {
                        if (ToolOptionsWindow.MyCircleFill == true)
                        {
                            circleFillBrush = new SolidBrush(ColorsWindow.MyBackColor);
                            g.FillEllipse(circleFillBrush, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                        }
                        circlePen = new Pen(new SolidBrush(ColorsWindow.MyForeColor), ToolOptionsWindow.MyCircleContour);
                        g.DrawEllipse(circlePen, (int)Math.Min(shapeStartX, e.X), (int)Math.Min(shapeStartY, e.Y), Math.Abs(e.X - shapeStartX), Math.Abs(e.Y - shapeStartY));
                    }
                    pictureBox1.Image = myImage;
                }
                isDragging = false;
            }

// On MouseUp, the Edit menu items are updated accordingly.
            MonitorEditMenu();
        }

// When mouse leaves the pictureBox1, the StatusStrip on the Main form is cleared.
        private void pictureBox1_MouseLeave(object sender, EventArgs e)
        {
            ((Main)(this.MdiParent)).StatusStripReset();
        }

/* The three methods below are called in the course of the 
           MouseDown, MouseMove and MouseUp events */

// On selection definition, mouse e values are inserted to eFixX, eFixY
        // accordingly, while ensuring values are inside image bounds.
        private void FixEValues(int eX, int eY)
        {
            if (eX < 0)
            {
                eFixX = 0;
            }
            else if (eX > tempBi.Width - 1)
            {
                eFixX = tempBi.Width - 1;
            }
            else
            {
                eFixX = eX;
            }

if (eY < 0)
            {
                eFixY = 0;
            }
            else if (eY > tempBi.Height - 1)
            {
                eFixY = tempBi.Height - 1;
            }
            else
            {
                eFixY = eY;
            }
        }

// Called when a selection is dropped down.
        private void DropSelection()
        {
            if (selectChanged == true)
            {
                // Before dropping, push the current image to the undoStack.
                PushEdit();

Graphics g = Graphics.FromImage(myImage);
                if (selectPaste == false) // if true, the original location will not be erased
                {
                    selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                    g.FillRectangle(selectionCutBrush, mySelection);
                }
                g.DrawImage(selectBi, selectionLocationX, selectionLocationY);
            }
            mySelectionState = SelectionState.None; // clear selection
            pictureBox1.Image = myImage;
        }

// Called recursively by the flood fill tool. This algorithm is from:
        // http://www.academictutorials.com/graphics/graphics-flood-fill.asp
        private void FillContiguously(int myX, int myY, Color myReplacedColor)
        {
            int myY1;

myY1 = myY;
            while ((myY1 < myImage.Height) && (myImage.GetPixel(myX, myY1) == myReplacedColor))
            {
                myImage.SetPixel(myX, myY1, ColorsWindow.MyBackColor);
                myY1++;
            }

myY1 = myY - 1;
            while ((myY1 >= 0) && (myImage.GetPixel(myX, myY1) == myReplacedColor))
            {
                myImage.SetPixel(myX, myY1, ColorsWindow.MyBackColor);
                myY1--;
            }

myY1 = myY;
            while ((myY1 < myImage.Height) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX > 0) && (myImage.GetPixel(myX-1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX - 1, myY1, myReplacedColor);
                }
                myY1++;
            }

myY1 = myY - 1;
            while ((myY1 >= 0) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX > 0) && (myImage.GetPixel(myX-1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX - 1, myY1, myReplacedColor);
                }
                myY1--;
            }

myY1 = myY;
            while ((myY1 < myImage.Height) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX < myImage.Width - 1) && (myImage.GetPixel(myX + 1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX + 1, myY1, myReplacedColor);
                }
                myY1++;
            }

myY1 = myY - 1;
            while ((myY1 >= 0) && (myImage.GetPixel(myX, myY1) == ColorsWindow.MyBackColor))
            {
                if ((myX < myImage.Width - 1) && (myImage.GetPixel(myX + 1, myY1) == myReplacedColor))
                {
                    FillContiguously(myX + 1, myY1, myReplacedColor);
                }
                myY1--;
            }
        }

// Updates the Edit menu items according to undo and redo Stacks counts,
        // Selection state, and clipboard contents.
        public void MonitorEditMenu()
        {
            if (undoStack.Count < 1)
            {
                undoToolStripMenuItem.Enabled = false;
            }
            else
            {
                undoToolStripMenuItem.Enabled = true;
            }
            if (redoStack.Count < 1)
            {
                redoToolStripMenuItem.Enabled = false;
            }
            else
            {
                redoToolStripMenuItem.Enabled = true;
            }
            if (mySelectionState == SelectionState.Selected)
            {
                cutToolStripMenuItem.Enabled = true;
                copyToolStripMenuItem.Enabled = true;
                deleteToolStripMenuItem.Enabled = true;
            }
            else
            {
                cutToolStripMenuItem.Enabled = false;
                copyToolStripMenuItem.Enabled = false;
                deleteToolStripMenuItem.Enabled = false;
            }
            if (Clipboard.ContainsImage() == true)
            {
                pasteToolStripMenuItem.Enabled = true;
            }
            else
            {
                pasteToolStripMenuItem.Enabled = false;
            }
        }

/* The ten methods below process the tasks of the File menu items,
           in the order of their appearance. */

// Called by the Main form, after a new instance of ImageForm class is declared
        public void FileNew(int myImageWidth, int myImageHeight, Color myImageBackground)
        {
            myImage = new Bitmap(myImageWidth, myImageHeight);
            Graphics g = Graphics.FromImage(myImage);
            g.Clear(myImageBackground);
            pictureBox1.ClientSize = new Size(myImage.Width, myImage.Height);
            pictureBox1.Image = myImage;
            saveToolStripMenuItem.Enabled = false;
            MonitorEditMenu();
        }

// Called by the Main form, using the FileName chosen by an OpenFileDialog
        public void FileOpen(string myFileName)
        {
            fileName = myFileName;

// The ImageFormat is determined according to the FileName extension.
            string myFileExt = myFileName.Substring(myFileName.LastIndexOf(".") + 1).ToLower();
            if ((myFileExt == "bmp") || (myFileExt == "dib"))
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Bmp;
            }
            else if ((myFileExt == "jpg") || (myFileExt == "jpeg") || (myFileExt == "jpe") || (myFileExt == "jfif"))
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Jpeg;
            }
            else if (myFileExt == "gif")
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Gif;
            }
            else if ((myFileExt == "tif") || (myFileExt == "tiff"))
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Tiff;
            }
            else
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Png;
            }

myImage = new Bitmap(Image.FromFile(myFileName));
            pictureBox1.ClientSize = new Size(myImage.Width, myImage.Height);
            pictureBox1.Image = myImage;
            saveToolStripMenuItem.Enabled = false;
            MonitorEditMenu();
        }

private void closeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }

// On ImageForm closing the user is prompted to save the image, if needed.
        private void ImageForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (saveToolStripMenuItem.Enabled == true)
            {
                DialogResult result;
                result = MessageBox.Show("Save changes to '" + this.Text + "'?", "Paint Application",
                    MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button3);
                if (result == DialogResult.Yes)
                {
                    saveAsToolStripMenuItem_Click(sender, e);
                }
                else if (result == DialogResult.Cancel)
                {
                    e.Cancel = true;
                }
            }
        }

private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (fileName != "")
            {
                myImage.Save(fileName, fileImageFormat);
                saveToolStripMenuItem.Enabled = false;
            }
            else // if the image isn't provided yet with a fileName, the save method calls saveAs
            {
                saveAsToolStripMenuItem_Click(sender, e);
            }
        }

private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SaveFileDialog saveFile1 = new SaveFileDialog();
            saveFile1.AddExtension = true;
            saveFile1.OverwritePrompt = true;
            saveFile1.Filter = "Bitmap Files (*.bmp;*.dib)|*.bmp;*.dib|JPEG (*.jpg;*.jpeg;*.jpe;*.jfif)|*.jpg;*.jpeg;*.jpe;*.jfif|" +
                "GIF (*.gif)|*.gif|TIFF (*.tif;*.tiff)|*.tif;*.tiff|PNG (*.png)|*.png";

// If the image provides ImageFormat (i.e. it is not 'Untitled'), 
            // the dialog jumps to the appropriate FilterIndex.
            if (fileImageFormat != null) 
            {
                if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Bmp)
                {
                    saveFile1.FilterIndex = 1;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Jpeg)
                {
                    saveFile1.FilterIndex = 2;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Gif)
                {
                    saveFile1.FilterIndex = 3;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Tiff)
                {
                    saveFile1.FilterIndex = 4;
                }
                else if (fileImageFormat == System.Drawing.Imaging.ImageFormat.Png)
                {
                    saveFile1.FilterIndex = 5;
                }                
            }
            else // if the image isn't provided yet with ImageFormat, the default is Png
            {
                fileImageFormat = System.Drawing.Imaging.ImageFormat.Png;
                saveFile1.FilterIndex = 5;
            }

// If the image provides fileName (i.e. it is not 'Untitled'), 
            // the dialog uses it, and also jumps to the appropriate directory.
            if (fileName != "")
            {
                saveFile1.FileName = fileName.Substring(fileName.LastIndexOf("\\") + 1).Remove(fileName.Substring(fileName.LastIndexOf("\\") + 1).LastIndexOf("."));
                saveFile1.InitialDirectory = (fileName.Remove(fileName.LastIndexOf("\\") + 1));
            }
            else // if the image is 'Untitled', it is used as default FileName
            {
                saveFile1.FileName = this.Text;
            }

if (saveFile1.ShowDialog() == System.Windows.Forms.DialogResult.OK &&
               saveFile1.FileName.Length > 0)
            {
                fileName = saveFile1.FileName;
                this.Text = saveFile1.FileName.Substring(fileName.LastIndexOf("\\") + 1);

// On DialogResult.OK, the fileImageFormat is updated.
                switch (saveFile1.FilterIndex)
                {
                    case 1:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Bmp;
                        break;
                    case 2:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Jpeg;
                        break;
                    case 3:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Gif;
                        break;
                    case 4:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Tiff;
                        break;
                    case 5:
                        fileImageFormat = System.Drawing.Imaging.ImageFormat.Png;
                        break;
                }
                myImage.Save(saveFile1.FileName, fileImageFormat);
                saveToolStripMenuItem.Enabled = false;
            }
        }

/* The four methods below serve the print items of the File menu. */

private void pageSetupToolStripMenuItem_Click(object sender, EventArgs e)
        {
            myPageSetupDialog.PageSettings = myPageSettings;
            myPageSetupDialog.ShowDialog();
            myPrintDocument.DefaultPageSettings = myPageSettings;
        }

private void printPreviewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            myPrintPreviewDialog.Document = myPrintDocument;
            myPrintPreviewDialog.ShowDialog();
        }

private void printToolStripMenuItem_Click(object sender, EventArgs e)
        {
            myPrintDialog.Document = myPrintDocument;
            myPrintDialog.AllowSomePages = false;
            if (myPrintDialog.ShowDialog() == DialogResult.OK)
            {
                myPrintDocument.Print();
            }
        }

private void myPrintDocument_PrintPage(object sender, PrintPageEventArgs e)
        {
            // Here myPrintArea of the image is determined according to 
            // the page orientation and margins on myPageSettings 
            // (which were defined in myPageSetupDialog).
            if (myPageSettings.Landscape == false) // for Portrait page printing
            {
                myPrintArea = new Rectangle(myPageSettings.Margins.Left, myPageSettings.Margins.Top,
                    (myPageSettings.PaperSize.Width - myPageSettings.Margins.Left - myPageSettings.Margins.Right),
                    (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom));
                myPrintArea.Height = (int)(myPrintArea.Width * myImage.Height / myImage.Width);

// This fixes myPrintArea if myImage aspect ratio is narrower than the page's. 
                if (myPrintArea.Height > (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom))
                {
                    myPrintArea.Height = (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom);
                    myPrintArea.Width = myPrintArea.Height * myImage.Width / myImage.Height;
                }
            }
            else // for landscape page printing
            {
                myPrintArea = new Rectangle(myPageSettings.Margins.Bottom, myPageSettings.Margins.Left,
                   (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom),
                   (myPageSettings.PaperSize.Width - myPageSettings.Margins.Left - myPageSettings.Margins.Right));
                myPrintArea.Width = (int)(myPrintArea.Height * myImage.Width / myImage.Height);

// This fixes myPrintArea if myImage aspect ratio is wider than the page's.
                if (myPrintArea.Width > (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom))
                {
                    myPrintArea.Width = (myPageSettings.PaperSize.Height - myPageSettings.Margins.Top - myPageSettings.Margins.Bottom);
                    myPrintArea.Height = myPrintArea.Width * myImage.Height / myImage.Width;
                }
            }

e.Graphics.DrawImage(myImage, myPrintArea);
        }

/* The nine methods below process the tasks of the Edit menu items,
           in the order of their appearance. */

private void undoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None; // the Undo first clears any existing selection
            if (undoStack.Count > 0)
            {
                Bitmap pushImage = new Bitmap(myImage);
                redoStack.Push(pushImage); // the current myImage is pushed to the redoStack
                myImage = undoStack.Pop();
                pictureBox1.Image = myImage;
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
        }

private void redoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None; // the Redo first clears any existing selection
            if (redoStack.Count > 0)
            {
                Bitmap pushImage = new Bitmap(myImage);
                undoStack.Push(pushImage); // the current myImage is pushed to the undoStack
                myImage = redoStack.Pop();
                pictureBox1.Image = myImage;
                saveToolStripMenuItem.Enabled = true;
            }
            MonitorEditMenu();
        }

// Pushes myImage into the undoStack.
        // Always called before a change is applied.
        public void PushEdit()
        {
            saveToolStripMenuItem.Enabled = true;
            redoStack.Clear();
            Bitmap pushImage = new Bitmap(myImage);
            undoStack.Push(pushImage);
        }

private void cutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetImage(selectBi);

// The cut method calls the delete method to erase the selection original location.
            deleteToolStripMenuItem_Click(sender, e);
        }

private void copyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Clipboard.SetImage(selectBi);
        }

private void pasteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None; // pasting first clears any existing selection
            selectBi = (Bitmap)Clipboard.GetImage();
            FetchSelection();
            selectChanged = true; // a pasted selection is always considered as changed
            selectPaste = true;
        }

// Called by the paste and selectAll methods, to define
        // a selection and locate it on the upper-left corner.
        private void FetchSelection()
        {
            selectionWidth = selectBi.Width;
            selectionHeight = selectBi.Height;
            if (selectionWidth > 0 && selectionHeight > 0)
            {
                selectionLocationX = selectionStartX = 0;
                selectionLocationY = selectionStartY = 0;
                mySelection = new Rectangle(selectionStartX, selectionStartY, selectionWidth, selectionHeight);
                mySelectionState = SelectionState.Selected;

tempBi = (Bitmap)myImage.Clone();
                Graphics tempGr = Graphics.FromImage(tempBi);
                tempGr.DrawImage(selectBi, selectionLocationX, selectionLocationY);
                tempGr.DrawRectangle(selectPen, selectionLocationX, selectionLocationY, selectionWidth - 1, selectionHeight - 1);
                pictureBox1.Image = tempBi;

((Main)(this.MdiParent)).ChosenToolUpdate("select");
            }
        }

private void deleteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (selectPaste == false)
            {
                PushEdit();
                Graphics g = Graphics.FromImage(myImage);
                selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                g.FillRectangle(selectionCutBrush, mySelection);
            }
            pictureBox1.Image = myImage;

// After erasing the selection original location, 
            // the selection is cleared.
            mySelectionState = SelectionState.None;
        }

private void selectAllToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mySelectionState = SelectionState.None;
            selectBi = (Bitmap)myImage.Clone();
            FetchSelection();
            selectPaste = false;
        }

/* The five methods below process the tasks of the Image menu items,
           in the order of their appearance. */

private void brightnessToolStripMenuItem_Click(object sender, EventArgs e)
        {
            BrightnessDialog MyBrightnessDialog = new BrightnessDialog();
            MyBrightnessDialog.Owner = this; // the new BrightnessDialog is owned by the ImageForm for interaction
            if (MyBrightnessDialog.ShowDialog() == DialogResult.OK)
            {
                if (mySelectionState == SelectionState.Selected) // the brightness is applied to the selection, if such exists
                {
                    // Here PushEdit is not needed, since the selection is yet to dropped down.
                    selectBi = BrightenImage(selectBi, MyBrightnessDialog.BrightnessLevel);
                    UpdateProcessedSelectionBitmap();
                }
                else // the brightness is applied to myImage
                {
                    PushEdit();
                    myImage = BrightenImage(myImage, MyBrightnessDialog.BrightnessLevel);
                    pictureBox1.Image = myImage;
                }
            }
        }

// Returns a brightened Bitmap according to the level defined in MyBrightnessDialog.
        // This method is public so MyBrightnessDialog can access it for its' preview.
        public Bitmap BrightenImage(Bitmap imageToBrighten, int brightnessLevel)
        {
            int newR, newG, newB;
            for (int x = 0; x < imageToBrighten.Width; x++)
            {
                for (int y = 0; y < imageToBrighten.Height; y++)
                {
                    newR = imageToBrighten.GetPixel(x, y).R + brightnessLevel;
                    if (newR > 255)
                        newR = 255;
                    else if (newR < 0)
                        newR = 0;
                    newG = imageToBrighten.GetPixel(x, y).G + brightnessLevel;
                    if (newG > 255)
                        newG = 255;
                    else if (newG < 0)
                        newG = 0;
                    newB = imageToBrighten.GetPixel(x, y).B + brightnessLevel;
                    if (newB > 255)
                        newB = 255;
                    else if (newB < 0)
                        newB = 0;
                    imageToBrighten.SetPixel(x, y, Color.FromArgb(newR, newG, newB));
                }
            }
            return imageToBrighten;
        }

private void invertToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (mySelectionState == SelectionState.Selected) // the inversion is applied to the selection, if such exists
            {
                // Here PushEdit is not needed, since the selection is yet to dropped down.
                selectBi = InvertImage(selectBi);
                UpdateProcessedSelectionBitmap();
            }
            else // the inversion is applied to myImage
            {
                PushEdit();
                myImage = InvertImage(myImage);
                pictureBox1.Image = myImage;
            }
        }

// Returns an inverted Bitmap.
        private Bitmap InvertImage(Bitmap imageToInvert)
        {
            int invR, invG, invB;
            for (int x = 0; x < imageToInvert.Width; x++)
            {
                for (int y = 0; y < imageToInvert.Height; y++)
                {
                    invR = 255 - imageToInvert.GetPixel(x, y).R;
                    invG = 255 - imageToInvert.GetPixel(x, y).G;
                    invB = 255 - imageToInvert.GetPixel(x, y).B;
                    imageToInvert.SetPixel(x, y, Color.FromArgb(invR, invG, invB));
                }
            }
            return imageToInvert;
        }

// If an image filter (i.e. brightness or invert) 
        // is applied to a selection, this method is called 
        // to update the selection display after processing.
        private void UpdateProcessedSelectionBitmap()
        {
            selectChanged = true; // declares the processed selection as changed
            tempBi = (Bitmap)myImage.Clone();
            Graphics tempGr = Graphics.FromImage(tempBi);
            if (selectPaste == false)
            {
                selectionCutBrush = new SolidBrush(ColorsWindow.MyBackColor);
                tempGr.FillRectangle(selectionCutBrush, mySelection);
            }
            tempGr.DrawImage(selectBi, selectionLocationX, selectionLocationY);
            tempGr.DrawRectangle(selectPen, selectionLocationX, selectionLocationY, selectionWidth, selectionHeight);
            pictureBox1.Image = tempBi;
        }
    }
}

Oren's Folder

Monday, October 26, 2009

Paint Application [C#]

No comments:

Post a Comment

Blog Archive

Labels

Contact Me:

Disclaimer