QuickImage – Rev 19

?pathlinks?

Rev 10 – Blame – Compare with Previous – Last modification – View Log – Download

using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using QuickImage.Utilities;
using Serilog;

namespace QuickImage
{
    public partial class EditorForm : Form
    {
        public class ImageChangedEventArgs : EventArgs
        {
            public string FileName { get; }

            public byte[] ImageBytes { get; }

            public ImageChangedEventArgs(string fileName, byte[] imageBytes)
            {
                FileName = fileName;
                ImageBytes = imageBytes;
            }
        }

        public event EventHandler<ImageChangedEventArgs> ImageSave;
        public event EventHandler<ImageChangedEventArgs> ImageSaveAs;

        private readonly string _fileName;
        private readonly CancellationToken _cancellationToken;

        private readonly global::Configuration.Configuration _configuration;
        private readonly MagicMime _magicMime;
        private RenameForm _renameForm;

        private EditorForm()
        {
            InitializeComponent();
        }

        public EditorForm(string fileName, global::Configuration.Configuration configuration, MagicMime magicMagicMime, CancellationToken cancellationToken) : this()
        {
            _fileName = fileName;
            _configuration = configuration;
            _magicMime = magicMagicMime;
            _cancellationToken = cancellationToken;
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                if (_renameForm != null)
                {
                    _renameForm.Close();
                    _renameForm.Dispose();
                    _renameForm = null;
                    return;
                }

                components.Dispose();
            }
            base.Dispose(disposing);
        }

        private void tsmiExit_Click(object sender, EventArgs e)
        {
            Close();
        }

        private async void tsmiExport_Click(object sender, EventArgs e)
        {
            var bytes = await GetExportBytes(_fileName);

            ImageSave?.Invoke(this, new ImageChangedEventArgs(_fileName, bytes));
        }

        private async void EditorForm_Load(object sender, EventArgs e)
        {
            JotFormTracker.Tracker.Track(this);

            using var memoryStream = new MemoryStream();
            using var fileStream = new FileStream(_fileName, FileMode.Open, FileAccess.Read);
            await fileStream.CopyToAsync(memoryStream);
            var image = Image.FromStream(memoryStream);
            imageEditor1.ReplaceInitialImage(image, false, true);
        }

        private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (_renameForm != null)
            {
                return;
            }

            _renameForm = new RenameForm(_fileName);
            _renameForm.Rename += _renameForm_Rename;
            _renameForm.Closing += _renameForm_Closing;
            _renameForm.Show();
        }

        private void _renameForm_Closing(object sender, CancelEventArgs e)
        {
            if (_renameForm == null)
            {
                return;
            }

            _renameForm.Rename -= _renameForm_Rename;
            _renameForm.Closing -= _renameForm_Closing;
            _renameForm.Dispose();
            _renameForm = null;
        }

        private async void _renameForm_Rename(object sender, RenameForm.RenameEventArgs e)
        {
            var directory = Path.GetDirectoryName(_fileName);
            var bytes = await GetExportBytes(_fileName);
            if(bytes == null)
            {
                return;
            }

            ImageSaveAs?.Invoke(this, new ImageChangedEventArgs(Path.Combine(directory, e.FileName), bytes));
        }

        private async Task<byte[]> GetExportBytes(string fileName)
        {
            try
            {
                var mime = await _magicMime.GetMimeType(_fileName, _cancellationToken);

                byte[] bytes;
                switch (mime)
                {
                    case "image/jpeg":
                        bytes = imageEditor1.ExportBytes(ImageFormat.Jpeg);
                        break;
                    case "image/png":
                        bytes = imageEditor1.ExportBytes(ImageFormat.Png);
                        break;
                    case "image/bmp":
                        bytes = imageEditor1.ExportBytes(ImageFormat.Bmp);
                        break;
                    default:
                        throw new NotSupportedException($"Not supported image type {mime} for file {fileName}.");
                }

                return bytes;
            }
            catch(Exception exception)
            {
                Log.Error(exception, $"Could not determine image type for file {fileName}");

                return null;
            }
        }
    }
}