FormHelper.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.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using static GenerallyPositive.Enums;
using static GenerallyPositive.GPALForm.GPALForm;
using HWND = System.IntPtr;
 
namespace GenerallyPositive.GPALForm
{
    internal class FormHelper
    {
        public static void FillInFrom(GPALControl controlEntry, string useText, WriteMode writeMode)
        {
            switch (controlEntry.ControlType)
            {
                case FormControlType.Input:
                case FormControlType.TextArea:
                    ((TextBox)controlEntry.WindowsControl).Text = useText;
                    break;
 
 
            }
 
        }
        public static void FillInWithTokens(GPALForm myForm, List<IGPALGrid<string>> tokenList, WriteMode writeMode)
        {
            foreach (IGPALGrid<string> tokens in tokenList)
            {
                // iterate over every row of tokens, filling in the form's editable controls a row at a time
                for (int tokenIdx = 0; tokenIdx < tokens.Count(); tokenIdx++)
                {
                    int elementIdx = 0;
                    List<string> currentRow = tokens[tokenIdx];
 
                    foreach (string token in currentRow)                                            // iterate over tokens, filling in the corresponding input/textarea webelement
                    {
                        bool textFilled = false;
 
                        while (false == textFilled && elementIdx < myForm.ControlList.Count)
                        {
                            switch (myForm.ControlList[elementIdx].ControlType)
                            {
                                case FormControlType.TextArea:
                                case FormControlType.Input:
                                    myForm.Form.SwitchToTab(myForm.ControlList[elementIdx]);    // bring the control's tab into view so the change is visible as it happens
                                    FillInFrom(myForm.ControlList[elementIdx], token, writeMode);
                                    textFilled = true;
                                    break;
 
                                default:
                                    break;
                            }
                            elementIdx++;
                        }
 
                        // detect if we have too many tokens to consume and publish an information event [entirely possible this scenario is fine]
                        if (elementIdx == myForm.ControlList.Count && false == textFilled)
                            GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"Unused token: [{token}]", myForm, GPALObjectType.GPALForm);
                    }
 
                    // detect if we do not have enough tokens for all the form fields [entirely possible this scenario is fine]
                    while (elementIdx < myForm.ControlList.Count)
                    {
                        switch (myForm.ControlList[elementIdx].ControlType)
                        {
                            case FormControlType.TextArea:
                            case FormControlType.Input:
                                GPAL.PublishSimpleEvent(GPALEventType.WARNING, $"No token for control: [{myForm.ControlList[elementIdx].Name}]", myForm, GPALObjectType.GPALForm);
                                break;
 
                            default:
                                break;
                        }
                        elementIdx++;
                    }
 
                    // CAVEAT: Handled/NotHandled are both ignored here, the handler can request to exit by returning CallIfStatus.Terminate
                    if (null != myForm.Form.CallAfterFillIn)
                    {
                        CallIfStatus handled = myForm.Form.CallAfterFillIn(myForm, tokens, tokenIdx);
 
                        if (CallIfStatus.Terminate == handled)
                        {
                            GPAL.PublishSimpleEvent(GPALEventType.INFO, $"CallAfterFillIn handler [{myForm.Form.CallAfterFillIn.GetInvocationList()[0].Method.Name}] requested program termination.", myForm, GPALObjectType.GPALForm);
                            throw new GPALException($"{GPAL.MyMethodName()}: CallAfterFillIn handler [{myForm.Form.CallAfterFillIn.GetInvocationList()[0].Method.Name}] requested program termination.");
                        }
                    }
                }
            }
        }
        public static HWND WaitForWindow(string windowTitle, int waitTimeInSeconds = 10)
        {
            return WaitForWindowGeneric(windowTitle, false, waitTimeInSeconds);
        }
 
        public static HWND WaitForWindowRegex(string windowTitleRegex, int waitTimeInSeconds)
        {
            return WaitForWindowGeneric(windowTitleRegex, true, waitTimeInSeconds);
        }
 
        public static HWND WaitForWindowGeneric(string waitForTitle, bool useRegex, int waitTimeInSeconds)
        {
            bool found = false;
            HWND retHWND = IntPtr.Zero;
 
            for (int cnt = 0; cnt < waitTimeInSeconds && false == found; cnt++)
            {
                Thread.Sleep(1000); // best to sleep first and give a second more for the window to appear
                IDictionary<HWND, string> windows = GetOpenWindows();
                foreach (var entry in windows)
                {
                    if (true == useRegex)
                    {
                        MatchCollection mc = Regex.Matches(entry.Value, waitForTitle);
                        if (0 < mc.Count)
                        {
                            found = true;
                            retHWND = entry.Key;
                            break;
                        }
                    }
                    else
                    {
                        if (true == waitForTitle.Equals(entry.Value))
                        {
                            found = true;
                            retHWND = entry.Key;
                            break;
                        }
                    }
                }
            }
            return retHWND;
        }
 
        // https://stackoverflow.com/questions/7268302/get-the-titles-of-all-open-windows
        public static IDictionary<HWND, string> GetOpenWindows()
        {
            HWND shellWindow = GetShellWindow();
            Dictionary<HWND, string> windows = new Dictionary<HWND, string>();
 
            EnumWindows(delegate (HWND hWnd, int lParam)
            {
                if (hWnd == shellWindow) return true;
                if (!IsWindowVisible(hWnd)) return true;
 
                int length = GetWindowTextLength(hWnd);
                if (length == 0) return true;
 
                StringBuilder builder = new StringBuilder(length);
                GetWindowText(hWnd, builder, length + 1);
 
                windows[hWnd] = builder.ToString();
                return true;
 
            }, 0);
 
            return windows;
        }
 
        private delegate bool EnumWindowsProc(HWND hWnd, int lParam);
 
        [DllImport("USER32.DLL")]
        private static extern bool EnumWindows(EnumWindowsProc enumFunc, int lParam);
 
        [DllImport("USER32.DLL")]
        private static extern int GetWindowText(HWND hWnd, StringBuilder lpString, int nMaxCount);
 
        [DllImport("USER32.DLL")]
        private static extern int GetWindowTextLength(HWND hWnd);
 
        [DllImport("USER32.DLL")]
        private static extern bool IsWindowVisible(HWND hWnd);
 
        [DllImport("USER32.DLL")]
        private static extern IntPtr GetShellWindow();
    }
}