TabsView.cs

Go to the documentation of this file.

using AForge;
using BioImager.Source;
using BioLib;
using javax.swing.text;
using OpenSlideGTK;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Threading;
using System.Windows.Forms;
using ZarrNET.Core;
using ZarrNET.Core.Helpers;
using BioImage = BioLib.BioImage;
using RotateFlipType = AForge.RotateFlipType;
using ZCT = AForge.ZCT;
namespace BioImager
{
    public partial class TabsView : Form
    {
        public static bool init = false;
        public Filter filters = null;
        public ImageView viewer;
        public static System.Drawing.Graphics graphics = null;
        /* Returning the ImageView object that is currently selected in the tabControl. */
        public ImageView Viewer
        {
            get
            {
                if (tabControl.TabPages.Count == 0)
                    return null;
                if (tabControl.SelectedIndex == -1)
                    return null;
                if (tabControl.SelectedTab.Controls.Count == 0)
                    return null;
                return (ImageView)tabControl.SelectedTab.Controls[0];
            }
        }
        private List<ImageView> viewers = new List<ImageView>();
        public ImageView GetViewer(int i)
        {
            return viewers[i];
        }
        public ImageView? GetViewer(string name)
        {
            for (int v = 0; v < viewers.Count; v++)
            {
                for (int i = 0; i < viewers.Count; i++)
                {
                    if (viewers[v].Images[i].Filename == name)
                        return viewers[v];
                }
            }
            return null;
        }
        public int GetViewerCount()
        {
            return viewers.Count;
        }
        public void RemoveViewer(ImageView v)
        {
            viewers.Remove(v);
        }
        public void AddViewer(ImageView v)
        {
            viewers.Add(v);
        }
        public static BioImage SelectedImage
        {
            get
            {
                return App.tabsView.Image;
            }
        }
        public static ImageView SelectedViewer
        {
            get
            {
                return App.tabsView.Viewer;
            }
        }
        public TabsView(BioImage arg)
        {
            InitializeComponent();
            LoadProperties();
            ResizeView();
            Init();
        }
        public TabsView()
        {
            InitializeComponent();
            LoadProperties();
            ResizeView();
            Init();
        }
        /* A constructor for a class called TabsView. It is initializing the component and loading
        properties. It is also initializing the class. */
        public TabsView(string[] arg)
        {
            InitializeComponent();
            LoadProperties();
            Init();
            KeyPreview = true;
            if (arg.Length == 0)
                return;
            else
            {
                for (int i = 0; i < arg.Length; i++)
                {
                    if (arg[i].EndsWith(".cs"))
                    {
                        App.runner.RunScriptFile(arg[0]);
                        return;
                    }
                    if (arg[i].EndsWith(".ijm"))
                    {
                        ImageJ.RunMacro(arg[i], "");
                        return;
                    }
                    else
                    {
                        BioImage.OpenFile(arg[i], true);
                    }
                }
            }
        }
        public void AddTab(BioImage b)
        {
            if (b == null)
                return;
            if (HasTab(b))
                return;
            if (tabControl.IsHandleCreated)
                tabControl.Invoke((MethodInvoker)delegate
                {
                    if (HasTab(b))
                        return;
                    AddTabCore(b);
                    AddAssociatedImageTabs(b);
                });
        }
        public void RemoveTab(BioImage b)
        {
            int i = 0;
            foreach (ImageView t in tabControl.TabPages)
            {
                if (t.Name == b.filename)
                {
                    Images.RemoveImage(b);
                    return;
                }
                i++;
            }
        }
        public bool HasTab(string name)
        {
            foreach (TabPage item in tabControl.TabPages)
            {
                if (item.Text == name)
                {
                    return true;
                }
            }
            return false;
        }
        public bool HasTab(BioImage image)
        {
            if (image == null)
                return false;
            foreach (TabPage tabPage in tabControl.TabPages)
            {
                if (tabPage.Controls.Count == 0 || tabPage.Controls[0] is not ImageView view)
                    continue;
                foreach (BioImage tabImage in view.Images)
                {
                    if (tabImage == null)
                        continue;
                    if (ReferenceEquals(tabImage, image))
                        return true;
                    if (!string.IsNullOrEmpty(tabImage.ID) && !string.IsNullOrEmpty(image.ID) && tabImage.ID == image.ID)
                        return true;
                    if (!string.IsNullOrEmpty(tabImage.Filename) && !string.IsNullOrEmpty(image.Filename) && tabImage.Filename == image.Filename)
                        return true;
                }
            }
            return false;
        }
        private void AddTabCore(BioImage b)
        {
            if (b == null)
                return;
            if (b.filename.Contains("/") || b.filename.Contains("\\"))
                b.filename = Path.GetFileName(b.filename);
            TabPage t = new TabPage(b.filename);
            ImageView v = new ImageView(b);
            v.ShowStage = false;
            v.Dock = DockStyle.Fill;
            t.Controls.Add(v);
            tabControl.TabPages.Add(t);
            tabControl.SelectedIndex = tabControl.TabCount - 1;
            ResizeView();
        }
        private static BioImage CreateAssociatedImageTab(BioImage source, string name, AssociatedImage image)
        {
            if (source == null || image == null)
                return null;
 
            string baseName = Path.GetFileNameWithoutExtension(source.Filename);
            if (string.IsNullOrEmpty(baseName))
                baseName = Path.GetFileNameWithoutExtension(source.ID);
            if (string.IsNullOrEmpty(baseName))
                baseName = "associated";
 
            string suffix = name.Trim();
            if (string.IsNullOrEmpty(suffix))
                suffix = "associated";
 
            BioImage bi = new BioImage($"{source.ID}::{suffix}");
            bi.Filename = $"{baseName}-{suffix}.png";
            bi.file = source.file;
            bi.Resolutions.Add(new Resolution(
                (int)image.Dimensions.Width,
                (int)image.Dimensions.Height,
                AForge.PixelFormat.Format32bppArgb,
                1,
                1,
                1,
                0,
                0,
                0));
            bi.Buffers.Add(new AForge.Bitmap(
                "",
                (int)image.Dimensions.Width,
                (int)image.Dimensions.Height,
                AForge.PixelFormat.Format32bppArgb,
                image.Data,
                new ZCT(),
                0,
                null,
                littleEndian: true,
                interleaved: true));
            bi.Channels.Add(new Channel(0, 8, 4));
            bi.UpdateCoords(1, 1, 1);
            bi.Volume = new VolumeD(new Point3D(0, 0, 0), new Point3D(
                bi.PhysicalSizeX * bi.SizeX,
                bi.PhysicalSizeY * bi.SizeY,
                bi.PhysicalSizeZ * bi.SizeZ));
            bi.Coordinate = new ZCT(0, 0, 0);
            return bi;
        }
        private void AddAssociatedImageTabs(BioImage source)
        {
            if (source?.OpenSlideBase?.SlideImage == null)
                return;
 
            foreach (var entry in source.OpenSlideBase.SlideImage.GetAssociatedImages())
            {
                string name = entry.Key ?? string.Empty;
                if (!name.Contains("label", StringComparison.OrdinalIgnoreCase) &&
                    !name.Contains("macro", StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }
 
                BioImage associated = CreateAssociatedImageTab(source, name, entry.Value);
                if (associated != null && !HasTab(associated))
                    AddTabCore(associated);
            }
        }
        private void Init()
        {
            TabPage t = new TabPage("Viewer");
            ImageView v = new ImageView();
            v.ShowStage = true;
            v.Dock = DockStyle.Fill;
            t.Controls.Add(v);
            tabControl.TabPages.Add(t);
            filters = new Filter();
            App.tabsView = this;
            Plugins.Initialize();
            string a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            foreach (char c in a)
            {
                ToolStripMenuItem me = new ToolStripMenuItem(c.ToString());
                foreach (ImageJ.Macro.Command command in ImageJ.Macro.Commands.Values)
                {
                    if (command.Name.StartsWith(c))
                    {
                        ToolStripMenuItem menuItem = new ToolStripMenuItem(command.Name.ToString());
                        menuItem.Click += MenuItem_Click;
                        me.DropDownItems.Add(menuItem);
                    }
                }
                commandToolStripMenuItem.DropDownItems.Add(me);
            }
            foreach (Scripting.Script s in Scripting.Scripts.Values)
            {
                ToolStripMenuItem mi = new ToolStripMenuItem(s.name);
                mi.Click += Mi_Click;
                runToolStripMenuItem.DropDownItems.Add(mi);
            }
            foreach (ImageJ.Macro.Command c in ImageJ.Macros)
            {
                ToolStripMenuItem mi = new ToolStripMenuItem(c.Name);
                mi.Click += Mi_Click;
                runToolStripMenuItem.DropDownItems.Add(mi);
            }
            ML.ML.Initialize();
            init = true;
        }
 
        private void Mi_Click(object? sender, EventArgs e)
        {
            ToolStripMenuItem m = (ToolStripMenuItem)sender;
            if (m.Text.EndsWith(".ijm") || m.Text.EndsWith(".txt") && !m.Text.EndsWith(".cs"))
            {
                string ma = File.ReadAllText(m.Text);
                ImageJ.RunOnImage(ma, BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.newTab);
            }
            else
                Scripting.RunByName(m.Text);
        }
 
        private void MenuItem_Click(object? sender, EventArgs e)
        {
            if (ImageView.SelectedImage == null) return;
            ToolStripMenuItem m = (ToolStripMenuItem)sender;
            ImageJ.RunOnImage("run(\"" + m.Text + "\");", BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.newTab);
            ToolStripMenuItem mi = new ToolStripMenuItem(m.Text);
            mi.Click += MenuItem_Click;
            bool con = false;
            foreach (ToolStripMenuItem item in recentToolStripMenuItem.DropDownItems)
            {
                if (item.Text == m.Text)
                    con = true;
            }
            if (!con)
                recentToolStripMenuItem.DropDownItems.Add(mi);
        }
 
        public void ResizeView()
        {
            if (Image == null)
                return;
            System.Drawing.Size s;
            if (SelectedImage.isPyramidal)
                s = new System.Drawing.Size(ImageView.SelectedImage.Resolutions[Viewer.Level].SizeX + 42, ImageView.SelectedImage.Resolutions[Viewer.Level].SizeY + 206);
            else
                s = new System.Drawing.Size(ImageView.SelectedImage.SizeX + 20, ImageView.SelectedImage.SizeY + 180);
            if (s.Width > Screen.PrimaryScreen.Bounds.Width || s.Height > Screen.PrimaryScreen.Bounds.Height)
            {
                this.WindowState = FormWindowState.Maximized;
                Viewer.GoToImage();
            }
            else
            {
                Size = s;
                Viewer.GoToImage();
            }
        }
 
        /* A property that returns the selected image from the image viewer. */
        public BioImage Image
        {
            get
            {
                if (Viewer == null)
                    return null;
                if (ImageView.SelectedImage == null)
                    return null;
                return ImageView.SelectedImage;
            }
        }
 
        /* A property that returns the number of tabs in the tab control. */
        public int TabCount
        {
            get
            {
                return tabControl.TabPages.Count;
            }
        }
 
        public void OpenInNewProcess(string file)
        {
            Process p = new Process();
            p.StartInfo.FileName = Application.ExecutablePath;
            p.StartInfo.Arguments = file;
            p.Start();
        }
 
        private async void openToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            foreach (string item in openFilesDialog.FileNames)
            {
                StartProgress("Opening selected image.", "Opening");
                BioImage im = await BioImage.OpenFile(item);
                StopProgress();
                if (im == null)
                    return;
                AddTab(im);
                if (!Images.images.Contains(im))
                    Images.images.Add(im);
                if (!App.recent.Contains(im.ID))
                    App.recent.Add(im.ID);
            }
            foreach (string item in App.recent)
            {
                openRecentToolStripMenuItem.DropDownItems.Add(item, null, ItemClicked);
            }
        }
 
        private void SaveProperties()
        {
            string s = "";
            for (int i = 0; i < App.recent.Count; i++)
            {
                s += "$" + App.recent[i];
            }
            Properties.Settings.Default["Recent"] = s;
            Properties.Settings.Default.Save();
        }
 
        private void LoadProperties()
        {
            App.recent.Clear();
            string s = (string)Properties.Settings.Default["Recent"];
            string[] sts = s.Split('$');
            foreach (string item in sts)
            {
                if (item != "")
                    App.recent.Add(item);
            }
        }
 
        private static bool done = false;
        private static Progress progress = new Progress("", "");
        private static string title;
        private static void ProgressUpdate()
        {
            do
            {
                progress.Text = title;
                progress.Status = BioImage.Status;
                progress.ProgressValue = BioImage.Progress;
                Thread.Sleep(250);
            } while (!done);
        }
        private static void StartProgress(string titl, string status)
        {
            done = false;
            title = titl;
            BioImage.Progress = 0;
            progress.Status = status;
            progress.Text = title;
            if (BioImage.Status == "" || BioImage.Status == null)
                progress.Status = status;
            else
                progress.Status = BioImage.Status;
            progress.ProgressValue = BioImage.Progress;
            progress.Show();
            Application.DoEvents();
            Thread th = new Thread(ProgressUpdate);
            th.Start();
        }
        private static void StopProgress()
        {
            done = true;
            progress.Hide();
        }
 
        private void closeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (this.Viewer != null)
            {
                Images.RemoveImage(SelectedImage);
            }
        }
 
        private void saveToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Image == null)
                return;
            saveTiffFileDialog.FileName = Path.GetFileNameWithoutExtension(Image.Filename);
            if (saveTiffFileDialog.ShowDialog() != DialogResult.OK)
                return;
            string[] sts = new string[1];
            sts[0] = ImageView.SelectedImage.ID;
            StartProgress("Saving selected Tiff.", "Saving");
            BioImage.SaveSeries(sts, saveTiffFileDialog.FileName);
            StopProgress();
        }
 
        private void ImageViewer_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
        {
            if (e.KeyCode == Keys.S && e.Control)
            {
                saveToolStripMenuItem.PerformClick();
            }
            else
                if (e.KeyCode == Keys.O && e.Control)
                {
                    openToolStripMenuItem.PerformClick();
                }
        }
 
        private void toolboxToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.tools.Show();
        }
 
        private void exportCSVToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveCSVFileDialog.ShowDialog() != DialogResult.OK)
                return;
            BioImage.ExportROIsCSV(saveCSVFileDialog.FileName, ImageView.SelectedImage.Annotations);
        }
 
        private void importCSVToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openCSVFileDialog.ShowDialog() != DialogResult.OK)
                return;
            ImageView.SelectedImage.Annotations.AddRange(BioImage.ImportROIsCSV(openCSVFileDialog.FileName));
        }
 
        private void exportROIsOfFolderOfImagesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (folderBrowserDialog.ShowDialog() != DialogResult.OK)
                return;
            saveOMEFileDialog.InitialDirectory = folderBrowserDialog.SelectedPath;
            if (saveCSVFileDialog.ShowDialog() != DialogResult.OK)
                return;
            string f = Path.GetFileName(saveCSVFileDialog.FileName);
 
            BioImage.ExportROIFolder(folderBrowserDialog.SelectedPath, f);
        }
 
        private void rOIManagerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.manager.Show();
        }
 
        private void ImageViewer_Activated(object sender, EventArgs e)
        {
            App.tabsView = this;
            //App.Image = SelectedImage;
        }
 
        private void channelsToolToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (ImageView.SelectedImage == null)
                return;
            if (App.channelsTool == null)
                App.channelsTool = new ChannelsTool(App.Channels);
            App.channelsTool.Show();
        }
 
        private void rGBToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Viewer == null)
                return;
            Viewer.Mode = ImageView.ViewMode.RGBImage;
            filteredToolStripMenuItem.Checked = false;
            rawToolStripMenuItem.Checked = false;
            emissionToolStripMenuItem.Checked = false;
            Viewer.UpdateStatus();
        }
 
        private void filteredToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Viewer == null)
                return;
            Viewer.Mode = ImageView.ViewMode.Filtered;
            rGBToolStripMenuItem.Checked = false;
            rawToolStripMenuItem.Checked = false;
            emissionToolStripMenuItem.Checked = false;
            Viewer.UpdateStatus();
        }
 
        private void rawToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Viewer == null)
                return;
            Viewer.Mode = ImageView.ViewMode.Raw;
            rGBToolStripMenuItem.Checked = false;
            filteredToolStripMenuItem.Checked = false;
            emissionToolStripMenuItem.Checked = false;
            Viewer.UpdateStatus();
        }
 
        private void autoThresholdToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Viewer == null)
                return;
            BioImage.AutoThreshold(ImageView.SelectedImage, true);
            if (ImageView.SelectedImage.bitsPerPixel > 8)
                ImageView.SelectedImage.StackThreshold(true);
            else
                ImageView.SelectedImage.StackThreshold(false);
        }
 
 
        public void UpdateViewMode(ImageView.ViewMode v)
        {
            if (v == ImageView.ViewMode.RGBImage)
                rGBToolStripMenuItem.Checked = true;
            if (v == ImageView.ViewMode.Filtered)
                filteredToolStripMenuItem.Checked = true;
            if (v == ImageView.ViewMode.Raw)
                rawToolStripMenuItem.Checked = true;
        }
 
        private void scriptRunnerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.runner.WindowState = FormWindowState.Normal;
            App.runner.Show();
        }
 
        private void stackToolsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.stackTools.Show();
        }
 
        private void scriptRecorderToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Recorder.recorder.WindowState = FormWindowState.Normal;
            Recorder.recorder.Show();
        }
 
        private void saveOMEToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Image == null)
                return;
            saveOMEFileDialog.FileName = Path.GetFileNameWithoutExtension(ImageView.SelectedImage.Filename);
            if (saveOMEFileDialog.ShowDialog() != DialogResult.OK)
                return;
            foreach (string file in saveOMEFileDialog.FileNames)
            {
                StartProgress("Saving selected OME.", "Saving OME");
                BioImage.SaveOME(file, Image.ID);
                StopProgress();
            }
        }
 
        private void copyToClipboardToolStripMenuItem_Click(object sender, EventArgs e)
        {
 
        }
 
        private void setToolToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SetTool tool = new SetTool();
            tool.Show();
        }
 
        private void timer_Tick(object sender, EventArgs e)
        {
            //Here we update the tabs based on images in the table.
 
        }
 
        private void filtersToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
        }
 
        private void to8BitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Image.To8Bit();
        }
 
        private void to16BitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Image.To16Bit();
        }
 
        private void filtersToolStripMenuItem_Click(object sender, EventArgs e)
        {
            filters = new Filter();
            filters.Show();
        }
 
        private void bit8ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Image.To8Bit();
            Viewer.InitGUI();
            Viewer.UpdateImages();
        }
 
        private void bit16ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Image.To16Bit();
            Viewer.InitGUI();
            Viewer.UpdateImages();
        }
 
        private void to24BitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Image.To24Bit();
            //We update the viewer gui since there are less planes now.
            Viewer.InitGUI();
            Viewer.UpdateImages();
        }
 
        private void to48BitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Image.To48Bit();
            //We update the viewer gui since there are less planes now.
            Viewer.InitGUI();
            Viewer.UpdateImages();
        }
 
        private void to32BitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Image.To32Bit();
            Viewer.InitGUI();
            Viewer.UpdateImages();
        }
 
        private void toWindowToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (tabControl.SelectedIndex == -1)
                return;
            BioImage im = ImageView.SelectedImage;
            ImageWindow vi = new ImageWindow(im);
            vi.Show();
        }
 
        private void tabControl_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (tabControl.SelectedIndex == -1)
                return;
            //We update the view status based on tab.
            if (Viewer.Mode == ImageView.ViewMode.Raw)
                rawToolStripMenuItem.Checked = true;
            else
                rawToolStripMenuItem.Checked = false;
            if (Viewer.Mode == ImageView.ViewMode.Filtered)
                filteredToolStripMenuItem.Checked = true;
            else
                filteredToolStripMenuItem.Checked = false;
            if (Viewer.Mode == ImageView.ViewMode.RGBImage)
                rGBToolStripMenuItem.Checked = true;
            else
                rGBToolStripMenuItem.Checked = false;
            //We update the active Viewer.
            App.viewer = Viewer;
            Viewer.SelectedIndex = 0;
        }
 
        private void closeToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            if (tabControl.SelectedIndex == -1)
                return;
            ImageView v = (ImageView)tabControl.SelectedTab.Controls[0];
            tabControl.TabPages.RemoveAt(tabControl.SelectedIndex);
            v.Dispose();
            foreach (BioImage item in v.Images)
            {
                Images.RemoveImage(item);
                item.Dispose();
            }
            GC.Collect();
        }
 
        private void saveAllToolStripMenuItem_Click(object sender, EventArgs e)
        {
 
            List<string> sts = new List<string>();
            foreach (BioImage item in Images.images)
            {
                StartProgress("Save Selected Tiff", "Saving");
                BioImage.SaveFile(Image.ID, Image.ID);
                StopProgress();
            }
        }
 
        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            About about = new About();
            about.Show();
        }
 
        private void scriptRunnerToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            App.runner.Show();
        }
 
        private void scriptRecorderToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            App.recorder.Show();
        }
 
        private void openOMEToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            foreach (string item in openFilesDialog.FileNames)
            {
                StartProgress("Opening selected OME", "Opening OME");
                BioImage im = BioImage.OpenOME(item, 0, false, false, false, 0, 0, 0, 0);
                if (im == null)
                    return;
                AddTab(im);
                if (!Images.images.Contains(im))
                    Images.images.Add(im);
                if (!App.recent.Contains(im.ID))
                    App.recent.Add(im.ID);
            }
            foreach (string item in App.recent)
            {
                openRecentToolStripMenuItem.DropDownItems.Add(item, null, ItemClicked);
            }
        }
 
        private void newTabViewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Process.Start(Application.ExecutablePath);
        }
 
        private void nodeViewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.nodeView.Show();
            App.nodeView.ShowInTaskbar = true;
        }
        private void saveToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            if (saveTiffFileDialog.ShowDialog() == DialogResult.OK)
            {
                StartProgress("Saving selected Tiff", "Saving");
                BioImage.SaveFile(ImageView.SelectedImage.ID, saveTiffFileDialog.FileName);
                StopProgress();
            }
        }
 
        private void saveOMEToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            if (saveOMEFileDialog.ShowDialog() == DialogResult.OK)
                BioImage.SaveOME(ImageView.SelectedImage.ID, saveOMEFileDialog.FileName);
        }
        private void openRecentToolStripMenuItem_DropDownOpening(object sender, EventArgs e)
        {
            openRecentToolStripMenuItem.DropDownItems.Clear();
            foreach (string item in App.recent)
            {
                openRecentToolStripMenuItem.DropDownItems.Add(item, null, ItemClicked);
            }
        }
        private void ItemClicked(object sender, EventArgs e)
        {
            ToolStripMenuItem ts = (ToolStripMenuItem)sender;
            if (!BioImage.isOME(ts.Text))
            {
                BioImage[] bs = BioImage.OpenSeries(ts.Text, true);
                for (int i = 0; i < bs.Length; i++)
                {
                    if (i == 0)
                        AddTab(bs[i]);
                    else
                        Viewer.AddImage(bs[i]);
                }
            }
            else
            {
                BioImage[] bs = BioImage.OpenOMESeries(ts.Text, true, true);
            }
            App.viewer.GoToImage();
            SaveProperties();
        }
        private void TabsView_KeyDown(object sender, KeyEventArgs e)
        {
            if (Viewer == null)
                return;
            double moveAmount = 1500 * (1 / App.viewer.Scale.Width);
            if (e.KeyCode == Keys.C && e.Control)
            {
                Viewer.CopySelection();
                return;
            }
            if (e.KeyCode == Keys.V && e.Control)
            {
                Viewer.PasteSelection();
                return;
            }
            if (e.KeyCode == Keys.Subtract || e.KeyCode == Keys.NumPad7)
            {
                App.viewer.Scale = new AForge.SizeF(App.viewer.Scale.Width - 0.1f, App.viewer.Scale.Height - 0.1f);
            }
            if (e.KeyCode == Keys.Add || e.KeyCode == Keys.NumPad9)
            {
                App.viewer.Scale = new AForge.SizeF(App.viewer.Scale.Width - 0.1f, App.viewer.Scale.Height - 0.1f);
            }
            if (e.KeyCode == Keys.W || e.KeyCode == Keys.NumPad8)
            {
                Viewer.Origin = new PointD(Viewer.Origin.X, Viewer.Origin.Y - moveAmount);
            }
            if (e.KeyCode == Keys.S || e.KeyCode == Keys.NumPad2)
            {
                Viewer.Origin = new PointD(Viewer.Origin.X, Viewer.Origin.Y + moveAmount);
            }
            if (e.KeyCode == Keys.A || e.KeyCode == Keys.NumPad4)
            {
                Viewer.Origin = new PointD(Viewer.Origin.X - moveAmount, Viewer.Origin.Y);
            }
            if (e.KeyCode == Keys.D || e.KeyCode == Keys.NumPad6)
            {
                Viewer.Origin = new PointD(Viewer.Origin.X + moveAmount, Viewer.Origin.Y);
            }
            if (e.KeyCode == Keys.Up)
                Microscope.MoveUp(Microscope.viewSize.Y / 2);
            if (e.KeyCode == Keys.Down)
                Microscope.MoveDown(Microscope.viewSize.Y / 2);
            if (e.KeyCode == Keys.Left)
                Microscope.MoveRight(-(Microscope.viewSize.X / 2));
            if (e.KeyCode == Keys.Right)
                Microscope.MoveRight((Microscope.viewSize.X / 2) / 2);
            Viewer.UpdateStatus();
            Viewer.UpdateView();
        }
 
        private void duplicateToolStripMenuItem_Click(object sender, EventArgs e)
        {
            BioImage im = Image.Copy();
            AddTab(im);
        }
 
        private void saveSeriesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.seriesTool.Show();
        }
 
        private void TabsView_FormClosing(object sender, FormClosingEventArgs e)
        {
            SaveProperties();
            Microscope.Close();
            App.imager.Close();
            App.stage.Close();
            App.nodeView.Close();
            Application.Exit();
        }
 
        private void automationToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.recordings.Show();
        }
 
        private void stageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.stage.Show();
        }
 
        private async void addImagesToTabToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            for (int i = 0; i < openFilesDialog.FileNames.Length; i++)
            {
                if (i == 0 && tabControl.TabPages.Count == 0)
                {
                    BioImage b = await BioImage.OpenFile(openFilesDialog.FileNames[i]);
                }
                else
                {
                    BioImage b = await BioImage.OpenFile(openFilesDialog.FileNames[i]);
                    Viewer.AddImage(b);
                }
            }
            App.viewer.GoToImage();
        }
 
        private void addImagesOMEToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            for (int i = 0; i < openFilesDialog.FileNames.Length; i++)
            {
                if (i == 0 && tabControl.TabPages.Count == 0)
                {
                    BioImage b = BioImage.OpenOME(openFilesDialog.FileNames[i], 0, true, true, false, 0, 0, 0, 0);
                }
                else
                {
                    BioImage b = BioImage.OpenOME(openFilesDialog.FileNames[i], 0, true, true, false, 0, 0, 0, 0);
                    Viewer.AddImage(b);
                }
            }
            App.viewer.GoToImage();
        }
 
        private void openSeriesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            BioImage[] bs = BioImage.OpenOMESeries(openFilesDialog.FileName, false, true);
            if (bs == null)
                return;
            AddTab(bs[0]);
            for (int i = 1; i < bs.Length; i++)
            {
                Viewer.AddImage(bs[i]);
            }
            App.viewer.GoToImage();
        }
 
        private void saveTabToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveOMEFileDialog.ShowDialog() != DialogResult.OK)
                return;
            bool convert = false;
            foreach (BioImage b in Viewer.Images)
            {
                if (b.isRGB)
                {
                    convert = true;
                    break;
                }
            }
            if (convert)
            {
                string mes;
                if (ImageView.SelectedImage.bitsPerPixel > 8)
                    mes = "Saving Series as OME only supports 8 bit & 16 bit images. Convert 16 bit?";
                else
                    mes = "Saving Series as OME only supports 8 bit & 16 bit images. Convert 8 bit?";
                if (MessageBox.Show(this, mes, "Convert to supported format?", MessageBoxButtons.OKCancel) == DialogResult.OK)
                {
                    foreach (BioImage b in Viewer.Images)
                    {
                        if (b.bitsPerPixel > 8)
                            b.To16Bit();
                        else
                            b.To8Bit();
                    }
                }
                else
                    return;
            }
 
            BioImage[] sts = new BioImage[App.viewer.Images.Count];
            for (int i = 0; i < sts.Length; i++)
            {
                sts[i] = App.viewer.Images[i];
            }
            BioImage.SaveOMESeries(sts, saveOMEFileDialog.FileName, Properties.Settings.Default.Planes);
        }
 
        private void saveTabTiffToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveTiffFileDialog.ShowDialog() != DialogResult.OK)
                return;
            string[] sts = new string[App.viewer.Images.Count];
            for (int i = 0; i < sts.Length; i++)
            {
                sts[i] = App.viewer.Images[i].Filename;
            }
            BioImage.SaveSeries(sts, saveTiffFileDialog.FileName);
        }
 
        private void openSeriesToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            BioImage[] bms = null;
            foreach (string item in openFilesDialog.FileNames)
            {
                bms = BioImage.OpenSeries(openFilesDialog.FileName, false);
                for (int i = 0; i < bms.Length; i++)
                {
                    if (i == 0)
                    {
                        AddTab(bms[i]);
                    }
                    else
                        App.viewer.AddImage(bms[i]);
                }
            }
            App.viewer.GoToImage();
        }
 
        private void TabsView_Load(object sender, EventArgs e)
        {
            if (App.viewer != null)
                App.viewer.GoToImage();
 
            Function.Initialize();
        }
 
        private void clearRecentToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Properties.Settings.Default.Recent = "";
            Properties.Settings.Default.Save();
            openRecentToolStripMenuItem.DropDownItems.Clear();
            App.recent.Clear();
        }
 
        private void rotateToolStripMenuItem_DropDownItemClicked(object sender, ToolStripItemClickedEventArgs e)
        {
            if (ImageView.SelectedImage == null)
                return;
            string st = e.ClickedItem.Text;
            RotateFlipType rot = (RotateFlipType)Enum.Parse(typeof(RotateFlipType), st);
            ImageView.SelectedImage.RotateFlip(rot);
            Viewer.UpdateImage();
            Viewer.UpdateView();
        }
 
        private void rotateToolStripMenuItem_DropDownOpening(object sender, EventArgs e)
        {
            if (rotateToolStripMenuItem.DropDownItems.Count > 0)
                return;
            string[] sts = Enum.GetNames(typeof(RotateFlipType));
            foreach (string item in sts)
            {
                rotateToolStripMenuItem.DropDownItems.Add(item);
            }
        }
 
        private void emissionToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (Viewer == null)
                return;
            Viewer.Mode = ImageView.ViewMode.Emission;
            rGBToolStripMenuItem.Checked = false;
            rawToolStripMenuItem.Checked = false;
            filteredToolStripMenuItem.Checked = false;
            emissionToolStripMenuItem.Checked = true;
            Viewer.UpdateStatus();
        }
 
        private void consoleToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.console.Show();
        }
 
        private void switchRedBlueToolStripMenuItem_Click(object sender, EventArgs e)
        {
            foreach (AForge.Bitmap bf in ImageView.SelectedImage.Buffers)
            {
                bf.SwitchRedBlue();
            }
            Viewer.UpdateImages();
        }
        private void createFunctionToolStripMenuItem_Click(object sender, EventArgs e)
        {
            FunctionForm f = new FunctionForm(new Function());
            f.Show();
        }
        private void DropDownItemClicked(object sender, EventArgs e)
        {
            ToolStripMenuItem ts = (ToolStripMenuItem)sender;
            Function.Functions[ts.Text].PerformFunction(true);
        }
        private void runToolStripMenuItem_DropDownOpening(object sender, EventArgs e)
        {
            runToolStripMenuItem.DropDownItems.Clear();
            foreach (var item in Function.Functions)
            {
                runToolStripMenuItem.DropDownItems.Add(item.Value.Name, null, DropDownItemClicked);
            }
        }
 
        private void reloadToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ImageView.SelectedImage.Update();
        }
 
        private void xMLToolStripMenuItem_Click(object sender, EventArgs e)
        {
            XMLView v = new XMLView(BioImage.OpenXML(ImageView.SelectedImage.file));
            v.Show();
        }
 
        private void imagesToStackToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OpenFileDialog fd = new OpenFileDialog();
            fd.Title = "Images to Stack";
            fd.Multiselect = true;
            if (fd.ShowDialog() != DialogResult.OK)
                return;
            BioImage b = BioImage.ImagesToStack(fd.FileNames, false);
            AddTab(b);
        }
 
        private void importImageJROIToSelectedImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openImageJROI.ShowDialog() != DialogResult.OK)
                return;
            foreach (string item in openImageJROI.FileNames)
            {
                ImageView.SelectedImage.Annotations.Add(ImageJ.RoiDecoder.open(item));
            }
            App.viewer.UpdateView();
        }
 
        private void exportImageJROIFromSelectedImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            saveImageJROI.Title = "Set Filename for exported ROI's.";
            saveImageJROI.FileName = ImageView.SelectedImage.Filename;
            if (saveImageJROI.ShowDialog() != DialogResult.OK)
                return;
            int i = 1;
            foreach (ROI roi in ImageView.SelectedImage.Annotations)
            {
                string s = Path.GetDirectoryName(saveImageJROI.FileName) + "//" + Path.GetFileNameWithoutExtension(saveImageJROI.FileName) + "-" + i + ".roi";
                ImageJ.RoiEncoder.save(roi, s);
                i++;
            }
            App.viewer.UpdateView();
        }
 
        private void lightToolToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.lightTool.Show();
        }
 
        private void savePyramidalToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveOMEFileDialog.ShowDialog() != DialogResult.OK)
                return;
            BioImage.SaveOMEPyramidal(App.viewer.Images.ToArray(), saveOMEFileDialog.FileName, NetVips.Enums.ForeignTiffCompression.None, 0);
        }
 
        private void findFocusToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (ImageView.SelectedImage == null) return;
            ZCT co = SelectedViewer.GetCoordinate();
            int f = BioImage.FindFocus(ImageView.SelectedImage, co.C, co.T);
            ZCT z = ImageView.SelectedImage.Buffers[f].Coordinate;
            SelectedViewer.SetCoordinate(z.Z, z.C, z.T);
        }
 
        private void setupToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.setup.Show();
        }
 
        private void imagerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.imager.Show();
        }
 
        private void stageToolToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.stage.Show();
        }
 
        private void cellImagerToolStripMenuItem_Click_1(object sender, EventArgs e)
        {
            App.cellImager.Show();
        }
 
        private void slideImagerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            App.slideImager.Show();
        }
 
        private void importGeoJSONROIToSelectedImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            ImageView.SelectedImage.Annotations.AddRange(QuPath.ReadROI(openFilesDialog.FileName, ImageView.SelectedImage));
        }
 
        private void exportGeoJSONROIFromSelectedImageToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveOMEFileDialog.ShowDialog() != DialogResult.OK)
                return;
            QuPath.SaveROI(saveOMEFileDialog.FileName, ImageView.SelectedImage);
        }
 
        private async void openQuPathProjectToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openQuPathProjDialog.ShowDialog() != DialogResult.OK)
                return;
            QuPath.Project pr = QuPath.OpenProject(openQuPathProjDialog.FileName);
            foreach (QuPath.Image p in pr.Images)
            {
                string s = p.ServerBuilder.Uri.Replace("file:/", "");
                App.tabsView.AddTab(await BioImage.OpenFile(s));
            }
        }
 
        private void saveQuPathProjectToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveQuPathDialog.ShowDialog() != DialogResult.OK)
                return;
            List<BioImage[]> images = new List<BioImage[]>();
            foreach (var item in viewers)
            {
                List<BioImage> imageList = new List<BioImage>();
                foreach (var image in item.Images)
                {
                    imageList.Add(image);
                }
                images.Add(imageList.ToArray());
            }
            QuPath.Project.SaveProject(saveQuPathDialog.FileName, images);
        }
        public void SetTab(int i)
        {
            tabControl.SelectTab(i);
        }
        private void oMEROToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OMERO om = new OMERO();
            om.Show();
        }
        public static void SelectWindow(string name)
        {
            TabsView tbs = App.tabsView;
 
            int c = tbs.GetViewerCount();
            for (int v = 0; v < c; v++)
            {
                int cc = tbs.GetViewer(v).Images.Count;
                for (int im = 0; im < cc; im++)
                {
                    if (tbs.GetViewer(v).Images[im].Filename == Path.GetFileName(name))
                    {
                        tbs.SetTab(v);
                        BioLib.Recorder.Record("App.SelectWindow(\"" + name + "\")");
                        ImageView.SelectedImage = tbs.GetViewer(v).Images[im];
                        App.viewer = tbs.GetViewer(v);
                        App.viewer.BringToFront();
                        return;
                    }
                }
            }
        }
        public static void CloseWindow(string name)
        {
            BioLib.Recorder.Record("App.CloseWindow(\"" + name + "\")");
            TabsView tbs = App.tabsView;
            int c = tbs.GetViewerCount();
            if (name == "ROI Manager")
                App.manager.Close();
            else
                if (name == "Stack Tool")
                    App.stackTools.Close();
                else
                    if (name == "Channels Tool")
                        App.channelsTool.Close();
                    else
                        if (name == "Scripting")
                            App.runner.Close();
                        else
                            if (name == "Recorder")
                                App.recorder.Close();
                            else
                                if (name == "Tools")
                                    App.tools.Close();
                                else
                                    for (int v = 0; v < c; v++)
                                    {
                                        int cc = tbs.GetViewer(v).Images.Count;
                                        for (int im = 0; im < cc; im++)
                                        {
                                            ImageView vi = tbs.GetViewer(v);
                                            if (vi.Images[im].Filename == Path.GetFileName(name))
                                            {
                                                tbs.RemoveTab(vi.Images[im]);
                                                return;
                                            }
                                            else if (vi.Name == name)
                                            {
                                                tbs.RemoveTab(vi.Images[im]);
                                                return;
                                            }
                                        }
                                    }
 
        }
        public void RenameTab(string name, string newName)
        {
            foreach (ImageView item in tabControl.TabPages)
            {
                if (item.Name == name)
                {
                    item.Name = newName;
                    foreach (var b in item.Images)
                    {
                        b.Filename = newName;
                        b.ID = newName;
                        return;
                    }
                }
            }
        }
        public static void Rename(string text)
        {
            App.tabsView.RenameTab(ImageView.SelectedImage.Filename, text);
            ImageView.SelectedImage.Rename(text);
            ImageView v = App.tabsView.GetViewer(ImageView.SelectedImage.Filename);
            v.Name = ImageView.SelectedImage.Filename;
            BioLib.Recorder.AddLine("App.Rename(\"" + text + "\");", false);
        }
 
        private async void zarrMenuItem_Click(object sender, EventArgs e)
        {
            if (folderBrowserDialog.ShowDialog() != DialogResult.OK)
                return;
            var bio = await BioImage.OpenURL(folderBrowserDialog.SelectedPath, new ZCT(0, 0, 0), 0, 0, 256, 256);
            App.tabsView.AddTab(bio);
        }
 
        private async void uriMenuItem_Click(object sender, EventArgs e)
        {
            UrlDialog dialog = new UrlDialog();
            if (dialog.ShowDialog() != DialogResult.OK)
                return;
            var bio = await BioImage.OpenURL(dialog.Url, new ZCT(0, 0, 0), 0, 0, 256, 256);
            App.tabsView.AddTab(bio);
        }
    }
}