TabsView.cs

using AForge;
using Bio;
using Gtk;
using omero.gateway;
using Pango;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
 
namespace BioGTK
{
    
    public class TabsView : Window
    {
        #region Properties
        private Builder _builder;
        private List<ImageView> viewers = new List<ImageView>();
        private const int MaxRecentImages = 10;
        private readonly List<string> recentImages = new List<string>();
        private readonly Menu recentImagesMenu = new Menu();
        private MenuItem openRecentMenu;
        private MenuItem clearRecentImagesMenu;
        private static readonly string RecentImagesPath = System.IO.Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
            "BioGTK", "recent-images.json");
        private static string Q(string s)
        {
            return "\"" + s.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
        }
        private static string Bool(bool value)
        {
            return value.ToString().ToLowerInvariant();
        }
        private static string StrArray(string[] values)
        {
            return "new string[] { " + string.Join(", ", values.Select(Q)) + " }";
        }
        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[v].Images.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 static string GetSeriesDisplayName(string file, int series, int seriesCount)
        {
            if (seriesCount <= 1)
                return System.IO.Path.GetFileName(file);
 
            string baseName = System.IO.Path.GetFileNameWithoutExtension(file);
            string ext = System.IO.Path.GetExtension(file);
            if (string.IsNullOrWhiteSpace(ext))
                ext = string.Empty;
            return $"{baseName}_s{series}{ext}";
        }
        private static bool IsRemoteZarrSource(BioImage image)
        {
            if (image == null || !image.IsZarrSource)
                return false;
 
            string source = image.SourceFile;
            return !string.IsNullOrWhiteSpace(source) &&
                (source.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
                 source.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
                 source.StartsWith("s3://", StringComparison.OrdinalIgnoreCase));
        }
 
        private static bool IsZarrLikeSource(string file)
        {
            if (string.IsNullOrWhiteSpace(file))
                return false;
 
            return file.Contains(".zarr", StringComparison.OrdinalIgnoreCase) ||
                file.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
                file.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
                file.StartsWith("s3://", StringComparison.OrdinalIgnoreCase);
        }
 
        private static void EnsureLargeZarrUsesPyramidalViewer(BioImage image)
        {
            if (image == null || !image.IsZarrSource || image.Resolutions.Count == 0)
                return;
 
            image.PyramidNativeLevelCount = image.Resolutions.Count;
            if (image.Resolutions.Count > 1)
                return;
 
            const int largeImageDimension = 2048;
            const int pyramidTargetDimension = 1024;
            Resolution baseResolution = image.Resolutions[0];
            if (baseResolution.SizeX <= largeImageDimension &&
                baseResolution.SizeY <= largeImageDimension)
            {
                return;
            }
 
            Resolution previous = baseResolution;
            int width = baseResolution.SizeX;
            int height = baseResolution.SizeY;
            while (width > pyramidTargetDimension || height > pyramidTargetDimension)
            {
                width = Math.Max(1, (width + 1) / 2);
                height = Math.Max(1, (height + 1) / 2);
                previous = new Resolution(
                    width,
                    height,
                    previous.PixelFormat,
                    previous.PhysicalSizeX * 2,
                    previous.PhysicalSizeY * 2,
                    previous.PhysicalSizeZ,
                    previous.StageSizeX,
                    previous.StageSizeY,
                    previous.StageSizeZ);
                image.Resolutions.Add(previous);
            }
 
            // OpenURL creates SlideBase before returning. Rebuild it so its tile
            // schema includes the synthetic levels that were added above.
            var slideImage = new SlideImage { BioImage = image };
            image.SlideBase = new SlideBase(image, slideImage);
        }
 
        private static async Task ApplyRemoteZarrDefaultCoordinateAsync(BioImage image, string source)
        {
            if (image == null || string.IsNullOrWhiteSpace(source))
                return;
            if (!source.StartsWith("https://", StringComparison.OrdinalIgnoreCase) &&
                !source.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
                !source.StartsWith("s3://", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }
 
            try
            {
                string metadataRoot = source;
                if (metadataRoot.StartsWith("s3://", StringComparison.OrdinalIgnoreCase))
                {
                    metadataRoot = "https://uk1s3.embassy.ebi.ac.uk/" +
                        metadataRoot.Substring("s3://".Length).TrimStart('/');
                }
 
                using var http = new System.Net.Http.HttpClient();
                string json = await http.GetStringAsync(metadataRoot.TrimEnd('/') + "/zarr.json")
                    .ConfigureAwait(false);
                using var document = JsonDocument.Parse(json);
 
                JsonElement root = document.RootElement;
                JsonElement omero = default;
                bool foundOmero = false;
                if (root.TryGetProperty("attributes", out JsonElement attributes))
                {
                    if (attributes.TryGetProperty("ome", out JsonElement ome) &&
                        ome.TryGetProperty("omero", out omero))
                    {
                        foundOmero = true;
                    }
                    else if (attributes.TryGetProperty("omero", out omero))
                    {
                        foundOmero = true;
                    }
                }
                if (!foundOmero && root.TryGetProperty("omero", out omero))
                    foundOmero = true;
                if (!foundOmero || !omero.TryGetProperty("rdefs", out JsonElement rdefs))
                    return;
 
                int defaultZ = image.Coordinate.Z;
                int defaultT = image.Coordinate.T;
                if (rdefs.TryGetProperty("defaultZ", out JsonElement zValue) && zValue.TryGetInt32(out int z))
                    defaultZ = z;
                if (rdefs.TryGetProperty("defaultT", out JsonElement tValue) && tValue.TryGetInt32(out int t))
                    defaultT = t;
 
                defaultZ = Math.Clamp(defaultZ, 0, Math.Max(0, image.SizeZ - 1));
                defaultT = Math.Clamp(defaultT, 0, Math.Max(0, image.SizeT - 1));
                image.Coordinate = new ZCT(defaultZ, image.Coordinate.C, defaultT);
            }
            catch (Exception ex) when (
                ex is System.Net.Http.HttpRequestException ||
                ex is TaskCanceledException ||
                ex is JsonException)
            {
                Console.WriteLine("Could not read the OME-Zarr default coordinate: " + ex.Message);
            }
        }
 
        private async Task<BioImage?> OpenSeriesAsTabAsync(
            string file,
            int series,
            int seriesCount,
            bool tab,
            bool tile,
            int tileX,
            int tileY,
            int tileSizeX,
            int tileSizeY,
            bool addToRegistry = true)
        {
            BioImage im = await BioImage.OpenFile(file, series, tab, false, tile, tileX, tileY, tileSizeX, tileSizeY);
            if (im == null)
                return null;
 
            if (seriesCount > 1)
                im.Rename(GetSeriesDisplayName(file, series, seriesCount));
 
            if (addToRegistry)
                Images.AddImage(im);
 
            AddTab(im, file);
            return im;
        }
 
        private async Task<BioImage?> OpenSeriesAsViewAsync(
            string file,
            int series,
            int seriesCount)
        {
            BioImage im = await BioImage.OpenFile(file, series, false, false, false, 0, 0, 0, 0);
            if (im == null)
                return null;
 
            ShowImageView(im, file, series, seriesCount);
            return im;
        }
 
        private async Task<List<BioImage>> CollectPyramidRootsAsync(string file)
        {
            if (IsZarrLikeSource(file))
            {
                BioImage? zarrImage = await BioImage.OpenFile(file, 0, false, false, false, 0, 0, 0, 0);
                List<BioImage> singleRoot = new List<BioImage>();
                if (zarrImage != null)
                {
                    EnsureLargeZarrUsesPyramidalViewer(zarrImage);
                    await ApplyRemoteZarrDefaultCoordinateAsync(zarrImage, file);
                    singleRoot.Add(zarrImage);
                }
                return singleRoot;
            }
 
            int seriesCount = 1;
            try
            {
                seriesCount = Math.Max(1, BioImage.GetSeriesCount(file));
            }
            catch
            {
                seriesCount = 1;
            }
 
            List<BioImage?> seriesImages = new List<BioImage?>(seriesCount);
            for (int series = 0; series < seriesCount; series++)
            {
                BioImage? im = await BioImage.OpenFile(file, series, false, false, false, 0, 0, 0, 0);
                seriesImages.Add(im);
            }
 
            List<BioImage> roots = new List<BioImage>();
            for (int series = 0; series < seriesImages.Count; series++)
            {
                BioImage? cur = seriesImages[series];
                BioImage? prev = series > 0 ? seriesImages[series - 1] : null;
                if (series > 0 && IsContinuationSeries(prev, cur))
                {
                    cur?.Dispose();
                    continue;
                }
 
                if (cur != null)
                    roots.Add(cur);
            }
 
            return roots;
        }
 
        private static bool IsContinuationSeries(BioImage? prev, BioImage? cur)
        {
            if (prev == null || cur == null)
                return false;
            if (prev.Resolutions.Count == 0 || cur.Resolutions.Count == 0)
                return false;
 
            Resolution pr = prev.Resolutions[0];
            Resolution cr = cur.Resolutions[0];
            return pr.SizeX > cr.SizeX &&
                   pr.SizeY > cr.SizeY &&
                   pr.PixelFormat == cr.PixelFormat;
        }
 
        private void ShowImageView(BioImage im, string file, int series, int seriesCount)
        {
            if (seriesCount > 1)
                im.Rename(GetSeriesDisplayName(file, series, seriesCount));
 
            TryLoadZarrROIs(im);
            ImageView view = ImageView.Create(im);
            view.RefreshZarrLabelOverlays(file);
            if (!viewers.Contains(view))
                viewers.Add(view);
 
            Label dummy = new Gtk.Label(im.Filename);
            dummy.Text = im.Filename;
            dummy.UseMarkup = false;
            dummy.Visible = false;
            Label l = new Gtk.Label(im.Filename);
            l.Text = im.Filename;
            l.UseMarkup = false;
            tabsView.AppendPage(dummy, l);
            view.Present();
            RememberRecentImage(file);
        }
 
        private async Task OpenPyramidRootsAsViewsAsync(string file, bool addToRegistry = false)
        {
            List<BioImage> roots = await CollectPyramidRootsInBackgroundAsync(file);
            for (int series = 0; series < roots.Count; series++)
            {
                if (addToRegistry)
                    Images.AddImage(roots[series]);
                ShowImageView(roots[series], file, series, roots.Count);
            }
        }
 
        private async Task OpenPyramidRootsAsTabsAsync(string file)
        {
            List<BioImage> roots = await CollectPyramidRootsInBackgroundAsync(file);
            for (int series = 0; series < roots.Count; series++)
            {
                BioImage im = roots[series];
                if (roots.Count > 1)
                    im.Rename(GetSeriesDisplayName(file, series, roots.Count));
                Images.AddImage(im);
                AddTab(im, file);
            }
        }
 
        private Task<List<BioImage>> CollectPyramidRootsInBackgroundAsync(string file)
        {
            return Task.Run(async () => await CollectPyramidRootsAsync(file));
        }
 
#pragma warning disable 649
        [Builder.Object]
        public MenuBar ImageJMenu;
        [Builder.Object]
        private MenuItem recentMenu;
        [Builder.Object]
        private MenuItem commandsMenu;
        [Builder.Object]
        private MenuItem runMenu;
        [Builder.Object]
        private MenuItem searchMenu;
        [Builder.Object]
        private MenuItem updateMenu;
        [Builder.Object]
        private MenuItem renameMenu;
        [Builder.Object]
        public MenuBar MainMenu;
        [Builder.Object]
        private MenuItem openURLMenu;
        [Builder.Object]
        private MenuItem openImagesMenu;
        [Builder.Object]
        private MenuItem openOMEImagesMenu;
        [Builder.Object]
        private MenuItem openOMESeriesMenu;
        [Builder.Object]
        private MenuItem openSeriesMenu;
        [Builder.Object]
        private MenuItem openZarr;
        [Builder.Object]
        private MenuItem openQuPathProject;
        [Builder.Object]
        private MenuItem addImagesToTabMenu;
        [Builder.Object]
        private MenuItem saveNumPyBut;
        [Builder.Object]
        private MenuItem addOMEImagesToTab;
        [Builder.Object]
        private MenuItem saveSelectedTiff;
        [Builder.Object]
        private MenuItem saveSelectedOME;
        [Builder.Object]
        private MenuItem saveTabOME;
        [Builder.Object]
        private MenuItem saveTabTiffMenu;
        [Builder.Object]
        private MenuItem saveSeriesMenu;
        [Builder.Object]
        private MenuItem savePyramidalMenu;
        [Builder.Object]
        private MenuItem saveZarr;
        [Builder.Object]
        private MenuItem saveQuPathProject;
        [Builder.Object]
        private MenuItem imagesToStack;
        [Builder.Object]
        private MenuItem uploadImageMenu;
 
        [Builder.Object]
        private Gtk.CheckMenuItem rgbMenu;
        [Builder.Object]
        private Gtk.CheckMenuItem filteredMenu;
        [Builder.Object]
        private Gtk.CheckMenuItem rawMenu;
        [Builder.Object]
        private Gtk.CheckMenuItem emissionMenu;
 
        [Builder.Object]
        private MenuItem toolsMenu;
        [Builder.Object]
        private MenuItem setToolMenu;
        [Builder.Object]
        private MenuItem runSAMMenu;
        [Builder.Object]
        private MenuItem plateToolMenu;
 
        [Builder.Object]
        private MenuItem roiManagerMenu;
        [Builder.Object]
        private MenuItem exportROIsToCSVMenu;
        [Builder.Object]
        private MenuItem importROIsFromCSVMenu;
        [Builder.Object]
        private MenuItem exportROIsOfFolderOfImagesMenu;
        [Builder.Object]
        private MenuItem importROIsFromImageJMenu;
        [Builder.Object]
        private MenuItem exportROIsFromImageJMenu;
        [Builder.Object]
        private MenuItem importROIQuPath;
        [Builder.Object]
        private MenuItem exportROIQuPath;
        [Builder.Object]
        private MenuItem importPointsNapari;
        [Builder.Object]
        private MenuItem importShapesNapari;
        [Builder.Object]
        private MenuItem exportROINapari;
 
 
        [Builder.Object]
        private MenuItem autoThresholdAllMenu;
        [Builder.Object]
        private MenuItem channelsToolMenu;
        [Builder.Object]
        private MenuItem switchRedBlueMenu;
 
        [Builder.Object]
        private MenuItem rotateFlipMenu;
        [Builder.Object]
        private MenuItem stackToolMenu;
        [Builder.Object]
        private MenuItem focusMenu;
        [Builder.Object]
        private MenuItem extractRegionMenu;
 
        [Builder.Object]
        private MenuItem to8BitMenu;
        [Builder.Object]
        private MenuItem to16BitMenu;
        [Builder.Object]
        private MenuItem to24BitMenu;
        [Builder.Object]
        private MenuItem to32BitMenu;
        [Builder.Object]
        private MenuItem to48BitMenu;
        [Builder.Object]
        private MenuItem toFloatMenu;
        [Builder.Object]
        private MenuItem toShortMenu;
 
        [Builder.Object]
        private MenuItem filtersMenu;
 
        [Builder.Object]
        private MenuItem functionsToolMenu;
        [Builder.Object]
        private MenuItem consoleMenu;
        [Builder.Object]
        private MenuItem scriptRunnerMenu;
        [Builder.Object]
        private MenuItem scriptRecorderMenu;
 
        [Builder.Object]
        private MenuItem aboutMenu;
 
        [Builder.Object]
        private Notebook tabsView;
 
        [Builder.Object]
        private Menu contextMenu;
        [Builder.Object]
        private MenuItem tabClose;
        [Builder.Object]
        private MenuItem tabDuplicate;
        [Builder.Object]
        private MenuItem runMicroSAMMenu;
        [Builder.Object]
        private MenuItem omeroMenu;
        [Builder.Object]
        private MenuItem AIMenu;
 
#pragma warning restore 649
 
        #endregion
 
        #region Constructors / Destructors
 
        public static TabsView Create()
        {
            Builder builder = new Builder(new FileStream(System.IO.Path.GetDirectoryName(Environment.ProcessPath) + "/" + "Glade/TabsView.glade", FileMode.Open));
            return new TabsView(builder, builder.GetObject("TabsView").Handle);
        }
        Menu recent = new Menu();
        /* Setting up the UI. */
        protected TabsView(Builder builder, IntPtr handle) : base(handle)
        {
            _builder = builder;
            App.tabsView = this;
            builder.Autoconnect(this);
            InitializeOpenRecentMenu();
            filteredMenu.Active = true;
            SetupHandlers();
            progress = Progress.Create(title, "", "");
            Function.InitializeMainMenu();
            filechooser =
        new Gtk.FileChooserDialog("Choose file to open",
            this,
            FileChooserAction.Open,
            "Cancel", ResponseType.Cancel,
            "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            Menu m = new Menu();
            foreach (RotateFlipType flip in (RotateFlipType[])Enum.GetValues(typeof(RotateFlipType)))
            {
                MenuItem mi = new MenuItem(flip.ToString());
                mi.ButtonPressEvent += RotateFlip_ButtonPressEvent;
                m.Append(mi);
            }
            rotateFlipMenu.Submenu = m;
            rotateFlipMenu.ShowAll();
            string a = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            Menu me = new Menu();
            foreach (char c in a)
            {
                MenuItem mi = new MenuItem(c.ToString());
                Menu men = new Menu();
                foreach (Fiji.Macro.Command command in Fiji.Macro.Commands.Values)
                {
                    if (command.Name.StartsWith(c))
                    {
                        MenuItem menuItem = new MenuItem(command.Name.ToString());
                        menuItem.ButtonPressEvent += CommandMenuItem_ButtonPressEvent;
                        men.Append(menuItem);
                    }
                }
                mi.Submenu = men;
                me.Append(mi);
            }
            commandsMenu.Submenu = me;
            commandsMenu.ShowAll();
            recentMenu.Submenu = recent;
 
            App.ApplyStyles(this);
            Menu rm = new Menu();
            foreach(Scripting.Script s in Scripting.scripts.Values)
            {
                MenuItem mi = new MenuItem(s.name);
                mi.ButtonPressEvent += Mi_ButtonPressEvent;
                rm.Append(mi);
            }
            //runMenu.ShowAll();
            Plugins.Initialize();
            ML.ML.Initialize();
            AIMenu.ShowAll();
            App.MoveToMain(this);
        }
        /*
        public PointD GetTextSize(string s, string font, int size)
        {
            // Get the Pango context from the window
            SKCanvas context = CreatePangoContext();
 
            // Create a Pango layout for measuring text
            Pango.Layout layout = new Pango.Layout(context);
            layout.FontDescription = FontDescription.FromString(font + " " + size);
            layout.SetText(s);
            // Get pixel size
            layout.GetPixelSize(out int width, out int height);
            return new PointD(width, height);
        }
        */
 
        public static bool SetImageJPath()
        {
            string st = BioLib.Settings.GetSettings("ImageJPath");
            if (st != "")
            {
                Fiji.ImageJPath = BioLib.Settings.GetSettings("ImageJPath");
                return true;
            }
            string title = "Select ImageJ Executable Location";
            if (OperatingSystem.IsMacOS())
                title = "Select ImageJ Executable Location (Fiji.app/Contents/MacOS/ImageJ-macosx)";
            Gtk.FileChooserDialog filechooser =
    new Gtk.FileChooserDialog(title, Scripting.window,
        FileChooserAction.Open,
        "Cancel", ResponseType.Cancel,
        "Save", ResponseType.Accept);
            filechooser.SetCurrentFolder(System.IO.Path.GetDirectoryName(Environment.ProcessPath));
            if (filechooser.Run() != (int)ResponseType.Accept)
                return false;
            Fiji.ImageJPath = filechooser.Filename;
            BioLib.Settings.AddSettings("ImageJPath", filechooser.Filename);
            filechooser.Destroy();
            BioLib.Settings.Save();
            return true;
        }
        private void Mi_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            MenuItem m = (MenuItem)o;
            if (m.Label.EndsWith(".ijm") || m.Label.EndsWith(".txt") && !m.Label.EndsWith(".cs"))
            {
                string file = Fiji.ImageJPath + m.Label;
                string ma = File.ReadAllText(file);
                Fiji.RunOnImage(ImageView.SelectedImage,ma, BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.resultInNewTab);
            }
            else
                Scripting.RunByName(m.Label);
            bool con = false;
            foreach (MenuItem item in recent.Children)
            {
                if (item.Label == m.Label)
                    con = true;
            }
            if (!con)
                recent.Append(m);
            recentMenu.ShowAll();
        }
 
        private async void CommandMenuItem_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (ImageView.SelectedImage == null) return;
            MenuItem m = (MenuItem)o;
            BioImage sourceImage = ImageView.SelectedImage;
            BioImage bm;
            string command = "run(\"" + m.Label + "\");";
            if (ImageView.SelectedImage.isPyramidal)
            {
                YesNoDialog pd = YesNoDialog.Create("Run on all pyramidal levels?");
                if (pd.Run() == (int)ResponseType.Yes)
                {
                    StartProgress("Run Command", "Running " + m.Label + " on all pyramid levels.");
                    try
                    {
                        bm = await ImageJ.RunOnAllPyramidLevels(ImageView.SelectedImage, command, BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.resultInNewTab);
                    }
                    finally
                    {
                        StopProgress();
                    }
                    AddToRecent(m.Label);
                }
                else
                {
                    ComboPicker cpd = ComboPicker.Create("Select pyramidal level to run command on.", ImageView.SelectedImage.Resolutions.Select(l => l.ToString()).ToArray());
                    if(cpd.Run() == (int)ResponseType.Ok)
                    {
                        int level = cpd.SelectedIndex;
                        bool currentViewOnly = false;
                        if (IsRemoteZarrSource(ImageView.SelectedImage))
                        {
                            YesNoDialog speedDialog = YesNoDialog.Create("Use only the current visible region for speed?");
                            currentViewOnly = speedDialog.Run() == (int)ResponseType.Yes;
                        }
 
                        string scopeText = currentViewOnly
                            ? "the current visible region of pyramid level " + (level + 1).ToString()
                            : "pyramid level " + (level + 1).ToString();
                        StartProgress("Run Command", "Running " + m.Label + " on " + scopeText + ".");
                        try
                        {
                            bm = await ImageJ.RunOnPyramidalImage(ImageView.SelectedImage, command, level, BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.resultInNewTab, currentViewOnly);
                        }
                        finally
                        {
                            StopProgress();
                        }
                        AddToRecent(m.Label);
                    }
                    else
                    {
                        return;
                    }
                }
                Console.WriteLine($"[TabsView.CommandMenuItem] pyramidal result={(bm == null ? "null" : bm.ID)}");
                PreserveSourceAnnotations(sourceImage, bm);
                AddTab(bm);
                return;
            }
            bm = await Fiji.RunOnImage(ImageView.SelectedImage, "run(\"" + m.Label + "\");", BioConsole.headless, BioConsole.onTab, BioConsole.useBioformats, BioConsole.resultInNewTab);
            Console.WriteLine($"[TabsView.CommandMenuItem] stack result={(bm == null ? "null" : bm.ID)}");
            AddToRecent(m.Label);
            PreserveSourceAnnotations(sourceImage, bm);
            AddTab(bm);
        }
 
        private static void PreserveSourceAnnotations(BioImage source, BioImage target)
        {
            if (source == null || target == null)
                return;
 
            if (target.Annotations == null)
                target.Annotations = new List<ROI>();
 
            foreach (ROI roi in source.Annotations ?? Enumerable.Empty<ROI>())
            {
                if (roi == null)
                    continue;
 
                ROI copy = roi.Copy();
                ScaleAnnotationToTargetVolume(copy, source, target);
                target.Annotations.Add(copy);
            }
 
            if (App.viewer == null)
                return;
 
            foreach (ROI roi in App.viewer.GetZarrLabelOverlaysForImage(source))
            {
                if (roi == null)
                    continue;
 
                if (!string.IsNullOrWhiteSpace(roi.roiID) &&
                    target.Annotations.Any(a => a != null && a.roiID == roi.roiID))
                    continue;
 
                ROI copy = roi.Copy();
                ScaleAnnotationToTargetVolume(copy, source, target);
                target.Annotations.Add(copy);
            }
        }
 
        private static void ScaleAnnotationToTargetVolume(ROI roi, BioImage source, BioImage target)
        {
            if (roi == null || source == null || target == null)
                return;
 
            double sourceW = GetStageWidth(source);
            double sourceH = GetStageHeight(source);
            double targetW = GetStageWidth(target);
            double targetH = GetStageHeight(target);
 
            if (sourceW <= 0 || sourceH <= 0 || targetW <= 0 || targetH <= 0)
                return;
 
            double scaleX = targetW / sourceW;
            double scaleY = targetH / sourceH;
            if (Math.Abs(scaleX - 1.0) < 0.000001 && Math.Abs(scaleY - 1.0) < 0.000001)
                return;
 
            double MapX(double x) => target.Volume.Location.X + ((x - source.Volume.Location.X) * scaleX);
            double MapY(double y) => target.Volume.Location.Y + ((y - source.Volume.Location.Y) * scaleY);
 
            roi.BoundingBox = new AForge.RectangleD(
                MapX(roi.BoundingBox.X),
                MapY(roi.BoundingBox.Y),
                roi.BoundingBox.W * scaleX,
                roi.BoundingBox.H * scaleY);
 
            for (int i = 0; i < roi.Points.Count; i++)
                roi.Points[i] = new AForge.PointD(MapX(roi.Points[i].X), MapY(roi.Points[i].Y));
 
            if (roi.roiMask != null)
            {
                double maskStageX = roi.roiMask.X * roi.roiMask.PhysicalSizeX;
                double maskStageY = roi.roiMask.Y * roi.roiMask.PhysicalSizeY;
                roi.roiMask.PhysicalSizeX *= scaleX;
                roi.roiMask.PhysicalSizeY *= scaleY;
                roi.roiMask.X = MapX(maskStageX) / Math.Max(roi.roiMask.PhysicalSizeX, 1e-12);
                roi.roiMask.Y = MapY(maskStageY) / Math.Max(roi.roiMask.PhysicalSizeY, 1e-12);
            }
        }
 
        private static double GetStageWidth(BioImage image)
        {
            if (image == null)
                return 0;
 
            if (image.Resolutions != null && image.Resolutions.Count > 0 &&
                image.Resolutions[0].SizeX > 0 && image.Resolutions[0].PhysicalSizeX > 0)
                return image.Resolutions[0].SizeX * image.Resolutions[0].PhysicalSizeX;
 
            return image.SizeX * (image.PhysicalSizeX > 0 ? image.PhysicalSizeX : 1.0);
        }
 
        private static double GetStageHeight(BioImage image)
        {
            if (image == null)
                return 0;
 
            if (image.Resolutions != null && image.Resolutions.Count > 0 &&
                image.Resolutions[0].SizeY > 0 && image.Resolutions[0].PhysicalSizeY > 0)
                return image.Resolutions[0].SizeY * image.Resolutions[0].PhysicalSizeY;
 
            return image.SizeY * (image.PhysicalSizeY > 0 ? image.PhysicalSizeY : 1.0);
        }
 
        private static void NormalizeMasksForOmeExport(BioImage image)
        {
            if (image == null || image.Annotations == null || image.Annotations.Count == 0)
                return;
 
            foreach (ROI roi in image.Annotations)
            {
                if (roi?.roiMask == null)
                    continue;
 
                if (roi.roiMask.PhysicalSizeX <= 0)
                    roi.roiMask.PhysicalSizeX = image.PhysicalSizeX > 0 ? image.PhysicalSizeX : 1.0;
 
                if (roi.roiMask.PhysicalSizeY <= 0)
                    roi.roiMask.PhysicalSizeY = image.PhysicalSizeY > 0 ? image.PhysicalSizeY : 1.0;
            }
        }
 
        private void InitializeOpenRecentMenu()
        {
            openRecentMenu = new MenuItem("Open Recent");
            openRecentMenu.Submenu = recentImagesMenu;
            clearRecentImagesMenu = new MenuItem("Clear Recent Files");
            clearRecentImagesMenu.Activated += ClearRecentImagesMenu_Activated;
            Menu fileMenu = (Menu)openImagesMenu.Parent;
            int recentMenuPosition = Array.IndexOf(fileMenu.Children, openImagesMenu) + 1;
            fileMenu.Insert(openRecentMenu, recentMenuPosition);
            fileMenu.Insert(clearRecentImagesMenu, recentMenuPosition + 1);
 
            try
            {
                if (File.Exists(RecentImagesPath))
                {
                    var savedImages = JsonSerializer.Deserialize<List<string>>(File.ReadAllText(RecentImagesPath));
                    if (savedImages != null)
                    {
                        recentImages.AddRange(savedImages
                            .Where(source => !string.IsNullOrWhiteSpace(source))
                            .Distinct(StringComparer.Ordinal)
                            .Take(MaxRecentImages));
                    }
                }
            }
            catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException || ex is JsonException)
            {
                Console.WriteLine("Could not load recent images: " + ex.Message);
            }
 
            RefreshOpenRecentMenu();
        }
 
        private void ClearRecentImagesMenu_Activated(object sender, EventArgs args)
        {
            recentImages.Clear();
            try
            {
                if (File.Exists(RecentImagesPath))
                    File.Delete(RecentImagesPath);
            }
            catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
            {
                Console.WriteLine("Could not clear recent images: " + ex.Message);
            }
 
            RefreshOpenRecentMenu();
        }
 
        private void RememberRecentImage(string source)
        {
            if (string.IsNullOrWhiteSpace(source))
                return;
 
            bool remote = source.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
                source.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
                source.StartsWith("s3://", StringComparison.OrdinalIgnoreCase);
            // Generated images should not become recent entries unless they have a saved source.
            if (!remote && !File.Exists(source) && !Directory.Exists(source))
                return;
            if (!remote)
                source = System.IO.Path.GetFullPath(source);
 
            StringComparison comparison = !remote && OperatingSystem.IsWindows()
                ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
            recentImages.RemoveAll(item => string.Equals(item, source, comparison));
            recentImages.Insert(0, source);
            if (recentImages.Count > MaxRecentImages)
                recentImages.RemoveRange(MaxRecentImages, recentImages.Count - MaxRecentImages);
 
            try
            {
                Directory.CreateDirectory(System.IO.Path.GetDirectoryName(RecentImagesPath));
                File.WriteAllText(RecentImagesPath, JsonSerializer.Serialize(recentImages));
            }
            catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
            {
                Console.WriteLine("Could not save recent images: " + ex.Message);
            }
 
            RefreshOpenRecentMenu();
        }
 
        private void RefreshOpenRecentMenu()
        {
            foreach (Widget item in recentImagesMenu.Children)
            {
                recentImagesMenu.Remove(item);
                item.Destroy();
            }
 
            foreach (string source in recentImages)
            {
                var item = new MenuItem(source) { UseUnderline = false };
                item.Activated += async (sender, args) => await OpenRecentImageAsync(source);
                recentImagesMenu.Append(item);
            }
 
            openRecentMenu.Sensitive = recentImages.Count > 0;
            clearRecentImagesMenu.Sensitive = recentImages.Count > 0;
            openRecentMenu.ShowAll();
            clearRecentImagesMenu.ShowAll();
        }
 
        private async Task OpenRecentImageAsync(string source)
        {
            StartProgress("Open Recent", "Opening");
            try
            {
                await FlushGtkEventsAsync();
                await OpenPyramidRootsAsTabsAsync(source);
            }
            catch (Exception ex)
            {
                using var dialog = new MessageDialog(this, DialogFlags.Modal,
                    MessageType.Error, ButtonsType.Ok, "{0}", ex.Message);
                dialog.Title = "Open Recent Failed";
                dialog.Run();
                dialog.Destroy();
            }
            finally
            {
                StopProgress();
            }
        }
 
        void AddToRecent(string name)
        {
            bool con = false;
            foreach (MenuItem item in recent.Children)
            {
                if (item.Label == name)
                {
                    con = true;
                    break;
                }
            }
            MenuItem mi = new MenuItem(name);
            if (!con)
                recent.Append(mi);
            mi.ButtonPressEvent += CommandMenuItem_ButtonPressEvent;
            recentMenu.ShowAll();
        }
 
        private void RotateFlip_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if(ImageView.SelectedImage==null) return;
            MenuItem m = (MenuItem)o;
            RotateFlipType r = Enum.Parse<RotateFlipType>(m.Label);
            ImageView.SelectedImage.RotateFlip(r);
            App.viewer.UpdateImage();
            App.viewer.UpdateView();
        }
 
        #endregion
 
        #region Handlers
 
        protected void SetupHandlers()
        {
            openURLMenu.ButtonPressEvent += OpenURLMenu_ButtonPressEvent;
            openImagesMenu.ButtonPressEvent += openImagesMenuClick;
            openOMEImagesMenu.ButtonPressEvent += openOMEImagesMenuClick;
            openOMESeriesMenu.ButtonPressEvent += openOMESeriesMenuClick;
            openSeriesMenu.ButtonPressEvent += openSeriesMenuClick;
            openQuPathProject.ButtonPressEvent += openQuPathProjectMenuClick;
            addImagesToTabMenu.ButtonPressEvent += addImagesToTabMenuClick;
            addOMEImagesToTab.ButtonPressEvent += addOMEImagesToTabClick;
            openZarr.ButtonPressEvent += OpenZarr_ButtonPressEvent;
            saveSelectedTiff.ButtonPressEvent += saveSelectedTiffClick;
            saveSelectedOME.ButtonPressEvent += saveSelectedOMEClick;
            saveNumPyBut.ButtonPressEvent += SaveNumPyBut_ButtonPressEvent;
 
            saveTabOME.ButtonPressEvent += saveTabOMEClick;
            saveTabTiffMenu.ButtonPressEvent += saveTabTiffMenuClick;
            saveSeriesMenu.ButtonPressEvent += saveSeriesMenuClick;
            savePyramidalMenu.ButtonPressEvent += SavePyramidalMenu_ButtonPressEvent;
            saveZarr.ButtonPressEvent += SaveZarr_ButtonPressEvent;
            saveQuPathProject.ButtonPressEvent += saveQuPathProject_ButtonPressEvent;
            imagesToStack.ButtonPressEvent += imagesToStackClick;
            uploadImageMenu.ButtonPressEvent += UploadImageMenu_ButtonPressEvent;
 
            rgbMenu.ButtonPressEvent += RgbMenu_ButtonPressEvent;
            filteredMenu.ButtonPressEvent += FilteredMenu_ButtonPressEvent;
            rawMenu.ButtonPressEvent += RawMenu_ButtonPressEvent;
            emissionMenu.ButtonPressEvent += EmissionMenu_ButtonPressEvent;
 
            toolsMenu.ButtonPressEvent += toolsMenuClick;
            setToolMenu.ButtonPressEvent += setToolMenuClick;
            runSAMMenu.ButtonPressEvent += RunSAMMenu_ButtonPressEvent;
            runMicroSAMMenu.ButtonPressEvent += RunMicroSAMMenu_ButtonPressEvent;
            plateToolMenu.ButtonPressEvent += PlateToolMenu_ButtonPressEvent;
            extractRegionMenu.ButtonPressEvent += ExtractRegionMenu_ButtonPressEvent;
 
            roiManagerMenu.ButtonPressEvent += roiManagerMenuClick;
            exportROIsToCSVMenu.ButtonPressEvent += exportROIsToCSVMenuClick;
            importROIsFromCSVMenu.ButtonPressEvent += importROIsFromCSVMenuClick;
            exportROIsOfFolderOfImagesMenu.ButtonPressEvent += exportROIsOfFolderOfImagesMenuClick;
            importROIsFromImageJMenu.ButtonPressEvent += ImportROIsFromImageJMenu_ButtonPressEvent;
            exportROIsFromImageJMenu.ButtonPressEvent += ExportROIsFromImageJMenu_ButtonPressEvent;
            importROIQuPath.ButtonPressEvent += ImportROIQuPath_ButtonPressEvent;
            exportROIQuPath.ButtonPressEvent += ExportROIQuPath_ButtonPressEvent;
            importPointsNapari.ButtonPressEvent += ImportPointsNapari_ButtonPressEvent;
            importShapesNapari.ButtonPressEvent += ImportShapesNapari_ButtonPressEvent;
            exportROINapari.ButtonPressEvent += ExportROINapari_ButtonPressEvent;
 
            autoThresholdAllMenu.ButtonPressEvent += autoThresholdAllMenuClick;
            channelsToolMenu.ButtonPressEvent += channelsToolMenuClick;
            switchRedBlueMenu.ButtonPressEvent += switchRedBlueMenuClick;
 
            stackToolMenu.ButtonPressEvent += stackToolMenuClick;
            focusMenu.ButtonPressEvent += FocusMenu_ButtonPressEvent;
 
            to8BitMenu.ButtonPressEvent += to8BitMenuClick;
            to16BitMenu.ButtonPressEvent += to16BitMenuClick;
            to24BitMenu.ButtonPressEvent += to24BitMenuClick;
            to32BitMenu.ButtonPressEvent += to32BitMenuClick;
            to48BitMenu.ButtonPressEvent += to48BitMenuClick;
            toFloatMenu.ButtonPressEvent += ToFloatMenu_ButtonPressEvent;
            toShortMenu.ButtonPressEvent += ToShortMenu_ButtonPressEvent;
 
            filtersMenu.ButtonPressEvent += filtersMenuClick;
            functionsToolMenu.ButtonPressEvent += functionsToolMenuClick;
            consoleMenu.ButtonPressEvent += consoleMenuClick;
            scriptRunnerMenu.ButtonPressEvent += scriptRunnerMenuClick;
            scriptRecorderMenu.ButtonPressEvent += ScriptRecorderMenu_ButtonPressEvent;
 
            aboutMenu.ButtonPressEvent += AboutClick;
 
            tabClose.ButtonPressEvent += TabClose_ButtonPressEvent;
            tabDuplicate.ButtonPressEvent += TabDuplicate_ButtonPressEvent;
            this.FocusInEvent += TabsView_FocusInEvent;
            rgbMenu.ButtonPressEvent += RgbMenu_ButtonPressEvent;
            filteredMenu.ButtonPressEvent += FilteredMenu_ButtonPressEvent;
            rawMenu.ButtonPressEvent += RawMenu_ButtonPressEvent;
            emissionMenu.ButtonPressEvent += EmissionMenu_ButtonPressEvent;
            tabsView.SwitchPage += TabsView_SwitchPage;
            tabsView.ButtonPressEvent += TabsView_ButtonPressEvent;
            this.WindowStateEvent += TabsView_WindowStateEvent;
            this.DeleteEvent += TabsView_DeleteEvent;
            omeroMenu.ButtonPressEvent += OmeroMenu_ButtonPressEvent;
 
            searchMenu.ButtonPressEvent += SearchMenu_ButtonPressEvent;
            updateMenu.ButtonPressEvent += UpdateMenu_ButtonPressEvent;
            renameMenu.ButtonPressEvent += RenameMenu_ButtonPressEvent;
            AIMenu.ButtonPressEvent += AiMenu_ButtonPressEvent;
 
            // Enable drag-and-drop for this window
            Gtk.Drag.DestSet(this, DestDefaults.All, new TargetEntry[]
            {
            new TargetEntry("text/uri-list", TargetFlags.OtherApp, 0)
            }, Gdk.DragAction.Copy);
            this.DragDataReceived += TabsView_DragDataReceived;
 
        }
        private async void SaveZarr_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
         new Gtk.FileChooserDialog("Choose Zarr file to save.",
             this,
             FileChooserAction.Save,
             "Cancel", ResponseType.Cancel,
             "Open", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            StartProgress("Saving Zarr", "Saving " + ImageView.SelectedImage.ID + " as Zarr file.");
            BioImage.Progress = 0;
            await Task.Yield();
            if (ImageView.SelectedImage == null)
                ImageView.SelectedImage = await BioImage.OpenFile(filechooser.Filename);
 
            await Task.Run(() =>
            {
                Zarr.SaveZarr(ImageView.SelectedImage, filechooser.Filename);
                Zarr.SaveV2Compatibility(ImageView.SelectedImage, filechooser.Filename);
                MergeZarrLabelOverlaysIntoAnnotations(ImageView.SelectedImage);
                TrySaveZarrROIs(ImageView.SelectedImage, filechooser.Filename);
                TrySaveZarrLabelOverlays(ImageView.SelectedImage, filechooser.Filename);
            });
            StopProgress();
        }
 
        private async void OpenZarr_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
         new Gtk.FileChooserDialog("Choose Zarr file to open.",
             this,
             FileChooserAction.SelectFolder,
             "Cancel", ResponseType.Cancel,
             "Open", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            await Task.Yield();
            string[] sts = filechooser.Filenames;
            StartProgressHidden("Open Zarr", "Opening");
            try
            {
                await Task.Yield();
                foreach (string f in filechooser.Filenames)
                {
                    await OpenPyramidRootsAsViewsAsync(f, true);
                }
            }
            finally
            {
                StopProgress();
            }
        }
 
        private async void OpenURLMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            OpenUrlBox box = OpenUrlBox.Create();
            try
            {
                if (box.Run() == (int)ResponseType.Ok)
                {
                    string url = box.GetUrl();
                    StartProgress("Open URL", "Opening");
                    try
                    {
                        await Task.Yield();
                        await OpenPyramidRootsAsViewsAsync(url, true);
                    }
                    catch (Exception ex)
                    {
                        var dialog = new MessageDialog(
                            this,
                            DialogFlags.Modal,
                            MessageType.Error,
                            ButtonsType.Ok,
                            ex.Message);
                        dialog.Title = "Open URL Failed";
                        dialog.Run();
                        dialog.Destroy();
                    }
                    finally
                    {
                        StopProgress();
                    }
                }
            }
            finally
            {
                box.Destroy();
            }
        }
 
        private void ImportPointsNapari_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
         new Gtk.FileChooserDialog("Choose Napari Points files to import.",
             this,
             FileChooserAction.Open,
             "Cancel", ResponseType.Cancel,
             "Open", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            string[] sts = filechooser.Filenames;
            Napari.Initialize(ImageView.SelectedImage.PhysicalSizeX, ImageView.SelectedImage.PhysicalSizeY,ImageView.SelectedImage.SizeT > 1);
            foreach (var f in filechooser.Filenames)
            {
                if (f.EndsWith(".CSV") || f.EndsWith(".csv"))
                    ImageView.SelectedImage.Annotations.AddRange(Napari.ParsePointsFile(f));
            }
            filechooser.Destroy();
            BioLib.Recorder.Record("Napari.ParsePointsFile(" + StrArray(sts) + ");");
        }
 
        private void ExportROINapari_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Choose filename for Shape and Points CSV files to save to.",
            this,
            FileChooserAction.Save,
            "Cancel", ResponseType.Cancel,
            "Open", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            string file = filechooser.Filename;
            Napari.Initialize(ImageView.SelectedImage.PhysicalSizeX, ImageView.SelectedImage.PhysicalSizeY, ImageView.SelectedImage.SizeT > 1);
            Napari.WriteNapariFiles(file + "_points.csv", file + "_shapes.csv", ImageView.SelectedImage.Annotations);
            filechooser.Destroy();
            BioLib.Recorder.Record("Napari.WriteNapariFiles(" + Q(file + "_points.csv") + ", " + Q(file + "_shapes.csv") + ", ImageView.SelectedImage.Annotations);");
        }
 
        private void ImportShapesNapari_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
         new Gtk.FileChooserDialog("Choose Napari Shape files to import.",
             this,
             FileChooserAction.Open,
             "Cancel", ResponseType.Cancel,
             "Open", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            Napari.Initialize(ImageView.SelectedImage.PhysicalSizeX, ImageView.SelectedImage.PhysicalSizeY, ImageView.SelectedImage.SizeT > 1);
            foreach (var f in filechooser.Filenames)
            {
                if (f.EndsWith(".CSV") || f.EndsWith(".csv"))
                {
                    List<ROI> rs = Napari.ParseShapesFile(f);
                    ImageView.SelectedImage.Annotations.AddRange(rs);
                }
            }
            filechooser.Destroy();
        }
 
        private void UploadImageMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (BioLib.OMERO.sc == null)
            OmeroMenu_ButtonPressEvent(o, args);
            BioImage b = ImageView.SelectedImage;
            var user = BioLib.OMERO.gateway.getLoggedInUser();
            long userId = user.getId();
            long imgid = 0;
            try
            {
                imgid = long.Parse(b.ID);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            BioLib.Recorder.Record("OMERO.Upload(" + (b?.ID ?? string.Empty) + ", " + userId + ");");
            if(imgid == 0)
            {
                BioLib.OMERO.Upload(b, userId);
            }
            try
            {
                imgid = long.Parse(b.ID);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
 
        private void AiMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            AI.Create();
            BioLib.Recorder.Record("AI.Create();");
        }
 
        private async void TabsView_DragDataReceived(object o, DragDataReceivedArgs args)
        {
            // Convert the received data to a string
            string receivedData = System.Text.Encoding.UTF8.GetString(args.SelectionData.Data);
 
            // Parse the URIs (file paths)
            string[] uris = receivedData.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string uri in uris)
            {
                if (Uri.TryCreate(uri, UriKind.Absolute, out Uri fileUri) && fileUri.IsFile)
                {
                    string filePath = fileUri.LocalPath;
                    await OpenPyramidRootsAsTabsAsync(filePath);
                }
            }
 
            args.RetVal = true; // Indicate the drop was handled
        }
 
        private void OmeroMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Login log = Login.Create();
            int status = log.Run();
            if (status == (int)ResponseType.Ok)
            {
                OMERO omr = OMERO.Create();
                omr.Show();
            }
            BioLib.Recorder.Record("Login.Create();");
        }
 
        private void SaveNumPyBut_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Choose filename for NumPy file to save to.",
            this,
            FileChooserAction.Save,
            "Cancel", ResponseType.Cancel,
            "Open", ResponseType.Accept);
            filechooser.SelectMultiple = false;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            NumPy.SaveNumPy(ImageView.SelectedImage,filechooser.Filename);
            filechooser.Hide();
            BioLib.Recorder.Record("NumPy.SaveNumPy(ImageView.SelectedImage, " + Q(filechooser.Filename) + ");");
        }
 
        private void RunMicroSAMMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            SAMTool sam = SAMTool.Create(true);
            if (sam.init)
                sam.Show();
            App.samTool = sam;
            BioLib.Recorder.Record("SAMTool.Create(true);");
        }
 
        public void RenameTab(string name, string newName)
        {
            int i = 0;
            foreach (Widget item in tabsView.Children)
            {
                // Get the tab widget for the page and set the new title
                Label l = (Label)tabsView.GetTabLabel(tabsView.GetNthPage(i));
                if (l.Text == name)
                {
                    l.Text = newName;
                    BioLib.Recorder.Record("TabsView.RenameTab(" + Q(name) + ", " + Q(newName) + ");");
                    return;
                }
            }
        }
 
        private void TabsView_FocusInEvent(object o, FocusInEventArgs args)
        {
            App.tabsView = this;
        }
 
        private void RenameMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            TextInput ti = TextInput.Create();
            ti.Show();
            if ((int)ti.Run() == (int)ResponseType.Ok)
            {
                App.Rename(ti.Text);
            }
            BioLib.Recorder.Record("App.Rename(" + Q(ti.Text) + ");");
        }
 
        private void TabsView_DeleteEvent(object o, DeleteEventArgs args)
        {
            foreach (var v in viewers)
            {
                foreach (var b in v.Images) 
                {
                    TrySaveZarrROIs(b);
                    Images.RemoveImage(b);
                }
                v.Close();
            }
        }
 
        private async void ExtractRegionMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            BioImage b = ImageView.SelectedImage.Copy();
            String name = System.IO.Path.GetFileNameWithoutExtension(ImageView.SelectedImage.Filename).Replace(".ome","");
            int c = Images.GetImageCountByName(name);
            b.ID = name + "-" + c + ".ome.tif";
            byte[] bms = null;
            if(b.OpenSlideBase != null)
            {
               bms = await b.OpenSlideBase.GetSliceAsync(new OpenSlideGTK.SliceInfo(b.PyramidalOrigin.X, b.PyramidalOrigin.Y, b.PyramidalSize.Width, b.PyramidalSize.Height, b.Resolution),b.Level,b.Coordinate);
            }
            else
                bms = await b.SlideBase.GetSlice(
                    new SliceInfo(b.PyramidalOrigin.X, b.PyramidalOrigin.Y, b.PyramidalSize.Width, b.PyramidalSize.Height, b.Resolution, b.Coordinate),
                    b.PyramidalOrigin, b.PyramidalSize);
            Point3D loc = b.Volume.Location;
            Point3D p = new Point3D(b.StageSizeX + b.PyramidalOrigin.X, b.StageSizeY + b.PyramidalOrigin.Y, b.StageSizeZ + b.SizeZ);
            Resolution res = new Resolution(b.PyramidalSize.Width, b.PyramidalSize.Height, b.Buffers[0].PixelFormat,b.PhysicalSizeX,b.PhysicalSizeY,b.PhysicalSizeZ,p.X,p.Y,p.Z);
            b.Resolutions.Clear();
            b.Resolutions.Add(res);
            b.Buffers.Clear();
            b.Buffers.Add(new Bitmap((int)b.PyramidalOrigin.X, (int)b.PyramidalOrigin.Y,PixelFormat.Format32bppArgb));
            Images.AddImage(b);
            AddTab(b);
        }
 
        private void ToShortMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            ImageView.SelectedImage.ToShort();
        }
 
        private void ToFloatMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            ImageView.SelectedImage.ToFloat();
        }
 
        private void UpdateMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            App.updater.Show();
        }
 
        private void PlateToolMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            PlateTool pl = PlateTool.Create();
            BioLib.Recorder.Record("App.viewer.Mode = ImageView.ViewMode.Emission;");
        }
 
        private void ExportROIQuPath_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Choose QuPath ROI(.geojson) file to save to.",
            this,
            FileChooserAction.Save,
            "Cancel", ResponseType.Cancel,
            "Open", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            QuPath.SaveROI(filechooser.Filename, ImageView.SelectedImage);
            filechooser.Hide();
            BioLib.Recorder.Record("BioImage.ExportROIsCSV(" + Q(filechooser.Filename) + ", ImageView.SelectedImage.Annotations);");
        }
 
        private void ImportROIQuPath_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Choose QuPath ROI(.geojson) file to open",
            this,
            FileChooserAction.Open,
            "Cancel", ResponseType.Cancel,
            "Open", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            foreach (string item in filechooser.Filenames)
            {
                ROI[] rois = QuPath.ReadROI(item,ImageView.SelectedImage);
                foreach (ROI r in rois)
                {
                    ImageView.SelectedImage.Annotations.Add(r);
                }
            }
            filechooser.Hide();
            BioLib.Recorder.Record("QuPath.ReadROI(" + StrArray(filechooser.Filenames) + ", ImageView.SelectedImage);");
        }
 
        private void SearchMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Search search = Search.Create();
            search.Show();
            BioLib.Recorder.Record("App.viewer.Mode = ImageView.ViewMode.Raw;");
        }
 
        private void TabsView_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            contextMenu.Popup();
        }
 
        private void TabDuplicate_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            List<BioImage> bm = new List<BioImage>();
            foreach (BioImage item in App.viewer.Images)
            {
                bm.Add(item.Copy());
            }
            for (int i = 1; i < bm.Count; i++)
            {
                Images.AddImage(bm[i]);
                AddTab(bm[i]);
            }
            BioLib.Recorder.Record("App.viewer.Images.Count;");
        }
 
        private void TabClose_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (App.viewer == null) return;
            ImageView v = App.viewer;
            foreach (BioImage item in v.Images)
            {
                TrySaveZarrROIs(item);
                Images.RemoveImage(item);
                RemoveTab(item.Filename);
                item.Dispose();
            }
            RemoveViewer(v);
            v.Hide();
            v.Destroy();
            BioLib.Recorder.Record("App.viewer.Images.Count;");
        }
 
        private void RunSAMMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            SAMTool sam = SAMTool.Create(false);
            if(sam.init)
            sam.Show();
            App.samTool = sam;
        }
 
        private async void SavePyramidalMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Set Pyramidal filename to save",
            this,
            FileChooserAction.Save,
            "Cancel", ResponseType.Cancel,
            "Save", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            ComboPicker picker = ComboPicker.Create(typeof(NetVips.Enums.ForeignTiffCompression));
            picker.Title = "Select Compression";
            picker.Show();
            if(picker.Run() != (int)ResponseType.Ok)
                return;
            NumberPicker numpicker = NumberPicker.Create(0,100,0);
            numpicker.Title = "Select Compression Level in %";
            if (numpicker.Run() != (int)ResponseType.Ok)
                return;
            await BioImage.SavePyramidalAsync(App.viewer.Images.ToArray(), filechooser.Filename, (NetVips.Enums.ForeignTiffCompression)picker.SelectedIndex, (int)numpicker.SelectedValue);
            BioLib.Recorder.Record("BioImage.SavePyramidalAsync(App.viewer.Images.ToArray(), " + Q(filechooser.Filename) + ", (NetVips.Enums.ForeignTiffCompression)" + picker.SelectedIndex + ", " + (int)numpicker.SelectedValue + ");");
        }
 
        private void FocusMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (ImageView.SelectedImage == null) return;
            ZCT co = App.viewer.GetCoordinate();
            int f = BioImage.FindFocus(ImageView.SelectedImage, co.C, co.T);
            ZCT z = ImageView.SelectedImage.Buffers[f].Coordinate;
            App.viewer.SetCoordinate(z.Z, z.C, z.T);
        }
 
        private void ScriptRecorderMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            App.recorder = Recorder.Create();
            App.recorder.Show();
            App.recorder.Present();
            BioLib.Recorder.Record("App.viewer.Mode = ImageView.ViewMode.Filtered;");
        }
 
        private void ExportROIsFromImageJMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Set ROI filename to save",
            this,
            FileChooserAction.Save,
            "Cancel", ResponseType.Cancel,
            "Save", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            int i = 1;
            foreach (ROI item in ImageView.SelectedImage.Annotations)
            {
                string f = filechooser.Filename;
                if (!f.EndsWith(".roi"))
                    f += i + ".roi";
                else
                {
                    f = f.Replace(".roi","") + i + ".roi";
                }
                Fiji.RoiEncoder.save(ImageView.SelectedImage, item, f);
                i++;
            }
            filechooser.Hide();
            BioLib.Recorder.Record("Fiji.RoiEncoder.save(ImageView.SelectedImage, item, " + Q(filechooser.Filename) + ");");
        }
 
        private void ImportROIsFromImageJMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Choose ROI file to open",
            this,
            FileChooserAction.Open,
            "Cancel", ResponseType.Cancel,
            "Open", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            foreach (string item in filechooser.Filenames)
            {
                ROI roi = Fiji.RoiDecoder.open(item, ImageView.SelectedImage.PhysicalSizeX, ImageView.SelectedImage.PhysicalSizeY, ImageView.SelectedImage.Volume.Location.X, ImageView.SelectedImage.Volume.Location.Y);
                ImageView.SelectedImage.Annotations.Add(roi);
            }
            filechooser.Hide();
            BioLib.Recorder.Record("Fiji.RoiDecoder.open(" + StrArray(filechooser.Filenames) + ", ImageView.SelectedImage.PhysicalSizeX, ImageView.SelectedImage.PhysicalSizeY, ImageView.SelectedImage.Volume.Location.X, ImageView.SelectedImage.Volume.Location.Y);");
        }
 
        private void TabsView_WindowStateEvent(object o, WindowStateEventArgs args)
        {
            if ((args.Event.ChangedMask & Gdk.WindowState.Iconified) != 0)
            {
                foreach (ImageView v in viewers)
                {
                    v.Hide();
                }
            }
            
            else if ((args.Event.ChangedMask & Gdk.WindowState.Maximized) == 0 && (args.Event.ChangedMask & Gdk.WindowState.Iconified) == 0)
            {
                foreach (ImageView v in viewers)
                {
                    // Only re-present viewers that still have images.
                    // A viewer with no images has been closed/destroyed and
                    // calling Present() on it would resurrect an empty window.
                    if(!v.Visible && v.Images.Count > 0)
                        v.Present();
                }
            }
            
        }
 
        private void TabsView_SwitchPage(object o, SwitchPageArgs args)
        {
            if(viewers.Count == 0) return;
            viewers[(int)args.PageNum].Present();
            App.viewer = viewers[(int)args.PageNum];
            ImageView.SelectedImage = App.viewer.Images[0];
            App.roiManager?.UpdateAnnotationList();
        }
 
        private void EmissionMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (emissionMenu.Active)
                emissionMenu.Active = false;
            else
                emissionMenu.Active = true;
            filteredMenu.Active = false;
            rawMenu.Active = false;
            rgbMenu.Active = false;
            App.viewer.Mode = ImageView.ViewMode.Emission;
            BioLib.Recorder.Record("App.viewer.Mode = ImageView.ViewMode.RGBImage;");
        }
        private void RawMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (rawMenu.Active)
                rawMenu.Active = false;
            else
                rawMenu.Active = true;
            filteredMenu.Active = false;
            rgbMenu.Active = false;
            emissionMenu.Active = false;
            App.viewer.Mode = ImageView.ViewMode.Raw;
            BioLib.Recorder.Record("PlateTool.Create();");
        }
        private void FilteredMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (filteredMenu.Active)
                filteredMenu.Active = false;
            else
                filteredMenu.Active = true;
            rgbMenu.Active = false;
            rawMenu.Active = false;
            emissionMenu.Active = false;
            App.viewer.Mode = ImageView.ViewMode.Filtered;
            BioLib.Recorder.Record("App.viewer.Mode = ImageView.ViewMode.Filtered;");
        }
        private void RgbMenu_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            if (rgbMenu.Active)
                rgbMenu.Active = false;
            else
                rgbMenu.Active = true;
            filteredMenu.Active = false;
            rawMenu.Active = false;
            emissionMenu.Active = false;
            App.viewer.Mode = ImageView.ViewMode.RGBImage;
            BioLib.Recorder.Record("App.viewer.Mode = ImageView.ViewMode.RGBImage;");
        }
        public void SetTab(int i)
        {
            tabsView.Page = i;
            BioLib.Recorder.Record("tabsView.Page = " + i + ";");
        }
        public void AddTab(BioImage im, string? sourcePath = null)
        {
            
            try
            {
                if (im == null)
                    return;
                for (int vi = 0; vi < viewers.Count; vi++)
                {
                    for (int i = 0; i < viewers[vi].Images.Count; i++)
                    {
                        if (viewers[vi].Images[i].Filename == im.Filename)
                        {
                            RememberRecentImage(sourcePath ?? im.SourceFile);
                            return;
                        }
                    }
                }
                TryLoadZarrROIs(im);
                ImageView v = ImageView.Create(im);
                v.RefreshZarrLabelOverlays(sourcePath ?? im.file);
                viewers.Add(v);
                Label dummy = new Gtk.Label(System.IO.Path.GetDirectoryName(im.file.Replace("\\", "/")) + "/" + im.Filename);
                dummy.Text = im.file.Replace("\\", "/") + "/" + im.Filename;
                dummy.Visible = false;
                Label l = new Gtk.Label(System.IO.Path.GetFileName(im.Filename));
                l.Text = System.IO.Path.GetFileName(im.Filename);
                tabsView.AppendPage(dummy, l);
                Console.WriteLine("New tab added for " + im.Filename);
                App.nodeView.UpdateItems();
                tabsView.ShowAll();
                v.ShowAll();
                RememberRecentImage(sourcePath ?? im.SourceFile);
                BioLib.Recorder.Record("AddTab(" + (im?.file ?? string.Empty) + ", " + Q(sourcePath ?? string.Empty) + ");");
                GLib.Timeout.Add(16, () =>
                {
                    if (v.View == null || !v.View.IsRealized || v.View.AllocatedWidth <= 1 || v.View.AllocatedHeight <= 1)
                        return true;
 
                    App.viewer = v;
                    v.GoToImage();
                    v.UpdateView();
                    if (!ImageView.MacOS)
                        v.glArea?.RequestRedraw();
                    else
                        v.View.QueueDraw();
                    return false;
                });
            }
            catch (Exception e)
            {
                BioLib.Recorder.Record("AddTab(" + (im?.file ?? string.Empty) + ", " + Q(sourcePath ?? string.Empty) + ");");
                // Execute on UI thread
                Gtk.Application.Invoke((sender, args) =>
                {
                    if (im == null)
                        return;
                    for (int vi = 0; vi < viewers.Count; vi++)
                    {
                    for (int i = 0; i < viewers[vi].Images.Count; i++)
                    {
                        if (viewers[vi].Images[i].Filename == im.Filename)
                        {
                            RememberRecentImage(sourcePath ?? im.SourceFile);
                            return;
                        }
                    }
                }
                ImageView v = ImageView.Create(im);
                viewers.Add(v);
                v.RefreshZarrLabelOverlays(sourcePath ?? im.file);
                    Label dummy = new Gtk.Label(System.IO.Path.GetDirectoryName(im.file.Replace("\\", "/")) + "/" + im.Filename);
                    dummy.Text = im.file.Replace("\\", "/") + "/" + im.Filename;
                    dummy.Visible = false;
                    Label l = new Gtk.Label(System.IO.Path.GetFileName(im.Filename));
                    l.Text = System.IO.Path.GetFileName(im.Filename);
                    tabsView.AppendPage(dummy, l);
                    Console.WriteLine("New tab added for " + im.Filename);
                    App.nodeView.UpdateItems();
                    tabsView.ShowAll();
                    v.ShowAll();
                    RememberRecentImage(sourcePath ?? im.SourceFile);
                    GLib.Timeout.Add(16, () =>
                    {
                        if (v.View == null || !v.View.IsRealized || v.View.AllocatedWidth <= 1 || v.View.AllocatedHeight <= 1)
                            return true;
 
                        App.viewer = v;
                        v.GoToImage();
                        v.UpdateView();
                        if (!ImageView.MacOS)
                            v.glArea?.RequestRedraw();
                        else
                            v.View.QueueDraw();
                        return false;
                    });
                });
            }
        }
 
        private static void TryLoadZarrROIs(BioImage image)
        {
            try
            {
                string zarrDir = image.file;
                if (string.IsNullOrWhiteSpace(zarrDir))
                    return;
 
                if (!Directory.Exists(zarrDir) && !zarrDir.EndsWith(".zarr", StringComparison.OrdinalIgnoreCase))
                    return;
 
                var rois = BioLib.Zarr.LoadROIs(zarrDir);
                if (rois.Count > 0)
                {
                    image.Annotations.AddRange(rois.Where(r =>
                        r != null &&
                        (string.IsNullOrWhiteSpace(r.roiID) ||
                         !r.roiID.StartsWith("zarr-label:", StringComparison.OrdinalIgnoreCase))));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Load Zarr ROIs failed: {ex.Message}");
            }
        }
 
        private static void TrySaveZarrROIs(BioImage image, string? overrideDir = null)
        {
            try
            {
                if (image == null)
                    return;
 
                string zarrDir = overrideDir ?? image.file;
                if (string.IsNullOrWhiteSpace(zarrDir))
                    return;
 
                if (!Directory.Exists(zarrDir) && !zarrDir.EndsWith(".zarr", StringComparison.OrdinalIgnoreCase))
                    return;
 
                BioLib.Zarr.SaveROIs(image, zarrDir);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Save Zarr ROIs failed: {ex.Message}");
            }
        }
 
        private static void MergeZarrLabelOverlaysIntoAnnotations(BioImage image)
        {
            if (image == null || App.viewer == null)
                return;
 
            var overlays = App.viewer.GetZarrLabelOverlaysForImage(image);
            if (overlays == null || overlays.Count == 0)
                return;
 
            foreach (var overlay in overlays)
            {
                if (overlay == null)
                    continue;
 
                if (string.IsNullOrWhiteSpace(overlay.roiID) ||
                    !overlay.roiID.StartsWith("zarr-label:", StringComparison.OrdinalIgnoreCase))
                    continue;
 
                bool exists = image.Annotations.Any(a => a != null && a.roiID == overlay.roiID);
                if (exists)
                    continue;
 
                image.Annotations.Add(overlay);
            }
        }
 
        private static void TrySaveZarrLabelOverlays(BioImage image, string? overrideDir = null)
        {
            try
            {
                if (image == null)
                    return;
 
                string zarrDir = overrideDir ?? image.file;
                if (string.IsNullOrWhiteSpace(zarrDir))
                    return;
 
                if (!Directory.Exists(zarrDir) && !zarrDir.EndsWith(".zarr", StringComparison.OrdinalIgnoreCase))
                    return;
 
                if (image.Annotations == null || image.Annotations.Count == 0)
                    return;
 
                BioLib.Zarr.SaveLabelOverlays(image, image.Annotations, zarrDir);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Save Zarr label overlays failed: {ex.Message}");
            }
        }
 
        Gtk.FileChooserDialog filechooser;
        protected async void openImagesMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Choose file to open", this, FileChooserAction.Open, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            string[] sts = filechooser.Filenames;
            filechooser.Hide();
            foreach (string item in sts)
            {
                StartProgress("Open File", "Opening");
                try
                {
                    await FlushGtkEventsAsync();
                    await OpenPyramidRootsAsTabsAsync(item);
                }
                finally
                {
                    StopProgress();
                }
            }
            BioLib.Recorder.Record("BioImage.OpenAsync(" + StrArray(sts) + ", false, true, true);");
        }
        protected async void openOMEImagesMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Choose OME file to open", this, FileChooserAction.Open, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            string[] sts = filechooser.Filenames;
            foreach (string item in filechooser.Filenames)
            {
                StartProgress("Open OME", "Opening");
                await OpenPyramidRootsAsTabsAsync(item);
                StopProgress();
            }
            BioLib.Recorder.Record("BioImage.OpenAsync(" + StrArray(sts) + ", true, true, true);");
        }
        protected async void openOMESeriesMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Choose OME Series file to open.", this, FileChooserAction.Open, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            string[] sts = filechooser.Filenames;
            foreach (string item in filechooser.Filenames)
            {
                StartProgress("Open OME", "Opening");
                await OpenPyramidRootsAsTabsAsync(item);
            }
            tabsView.ShowAll();
            BioLib.Recorder.Record("BioImage.OpenAsync(" + StrArray(sts) + ", true, true, true);");
            
        }
        protected async void openSeriesMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Choose series file to open", this, FileChooserAction.Open, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            string[] sts = filechooser.Filenames;
            foreach (string item in filechooser.Filenames)
            {
                StartProgress("Open OME Series", "Opening");
                await OpenPyramidRootsAsTabsAsync(item);
                StopProgress();
            }
            tabsView.Show();
            BioLib.Recorder.Record("BioImage.ImportROIsCSV(" + StrArray(sts) + ");");
        }
        private async void openQuPathProjectMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Choose QuPath project file to open", this, FileChooserAction.Open, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            QuPath.Project pr = QuPath.OpenProject(filechooser.Filename);
            foreach (var item in pr.Images)
            {
                string file = item.ServerBuilder.Uri.Replace("file:/", "");
                BioImage bm = await BioImage.OpenFile(file);
                AddTab(bm, file);
                string[] rs = Directory.GetFiles(System.IO.Path.GetDirectoryName(file));
                foreach (string s in rs)
                {
                    if (s.EndsWith(".geojson") && s.Contains(System.IO.Path.GetFileNameWithoutExtension(file)))
                    {
                        ROI[] rois = QuPath.ReadROI(s, bm);
                        bm.Annotations.AddRange(rois);
                    }
                }
            }
            BioLib.Recorder.Record("QuPath.OpenProject(" + Q(filechooser.Filename) + ");");
        }
        private void saveQuPathProject_ButtonPressEvent(object o, ButtonPressEventArgs args)
        {
            Gtk.FileChooserDialog filechooser =
        new Gtk.FileChooserDialog("Set QuPath project file to save.",
            this,
            FileChooserAction.Save,
            "Cancel", ResponseType.Cancel,
            "Save", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            List<BioImage[]> bms = new List<BioImage[]>();
            foreach (var item in viewers)
            {
                List<BioImage> bs = new List<BioImage>();
                foreach (var b in item.Images)
                {
                    bs.Add(b);
                }
                bms.Add(bs.ToArray());
            }
            QuPath.Project.SaveProject(filechooser.Filename, bms);
            BioLib.Recorder.Record("QuPath.Project.SaveProject(" + Q(filechooser.Filename) + ", bms);");
        }
        protected async void addImagesToTabMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Choose file to add to current tab.", this, FileChooserAction.Open, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            string[] sts = filechooser.Filenames;
            foreach (string item in filechooser.Filenames)
            {
                StartProgress("Add Image to Tab", "Opening");
                await BioImage.OpenAsync(item, false, false, true, 0);
                BioImage im = Images.GetImage(item);
                AddTab(im, item);
                StopProgress();
            }
            this.ShowAll();
            BioLib.Recorder.Record("BioImage.OpenAsync(" + StrArray(sts) + ", false, false, true);");
        }
        protected async void addOMEImagesToTabClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Choose OME file to add to current tab.", this, FileChooserAction.Open, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            string[] sts = filechooser.Filenames;
            foreach (string item in filechooser.Filenames)
            {
                StartProgress("Add Image to Tab", "Opening");
                await BioImage.OpenAsync(item, true, false, true, 0);
                BioImage im = Images.GetImage(item);
                AddTab(im, item);
                StopProgress();
            }
            this.Show();
            BioLib.Recorder.Record("BioImage.OpenAsync(" + StrArray(sts) + ", true, false, true);");
        }
        private static bool done = false;
        private static bool progressShown = false;
        private static int progressShowThreshold = 0;
        private static int progressDisplayOffset = 0;
        private static int progressRunId = 0;
        private static readonly Stopwatch progressStopwatch = new Stopwatch();
        private static Progress progress;
        private static string title;
        private static string FormatProgressTiming(double progressPercent)
        {
            TimeSpan elapsed = progressStopwatch.Elapsed;
            string elapsedText = FormatDuration(elapsed);
            string etaText = "--:--";
 
            if (progressPercent > 0.01 && progressPercent < 100)
            {
                double remainingSeconds = elapsed.TotalSeconds * ((100.0 - progressPercent) / progressPercent);
                if (double.IsFinite(remainingSeconds) && remainingSeconds >= 0)
                    etaText = FormatDuration(TimeSpan.FromSeconds(remainingSeconds));
            }
            else if (progressPercent >= 100)
            {
                etaText = "00:00";
            }
 
            return $"Elapsed: {elapsedText}   ETA: {etaText}";
        }
        private static string FormatDuration(TimeSpan span)
        {
            if (span.TotalHours >= 1)
                return span.ToString(@"hh\:mm\:ss");
            return span.ToString(@"mm\:ss");
        }
        private static void ProgressUpdate(int runId)
        {
            do
            {
                float displayProgress = BioImage.Progress;
                if (progressDisplayOffset > 0)
                {
                    float normalized = (BioImage.Progress - progressDisplayOffset) * 100f / Math.Max(1, 100 - progressDisplayOffset);
                    displayProgress = Math.Max(0, Math.Min(100, normalized));
                }
                progress.Title = title;
                if (!string.IsNullOrEmpty(BioImage.Status))
                    progress.Status = BioImage.Status;
                if (!progressShown && BioImage.Progress >= progressShowThreshold)
                {
                    progressShown = true;
                    Gtk.Application.Invoke(delegate
                    {
                        if (done || runId != progressRunId)
                            return;
                        progress.ShowAll();
                    });
                }
                progress.ProgressPercentValue = displayProgress;
                progress.Text = FormatProgressTiming(displayProgress);
                Thread.Sleep(250);
            } while (!done && runId == progressRunId);
        }
        private static void StartProgress(string titl, string status)
        {
            StartProgressInternal(titl, status, true, 0, 0);
        }
        private static void StartProgressHidden(string titl, string status)
        {
            StartProgressInternal(titl, status, false, 85, 85);
        }
        private static void StartProgressInternal(string titl, string status, bool showImmediately, int showThreshold, int displayOffset)
        {
            done = false;
            progressRunId++;
            int runId = progressRunId;
            progressShown = showImmediately;
            progressShowThreshold = showThreshold;
            progressDisplayOffset = displayOffset;
            title = titl;
            BioImage.Progress = 0;
            progress.Status = status;
            progress.Title = title;
            if (BioImage.Status == "" || BioImage.Status == null)
                progress.Status = status;
            else
                progress.Status = BioImage.Status;
            progress.ProgressPercentValue = BioImage.Progress;
            progressStopwatch.Restart();
            progress.Text = FormatProgressTiming(BioImage.Progress);
            if (showImmediately)
                progress.ShowAll();
            else
                progress.Hide();
            Thread th = new Thread(() => ProgressUpdate(runId));
            th.IsBackground = true;
            th.Start();
        }
 
        private static async Task FlushGtkEventsAsync()
        {
            await Task.Yield();
            while (Gtk.Application.EventsPending())
                Gtk.Application.RunIteration(false);
            await Task.Delay(50);
            while (Gtk.Application.EventsPending())
                Gtk.Application.RunIteration(false);
        }
 
        private static void StopProgress()
        {
            done = true;
            progressStopwatch.Stop();
            int runId = ++progressRunId;
            Gtk.Application.Invoke(delegate
            {
                if (runId != progressRunId)
                    return;
                progress.Hide();
            });
        }
 
        private static bool IsZarrSource(BioImage image)
        {
            if (image == null)
                return false;
 
            string source = image.file;
            if (string.IsNullOrWhiteSpace(source))
                source = image.Filename;
 
            return source.Contains(".zarr", StringComparison.OrdinalIgnoreCase) ||
                   source.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
                   source.StartsWith("s3://", StringComparison.OrdinalIgnoreCase);
        }
 
        private static async Task<(BioImage Image, bool IsTemporary)> GetOmeExportImageAsync(BioImage image)
        {
            if (image == null)
                return (null, false);
 
            if (!IsZarrSource(image))
                return (image, false);
 
            string source = image.file;
            if (string.IsNullOrWhiteSpace(source))
                source = image.Filename;
 
            BioImage exportImage = await BioImage.OpenZarrAsync(source, 0, 0, image.ID).ConfigureAwait(false);
            return (exportImage, true);
        }
 
        private static void ReleaseTemporaryExportImage(BioImage image)
        {
            if (image == null)
                return;
 
            Images.images.Remove(image);
            image.Dispose();
        }
 
        protected async void saveSelectedTiffClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Save Selected Image To TIFF", this, FileChooserAction.Save, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            StartProgress("Save Selected Tiff","Saving");
            await BioImage.SaveAsync(filechooser.Filename, ImageView.SelectedImage.Filename, 0, false);
            StopProgress();
        }
        protected async void saveSelectedOMEClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Save Selected OME Image to File", this, FileChooserAction.Save, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            StartProgress("Save Selected OME", "Saving");
            var (exportImage, isTemporary) = await GetOmeExportImageAsync(ImageView.SelectedImage);
            try
            {
                PreserveSourceAnnotations(ImageView.SelectedImage, exportImage);
                NormalizeMasksForOmeExport(exportImage);
                await Task.Run(() => BioImage.SaveOMESeries(new[] { exportImage }, filechooser.Filename, BioImage.Planes));
            }
            finally
            {
                if (isTemporary)
                    ReleaseTemporaryExportImage(exportImage);
            }
            StopProgress();
        }
        protected async void saveTabOMEClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Save Tab as an OME image.", this, FileChooserAction.Save, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            StartProgress("Save Selected OME", "Saving");
            BioImage[] exportImages = new BioImage[App.viewer.Images.Count];
            List<BioImage> temporaryImages = new List<BioImage>();
            try
            {
                for (int i = 0; i < App.viewer.Images.Count; i++)
                {
                    BioImage sourceImage = App.viewer.Images[i];
                    var (exportImage, isTemporary) = await GetOmeExportImageAsync(sourceImage);
                    PreserveSourceAnnotations(sourceImage, exportImage);
                    NormalizeMasksForOmeExport(exportImage);
                    exportImages[i] = exportImage;
                    if (isTemporary)
                        temporaryImages.Add(exportImage);
                }
 
                await Task.Run(() => BioImage.SaveOMESeries(exportImages, filechooser.Filename, true));
            }
            finally
            {
                foreach (BioImage temp in temporaryImages)
                    ReleaseTemporaryExportImage(temp);
            }
            StopProgress();
        }
        protected async void saveTabTiffMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Save Tab as an image.", this, FileChooserAction.Save, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            StartProgress("Save Selected Tiff", "Saving");
            await BioImage.SaveSeriesAsync(App.viewer.Images.ToArray(), filechooser.Filename, false);     
            StopProgress();
        }
        protected async void saveSeriesMenuClick(object sender, EventArgs a)
        {
            filechooser = new FileChooserDialog("Save TIFF series.", this, FileChooserAction.Save, "Cancel", ResponseType.Cancel, "OK", ResponseType.Accept);
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            StartProgress("Save Selected Tiff", "Saving");
            await BioImage.SaveSeriesAsync(App.viewer.Images.ToArray(), filechooser.Filename, true);
            StopProgress();
        }
        protected void imagesToStackClick(object sender, EventArgs a)
        {
            Gtk.FileChooserDialog filechooser =
    new Gtk.FileChooserDialog("Choose images to convert to stack.",
        this,
        FileChooserAction.Save,
        "Cancel", ResponseType.Cancel,
        "Save", ResponseType.Accept);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Accept)
                return;
            filechooser.Hide();
            string[] sts = filechooser.Filenames;
            BioImage b = BioImage.ImagesToStack(sts, true);
            AddTab(b);
        }
 
        protected void toolsMenuClick(object sender, EventArgs a)
        {
            if(App.tools == null)
            App.tools = Tools.Create();
            App.tools.Show();
            App.tools.Present();
        }
        protected void setToolMenuClick(object sender, EventArgs a)
        {
            App.setTool = SetTool.Create();
            App.setTool.Show();
            App.setTool.Present();
        }
 
        protected void roiManagerMenuClick(object sender, EventArgs a)
        {
            App.roiManager = ROIManager.Create();   
            App.roiManager.Show();
            App.roiManager.Present();
        }
 
        protected void exportROIsToCSVMenuClick(object sender, EventArgs a)
        {
            Gtk.FileChooserDialog filechooser = new Gtk.FileChooserDialog("Set filename for export.",
           this,
           FileChooserAction.Save,
           "Cancel", ResponseType.Cancel,
           "Ok", ResponseType.Ok);
            filechooser.SelectMultiple = false;
            if (filechooser.Run() != (int)ResponseType.Ok)
                return;
            BioImage.ExportROIsCSV(filechooser.Filename, ImageView.SelectedImage.Annotations);
            filechooser.Hide();
            BioLib.Recorder.Record("BioImage.ExportROIsCSV(" + Q(filechooser.Filename) + ", ImageView.SelectedImage.Annotations);");
        }
        protected void importROIsFromCSVMenuClick(object sender, EventArgs a)
        {
            Gtk.FileChooserDialog filechooser = new Gtk.FileChooserDialog("Choose the file to open.",
          this,
          FileChooserAction.Open,
          "Cancel", ResponseType.Cancel,
          "Ok", ResponseType.Ok);
            filechooser.SelectMultiple = true;
            if (filechooser.Run() != (int)ResponseType.Ok)
                return;
            string[] sts = filechooser.Filenames;
            foreach (string item in filechooser.Filenames)
            {
                ImageView.SelectedImage.Annotations.AddRange(BioImage.ImportROIsCSV(item));
            }
            filechooser.Hide();
            BioLib.Recorder.Record("BioImage.ImportROIsCSV(" + StrArray(sts) + ");");
        }
        protected void exportROIsOfFolderOfImagesMenuClick(object sender, EventArgs a)
        {
            Gtk.FileChooserDialog folderchooser = new Gtk.FileChooserDialog("Set folder of images for export.",
          this,
          FileChooserAction.SelectFolder,
          "Cancel", ResponseType.Cancel,
          "Ok", ResponseType.Ok);
            folderchooser.SelectMultiple = true;
            if (folderchooser.Run() != (int)ResponseType.Ok)
                return;
            string folder = folderchooser.Filename;
            folderchooser.Destroy();
            Gtk.FileChooserDialog filechooser = new Gtk.FileChooserDialog("Set filename for CSV to export.",
           this,
           FileChooserAction.Save,
           "Cancel", ResponseType.Cancel,
           "Ok", ResponseType.Ok);
            filechooser.SelectMultiple = false;
            if (filechooser.Run() != (int)ResponseType.Ok)
                return;
            string file = filechooser.Filename;
            filechooser.Hide();
            BioImage.ExportROIFolder(folder, file);
            BioLib.Recorder.Record("BioImage.ExportROIFolder(" + Q(folder) + ", " + Q(file) + ");");
        }
 
        protected void autoThresholdAllMenuClick(object sender, EventArgs a)
        {
            BioImage.AutoThreshold(ImageView.SelectedImage, true);
            if (ImageView.SelectedImage.bitsPerPixel > 8)
                ImageView.SelectedImage.StackThreshold(true);
            else
                ImageView.SelectedImage.StackThreshold(false);
            App.viewer.RefreshPyramidalTiles();
            App.viewer.UpdateImage();
            App.viewer.UpdateView();
        }
        protected void channelsToolMenuClick(object sender, EventArgs a)
        {
            if (App.viewer == null)
                return;
            App.channelsTool = ChannelsTool.Create();
            App.channelsTool.Show();
            App.channelsTool.Present();
        }
        protected void switchRedBlueMenuClick(object sender, EventArgs a)
        {
            foreach (AForge.Bitmap bf in ImageView.SelectedImage.Buffers)
            {
                bf.SwitchRedBlue();
            }
            App.viewer.UpdateImage();
            App.viewer.UpdateView();
        }
 
        protected void stackToolMenuClick(object sender, EventArgs a)
        {
            App.stack = StackTools.Create();
            App.stack.Show();
            App.stack.Present();
        }
 
        protected void to8BitMenuClick(object sender, EventArgs a)
        {
            ImageView.SelectedImage.To8Bit();
        }
        protected void to16BitMenuClick(object sender, EventArgs a)
        {
            ImageView.SelectedImage.To16Bit();
        }
        protected void to24BitMenuClick(object sender, EventArgs a)
        {
            ImageView.SelectedImage.To24Bit();
        }
        protected void to32BitMenuClick(object sender, EventArgs a)
        {
            ImageView.SelectedImage.To32Bit();
        }
        protected void to48BitMenuClick(object sender, EventArgs a)
        {
            ImageView.SelectedImage.To48Bit();
        }
 
        protected void filtersMenuClick(object sender, EventArgs a)
        {
            App.filters = FiltersView.Create();
            App.filters.Show();
            App.filters.Present();
        }
 
        protected void functionsToolMenuClick(object sender, EventArgs a)
        {
            App.funcs = Functions.Create();
            App.funcs.Show();
            App.funcs.Present();
        }
        protected void consoleMenuClick(object sender, EventArgs a)
        {
            App.console = BioConsole.Create();
            App.console.Show();
            App.console.Present();
        }
        protected void scriptRunnerMenuClick(object sender, EventArgs a)
        {
            App.scripting = Scripting.Create();
            App.scripting.Show();
            App.scripting.Present();
        }
 
        protected void AboutClick(object sender, EventArgs a)
        {
            App.about = About.Create();
            App.about.Show();
            App.about.Present();
        }
 
        public void RemoveTab(string tabName)
        {
            string shortName = System.IO.Path.GetFileName(tabName);
            for (int i = tabsView.NPages - 1; i >= 0; i--)
            {
                Widget page = tabsView.GetNthPage(i);
                // Check the visible tab label (the one the user sees)
                Widget tabLabelWidget = tabsView.GetTabLabel(page);
                string tabText = null;
                if (tabLabelWidget is Gtk.Label tl)
                    tabText = tl.Text;
 
                // Also check the page content widget (a hidden dummy Label
                // whose Text holds the full path)
                string pageText = null;
                if (page is Gtk.Label pl)
                    pageText = pl.Text;
 
                bool match = (tabText != null && (tabText == tabName || tabText == shortName))
                          || (pageText != null && (pageText == tabName
                              || System.IO.Path.GetFileName(pageText) == shortName));
 
                if (match)
                {
                    tabsView.RemovePage(i);
                    App.nodeView.UpdateItems();
                    return;
                }
            }
        }
        public async void Open(string file)
        {
            await OpenPyramidRootsAsViewsAsync(file, true);
        }
        #endregion
 
    }
}