Tools.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using AForge.Imaging.Filters;
using AForge.Imaging;
using AForge.Math.Geometry;
using AForge;
using BioImager.Graphics;
using BioImager;
using Rectangle = AForge.Rectangle;
using Bitmap = AForge.Bitmap;
using BioLib;
using Gdk;
using OpenSlideGTK;
namespace BioImager
{
    public partial class Tools : Form
    {
        public static bool applyToStack = false;
        public static ColorTool colorTool;
        public static bool rEnabled = true;
        public static bool gEnabled = true;
        public static bool bEnabled = true;
        private static ColorS drawColor = new ColorS(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
        private static ColorS eraseColor = new ColorS(0, 0, 0);
        private static int width = 1;
 
        public static System.Drawing.Rectangle selectionRectangle;
        public static Hashtable tools = new Hashtable();
        private AbstractFloodFiller floodFiller = null;
        /* It's a class that contains a list of tools, and each tool has a type, a rectangle, a script,
        and a tolerance. */
        public class Tool
        {
            public enum ToolType
            {
                color,
                annotation,
                select,
                function
            }
            public enum Type
            {
                pencil,
                brush,
                bucket,
                eraser,
                move,
                point,
                line,
                rect,
                select,
                ellipse,
                polyline,
                polygon,
                text,
                delete,
                freeform,
                rectSel,
                pointSel,
                pan,
                magic,
                script,
                dropper
            }
 
            public static void Init()
            {
                if (tools.Count == 0)
                {
                    foreach (Tool.Type tool in (Tool.Type[])Enum.GetValues(typeof(Tool.Type)))
                    {
                        tools.Add(tool.ToString(), new Tool(tool, new ColorS(0, 0, 0)));
                    }
                }
            }
            public List<AForge.Point> Points;
            public ToolType toolType;
            private RectangleD rect;
            public RectangleD Rectangle
            {
                get { return rect; }
                set { rect = value; }
            }
            public AForge.RectangleF RectangleF
            {
                get { return new AForge.RectangleF((float)rect.X, (float)rect.Y, (float)rect.W, (float)rect.H); }
            }
            public string script;
            public Type type;
            public ColorS tolerance;
            public Tool()
            {
                tolerance = new ColorS(0, 0, 0);
            }
            public Tool(Type t)
            {
                type = t;
                tolerance = new ColorS(0, 0, 0);
            }
            public Tool(Type t, ColorS col)
            {
                type = t;
                tolerance = new ColorS(0, 0, 0);
            }
            public Tool(Type t, RectangleD r)
            {
                type = t;
                rect = r;
                tolerance = new ColorS(0, 0, 0);
            }
            public Tool(Type t, string sc)
            {
                type = t;
                script = sc;
                tolerance = new ColorS(0, 0, 0);
            }
            public override string ToString()
            {
                return type.ToString();
            }
        }
        public static Tool currentTool;
        public static ColorS DrawColor
        {
            get
            {
                return drawColor;
            }
            set
            {
                drawColor = value;
            }
        }
        public static ColorS EraseColor
        {
            get
            {
                return eraseColor;
            }
            set
            {
                eraseColor = value;
            }
        }
 
        public static int StrokeWidth
        {
            get
            {
                return width;
            }
            set
            {
                width = value;
                App.tools.UpdateGUI();
            }
        }
 
        public static RectangleD selectionRect;
        public Font font;
        /* Initializing the tools. */
        public Tools()
        {
            InitializeComponent();
            Tool.Init();
            ColorS col = new ColorS(ushort.MaxValue);
            //We initialize the tools
            currentTool = GetTool(Tool.Type.move);
            ROI.selectBoxSize = 1;
            floodFiller = null;
            floodFiller = new QueueLinearFloodFiller(floodFiller);
        }
 
        public static Tool GetTool(string name)
        {
            return (Tool)tools[name];
        }
        public static Tool GetTool(Tool.Type typ)
        {
            return (Tool)tools[typ.ToString()];
        }
        public void UpdateOverlay()
        {
            App.viewer.UpdateOverlay();
        }
        public void UpdateView()
        {
            App.viewer.UpdateView();
        }
        public void UpdateSelected()
        {
            foreach (Control item in this.Controls)
            {
                if (item.Tag != null)
                    if (item.Tag.ToString() == "tool")
                        item.BackColor = System.Drawing.Color.White;
            }
        }
        private void UpdateGUI()
        {
            if (ImageView.SelectedImage != null)
            {
                color1Box.BackColor = System.Drawing.Color.FromArgb((int)((float)DrawColor.R / (float)ushort.MaxValue) * 255,(int)((float)DrawColor.G / (float)ushort.MaxValue) * 255, (int)((float)DrawColor.B / (float)ushort.MaxValue) * 255);
                color2Box.BackColor = System.Drawing.Color.FromArgb((int)(((float)EraseColor.R / (float)ushort.MaxValue) * 255), (int)(((float)EraseColor.G / (float)ushort.MaxValue) * 255), (int)(((float)EraseColor.B / (float)ushort.MaxValue) * 255));
            }
            widthBox.Value = width;
        }
        public static float selectBoxSize = 1;// ROI.selectBoxSize;
        ROI anno = new ROI();
        PointD rectStart = new PointD();
 
        private void RefreshRoiManager()
        {
            App.manager?.UpdateAnnotationList();
        }
 
        private static PointD GetAnnotationPoint(PointD p)
        {
            return p;
        }
        public void ToolDown(PointD e, MouseButtons buts)
        {
            if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null)
                return;
            Scripting.UpdateState(Scripting.State.GetDown(e, buts));
            PointD p = ImageView.SelectedImage.isPyramidal ? e : ImageView.SelectedImage.ToImageSpace(e);
            PointD roiPoint = GetAnnotationPoint(e);
            if (currentTool.type == Tool.Type.line && buts == MouseButtons.Left)
            {
                if (anno.type != ROI.Type.Line)
                {
                    anno = new ROI();
                    anno.type = ROI.Type.Line;
                    anno.AddPoint(roiPoint);
                    anno.AddPoint(roiPoint);
                    anno.coord = App.viewer.GetCoordinate();
                    ImageView.SelectedImage.Annotations.Add(anno);
                    RefreshRoiManager();
                }
            }
            else
            if (currentTool.type == Tool.Type.polygon && buts == MouseButtons.Left)
            {
                if (anno.type != ROI.Type.Polygon)
                {
                    anno = new ROI();
                    anno.type = ROI.Type.Polygon;
                    anno.closed = false;
                    anno.AddPoint(roiPoint);
                    anno.coord = App.viewer.GetCoordinate();
                    ImageView.SelectedImage.Annotations.Add(anno);
                    RefreshRoiManager();
                }
                else
                {
                    //If we click on a point 1 we close this polygon
                    double hitSize = App.viewer.GetSelectionBoxHitSize();
                    PointD firstPoint = anno.Points[0];
                    double dx = roiPoint.X - firstPoint.X;
                    double dy = roiPoint.Y - firstPoint.Y;
                    if ((dx * dx) + (dy * dy) <= (hitSize * hitSize))
                    {
                        anno.closed = true;
                        anno.UpdateBoundingBox();
                        RefreshRoiManager();
                        anno = new ROI();
                    }
                    else
                    {
                        anno.AddPoint(roiPoint);
                        RefreshRoiManager();
                    }
                }
            }
            else
            if (currentTool.type == Tool.Type.freeform && buts == MouseButtons.Left)
            {
                if (anno.type != ROI.Type.Freeform)
                {
                    anno = new ROI();
                    anno.type = ROI.Type.Freeform;
                    anno.closed = false;
                    anno.AddPoint(roiPoint);
                    anno.coord = App.viewer.GetCoordinate();
                    ImageView.SelectedImage.Annotations.Add(anno);
                    RefreshRoiManager();
                }
                else
                {
                    anno.AddPoint(roiPoint);
                    RefreshRoiManager();
                }
            }
            else
            if (currentTool.type == Tool.Type.rect && buts == MouseButtons.Left)
            {
                anno = new ROI();
                anno.type = ROI.Type.Rectangle;
                rectStart = roiPoint;
                anno.BoundingBox = new RectangleD(roiPoint.X, roiPoint.Y, 0, 0);
                anno.Validate();
                anno.coord = App.viewer.GetCoordinate();
                ImageView.SelectedImage.Annotations.Add(anno);
                currentTool.Rectangle = anno.BoundingBox;
            }
            else
            if (currentTool.type == Tool.Type.ellipse && buts == MouseButtons.Left)
            {
                anno = new ROI();
                anno.type = ROI.Type.Ellipse;
                rectStart = roiPoint;
                anno.BoundingBox = new RectangleD(roiPoint.X, roiPoint.Y, 0, 0);
                anno.Validate();
                anno.coord = App.viewer.GetCoordinate();
                ImageView.SelectedImage.Annotations.Add(anno);
                currentTool.Rectangle = anno.BoundingBox;
            }
            else
            if (currentTool.type == Tool.Type.delete && buts == MouseButtons.Left)
            {
                for (int i = 0; i < ImageView.SelectedImage.Annotations.Count; i++)
                {
                    ROI an = ImageView.SelectedImage.Annotations[i];
                    if (an.BoundingBox.IntersectsWith(new RectangleD(roiPoint.X, roiPoint.Y, 1, 1)))
                    {
                        if (an.selectedPoints.Count == 0)
                        {
                            ImageView.SelectedImage.Annotations.Remove(an);
                            RefreshRoiManager();
                            break;
                        }
                        else
                        if (an.selectedPoints.Count == 1 && !(an.type == ROI.Type.Polygon || an.type == ROI.Type.Polyline || an.type == ROI.Type.Freeform))
                        {
                            ImageView.SelectedImage.Annotations.Remove(an);
                            RefreshRoiManager();
                            break;
                        }
                        else
                        {
                            if (an.type == ROI.Type.Polygon ||
                                an.type == ROI.Type.Polyline ||
                                an.type == ROI.Type.Freeform)
                            {
                                an.closed = false;
                                an.RemovePoints(an.selectedPoints.ToArray());
                                break;
                            }
                        }
                    }
                }
                UpdateOverlay();
            }
            else
            if (currentTool.type == Tool.Type.text && buts == MouseButtons.Left)
            {
                ROI an = new ROI();
                an.type = ROI.Type.Label;
                an.AddPoint(roiPoint);
                an.coord = App.viewer.GetCoordinate();
                TextInput ti = new TextInput("");
                if (ti.ShowDialog() != DialogResult.OK)
                    return;
                Font labelFont = ti.font ?? SystemFonts.DefaultFont;
                string labelText = ti.TextValue ?? string.Empty;
                System.Drawing.Size labelSize = TextRenderer.MeasureText(labelText, labelFont);
                AForge.RectangleF labelBox = ImageView.SelectedImage.ToImageSpace(new RectangleD(0, 0, labelSize.Width, labelSize.Height));
                an.family = labelFont.FontFamily.Name;
                an.fontSize = labelFont.Size;
                an.strokeColor = AForge.Color.FromArgb(ti.color.A, ti.color.R, ti.color.G, ti.color.B);
                an.Text = labelText;
                an.BoundingBox = new RectangleD(roiPoint.X, roiPoint.Y, labelBox.Width, labelBox.Height);
                ImageView.SelectedImage.Annotations.Add(an);
                RefreshRoiManager();
            }
            
            if (buts == MouseButtons.Middle)
            {
                currentTool = GetTool(Tool.Type.pan);
                UpdateSelected();
                panPanel.BackColor = System.Drawing.Color.LightGray;
            }
            
 
            UpdateOverlay();
        }
        public void ToolUp(PointD e, MouseButtons buts)
        {
            PointD p = new PointD();
            if (ImageView.SelectedImage == null)
                return;
            p = ImageView.SelectedImage.isPyramidal ? e : ImageView.SelectedImage.ToImageSpace(e);
            PointD roiPoint = GetAnnotationPoint(e);
            if (App.viewer == null || currentTool == null || ImageView.SelectedImage == null || anno == null)
                return;
            Scripting.UpdateState(Scripting.State.GetUp(e, buts));
            if (currentTool.type == Tool.Type.point && buts == MouseButtons.Left)
            {
                ROI an = new ROI();
                an.AddPoint(roiPoint);
                an.type = ROI.Type.Point;
                an.coord = App.viewer.GetCoordinate();
                ImageView.SelectedImage.Annotations.Add(an);
            }
            else
            if (currentTool.type == Tool.Type.line && anno.type == ROI.Type.Line && buts == MouseButtons.Left)
            {
                if (anno.GetPointCount() > 0)
                {
                    anno.UpdatePoint(roiPoint, 1);
                    anno.UpdateBoundingBox();
                    RefreshRoiManager();
                    anno = new ROI();
                }
            }
            else
            if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle && buts == MouseButtons.Left)
            {
                currentTool.Rectangle = new RectangleD(0, 0, 0, 0);
                anno = new ROI();
                rectStart = new PointD();
            }
            else
            if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse && buts == MouseButtons.Left)
            {
                currentTool.Rectangle = new RectangleD(0, 0, 0, 0);
                anno = new ROI();
                rectStart = new PointD();
            }
            else
            if (currentTool.type == Tool.Type.freeform && anno.type == ROI.Type.Freeform && buts == MouseButtons.Left)
            {
                anno.closed = true;
                anno.UpdateBoundingBox();
                RefreshRoiManager();
                anno = new ROI();
            }
            else
            if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left)
            {
                if (!Win32.GetKeyState(Keys.LControlKey))
                    ImageView.selectedAnnotations.Clear();
                RectangleD r = GetTool(Tool.Type.rectSel).Rectangle;
                double hitSize = App.viewer.GetSelectionBoxHitSize();
                foreach (ROI an in App.viewer.AnnotationsRGB)
                {
                    if (an.GetSelectBound(hitSize, hitSize).ToRectangleF().IntersectsWith(r.ToRectangleF()))
                    {
                        if(!Win32.GetKeyState(Keys.LControlKey))
                        an.selectedPoints.Clear();
                        ImageView.selectedAnnotations.Add(an);
                        an.Selected = true;
                        RectangleD[] sels = an.GetSelectBoxes(selectBoxSize);
                        for (int i = 0; i < sels.Length; i++)
                        {
                            if (sels[i].IntersectsWith(r))
                            {
                                an.selectedPoints.Add(i);
                            }
                        }
                    }
                    else
                        an.Selected = false;
                }
                Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
            }
            else
            if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
            {
                RectangleD r = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, Math.Abs(ImageView.mouseUp.X - ImageView.mouseDown.X), Math.Abs(ImageView.mouseUp.Y - ImageView.mouseDown.Y));
                AForge.RectangleF rr = ImageView.SelectedImage.ToImageSpace(r);
                ZCT coord = App.viewer.GetCoordinate();
                Bitmap bf;
                if (ImageView.SelectedImage.Buffers[0].RGBChannelsCount > 1)
                    bf = ImageView.SelectedImage.GetFiltered(coord, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[1].Range, ImageView.SelectedBuffer.Stats[2].Range);
                else
                    bf = ImageView.SelectedImage.GetFiltered(coord, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[0].Range, ImageView.SelectedBuffer.Stats[0].Range);
                bf.Crop(rr.ToRectangleInt());
                Statistics[] sts = Statistics.FromBytes(bf);
                Statistics st = sts[0];
                int th = 0;
                if (magicSel.Numeric)
                {
                    th = magicSel.Threshold;
                }
                else
                if (magicSel.Index == 2)
                    th = (int)(st.Min + st.Mean);
                else
                if (magicSel.Index == 1)
                    th = (int)st.Median;
                else
                    th = (int)st.Min;
                Bitmap det;
                if (bf.BitsPerPixel > 8)
                {
                    bf.To8Bit();
                    det = bf;
                    //blobCounter.BackgroundThreshold = AForge.Color.FromArgb((int)(((float)th / (float)ushort.MaxValue) * 255), (int)(((float)th / (float)ushort.MaxValue) * 255), (int)(((float)th / (float)ushort.MaxValue) * 255));
                }
                else
                {
                    //blobCounter.BackgroundThreshold = AForge.Color.FromArgb((int)th, (int)th, (int)th);
                    det = bf;
                }
                BlobCounter blobCounter = new BlobCounter(det);
                blobCounter.FilterBlobs = true;
                blobCounter.MinWidth = 2;
                blobCounter.MinHeight = 2;
                blobCounter.CoupledSizeFiltering = true;
                Blob[] blobs = blobCounter.GetObjects(det, true);
                double px = ImageView.SelectedImage.PhysicalSizeX;
                double py = ImageView.SelectedImage.PhysicalSizeY;
                foreach (Blob blob in blobs)
                {
                    AForge.RectangleD rd = new RectangleD(blob.Rectangle.X * px, blob.Rectangle.Y * py, blob.Rectangle.Width * px, blob.Rectangle.Height * py);
                    PointD loc = new PointD(r.X + rd.X, r.Y + rd.Y); 
                    ROI an = ROI.CreateRectangle(coord, loc.X, loc.Y, rd.W, rd.H);
                    ImageView.SelectedImage.Annotations.Add(an);
                }
            }
            else
            if (Tools.currentTool.type == Tools.Tool.Type.bucket && buts == MouseButtons.Left)
            {
                ZCT coord = App.viewer.GetCoordinate();
                floodFiller.FillColor = DrawColor;
                floodFiller.Tolerance = currentTool.tolerance;
                floodFiller.Bitmap = ImageView.SelectedImage.Buffers[ImageView.SelectedImage.Coords[coord.C, coord.Z, coord.T]];
                floodFiller.FloodFill(new AForge.Point((int)p.X, (int)p.Y));
                App.viewer.UpdateImages();
            }
            else
            if (Tools.currentTool.type == Tools.Tool.Type.dropper && buts == MouseButtons.Left)
            {
                DrawColor = ImageView.SelectedBuffer.GetPixel((int)p.X, (int)p.Y);
                UpdateGUI();
            }
            UpdateOverlay();
        }
 
        public void ToolMove(PointD e, MouseButtons buts)
        {
            if (App.viewer == null)
                return;
            if (ImageView.SelectedImage == null)
                return;
            PointD p = ImageView.SelectedImage.isPyramidal ? e : ImageView.SelectedImage.ToImageSpace(e);
            PointD roiPoint = GetAnnotationPoint(e);
            if (Tools.currentTool.type == Tools.Tool.Type.pan && (buts.HasFlag(MouseButtons.Left) || buts.HasFlag(MouseButtons.Middle)))
            {
                if (ImageView.SelectedImage.isPyramidal)
                {
                    if (App.viewer.MouseMoveInt.X != 0 || App.viewer.MouseMoveInt.Y != 0)
                    {
                        App.viewer.PyramidalOrigin = new PointD(
                            App.viewer.PyramidalOrigin.X + (ImageView.mouseDown.X - e.X),
                            App.viewer.PyramidalOrigin.Y + (ImageView.mouseDown.Y - e.Y));
                        App.viewer.UpdateImages();
                    }
                }
                else
                {
                    PointD pf = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
                    App.viewer.Origin = new PointD(App.viewer.Origin.X + pf.X, App.viewer.Origin.Y + pf.Y);
                    App.viewer.UpdateView(false);
                }
                App.viewer.UpdateStatus();
                return;
            }
            
            if (currentTool.type == Tool.Type.line && ImageView.down)
            {
                anno.UpdatePoint(roiPoint, 1);
                UpdateOverlay();
            }
            else
            if (currentTool.type == Tool.Type.freeform && ImageView.down)
            {
                if (anno.type != ROI.Type.Freeform)
                {
                    anno = new ROI();
                    anno.type = ROI.Type.Freeform;
                    anno.closed = false;
                    anno.AddPoint(roiPoint);
                    anno.coord = App.viewer.GetCoordinate();
                    ImageView.SelectedImage.Annotations.Add(anno);
                    RefreshRoiManager();
                }
                else
                {
                    anno.AddPoint(roiPoint);
                    RefreshRoiManager();
                }
                UpdateOverlay();
            }
            else
 
            if (currentTool.type == Tool.Type.rect && anno.type == ROI.Type.Rectangle)
            {
                RectangleD rect;
                double x = Math.Min(rectStart.X, roiPoint.X);
                double y = Math.Min(rectStart.Y, roiPoint.Y);
                double w = Math.Abs(roiPoint.X - rectStart.X);
                double h = Math.Abs(roiPoint.Y - rectStart.Y);
                rect = new RectangleD(x, y, w, h);
                anno.BoundingBox = rect;
                anno.Validate();
                currentTool.Rectangle = rect;
                UpdateOverlay();
            }
            else
            if (currentTool.type == Tool.Type.ellipse && anno.type == ROI.Type.Ellipse)
            {
                RectangleD rect;
                double x = Math.Min(rectStart.X, roiPoint.X);
                double y = Math.Min(rectStart.Y, roiPoint.Y);
                double w = Math.Abs(roiPoint.X - rectStart.X);
                double h = Math.Abs(roiPoint.Y - rectStart.Y);
                rect = new RectangleD(x, y, w, h);
                anno.BoundingBox = rect;
                anno.Validate();
                currentTool.Rectangle = rect;
                UpdateOverlay();
            }
            else
            if (currentTool.type == Tool.Type.rectSel && buts == MouseButtons.Left && ImageView.down)
            {
                PointD roiDown = GetAnnotationPoint(ImageView.mouseDown);
                PointD d = new PointD(roiPoint.X - roiDown.X, roiPoint.Y - roiDown.Y);
                Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(roiDown.X, roiDown.Y, d.X, d.Y);
                UpdateOverlay();
            }
            else
            if (currentTool.type == Tool.Type.rectSel && ImageView.up)
            {
                Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(0, 0, 0, 0);
            }
            else
            if (Win32.GetKeyState(Keys.Delete))
            {
                foreach (ROI an in ImageView.selectedAnnotations)
                {
                    if (an != null)
                    {
                        if (an.selectedPoints.Count == 0)
                        {
                            ImageView.SelectedImage.Annotations.Remove(an);
                        }
                        else
                        {
                            if (an.type == ROI.Type.Polygon ||
                                an.type == ROI.Type.Polyline ||
                                an.type == ROI.Type.Freeform)
                            {
                                an.closed = false;
                                an.RemovePoints(an.selectedPoints.ToArray());
 
                            }
                        }
                    }
                }
                UpdateOverlay();
            }
            /*
            if (Tools.currentTool.type == Tools.Tool.Type.magic && buts == MouseButtons.Left)
            {
                //First we draw the selection rectangle
                PointD d = new PointD(e.X - ImageView.mouseDown.X, e.Y - ImageView.mouseDown.Y);
                Tools.GetTool(Tools.Tool.Type.rectSel).Rectangle = new RectangleD(ImageView.mouseDown.X, ImageView.mouseDown.Y, d.X, d.Y);
                UpdateOverlay();
            }
            */
            if (buts == MouseButtons.Left && currentTool.type == Tool.Type.eraser)
            {
                Graphics.Graphics g = Graphics.Graphics.FromImage(ImageView.SelectedBuffer);
                Graphics.Pen pen = new Graphics.Pen(Tools.EraseColor, (int)Tools.StrokeWidth, ImageView.SelectedBuffer.BitsPerPixel);
                g.FillEllipse(new Rectangle((int)p.X, (int)p.Y, (int)width, (int)Tools.StrokeWidth), pen.color);
                pen.Dispose();
                App.viewer.UpdateImage();
            }
        }
 
        private void movePanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.move);
            UpdateSelected();
            movePanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void textPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.text);
            UpdateSelected();
            textPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void textPanel_DoubleClick(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.text);
            UpdateSelected();
            textPanel.BackColor = System.Drawing.Color.LightGray;
 
            if (fontDialog.ShowDialog() != DialogResult.OK)
                return;
            font = fontDialog.Font;
        }
        private void pointPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.point);
            UpdateSelected();
            pointPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void linePanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.line);
            UpdateSelected();
            linePanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void rectPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.rect);
            UpdateSelected();
            rectPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void ellipsePanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.ellipse);
            UpdateSelected();
            ellipsePanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void polyPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.polygon);
            UpdateSelected();
            polyPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void deletePanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.delete);
            UpdateSelected();
            deletePanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void freeformPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.freeform);
            UpdateSelected();
            freeformPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void rectSelPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.rectSel);
            UpdateSelected();
            rectSelPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void panPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.pan);
            UpdateSelected();
            panPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void magicPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.magic);
            UpdateSelected();
            magicPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void bucketPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.bucket);
            UpdateSelected();
            bucketPanel.BackColor = System.Drawing.Color.LightGray;
        }
        private void pencilPanel_Click(object sender, EventArgs e)
        {
            currentTool = GetTool(Tool.Type.pencil);
            UpdateSelected();
            pencilPanel.BackColor = System.Drawing.Color.LightGray;
        }
        MagicSelect magicSel = new MagicSelect(2);
        private void magicPanel_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (magicSel.ShowDialog() != DialogResult.OK)
                return;
        }
        private void Tools_FormClosing(object sender, FormClosingEventArgs e)
        {
            e.Cancel = true;
            this.Hide();
        }
 
        private void pencilPanel_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            currentTool = GetTool(Tool.Type.pencil);
            UpdateSelected();
            pencilPanel.BackColor = System.Drawing.Color.LightGray;
            PenTool pt = new PenTool(new Graphics.Pen(DrawColor, (int)Tools.StrokeWidth, ImageView.SelectedBuffer.BitsPerPixel));
            if (pt.ShowDialog() != DialogResult.OK)
                return;
            Tools.StrokeWidth = pt.Pen.width;
            DrawColor = pt.Pen.color;
        }
 
        private void bucketPanel_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            currentTool = GetTool(Tool.Type.bucket);
            UpdateSelected();
            bucketPanel.BackColor = System.Drawing.Color.LightGray;
            FloodTool pt = new FloodTool(new Graphics.Pen(DrawColor, (int)Tools.StrokeWidth, ImageView.SelectedBuffer.BitsPerPixel), currentTool.tolerance, ImageView.SelectedBuffer.BitsPerPixel);
            if (pt.ShowDialog() != DialogResult.OK)
                return;
            Tools.StrokeWidth = pt.Pen.width;
            DrawColor = pt.Pen.color;
            currentTool.tolerance = pt.Tolerance;
        }
 
        private void dropperPanel_MouseClick(object sender, MouseEventArgs e)
        {
            currentTool = GetTool(Tool.Type.dropper);
            UpdateSelected();
            dropperPanel.BackColor = System.Drawing.Color.LightGray;
        }
 
        private void color1Box_MouseClick(object sender, MouseEventArgs e)
        {
            ColorTool t = new ColorTool(DrawColor, ImageView.SelectedBuffer.BitsPerPixel);
            if (t.ShowDialog() != DialogResult.OK)
                return;
            DrawColor = t.Color;
            UpdateGUI();
        }
 
        private void color2Box_MouseClick(object sender, MouseEventArgs e)
        {
            ColorTool t = new ColorTool(EraseColor, ImageView.SelectedBuffer.BitsPerPixel);
            if (t.ShowDialog() != DialogResult.OK)
                return;
            EraseColor = t.Color;
            UpdateGUI();
        }
 
        private void widthBox_ValueChanged(object sender, EventArgs e)
        {
            width = (int)widthBox.Value;
        }
 
        private void eraserPanel_MouseClick(object sender, MouseEventArgs e)
        {
            currentTool = GetTool(Tool.Type.eraser);
            UpdateSelected();
            eraserPanel.BackColor = System.Drawing.Color.LightGray;
        }
 
        private void switchBox_MouseClick(object sender, MouseEventArgs e)
        {
            ColorS s = DrawColor;
            DrawColor = eraseColor;
            EraseColor = s;
            UpdateGUI();
        }
 
        private void Tools_Activated(object sender, EventArgs e)
        {
            UpdateGUI();
        }
    }
}