MainForm.cs

namespace ForestPlot
{
    using System;
    using System.IO;
    using System.Windows.Forms;
    using Bitmap = System.Drawing.Bitmap;
    using Size = System.Drawing.Size;

    public partial class MainForm : Form
    {
        private const int SaveFileFilterIndexCmykTiff = 3;
        private readonly Plotter plotter = new Plotter();
        private readonly Form helpForm;
        private readonly string initialText;
        private float dpiX, dpiY;
        private string dataFileName = "";
        private bool dirty;
        private PlotTarget plotTarget = PlotTarget.Printer;
        private Zoom plotZoom = Zoom.Inches100;

        private enum Zoom
        {
            None,
            Pixels50,
            Pixels100,
            Pixels200,
            Inches50,
            Inches100,
            Inches200
        }

        public MainForm()
        {
            this.InitializeComponent();
            this.helpForm = new HelpForm();
            this.initialText = this.Text ?? "";
        }

        private PlotTarget PlotTarget
        {
            get
            {
                return this.plotTarget;
            }

            set
            {
                if (value != this.plotTarget)
                {
                    this.plotTarget = value;
                    this.screenImageMenu.Checked = value == PlotTarget.Screen;
                    this.printerImageMenu.Checked = value == PlotTarget.Printer;
                    this.RenderImage();
                }
            }
        }

        private Zoom PlotZoom
        {
            get
            {
                return this.plotZoom;
            }

            set
            {
                if (value != this.plotZoom)
                {
                    this.plotZoom = value;
                    this.zoomPixels50.Checked = value == Zoom.Pixels50;
                    this.zoomPixels100.Checked = value == Zoom.Pixels100;
                    this.zoomPixels200.Checked = value == Zoom.Pixels200;
                    this.zoomInches50.Checked = value == Zoom.Inches50;
                    this.zoomInches100.Checked = value == Zoom.Inches100;
                    this.zoomInches200.Checked = value == Zoom.Inches200;
                    this.ZoomImage();
                }
            }
        }

        private bool Dirty
        {
            get
            {
                return this.dirty;
            }

            set
            {
                if (value != this.Dirty)
                {
                    this.UpdateDataFileName(this.DataFileName, value);
                }
            }
        }

        private string DataFileName
        {
            get
            {
                return this.dataFileName;
            }

            set
            {
                var valueOrEmpty = value ?? "";
                if (valueOrEmpty != this.dataFileName)
                {
                    this.UpdateDataFileName(valueOrEmpty, this.Dirty);
                }
            }
        }

        private void OnFormLoaded(object sender, EventArgs e)
        {
            using (var g = this.CreateGraphics())
            {
                this.dpiX = g.DpiX;
                this.dpiY = g.DpiY;
            }

            var sample = Resource.Sample;
            this.data.Text = sample;
            this.data.Select(0, 0);
            this.plotter.DataChanged += this.PlotterDataChanged;
            this.plotter.DataText = sample;
            this.Dirty = false;
        }

        private void OnFormClosing(object sender, FormClosingEventArgs e)
        {
            if (!this.QuerySaveData())
            {
                e.Cancel = true;
            }
        }

        private void PlotterDataChanged(object sender, EventArgs e)
        {
            this.RenderImage();
        }

        private void OpenDataClicked(object sender, EventArgs e)
        {
            try
            {
                if (this.QuerySaveData() &&
                    this.openDataDialog.ShowDialog(this) == DialogResult.OK)
                {
                    string filename = this.openDataDialog.FileName;
                    this.data.Text = File.ReadAllText(filename);
                    this.UpdateDataFileName(filename, false);
                    this.plotter.DataText = this.data.Text;
                }
            }
            catch (Exception ex)
            {
                if (Program.ExceptionIsDangerous(ex))
                {
                    throw;
                }

                MessageBox.Show(this, ex.Message, "Error opening file", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void SaveDataClicked(object sender, EventArgs e)
        {
            this.SaveData(false);
        }

        private void SaveDataAsClicked(object sender, EventArgs e)
        {
            this.SaveData(true);
        }

        private void RedrawImageClicked(object sender, EventArgs e)
        {
            this.plotter.DataText = this.data.Text;
        }

        private void SaveScreenImageClicked(object sender, EventArgs e)
        {
            SaveImage(this.saveScreenImageDialog, PlotTarget.Screen);
        }

        private void SavePrinterImageClicked(object sender, EventArgs e)
        {
            SaveImage(this.savePrinterImageDialog, PlotTarget.Printer);
        }

        private void SaveImage(SaveFileDialog saveFileDialog, PlotTarget plotTarget)
        {
            try
            {
                this.plotter.DataText = this.data.Text;
                if (saveFileDialog.ShowDialog(this) == DialogResult.OK)
                {
                    var saveFileName = saveFileDialog.FileName;
                    var emf = saveFileName.EndsWith(".emf", StringComparison.OrdinalIgnoreCase);
                    using (var bmp = this.plotter.Render(plotTarget, emf ? saveFileName : null))
                    {
                        if (!emf)
                        {
                            BitmapSaver.SaveRgb32(
                                bmp,
                                saveFileName,
                                this.optimizeImageFilesMenu.Checked,
                                saveFileDialog.FilterIndex == SaveFileFilterIndexCmykTiff);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                if (Program.ExceptionIsDangerous(ex))
                {
                    throw;
                }

                MessageBox.Show(this, ex.Message, "Error saving file", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

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

        private void HelpViewHelpClicked(object sender, EventArgs e)
        {
            if (!this.helpForm.Visible)
            {
                this.helpForm.Show(this);
            }
        }

        private void HelpViewLicenceClicked(object sender, EventArgs e)
        {
            MessageBox.Show(
                this,
                Resource.License,
                "License Information",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information);
        }

        private void ScreenImageClicked(object sender, EventArgs e)
        {
            this.PlotTarget = PlotTarget.Screen;
        }

        private void PrinterImageClicked(object sender, EventArgs e)
        {
            this.PlotTarget = PlotTarget.Printer;
        }

        private void ZoomPixels50(object sender, EventArgs e)
        {
            this.PlotZoom = Zoom.Pixels50;
        }

        private void ZoomPixels100(object sender, EventArgs e)
        {
            this.PlotZoom = Zoom.Pixels100;
        }

        private void ZoomPixels200(object sender, EventArgs e)
        {
            this.PlotZoom = Zoom.Pixels200;
        }

        private void ZoomInches50(object sender, EventArgs e)
        {
            this.PlotZoom = Zoom.Inches50;
        }

        private void ZoomInches100(object sender, EventArgs e)
        {
            this.PlotZoom = Zoom.Inches100;
        }

        private void ZoomInches200(object sender, EventArgs e)
        {
            this.PlotZoom = Zoom.Inches200;
        }

        private void PicturePanelResized(object sender, EventArgs e)
        {
            return;
        }

        private void DataChanged(object sender, EventArgs e)
        {
            this.Dirty = true;
        }

        private bool QuerySaveData()
        {
            bool canContinue;
            if (this.Dirty)
            {
                var result = MessageBox.Show(
                    this,
                    "Do you want to save changes to your data?",
                    "Data changed",
                    MessageBoxButtons.YesNoCancel,
                    MessageBoxIcon.Question,
                    MessageBoxDefaultButton.Button1);
                if (result == DialogResult.Cancel)
                {
                    canContinue = false;
                }
                else if (result == DialogResult.No)
                {
                    canContinue = true;
                }
                else
                {
                    canContinue = this.SaveData(false);
                }
            }
            else
            {
                canContinue = true;
            }

            return canContinue;
        }

        private bool SaveData(bool saveAs)
        {
            bool canContinue = false;
            try
            {
                string filename;
                if (!saveAs && !string.IsNullOrEmpty(this.dataFileName))
                {
                    filename = this.dataFileName;
                }
                else if (this.saveDataDialog.ShowDialog(this) == DialogResult.OK)
                {
                    filename = this.saveDataDialog.FileName;
                }
                else
                {
                    filename = null;
                }

                if (filename != null)
                {
                    File.WriteAllText(filename, this.data.Text);
                    this.UpdateDataFileName(filename, false);
                    canContinue = true;
                }
            }
            catch (Exception ex)
            {
                if (Program.ExceptionIsDangerous(ex))
                {
                    throw;
                }

                MessageBox.Show(this, ex.Message, "Error saving file", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            return canContinue;
        }

        private void UpdateDataFileName(string filename, bool dirty)
        {
            this.dataFileName = filename;
            this.dirty = dirty;
            this.UpdateWindowTitle();
        }

        private void UpdateWindowTitle()
        {
            string filename = string.IsNullOrEmpty(this.dataFileName)
                ? "SampleData.csv"
                : this.dataFileName;
            this.Text = this.initialText + " - " + filename + (this.dirty ? "*" : "");
        }

        private void RenderImage()
        {
            try
            {
                Bitmap bmp;
                var old = this.picture.Image;
                try
                {
                    bmp = this.plotter.Render(
                        this.screenImageMenu.Checked
                        ? PlotTarget.Screen
                        : PlotTarget.Printer);
                }
                catch (Exception ex)
                {
                    if (Program.ExceptionIsDangerous(ex))
                    {
                        throw;
                    }

                    bmp = this.plotter.RenderText(ex.Message);
                }

                this.picture.Image = bmp;
                this.ZoomImage();
                if (old != null)
                {
                    old.Dispose();
                }
            }
            catch (Exception ex)
            {
                if (Program.ExceptionIsDangerous(ex))
                {
                    throw;
                }

                MessageBox.Show(this, ex.Message, "Unexpected error rendering image", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void ZoomImage()
        {
            try
            {
                var bmp = this.picture.Image as Bitmap;
                if (bmp != null)
                {
                    var scaleX = this.dpiX / bmp.HorizontalResolution;
                    var scaleY = this.dpiY / bmp.VerticalResolution;
                    Size size = bmp.Size;
                    switch (this.plotZoom)
                    {
                        default:
                            break;
                        case Zoom.Pixels50:
                            size = new Size(
                                size.Width / 2,
                                size.Height / 2);
                            break;
                        case Zoom.Pixels100:
                            break;
                        case Zoom.Pixels200:
                            size = new Size(
                                size.Width * 2,
                                size.Height * 2);
                            break;
                        case Zoom.Inches50:
                            size = new Size(
                                (int)((float)size.Width * scaleX * 0.5f),
                                (int)((float)size.Height * scaleY * 0.5f));
                            break;
                        case Zoom.Inches100:
                            size = new Size(
                                (int)((float)size.Width * scaleX * 1.0f),
                                (int)((float)size.Height * scaleY * 1.0f));
                            break;
                        case Zoom.Inches200:
                            size = new Size(
                                (int)((float)size.Width * scaleX * 2.0f),
                                (int)((float)size.Height * scaleY * 2.0f));
                            break;
                    }

                    this.picture.Size = size;
                }
            }
            catch (Exception ex)
            {
                if (Program.ExceptionIsDangerous(ex))
                {
                    throw;
                }

                MessageBox.Show(this, ex.Message, "Unexpected error zooming image", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}