Program.cs

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using Microsoft.Office.Interop.Visio;
using VisioApp = Microsoft.Office.Interop.Visio.Application;

namespace VisioAutomation
{
    public class Program
    {
        [STAThread]
        public static void Main(string[] args)
        {
            string title = null;

            if (args != null && args.Length > 0)
            {
                title = args[0];
                if (title != null) title = title.Trim();
                if (title != null && title.Length == 0) title = null;
            }

            string scriptText;
            try
            {
                scriptText = Clipboard.GetText();
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: Unable to read clipboard text. " + ex.Message);
                return;
            }

            if (scriptText == null) scriptText = "";
            scriptText = scriptText.Trim();

            if (scriptText.Length == 0)
            {
                Console.WriteLine("ERROR: Clipboard is empty. Copy your chart script to the clipboard and try again.");
                return;
            }

            VisioApp app;
            try
            {
                app = GetOrCreateVisio();
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: Unable to start/connect to Visio. " + ex.Message);
                return;
            }

            app.Visible = true;

            Document doc = null;
            Page page = null;

            try
            {
                if (app.Documents != null && app.Documents.Count > 0)
                {
                    doc = app.ActiveDocument;
                }
                else
                {
                    if (title == null)
                    {
                        Console.WriteLine("ERROR: No Visio document is open, and no title argument was provided to create a new one.");
                        return;
                    }

                    doc = app.Documents.Add("");
                    try
                    {
                        doc.Title = title;
                    }
                    catch
                    {
                        // shield: Some Visio/interop setups may not allow setting Title; ignore and continue.
                    }
                }

                page = app.ActivePage ?? (doc.Pages.Count > 0 ? doc.Pages[1] : doc.Pages.Add());
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: Unable to get/create document/page. " + ex.Message);
                return;
            }

            Document stencil;
            try
            {
                stencil = OpenAnyBasicFlowchartStencil(app);
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: Could not open a Basic Flowchart stencil. " + ex.Message);
                return;
            }

            Master startEndMaster;
            Master processMaster;
            object dynamicConnector;

            try
            {
                startEndMaster = TryGetMaster(stencil, "Start/End", "Start-End", "Terminator");
                processMaster = TryGetMaster(stencil, "Process", "Process (rectangle)");
                dynamicConnector = app.ConnectorToolDataObject;
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: Could not access required masters/connectors. " + ex.Message);
                return;
            }

            try
            {
                BuildForkableChartFromClipboard(page, scriptText, startEndMaster, processMaster, dynamicConnector);
                Console.WriteLine("Done. Chart created in the active document. Visio left open.");
            }
            catch (Exception ex)
            {
                Console.WriteLine("ERROR: Failed while building the chart. " + ex.Message);
                return;
            }
        }

        private static VisioApp GetOrCreateVisio()
        {
            try
            {
                return (VisioApp)Marshal.GetActiveObject("Visio.Application");
            }
            catch
            {
                return new VisioApp();
            }
        }

        private static Document OpenAnyBasicFlowchartStencil(VisioApp app)
        {
            // shield: Try common stencil names; Visio resolves installed stencils by name.
            // shield: This avoids hardcoding a filesystem path.
            var candidates = new[]
            {
                "BASFLO_U.VSSX",
                "BASFLO_U.VSS",
                "Basic Flowchart Shapes.vssx",
                "Basic Flowchart Shapes.vss",
                "Basic Flowchart Shapes (US units).vssx",
                "Basic Flowchart Shapes (US units).vss"
            };

            foreach (var name in candidates)
            {
                try
                {
                    return app.Documents.OpenEx(name, (short)(VisOpenSaveArgs.visOpenDocked | VisOpenSaveArgs.visOpenRO));
                }
                catch
                {
                }
            }

            throw new Exception("None of the known Basic Flowchart stencil names could be opened on this machine.");
        }

        private static Master TryGetMaster(Document stencil, params string[] names)
        {
            foreach (var n in names)
            {
                try
                {
                    return stencil.Masters[n];
                }
                catch
                {
                }
            }

            throw new Exception("Master not found. Tried: " + string.Join(", ", names));
        }

        private static void BuildForkableChartFromClipboard(
            Page page,
            string scriptText,
            Master startEndMaster,
            Master processMaster,
            object dynamicConnector)
        {
            var lines = scriptText.Replace("\r\n", "\n").Replace("\r", "\n").Split('\n');

            var chains = new List<List<string>>();
            foreach (var raw in lines)
            {
                var line = raw.Trim();
                if (line.Length == 0) continue;

                var tokens = ParseChain(line);
                if (tokens.Count > 0) chains.Add(tokens);
            }

            if (chains.Count == 0)
                throw new Exception("No valid lines found.");

            var nodes = new Dictionary<string, Shape>(StringComparer.OrdinalIgnoreCase);

            double startX = 2.0;
            double startY = 10.0;
            double colStep = 3.5;
            double rowStep = 1.5;

            for (int i = 0; i < chains.Count; i++)
            {
                var tokens = chains[i];

                double x = startX + (i * colStep);
                double y = startY;

                Shape prev = null;

                for (int t = 0; t < tokens.Count; t++)
                {
                    var label = tokens[t];

                    Shape current;
                    if (!nodes.TryGetValue(label, out current))
                    {
                        Master masterToUse = processMaster;

                        if (IsStartOrEnd(label))
                            masterToUse = startEndMaster;

                        current = page.Drop(masterToUse, x, y);
                        current.Text = label;

                        nodes[label] = current;
                    }

                    if (prev != null)
                    {
                        Shape connector = page.Drop(dynamicConnector, 0, 0);
                        connector.CellsU["BeginX"].GlueTo(prev.CellsU["PinX"]);
                        connector.CellsU["EndX"].GlueTo(current.CellsU["PinX"]);
                    }

                    prev = current;
                    y -= rowStep;
                }
            }
        }

        private static List<string> ParseChain(string line)
        {
            var parts = line.Split(new[] { "->" }, StringSplitOptions.RemoveEmptyEntries);
            var tokens = new List<string>();

            foreach (var p in parts)
            {
                var t = p.Trim();
                if (t.Length > 0) tokens.Add(t);
            }

            return tokens;
        }

        private static bool IsStartOrEnd(string label)
        {
            var v = label.Trim().ToLowerInvariant();
            return v == "start" || v == "end";
        }
    }
}