TabsView.cs

Go to the documentation of this file.

using AForge;
using BioCore;
using BioLib;
using System.Diagnostics;
using System.ComponentModel;
namespace BioCore
{
    public partial class TabsView : Form
    {
        public static bool init = false;
        public Filter filters = null;
        public static System.Drawing.Graphics graphics = null;
        public List<ImageView> viewers = new List<ImageView>();
        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];
            }
        }
        /* A property that returns the image that is currently selected in the tabsView. */
        public static BioImage SelectedImage
        {
            get
            {
                return App.tabsView.Image;
            }
        }
        /* A property that returns the ImageViewer object from the tab control. */
        public static ImageView SelectedViewer
        {
            get
            {
                return App.tabsView.ImageView;
            }
        }
        /* Initializing the component. */
        public TabsView(BioImage arg)
        {
            InitializeComponent();
            LoadProperties();
            ResizeView();
            Init();
            AddTab(arg);
        }
        /* Initializing the component and loading the properties. */
        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();
            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"))
                    {
                        Fiji.RunMacroFiji(ImageView.SelectedImage, arg[i], "");
                        return;
                    }
                    else
                    {
                        AddTab(BioImage.OpenFile(arg[i]).Result);
                    }
                }
            }
        }
        public void AddTab(BioImage b)
        {
            if (b == null)
                throw new ArgumentNullException(nameof(b), "The image loader returned no image to display.");
            if (b.filename.Contains('/') || b.filename.Contains('\\'))
                b.filename = Path.GetFileName(b.filename);
            TabPage t = new TabPage(GetAvailableTabTitle(b.filename));
            ImageView v = new ImageView(b);
            v.Dock = DockStyle.Fill;
            t.Controls.Add(v);
            if (Width < b.SizeX || Height < b.SizeY)
            {
                Width = b.SizeX;
                Height = b.SizeY + 190;
            }
            tabControl.TabPages.Add(t);
            tabControl.Dock = DockStyle.Fill;
            tabControl.SelectedIndex = tabControl.TabCount - 1;
            viewers.Add(v);
            ResizeView();
            if (!Visible)
                Show();
            if (WindowState == FormWindowState.Minimized)
                WindowState = FormWindowState.Normal;
            Activate();
        }
 
        private string GetAvailableTabTitle(string filename)
        {
            var titles = new HashSet<string>(tabControl.TabPages.Cast<TabPage>().Select(page => page.Text), StringComparer.OrdinalIgnoreCase);
            if (!titles.Contains(filename))
                return filename;
 
            // Keep the compound OME extension together when numbering copies.
            string extension = filename.EndsWith(".ome.zarr", StringComparison.OrdinalIgnoreCase) ? filename.Substring(filename.Length - 9)
                : filename.EndsWith(".ome.tiff", StringComparison.OrdinalIgnoreCase) ? filename.Substring(filename.Length - 9)
                : filename.EndsWith(".ome.tif", StringComparison.OrdinalIgnoreCase) ? filename.Substring(filename.Length - 8)
                : Path.GetExtension(filename);
            string stem = filename.Substring(0, filename.Length - extension.Length);
            for (int number = 2; ; number++)
            {
                string title = $"{stem}-{number}{extension}";
                if (!titles.Contains(title))
                    return title;
            }
        }
 
        public void RemoveTab(string tabName)
        {
            for (int i = 0; i < tabControl.TabPages.Count; i++)
            {
                var item = tabControl.TabPages[i];
                string name = System.IO.Path.GetFileName(item.Name);
                if (name == tabName)
                {
                    ImageView iv = viewers[i];
                    for (int v = 0; v < iv.Images.Count; v++)
                    {
                        Images.RemoveImage(iv.Images[v]);
                    }
                    tabControl.TabPages.Remove(item);
                    viewers.RemoveAt(i);
                    App.nodeView.UpdateNodes();
                    return;
                }
                i++;
            }
        }
 
        public void SetTab(string tabName)
        {
            tabControl.SelectTab(tabName);
        }
        public void SetTab(int i)
        {
            tabControl.SelectedIndex = i;
        }
 
        public void RenameTab(string tabName, string text)
        {
            for (int i = 0; i < tabControl.TabPages.Count; i++)
            {
                TabPage t = tabControl.TabPages[i];
                if (t.Text == tabName)
                {
                    t.Text = text;
                    return;
                }
            }
        }
 
        private void Init()
        {
            App.tabsView = this;
            InitializeZarrMenu();
            Plugins.Initialize();
            filters = new Filter();
            InitializeCommandMenu();
            foreach (Scripting.Script s in Scripting.Scripts.Values)
            {
                ToolStripMenuItem mi = new ToolStripMenuItem(s.name);
                mi.Click += Mi_Click;
                runToolStripMenuItem1.DropDownItems.Add(mi);
            }
            foreach (Fiji.Macro.Command c in Fiji.Macros)
            {
                ToolStripMenuItem mi = new ToolStripMenuItem(c.Name);
                mi.Click += Mi_Click;
                runToolStripMenuItem1.DropDownItems.Add(mi);
            }
            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);
                Fiji.RunOnImage(ImageView.SelectedImage, ma, BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.newTab);
            }
            else
                Scripting.RunByName(m.Text);
        }
        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);
        }
        private async void MenuItem_Click(object? sender, EventArgs e)
        {
            BioImage source = Image;
            if (source == null) return;
            ToolStripMenuItem m = (ToolStripMenuItem)sender;
            string command = m.Tag as string ?? m.Text;
            string escaped = command.Replace("\\", "\\\\").Replace("\"", "\\\"");
            try
            {
                BioImage result = await Fiji.RunOnImage(source, "run(\"" + escaped + "\");", BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.newTab);
                if (result == null)
                {
                    MessageBox.Show(this, $"'{command}' did not return an image. It may have produced another type of result or failed in Fiji.",
                        "Fiji Command", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                if (ReferenceEquals(result, source))
                {
                    ImageView? sourceViewer = viewers.FirstOrDefault(viewer => viewer.Images.Contains(source));
                    if (sourceViewer != null && !sourceViewer.IsDisposed)
                    {
                        TabPage? sourceTab = tabControl.TabPages.Cast<TabPage>()
                            .FirstOrDefault(page => page.Controls.Contains(sourceViewer));
                        if (sourceTab != null)
                            tabControl.SelectedTab = sourceTab;
                        App.viewer = sourceViewer;
                        sourceViewer.SelectedIndex = sourceViewer.Images.IndexOf(source);
                        sourceViewer.UpdateView();
                    }
                }
                else
                    AddTab(result);
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.ToString());
                MessageBox.Show(this, $"Could not run '{command}':\n\n{ex}", "Fiji Command", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            ToolStripMenuItem mi = new ToolStripMenuItem(m.Text);
            mi.Tag = command;
            mi.Click += MenuItem_Click;
            bool con = false;
            foreach (ToolStripMenuItem item in recentToolStripMenuItem.DropDownItems)
            {
                if ((item.Tag as string ?? item.Text) == command)
                    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[ImageView.Level].SizeX + 42, ImageView.SelectedImage.Resolutions[ImageView.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();
            }
        }
 
        /* Setting the image property of the viewer. */
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public BioImage Image
        {
            get
            {
                if (Viewer == null)
                    return null;
                if (ImageView.SelectedImage == null)
                    return null;
                return ImageView.SelectedImage;
            }
            set
            {
                App.viewer.Images[App.viewer.SelectedIndex] = value;
            }
        }
 
        /* A property of the ImageView class. */
        public ImageView ImageView
        {
            get
            {
                return Viewer;
            }
        }
 
        /* 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)
            {
                try
                {
                    BioImage im = await BioImage.OpenFile(item);
                    if (im == null)
                        throw new InvalidOperationException("The image loader returned no image.");
                    AddTab(im);
                    if (!App.recent.Contains(im.ID))
                        App.recent.Add(im.ID);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(this, $"Could not open '{item}'.\n{ex.Message}",
                        "Open Image", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            openRecentToolStripMenuItem.DropDownItems.Clear();
            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 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;
            BioImage.SaveSeries(sts, saveTiffFileDialog.FileName);
        }
 
        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)
            {
                BioImage.SaveOME(file, Image.ID);
            }
        }
 
        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(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;
            ImageView.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 openOMEToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            int img = Images.images.Count;
            foreach (string item in openFilesDialog.FileNames)
            {
                BioImage im = BioImage.OpenOME(item, true);
                AddTab(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 saveAllToolStripMenuItem_Click(object sender, EventArgs e)
        {
            List<string> sts = new List<string>();
            foreach (BioImage item in Images.images)
            {
                BioImage.SaveFile(Image.ID, Image.ID);
            }
        }
 
        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 sts in openFilesDialog.FileNames)
            {
                BioImage im = BioImage.OpenOME(sts, true);
                if (im == null)
                    return;
                AddTab(im);
            }
        }
 
        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)
                BioImage.SaveFile(ImageView.SelectedImage.ID, saveTiffFileDialog.FileName);
        }
 
        private void saveOMEToolStripMenuItem1_Click(object sender, EventArgs e)
        {
            if (saveOMEFileDialog.ShowDialog() == DialogResult.OK)
                BioImage.SaveFile(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 async void ItemClicked(object sender, EventArgs e)
        {
            ToolStripMenuItem ts = (ToolStripMenuItem)sender;
            if (IsZarrSource(ts.Text))
            {
                await OpenZarrSourceAsync(ts.Text);
                return;
            }
            if (!BioImage.isOME(ts.Text))
            {
                BioImage[] bs = BioImage.OpenSeries(ts.Text, false);
                for (int i = 0; i < bs.Length; i++)
                {
                    if (i == 0)
                        AddTab(bs[i]);
                    else
                        Viewer.AddImage(bs[i]);
                }
            }
            else
            {
                OpenInTab tb = new OpenInTab();
                bool separateTabs = tb.ShowDialog() == DialogResult.Yes;
                bool firstImage = true;
                await foreach (BioImage image in ImageSeriesLoader.OpenAsync(ts.Text))
                {
                    if (separateTabs || firstImage)
                        AddTab(image);
                    else
                        Viewer.AddImage(image);
                    firstImage = false;
                }
            }
            App.viewer.GoToImage();
            SaveProperties();
        }
        private void TabsView_KeyDown(object sender, KeyEventArgs e)
        {
            if (Viewer == null)
                return;
            Viewer.ImageView_KeyDown(sender, e);
            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();
            App.nodeView.Close();
            Application.Exit();
        }
 
        private 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[] bms = BioImage.OpenOMESeries(openFilesDialog.FileNames[0], true, true);
                    AddTab(bms[0]);
                    for (int a = 1; a < bms.Length; a++)
                    {
                        App.viewer.AddImage(bms[a]);
                    }
                    App.viewer.GoToImage();
                    return;
                }
                else
                {
                    BioImage[] bms = BioImage.OpenOMESeries(openFilesDialog.FileNames[0], false, true);
                    for (int a = 0; a < bms.Length; a++)
                    {
                        App.viewer.AddImage(bms[a]);
                    }
                    App.viewer.GoToImage();
                    return;
                }
            }
 
        }
 
        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)
                {
                    AddTab(BioImage.OpenOME(openFilesDialog.FileNames[0], false));
                }
                else
                    App.viewer.AddImage(BioImage.OpenOME(openFilesDialog.FileNames[i], false));
            }
            App.viewer.GoToImage();
        }
 
        private async void openSeriesToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openFilesDialog.ShowDialog() != DialogResult.OK)
                return;
            foreach (var file in openFilesDialog.FileNames)
            {
                await foreach (BioImage image in ImageSeriesLoader.OpenAsync(file))
                {
                    AddTab(image);
                }
            }
        }
 
        private void saveTabToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveOMEFileDialog.ShowDialog() != DialogResult.OK)
                return;
            bool convert = false;
            foreach (BioImage b in ImageView.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 ImageView.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] = Images.GetImage(App.viewer.Images[i].ID);
            }
            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(item, 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;
            AForge.RotateFlipType rot = (AForge.RotateFlipType)Enum.Parse(typeof(AForge.RotateFlipType), st);
            ImageView.SelectedImage.RotateFlip(rot);
            ImageView.UpdateImage();
            ImageView.UpdateView();
        }
 
        private void rotateToolStripMenuItem_DropDownOpening(object sender, EventArgs e)
        {
            if (rotateToolStripMenuItem.DropDownItems.Count > 0)
                return;
            string[] sts = Enum.GetNames(typeof(AForge.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 (Bitmap bf in ImageView.SelectedImage.Buffers)
            {
                bf.SwitchRedBlue();
            }
            ImageView.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, true);
            AddTab(b);
        }
 
        private void importImageJROIToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openImageJDialog.ShowDialog() != DialogResult.OK)
                return;
            foreach (string item in openImageJDialog.FileNames)
            {
                ImageView.SelectedImage.Annotations.Add(Fiji.RoiDecoder.open(item, ImageView.SelectedImage.PhysicalSizeX, ImageView.SelectedImage.PhysicalSizeY, ImageView.SelectedImage.StageSizeX, ImageView.SelectedImage.StageSizeY));
            }
            App.viewer.UpdateView();
        }
 
        private void exportImageJROIToolStripMenuItem_Click(object sender, EventArgs e)
        {
            saveImageJDialog.Title = "Set Filename for exported ROI's.";
            saveImageJDialog.FileName = ImageView.SelectedImage.Filename;
            if (saveImageJDialog.ShowDialog() != DialogResult.OK)
                return;
            int i = 1;
            foreach (ROI roi in ImageView.SelectedImage.Annotations)
            {
                string s = Path.GetDirectoryName(saveImageJDialog.FileName) + "//" + Path.GetFileNameWithoutExtension(saveImageJDialog.FileName) + "-" + i + ".roi";
                Fiji.RoiEncoder.save(ImageView.SelectedImage, roi, s);
                i++;
            }
            App.viewer.UpdateView();
        }
 
        private void autoFocusToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (SelectedImage == null) return;
            ZCT co = ImageView.GetCoordinate();
            int f = BioImage.FindFocus(SelectedImage, co.C, co.T);
            ZCT z = SelectedImage.Buffers[f].Coordinate;
            ImageView.SetCoordinate(z.Z, z.C, z.T);
        }
 
        private void savePyramidalToolStripMenuItem_Click(object sender, EventArgs e)
        {
            saveOMEFileDialog.Title = "Save Pyramidal";
            if (saveOMEFileDialog.ShowDialog() != DialogResult.OK)
                return;
            BioImage.SaveOMEPyramidal(App.viewer.Images.ToArray(), saveOMEFileDialog.FileName, NetVips.Enums.ForeignTiffCompression.Lzw, 0);
        }
 
        private void TabsView_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (Viewer == null) return;
            Viewer.ImageView_KeyPress(Viewer, e);
        }
 
        private void TabsView_KeyUp(object sender, KeyEventArgs e)
        {
            if (Viewer == null) return;
            Viewer.ImageView_KeyUp(Viewer, e);
        }
 
        private void importQuPathROIToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (openQuPathDialog.ShowDialog() != DialogResult.OK)
                return;
            foreach (string item in openQuPathDialog.FileNames)
            {
                ROI[] rois = QuPath.ReadROI(item, ImageView.SelectedImage);
                foreach (ROI r in rois)
                {
                    ImageView.SelectedImage.Annotations.Add(r);
                }
            }
        }
 
        private void exportQuPathROIToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveQuPathDialog.ShowDialog() != DialogResult.OK)
                return;
            foreach (string item in saveQuPathDialog.FileNames)
            {
                QuPath.SaveROI(item, ImageView.SelectedImage);
            }
        }
 
        private void extractRegionPyramidalToolStripMenuItem_Click(object sender, EventArgs e)
        {
            BioImage bm = SelectedImage.Copy(true);
            bm.ID = Images.GetImageName(bm.ID);
            Images.AddImage(bm);
        }
 
        private 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(BioImage.OpenFile(s).Result);
            }
        }
 
        private void saveQuPathProjectToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveNumPyDialog.ShowDialog() != DialogResult.OK)
                return;
            List<BioImage> bms = new List<BioImage>();
            foreach (var v in viewers)
            {
                foreach (var item in v.Images)
                {
                    bms.Add(item);
                }
            }
            QuPath.Project.SaveProject(saveNumPyDialog.FileName, new List<BioImage[]> { bms.ToArray() });
        }
 
        private void renameToolStripMenuItem_Click(object sender, EventArgs e)
        {
            TextInput ti = new TextInput("Rename Image");
            if (ti.ShowDialog() != DialogResult.OK)
                return;
            RenameTab(ImageView.SelectedImage.Filename, ti.TextValue);
        }
 
        private void saveNumPyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (saveNumPyDialog.ShowDialog() != DialogResult.OK)
                return;
            NumPy.SaveNumPy(ImageView.SelectedImage, saveNumPyDialog.FileName);
        }
 
        private void oMEROToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OMERO om = new OMERO();
            om.Show();
        }
    }
}