GPALClipboard.cs

// =============================================================================
// GPAL - Generally Positive Automation Library
// Copyright © 2026 Software Decisions, Inc. All rights reserved.
//
// This file is part of GPAL.
// Licensed under the Business Source License 1.1
//
// Primary development, architecture, and vision by Michael B. Vederman,
// CEO of Software Decisions, Inc., Texas.
//
// Internal development maintained privately.
// Public releases appear on GitHub: https://github.com/SoftwareDecisionsInc/GPAL.
//
// See LICENSE for full terms, including Additional Use Grant.
// =============================================================================
 
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Drawing;
using System.IO;
using System.Threading;
using static GenerallyPositive.Enums;
 
namespace GenerallyPositive
{
    internal class ClipboardSettings
    {
        public GPALClipboard Clipboard { get; set; }
        public ClipboardType ClipboardType { get; set; } = ClipboardType.Text;
        public string InputText { get; set; }
        public IGPALGrid<string> InputGrid { get; set; }
        public GPALFile InputFile { get; set; }
 
        public ClipboardSettings(GPALClipboard clipboard)
        {
            Clipboard = clipboard;
        }
    }

    public class GPALClipboard : IGPALClipboard, IAllowClipboardInput, IAllowClipboardSet, IAllowClipboardInto
    {
        internal ClipboardSettings ClipboardSettings { get; set; }

        private const int ATTEMPTS = 10;

        private const int BETWEEN_ATTEMPTS = 100;
 
        internal GPALClipboard()
        {
            ClipboardSettings = new ClipboardSettings(this);
        }
 
        public IGPALClipboard ToGPALObject()
        {
            return this;
        }

        public IAllowClipboardSet WithInput(string text)
        {
            ClipboardSettings.InputText = text;
            return this;
        }

        public IAllowClipboardSet WithInput(IGPALGrid<string> grid)
        {
            ClipboardSettings.InputGrid = grid;
            return this;
        }

        public IAllowClipboardSet WithInput(GPALFile file)
        {
            ClipboardSettings.InputFile = file;
            return this;
        }

        public IGPALClipboard SetClipboard(ClipboardType clipboardType = ClipboardType.Text)
        {
            ClipboardSettings.ClipboardType = clipboardType;
 
            string text = InputAsText();
 
            if (null == text && null == ClipboardSettings.InputFile)
                GPAL.PublishSimpleEvent(GPALEventType.ERROR, "Nothing said what to put on the clipboard. Use .WithInput first", this, GPALObjectType.Other);
            else
                OnStaThread(() => Write(text));
 
            return this;
        }

        public IAllowClipboardInto GetClipboard(ClipboardType clipboardType = ClipboardType.Text)
        {
            ClipboardSettings.ClipboardType = clipboardType;
            return this;
        }

        public IGPALClipboard SaveTo(out string text)
        {
            string read = null;
 
            if (ClipboardType.Image == ClipboardSettings.ClipboardType)
                OnStaThread(() => read = ReadImageAsBase64());
            else
                OnStaThread(() => read = Read());
 
            text = read;
            return this;
        }

        public IGPALClipboard SaveTo(out IGPALGrid<string> grid)
        {
            IGPALGrid<string> retVal = GPAL.Grid.ToGPALObject();
            string read = null;
 
            OnStaThread(() => read = Read());
 
            if (false == string.IsNullOrEmpty(read))
                foreach (string line in read.Replace("\r\n", "\n").TrimEnd('\n').Split('\n'))
                    retVal.AddRow(new List<string>(line.Split('\t')));
 
            grid = retVal;
            return this;
        }

        public IGPALClipboard SaveTo(GPALFile file)
        {
            if (ClipboardType.Image == ClipboardSettings.ClipboardType)
                OnStaThread(() => WriteImageFile(file));
            else
            {
                string read = null;
 
                OnStaThread(() => read = Read());
 
                if (null == read)
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"The clipboard holds nothing of type [{ClipboardSettings.ClipboardType}], so [{file?.Filename}] was not written", this, GPALObjectType.Other);
                else
                    File.WriteAllText(file.Filename, read);
            }
 
            return this;
        }

        public IGPALClipboard Clear()
        {
            OnStaThread(() => Attempt(() => System.Windows.Forms.Clipboard.Clear(), "clear the clipboard"));
 
            return this;
        }

        private string InputAsText()
        {
            string retVal = ClipboardSettings.InputText;
 
            if (null == retVal && null != ClipboardSettings.InputGrid)
            {
                var lines = new List<string>();
 
                foreach (List<string> row in ClipboardSettings.InputGrid)
                    lines.Add(string.Join("\t", row));
 
                retVal = string.Join(Environment.NewLine, lines);
            }
 
            if (null == retVal && null != ClipboardSettings.InputFile
                && ClipboardType.FileList != ClipboardSettings.ClipboardType
                && ClipboardType.Image != ClipboardSettings.ClipboardType)
                retVal = File.ReadAllText(ClipboardSettings.InputFile.Filename);
 
            return retVal;
        }

        private void Write(string text)
        {
            var data = new System.Windows.Forms.DataObject();
 
            if (ClipboardType.Image == ClipboardSettings.ClipboardType)
            {
                // an image goes on from a file or from the base64 a string holds it in, which is the same
                // string GetClipboard hands back, so what comes off the clipboard goes back on unchanged
                if (null != ClipboardSettings.InputFile)
                    Attempt(() => System.Windows.Forms.Clipboard.SetImage(Image.FromFile(ClipboardSettings.InputFile.Filename)), "put an image on the clipboard");
                else if (false == string.IsNullOrWhiteSpace(text))
                    Attempt(() => System.Windows.Forms.Clipboard.SetImage(ImageHelper.Base64ToImage(text)), "put an image on the clipboard");
                else
                    GPAL.PublishSimpleEvent(GPALEventType.ERROR, "An image goes on the clipboard from a file or from base64. Use .WithInput with a GPALFile or with the encoded string", this, GPALObjectType.Other);
 
                return;
            }
 
            if (ClipboardType.FileList == ClipboardSettings.ClipboardType)
            {
                var files = new StringCollection();
                files.Add(ClipboardSettings.InputFile.Filename);
                data.SetFileDropList(files);
            }
            else
                data.SetData(FormatFor(ClipboardSettings.ClipboardType), text);
 
            Attempt(() => System.Windows.Forms.Clipboard.SetDataObject(data, true, ATTEMPTS, BETWEEN_ATTEMPTS), "put data on the clipboard");
        }

        private string Read()
        {
            string retVal = null;
 
            Attempt(() =>
            {
                if (ClipboardType.FileList == ClipboardSettings.ClipboardType)
                {
                    StringCollection files = System.Windows.Forms.Clipboard.GetFileDropList();
                    var names = new List<string>();
 
                    foreach (string name in files)
                        names.Add(name);
 
                    retVal = 0 == names.Count ? null : string.Join(Environment.NewLine, names);
                }
                else
                {
                    string format = FormatFor(ClipboardSettings.ClipboardType);
 
                    if (true == System.Windows.Forms.Clipboard.ContainsData(format))
                        retVal = System.Windows.Forms.Clipboard.GetData(format) as string;
                }
            }, "read the clipboard");
 
            return retVal;
        }
        private string ReadImageAsBase64()
        {
            string retVal = null;
 
            Attempt(() =>
            {
                Image image = System.Windows.Forms.Clipboard.GetImage();
 
                if (null == image)
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, "The clipboard holds no image, so nothing was encoded", this, GPALObjectType.Other);
                else
                {
                    using (var stream = new MemoryStream())
                    {
                        image.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
                        retVal = Convert.ToBase64String(stream.ToArray());
                    }
                }
            }, "read an image from the clipboard");
 
            return retVal;
        }
 
        private void WriteImageFile(GPALFile file)
        {
            Attempt(() =>
            {
                Image image = System.Windows.Forms.Clipboard.GetImage();
 
                if (null == image)
                    GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"The clipboard holds no image, so [{file?.Filename}] was not written", this, GPALObjectType.Other);
                else
                    image.Save(file.Filename, ImageHelper.FormatForFile(file.Filename));
            }, "read an image from the clipboard");
        }

        private static string FormatFor(ClipboardType clipboardType)
        {
            string retVal;
 
            switch (clipboardType)
            {
                case ClipboardType.Html:
                    retVal = System.Windows.Forms.DataFormats.Html;
                    break;
                case ClipboardType.Rtf:
                    retVal = System.Windows.Forms.DataFormats.Rtf;
                    break;
                case ClipboardType.Csv:
                    retVal = System.Windows.Forms.DataFormats.CommaSeparatedValue;
                    break;
                default:
                    retVal = System.Windows.Forms.DataFormats.UnicodeText;
                    break;
            }
 
            return retVal;
        }

        private static void OnStaThread(Action work)
        {
            if (ApartmentState.STA == Thread.CurrentThread.GetApartmentState())
                work();
            else
            {
                Thread staThread = new Thread(() => work());
 
                staThread.SetApartmentState(ApartmentState.STA);
                staThread.Start();
                staThread.Join();
            }
        }

        private static void Attempt(Action work, string what)
        {
            Exception last = null;
            bool done = false;
 
            for (int attempt = 0; attempt < ATTEMPTS && false == done; attempt++)
            {
                try
                {
                    work();
                    done = true;
                }
                catch (Exception ex)
                {
                    last = ex;
                    Thread.Sleep(BETWEEN_ATTEMPTS);
                }
            }
 
            if (false == done)
                GPAL.PublishSimpleEvent(GPALEventType.EXCEPTION, $"Unable to {what} after [{ATTEMPTS}] attempts. Another process is holding it.", null, GPALObjectType.Other, last);
        }
    }
}