@copylee/dsh-office 0.1.0 → 0.2.0

package/helper/OfficeHelper.cs

@@ -100,8 +100,158 @@ class MessageFilter : IOleMessageFilter
     public int MessagePending(IntPtr hTaskCallee, int dwTickCount, int dwPendingType) { return 2; }
 }
 
+
+/// A small always-on-top card shown while the agent edits: what it is doing, and two switches the user
+/// can flip at any moment (follow the edits / write like typing). It never takes the focus.
+class Card : Form
+{
+    static Card instance;
+    static readonly ManualResetEvent Ready = new ManualResetEvent(false);
+    /// Set once the user has flipped a switch here: from then on the card, not the settings page, decides.
+    public static volatile bool FollowChosen, TypingChosen;
+
+    string line = "";
+    DateTime shown = DateTime.MinValue;
+    readonly float scale;
+    Rectangle followBox, typingBox;
+    Point grip;
+    bool pressed, dragged;
+    readonly System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
+
+    [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr handle, int command);
+
+    protected override bool ShowWithoutActivation { get { return true; } }
+
+    protected override CreateParams CreateParams
+    {
+        get
+        {
+            CreateParams p = base.CreateParams;
+            p.ExStyle |= 0x08000000 | 0x00000080 | 0x00000008; // no-activate, tool window, topmost
+            return p;
+        }
+    }
+
+    Card()
+    {
+        FormBorderStyle = FormBorderStyle.None;
+        ShowInTaskbar = false;
+        StartPosition = FormStartPosition.Manual;
+        TopMost = true;
+        DoubleBuffered = true;
+        BackColor = Color.FromArgb(34, 34, 38);
+        Opacity = 0.94;
+        using (Graphics g = CreateGraphics()) scale = g.DpiX / 96f;
+        Size = new Size(S(330), S(38));
+        Rectangle area = Screen.PrimaryScreen.WorkingArea;
+        Location = new Point(area.Right - Width - S(18), area.Bottom - Height - S(18));
+        using (System.Drawing.Drawing2D.GraphicsPath path = Rounded(new Rectangle(0, 0, Width, Height), S(10))) Region = new Region(path);
+        timer.Interval = 500;
+        timer.Tick += delegate { if (Visible && (DateTime.UtcNow - shown).TotalSeconds > 6) Hide(); };
+        timer.Start();
+    }
+
+    int S(int value) { return (int)Math.Round(value * scale); }
+
+    static System.Drawing.Drawing2D.GraphicsPath Rounded(Rectangle r, int radius)
+    {
+        System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
+        int d = radius * 2;
+        path.AddArc(r.X, r.Y, d, d, 180, 90);
+        path.AddArc(r.Right - d, r.Y, d, d, 270, 90);
+        path.AddArc(r.Right - d, r.Bottom - d, d, d, 0, 90);
+        path.AddArc(r.X, r.Bottom - d, d, d, 90, 90);
+        path.CloseFigure();
+        return path;
+    }
+
+    void Chip(Graphics g, Font font, string label, bool on, ref int right, out Rectangle box)
+    {
+        Size size = TextRenderer.MeasureText(label, font);
+        box = new Rectangle(right - size.Width - S(14), (Height - S(24)) / 2, size.Width + S(14), S(24));
+        right = box.Left - S(6);
+        Color accent = Color.FromArgb(217, 119, 87);
+        using (System.Drawing.Drawing2D.GraphicsPath path = Rounded(box, S(12)))
+        {
+            if (on) using (SolidBrush fill = new SolidBrush(accent)) g.FillPath(fill, path);
+            else using (Pen pen = new Pen(Color.FromArgb(110, 110, 118))) g.DrawPath(pen, path);
+        }
+        TextRenderer.DrawText(g, label, font, box, on ? Color.White : Color.FromArgb(170, 170, 178), TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
+    }
+
+    protected override void OnPaint(PaintEventArgs e)
+    {
+        Graphics g = e.Graphics;
+        g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+        using (Font font = new Font("Microsoft YaHei UI", 9f))
+        {
+            int right = Width - S(10);
+            Chip(g, font, "逐字", Program.Typing, ref right, out typingBox);
+            Chip(g, font, "跟随", Program.Following, ref right, out followBox);
+            using (SolidBrush dot = new SolidBrush(Color.FromArgb(217, 119, 87))) g.FillEllipse(dot, S(12), (Height - S(8)) / 2, S(8), S(8));
+            Rectangle text = new Rectangle(S(26), 0, right - S(30), Height);
+            TextRenderer.DrawText(g, line, font, text, Color.FromArgb(235, 235, 240), TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis | TextFormatFlags.NoPrefix);
+        }
+    }
+
+    protected override void OnMouseDown(MouseEventArgs e) { pressed = true; dragged = false; grip = e.Location; }
+
+    protected override void OnMouseMove(MouseEventArgs e)
+    {
+        if (!pressed) return;
+        if (!dragged && Math.Abs(e.X - grip.X) + Math.Abs(e.Y - grip.Y) < S(4)) return;
+        dragged = true;
+        Location = new Point(Location.X + e.X - grip.X, Location.Y + e.Y - grip.Y);
+    }
+
+    protected override void OnMouseUp(MouseEventArgs e)
+    {
+        pressed = false;
+        if (dragged) return;
+        if (followBox.Contains(e.Location)) { Program.Following = !Program.Following; FollowChosen = true; }
+        else if (typingBox.Contains(e.Location)) { Program.Typing = !Program.Typing; TypingChosen = true; }
+        shown = DateTime.UtcNow;
+        Invalidate();
+    }
+
+    public static void Start()
+    {
+        Thread thread = new Thread(delegate()
+        {
+            try { instance = new Card(); IntPtr handle = instance.Handle; }
+            catch (Exception) { instance = null; }
+            Ready.Set();
+            if (instance != null) Application.Run();
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.IsBackground = true;
+        thread.Start();
+        Ready.WaitOne(5000);
+    }
+
+    /// Show the card (if it is not up yet) with this line; it goes away by itself a few seconds after the last report.
+    public static void Report(string text)
+    {
+        Card card = instance;
+        if (card == null) return;
+        try
+        {
+            card.BeginInvoke(new MethodInvoker(delegate
+            {
+                card.line = text;
+                card.shown = DateTime.UtcNow;
+                if (!card.Visible) ShowWindow(card.Handle, 4);
+                card.Invalidate();
+            }));
+        }
+        catch (Exception) { }
+    }
+}
+
 static class Program
 {
+    [DllImport("user32.dll")] static extern bool SetProcessDPIAware();
+
     static readonly JavaScriptSerializer Json = new JavaScriptSerializer();
     static TextWriter Out;
 
@@ -113,6 +263,7 @@ static class Program
         Out = new StreamWriter(Console.OpenStandardOutput(), new UTF8Encoding(false));
         TextReader input = new StreamReader(Console.OpenStandardInput(), new UTF8Encoding(false));
         MessageFilter.Register();
+        try { SetProcessDPIAware(); } catch (Exception) { }
         Send(new Dictionary<string, object> { { "event", "ready" } });
         string line;
         while ((line = input.ReadLine()) != null)
@@ -320,6 +471,20 @@ static class Program
         if (cmd == "render") return Render(kind, app, doc, a);
         if (cmd == "save") return Save(kind, app, doc, a);
         if (cmd == "close") return Close(kind, doc, a);
+        if (cmd == "view")
+        {
+            // Where the window is looking (for checking the follow mode).
+            Dictionary<string, object> view = new Dictionary<string, object>();
+            if (kind == "word")
+            {
+                dynamic window = doc.Windows[1];
+                view["scrolled"] = (int)window.VerticalPercentScrolled;
+                view["windows"] = (int)doc.Windows.Count;
+                view["viewType"] = (int)window.View.Type;
+                view["selection"] = (int)window.Selection.Start;
+            }
+            return view;
+        }
         if (cmd == "undo")
         {
             if (kind != "word") throw new Fail("BAD_ARGS", "Only Word keeps the agent's edits on its undo stack.");
@@ -503,6 +668,226 @@ static class Program
         return text.Replace("\r\n", "\r").Replace("\n", "\r");
     }
 
+
+    // ───────────────────────── watching the work ─────────────────────────
+
+    /// Scroll the window to where the agent is working (off = silent mode: the user's view is left alone).
+    public static volatile bool Following;
+    /// Write text a few characters at a time, the way a person types, instead of all at once.
+    public static volatile bool Typing;
+
+    static bool cardStarted;
+
+    static void Follow(dynamic doc, dynamic range)
+    {
+        if (!Following) return;
+        try { doc.Windows[1].ScrollIntoView(range, true); } catch (Exception) { }
+    }
+
+    /// Pieces to write a text in: up to 40 of them, so that a long paragraph still takes about a second.
+    static List<string> Pieces(string text)
+    {
+        List<string> pieces = new List<string>();
+        int size = Math.Max(2, (int)Math.Ceiling(text.Length / 40.0));
+        for (int i = 0; i < text.Length; i += size) pieces.Add(text.Substring(i, Math.Min(size, text.Length - i)));
+        return pieces;
+    }
+
+    /// Put text at a position of a Word document; returns the position after it.
+    static int Write(dynamic doc, int at, string text)
+    {
+        if (text.Length == 0) return at;
+        if (!Typing || text.Length < 4)
+        {
+            doc.Range(at, at).InsertAfter(text);
+            return at + text.Length;
+        }
+        foreach (string piece in Pieces(text))
+        {
+            doc.Range(at, at).InsertAfter(piece);
+            at += piece.Length;
+            Thread.Sleep(22);
+        }
+        return at;
+    }
+
+    // ───────────────────────── equations ─────────────────────────
+
+    static readonly Dictionary<string, string> TexSymbols = new Dictionary<string, string>
+    {
+        { "alpha", "α" }, { "beta", "β" }, { "gamma", "γ" }, { "delta", "δ" }, { "epsilon", "ε" }, { "varepsilon", "ε" }, { "zeta", "ζ" }, { "eta", "η" },
+        { "theta", "θ" }, { "vartheta", "ϑ" }, { "iota", "ι" }, { "kappa", "κ" }, { "lambda", "λ" }, { "mu", "μ" }, { "nu", "ν" }, { "xi", "ξ" },
+        { "pi", "π" }, { "rho", "ρ" }, { "sigma", "σ" }, { "tau", "τ" }, { "upsilon", "υ" }, { "phi", "φ" }, { "varphi", "φ" }, { "chi", "χ" },
+        { "psi", "ψ" }, { "omega", "ω" }, { "Gamma", "Γ" }, { "Delta", "Δ" }, { "Theta", "Θ" }, { "Lambda", "Λ" }, { "Xi", "Ξ" }, { "Pi", "Π" },
+        { "Sigma", "Σ" }, { "Phi", "Φ" }, { "Psi", "Ψ" }, { "Omega", "Ω" },
+        { "cdot", "⋅" }, { "times", "×" }, { "div", "÷" }, { "pm", "±" }, { "mp", "∓" }, { "approx", "≈" }, { "neq", "≠" }, { "ne", "≠" },
+        { "leq", "≤" }, { "le", "≤" }, { "geq", "≥" }, { "ge", "≥" }, { "ll", "≪" }, { "gg", "≫" }, { "equiv", "≡" }, { "propto", "∝" }, { "sim", "∼" },
+        { "infty", "∞" }, { "partial", "∂" }, { "nabla", "∇" }, { "sum", "∑" }, { "prod", "∏" }, { "int", "∫" }, { "oint", "∮" },
+        { "to", "→" }, { "rightarrow", "→" }, { "leftarrow", "←" }, { "Rightarrow", "⇒" }, { "Leftrightarrow", "⇔" }, { "in", "∈" }, { "notin", "∉" },
+        { "subset", "⊂" }, { "cup", "∪" }, { "cap", "∩" }, { "forall", "∀" }, { "exists", "∃" }, { "angle", "∠" }, { "perp", "⊥" }, { "parallel", "∥" },
+        { "circ", "∘" }, { "degree", "°" }, { "ldots", "…" }, { "cdots", "⋯" }, { "dots", "…" }, { "prime", "′" }, { "hbar", "ℏ" }, { "ell", "ℓ" },
+        { "quad", " " }, { "qquad", "  " }, { "left", "" }, { "right", "" }, { "displaystyle", "" }, { "limits", "" }, { "lim", "lim" },
+        { "sin", "sin" }, { "cos", "cos" }, { "tan", "tan" }, { "cot", "cot" }, { "ln", "ln" }, { "log", "log" }, { "exp", "exp" }, { "max", "max" }, { "min", "min" },
+        { "arcsin", "arcsin" }, { "arccos", "arccos" }, { "arctan", "arctan" }, { "sinh", "sinh" }, { "cosh", "cosh" }, { "tanh", "tanh" },
+    };
+
+    /// One TeX argument starting at i: a {group}, a \command, or a single character. Returns it converted.
+    static string TexArg(string s, ref int i)
+    {
+        while (i < s.Length && s[i] == ' ') i++;
+        if (i >= s.Length) return "";
+        if (s[i] == '{')
+        {
+            int depth = 0, start = i + 1;
+            for (; i < s.Length; i++)
+            {
+                if (s[i] == '{') depth++;
+                else if (s[i] == '}' && --depth == 0) break;
+            }
+            string inner = s.Substring(start, Math.Max(0, Math.Min(i, s.Length) - start));
+            i++;
+            return Tex(inner);
+        }
+        if (s[i] == '\\')
+        {
+            int start = i;
+            i++;
+            while (i < s.Length && char.IsLetter(s[i])) i++;
+            if (i == start + 1 && i < s.Length) i++;
+            return Tex(s.Substring(start, i - start));
+        }
+        return s[i++].ToString();
+    }
+
+    /// A space ends the fraction or root just written; without it Word pulls what follows into the denominator.
+    static void Gap(StringBuilder o, string s, int i)
+    {
+        while (i < s.Length && s[i] == ' ') i++;
+        if (i < s.Length && (char.IsLetterOrDigit(s[i]) || s[i] == '\\' || s[i] == '(' || s[i] == '{')) o.Append(' ');
+    }
+
+    /// The common part of LaTeX math to Word's linear format (UnicodeMath), which Word then builds into a native equation.
+    static string Tex(string s)
+    {
+        StringBuilder o = new StringBuilder();
+        int i = 0;
+        while (i < s.Length)
+        {
+            char c = s[i];
+            if (c == '\\')
+            {
+                int start = ++i;
+                while (i < s.Length && char.IsLetter(s[i])) i++;
+                if (i == start)
+                {
+                    // \, \; \! \  are spacing; \{ \} \% and the like are the character itself.
+                    char next = i < s.Length ? s[i++] : ' ';
+                    if (next == ',' || next == ';' || next == ':' || next == ' ') o.Append(' ');
+                    else if (next == '\\') o.Append(' ');
+                    else if (next != '!') o.Append(next);
+                    continue;
+                }
+                string name = s.Substring(start, i - start);
+                if (name == "frac" || name == "dfrac" || name == "tfrac") {
+                    string top = TexArg(s, ref i), bottom = TexArg(s, ref i);
+                    // A factor written right before the fraction (2rac{a}{b}) must not be read into its numerator.
+                    if (o.Length > 0 && char.IsLetterOrDigit(o[o.Length - 1])) o.Append(' ');
+                    o.Append("(" + top + ")/(" + bottom + ")");
+                    Gap(o, s, i);
+                }
+                else if (name == "sqrt")
+                {
+                    string degree = null;
+                    if (i < s.Length && s[i] == '[') { int end = s.IndexOf(']', i); if (end > i) { degree = Tex(s.Substring(i + 1, end - i - 1)); i = end + 1; } }
+                    string body = TexArg(s, ref i);
+                    o.Append(degree == null ? "√(" + body + ")" : "√(" + degree + "&" + body + ")");
+                    Gap(o, s, i);
+                }
+                else if (name == "bar" || name == "overline") o.Append("¯(" + TexArg(s, ref i) + ")");
+                else if (name == "hat") o.Append(TexArg(s, ref i) + "\u0302");
+                else if (name == "vec") o.Append(TexArg(s, ref i) + "\u20D7");
+                else if (name == "dot") o.Append(TexArg(s, ref i) + "\u0307");
+                else if (name == "ddot") o.Append(TexArg(s, ref i) + "\u0308");
+                else if (name == "tilde") o.Append(TexArg(s, ref i) + "\u0303");
+                else if (name == "text" || name == "mathrm" || name == "textrm" || name == "operatorname")
+                {
+                    while (i < s.Length && s[i] == ' ') i++;
+                    if (i < s.Length && s[i] == '{') { int end = s.IndexOf('}', i); if (end < 0) end = s.Length; o.Append("\"" + s.Substring(i + 1, end - i - 1) + "\""); i = Math.Min(s.Length, end + 1); }
+                }
+                else if (name == "mathbf" || name == "boldsymbol" || name == "mathit" || name == "mathbb" || name == "mathcal") o.Append(TexArg(s, ref i));
+                else
+                {
+                    string symbol;
+                    if (TexSymbols.TryGetValue(name, out symbol))
+                    {
+                        o.Append(symbol);
+                        // A function name is applied to what follows: Word needs a space after it.
+                        if (symbol.Length > 1 && symbol == name && i < s.Length && s[i] != ' ' && s[i] != '^' && s[i] != '_') o.Append(' ');
+                    }
+                    else o.Append('\\').Append(name);
+                }
+                continue;
+            }
+            if (c == '^' || c == '_')
+            {
+                i++;
+                bool braced = i < s.Length && s[i] == '{';
+                string arg = TexArg(s, ref i);
+                o.Append(c).Append(braced && arg.Length > 1 ? "(" + arg + ")" : arg);
+                // Otherwise Word reads the next letter into the script: x^2y.
+                if (i < s.Length && (char.IsLetterOrDigit(s[i]) || s[i] == '\\')) o.Append(' ');
+                continue;
+            }
+            if (c == '{') { string group = TexArg(s, ref i); o.Append("〖" + group + "〗"); continue; }
+            if (c == '}') { i++; continue; }
+            if (c == '~') { o.Append(' '); i++; continue; }
+            o.Append(c);
+            i++;
+        }
+        return o.ToString();
+    }
+
+    static readonly System.Text.RegularExpressions.Regex Dollars = new System.Text.RegularExpressions.Regex(@"\$\$([^$\r]+?)\$\$|\$([^$\r]+?)\$(?!\$)");
+
+    static readonly System.Text.RegularExpressions.Regex Tag = new System.Text.RegularExpressions.Regex(@"\\tag\s*\{([^}]*)\}");
+
+    /// Turn every $...$ (inline) and $$...$$ (on a line of its own) inside a range into a native Word equation.
+    static int Mathify(dynamic doc, dynamic range)
+    {
+        string text = (string)range.Text;
+        if (text == null || text.IndexOf('$') < 0) return 0;
+        int start = (int)range.Start, made = 0;
+        System.Text.RegularExpressions.MatchCollection found = Dollars.Matches(text);
+        for (int k = found.Count - 1; k >= 0; k--)
+        {
+            System.Text.RegularExpressions.Match m = found[k];
+            bool display = m.Groups[1].Success;
+            string source = (display ? m.Groups[1].Value : m.Groups[2].Value).Trim();
+            // 	ag{1} numbers a display equation: Word sets "#(1)" flush right on the equation's line.
+            string tag = null;
+            System.Text.RegularExpressions.Match tagged = Tag.Match(source);
+            if (tagged.Success) { tag = tagged.Groups[1].Value.Trim(); source = source.Remove(tagged.Index, tagged.Length).Trim(); }
+            dynamic spot = null;
+            if (m.Length <= 250)
+            {
+                // Found by its text: positions counted in the text are off wherever the range holds a field (a caption number).
+                dynamic search = range.Duplicate;
+                if ((bool)search.Find.Execute(FindText: m.Value.Replace("^", "^^"), MatchCase: true, MatchWildcards: false, Forward: true, Wrap: 0)) spot = search;
+            }
+            if (spot == null) spot = doc.Range(start + m.Index, start + m.Index + m.Length);
+            spot.Text = Tex(source) + (display && !string.IsNullOrEmpty(tag) ? "#(" + tag + ")" : "");
+            try
+            {
+                dynamic math = doc.OMaths.Add(spot);
+                math.OMaths[1].BuildUp();
+                if (display) { try { math.OMaths[1].Type = 0; math.OMaths[1].Justification = 1; } catch (COMException) { } }
+                made++;
+            }
+            catch (COMException) { }
+        }
+        return made;
+    }
+
     // ───────────────────────── Word ─────────────────────────
 
     static readonly Dictionary<string, int> WordStyles = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase)
@@ -530,6 +915,7 @@ static class Program
         int total = (int)doc.Paragraphs.Count;
         if (index < 1 || index > total) throw new Fail("ANCHOR_MISSING", "There is no paragraph " + index + " (the document has " + total + "). Call office_read again.");
         dynamic p = doc.Paragraphs[index];
+        Follow(doc, p.Range);
         if (expect != null)
         {
             string text = Squash(Clean((string)p.Range.Text)), want = Squash(expect);
@@ -572,7 +958,7 @@ static class Program
         int from = Math.Max(1, a.Int("from", 1)), count = Math.Max(1, Math.Min(400, a.Int("count", 120)));
         bool full = a.Flag("full", false);
         List<object> items = new List<object>();
-        int shown = from - 1;
+        int shown = from - 1, openTable = -1;
         string titleStyle = null;
         try { titleStyle = (string)doc.Styles[-63].NameLocal; } catch (Exception) { }
         if (from <= total)
@@ -596,19 +982,38 @@ static class Program
                 try { inTable = Truthy(p.Range.Information[12]); } catch (Exception) { }
                 if (inTable)
                 {
-                    // A table is one entry, not one per cell: its cells are read with "table".
                     dynamic table = p.Range.Tables[1];
-                    int end = (int)table.Range.End, inside = (int)table.Range.Paragraphs.Count;
-                    item.Clear();
-                    item["i"] = i;
-                    item["to"] = i + inside - 1;
-                    item["table"] = (int)doc.Range(0, end).Tables.Count;
-                    item["size"] = (int)table.Rows.Count + "x" + (int)table.Columns.Count;
-                    items.Add(item);
-                    i += inside - 1;
-                    p = i < total ? doc.Range(end, end).Paragraphs[1] : null;
-                    shown = i;
-                    continue;
+                    int tableStart = (int)table.Range.Start, end = (int)table.Range.End;
+                    if (tableStart != openTable)
+                    {
+                        int inside = (int)table.Range.Paragraphs.Count, cells = (int)table.Range.Cells.Count, rows = (int)table.Rows.Count;
+                        bool nested = false;
+                        try { nested = (int)table.NestingLevel > 1; } catch (Exception) { }
+                        Dictionary<string, object> head = new Dictionary<string, object>();
+                        head["i"] = i;
+                        head["to"] = i + inside - 1;
+                        if (!nested) head["table"] = (int)doc.Range(0, end).Tables.Count;
+                        string size = "?";
+                        try { size = rows + "x" + (int)table.Columns.Count; } catch (COMException) { size = cells + " cells"; }
+                        head["size"] = size;
+                        // A grid of short cells is one entry (read its cells with "table"). A table whose cells hold the
+                        // document's text, as in a form or a report template, is listed paragraph by paragraph.
+                        bool open = inside > cells + rows + 2;
+                        if (open) head["open"] = true;
+                        items.Add(head);
+                        if (!open)
+                        {
+                            i += inside - 1;
+                            p = i < total ? doc.Range(end, end).Paragraphs[1] : null;
+                            shown = i;
+                            continue;
+                        }
+                        openTable = tableStart;
+                    }
+                    bool rowEnd = false;
+                    try { rowEnd = Truthy(p.Range.Information[31]); } catch (Exception) { }
+                    if (rowEnd) { shown = i; p = p.Next(); continue; }
+                    item["inTable"] = true;
                 }
                 items.Add(item);
                 shown = i;
@@ -683,7 +1088,62 @@ static class Program
     {
         int end = (int)paragraph.Range.End;
         paragraph.Range.InsertParagraphAfter();
-        return doc.Range(end, end).Paragraphs[1];
+        dynamic made = doc.Range(end, end).Paragraphs[1];
+        // Word gives the new paragraph the look of whatever FOLLOWS (a caption, a heading); it should
+        // continue the paragraph it was added after.
+        try
+        {
+            made.Style = paragraph.Style;
+            made.Range.ParagraphFormat = paragraph.Range.ParagraphFormat.Duplicate;
+            made.Range.Font = paragraph.Range.Font.Duplicate;
+        }
+        catch (COMException) { }
+        return made;
+    }
+
+    /// Breathing room around a table or figure: at least this much space before / after a paragraph.
+    /// Paragraph spacing, not blank lines, so nothing has to be cleaned up later.
+    const float Air = 8f;
+
+    static void Space(dynamic paragraph, bool before)
+    {
+        if (paragraph == null) return;
+        try
+        {
+            dynamic format = paragraph.Range.ParagraphFormat;
+            if (before) { if ((float)format.SpaceBefore < Air) format.SpaceBefore = Air; }
+            else if ((float)format.SpaceAfter < Air) format.SpaceAfter = Air;
+        }
+        catch (Exception) { }
+    }
+
+    /// A numbered caption, the way reports set them: "表 1 ..." centred above a table, "图 1 ..." centred below
+    /// a figure. The number is a Word caption field, so it renumbers itself and can be cross-referenced.
+    static void Caption(dynamic doc, dynamic target, bool table, string title, string fontName, string fontFarEast)
+    {
+        string label = table ? "表" : "图";
+        dynamic labels = doc.Application.CaptionLabels;
+        bool known = false;
+        foreach (dynamic item in labels) if ((string)item.Name == label) { known = true; break; }
+        if (!known) labels.Add(label);
+        int start = (int)target.Start, end = (int)target.End;
+        target.InsertCaption(Label: label, Title: "  " + title.Trim(), Position: table ? 0 : 1);
+        // Above a table the caption is the paragraph that now sits where the table began; below a figure it is the next one.
+        dynamic caption = table ? doc.Range(start, start).Paragraphs[1] : doc.Range(end, end).Paragraphs[1].Next();
+        if (caption == null) return;
+        try
+        {
+            dynamic range = caption.Range;
+            range.ParagraphFormat.Alignment = 1;
+            range.ParagraphFormat.CharacterUnitFirstLineIndent = 0; range.ParagraphFormat.FirstLineIndent = 0;
+            range.Font.Bold = 0; range.Font.Italic = 0; range.Font.Color = -16777216; range.Font.Size = 10.5f;
+            if (!string.IsNullOrEmpty(fontName)) range.Font.Name = fontName;
+            if (!string.IsNullOrEmpty(fontFarEast)) range.Font.NameFarEast = fontFarEast;
+            range.ParagraphFormat.SpaceBefore = table ? Air : 3f;
+            range.ParagraphFormat.SpaceAfter = table ? 3f : Air;
+            Mathify(doc, caption.Range);
+        }
+        catch (COMException) { }
     }
 
     /// The number of a paragraph, counted from the start of the document.
@@ -692,6 +1152,23 @@ static class Program
         return (int)doc.Range(0, paragraph.Range.End).Paragraphs.Count;
     }
 
+    /// A new paragraph with no style named: body text that matches its surroundings. Written next to body
+    /// text it keeps that text's font, size and spacing (a template's own look) but not the emphasis of the
+    /// line it was split from (a bold label, a red hint); written after a heading it becomes Normal.
+    static void Body(dynamic paragraph)
+    {
+        int level = 10;
+        try { level = (int)paragraph.OutlineLevel; } catch (Exception) { }
+        if (level != 10) { Plain(paragraph, "Normal"); return; }
+        try
+        {
+            dynamic font = paragraph.Range.Font;
+            font.Bold = 0; font.Italic = 0; font.Underline = 0; font.Color = -16777216;
+            paragraph.Range.ParagraphFormat.Alignment = 3;
+        }
+        catch (COMException) { }
+    }
+
     static void Plain(dynamic paragraph, string style)
     {
         SetStyle(paragraph.Range, style);
@@ -721,7 +1198,7 @@ static class Program
             IList items = op.List("items");
             if (items == null) { items = new ArrayList(); items.Add(new Dictionary<string, object> { { "text", op.Need("text") } }); }
             dynamic current = null;
-            int made = 0;
+            int made = 0, equations = 0;
             foreach (object raw in items)
             {
                 Bag item = raw is string ? new Bag(new Dictionary<string, object> { { "text", raw } }) : new Bag(raw);
@@ -730,16 +1207,20 @@ static class Program
                     dynamic p;
                     if (current == null) p = NewParagraph(doc, op);
                     else p = After(doc, current);
-                    Plain(p, item.Str("style", op.Str("style", "Normal")));
-                    if (text.Length > 0) p.Range.InsertBefore(text);
+                    string style = item.Str("style", op.Str("style", null));
+                    if (style != null) Plain(p, style);
+                    else Body(p);
                     WordFormat(p.Range, StyleLess(op));
                     WordFormat(p.Range, StyleLess(item));
+                    Follow(doc, p.Range);
+                    Write(doc, (int)p.Range.Start, text);
+                    equations += Mathify(doc, p.Range);
                     current = p;
                     made++;
                 }
             }
             int lastIndex = Index(doc, current);
-            return "inserted " + made + " paragraph(s), now paragraphs " + (lastIndex - made + 1) + "–" + lastIndex + " of " + (int)doc.Paragraphs.Count;
+            return "inserted " + made + " paragraph(s), now paragraphs " + (lastIndex - made + 1) + "–" + lastIndex + " of " + (int)doc.Paragraphs.Count + (equations > 0 ? ", " + equations + " equation(s)" : "");
         }
         if ((type == "set_text" || (type == "delete_range" && op.Has("para"))) && op.Raw("expect") == null)
         {
@@ -750,8 +1231,10 @@ static class Program
             dynamic p = Para(doc, op.Int("para", 0), op.Str("expect", null));
             dynamic range = p.Range;
             range.MoveEnd(1, -1);
-            range.Text = Lines(op.Raw("text") ?? "");
-            return "paragraph " + op.Int("para", 0) + " rewritten";
+            range.Text = "";
+            Write(doc, (int)p.Range.Start, Lines(op.Raw("text") ?? ""));
+            int built = Mathify(doc, p.Range);
+            return "paragraph " + op.Int("para", 0) + " rewritten" + (built > 0 ? ", " + built + " equation(s)" : "");
         }
         if (type == "format_text" || type == "set_style")
         {
@@ -762,8 +1245,20 @@ static class Program
         if (type == "delete_range")
         {
             if (!op.Has("para") && !op.Has("find")) throw new Fail("BAD_ARGS", "Say what to delete with \"para\" (and \"to\") or \"find\".");
-            WordRange(doc, op).Delete();
-            return "deleted, " + (int)doc.Paragraphs.Count + " paragraphs now";
+            dynamic gone = WordRange(doc, op);
+            string note = "";
+            try { gone.Delete(); }
+            catch (COMException)
+            {
+                // The mark that ends a table cell cannot be deleted: take everything before it.
+                int limit = (int)gone.End - 1;
+                try { int from = (int)gone.Start; limit = Math.Min(limit, (int)doc.Range(from, from).Cells[1].Range.End - 1); } catch (Exception) { }
+                gone.End = limit;
+                if ((int)gone.End <= (int)gone.Start) throw new Fail("BAD_ARGS", "This is the last paragraph of a table cell; a cell always keeps one. Leave it empty.");
+                gone.Delete();
+                note = " (the last paragraph of the cell stays, a cell always keeps one)";
+            }
+            return "deleted, " + (int)doc.Paragraphs.Count + " paragraphs now" + note;
         }
         if (type == "insert_table")
         {
@@ -772,7 +1267,18 @@ static class Program
             if (data != null) foreach (object row in data) { IList cells = row as IList; if (cells != null) cols = Math.Max(cols, cells.Count); }
             if (rows < 1 || cols < 1) throw new Fail("BAD_ARGS", "Give \"data\" (rows of cells) or \"rows\" and \"cols\".");
             dynamic p = NewParagraph(doc, op);
+            string fontName = null, fontFarEast = null;
+            float fontSize = 0;
+            try
+            {
+                if ((int)p.OutlineLevel == 10)
+                {
+                    fontName = (string)p.Range.Font.Name; fontFarEast = (string)p.Range.Font.NameFarEast; fontSize = (float)p.Range.Font.Size;
+                }
+            }
+            catch (Exception) { }
             Plain(p, "Normal");
+            Follow(doc, p.Range);
             dynamic table = doc.Tables.Add(p.Range, rows, cols);
             // The cells take the formatting of the paragraph that follows (a heading, say): make them plain.
             SetStyle(table.Range, "Normal");
@@ -782,36 +1288,76 @@ static class Program
                 table.Range.ParagraphFormat.CharacterUnitFirstLineIndent = 0; table.Range.ParagraphFormat.FirstLineIndent = 0;
             }
             catch (COMException) { }
+            try
+            {
+                // Same typeface and size as the body text the table sits in; cells centred like a data table.
+                if (!string.IsNullOrEmpty(fontName)) table.Range.Font.Name = fontName;
+                if (!string.IsNullOrEmpty(fontFarEast)) table.Range.Font.NameFarEast = fontFarEast;
+                if (fontSize > 4 && fontSize < 100) table.Range.Font.Size = fontSize;
+                table.Range.ParagraphFormat.Alignment = 1;
+                table.Range.Cells.VerticalAlignment = 1;
+            }
+            catch (COMException) { }
             table.Borders.Enable = 1;
+            try { table.AutoFitBehavior(2); } catch (COMException) { }
             if (data != null)
             {
                 for (int r = 0; r < data.Count && r < rows; r++)
                 {
                     IList cells = data[r] as IList;
                     if (cells == null) continue;
-                    for (int c = 0; c < cells.Count; c++) if (cells[c] != null) table.Cell(r + 1, c + 1).Range.Text = Convert.ToString(cells[c]);
+                    for (int c = 0; c < cells.Count; c++)
+                    {
+                        if (cells[c] == null) continue;
+                        dynamic cell = table.Cell(r + 1, c + 1).Range;
+                        string value = Convert.ToString(cells[c], System.Globalization.CultureInfo.InvariantCulture);
+                        cell.Text = value;
+                        if (value.IndexOf('$') >= 0) Mathify(doc, table.Cell(r + 1, c + 1).Range);
+                    }
+                    if (Typing) Thread.Sleep(25);
                 }
             }
             if (op.Flag("header", true)) table.Rows[1].Range.Font.Bold = 1;
+            if (op.Has("caption")) Caption(doc, table.Range, true, op.Need("caption"), fontName, fontFarEast);
+            else
+            {
+                int tableStart = (int)table.Range.Start;
+                if (tableStart > 0) Space(doc.Range(tableStart - 1, tableStart - 1).Paragraphs[1], false);
+            }
+            int afterTable = (int)table.Range.End;
+            if (afterTable < (int)doc.Content.End) Space(doc.Range(afterTable, afterTable).Paragraphs[1], true);
             int tableEnd = (int)doc.Range(0, table.Range.End).Paragraphs.Count;
-            return "table " + (int)doc.Range(0, table.Range.End).Tables.Count + " inserted (" + rows + "×" + cols + "), now paragraphs " + (tableEnd - (int)table.Range.Paragraphs.Count + 1) + "–" + tableEnd + " of " + (int)doc.Paragraphs.Count;
+            bool nested = false;
+            try { nested = (int)table.NestingLevel > 1; } catch (Exception) { }
+            return (nested ? "table inserted inside a cell of table " + (int)doc.Range(0, table.Range.End).Tables.Count : "table " + (int)doc.Range(0, table.Range.End).Tables.Count + " inserted") + " (" + rows + "×" + cols + "), now paragraphs " + (tableEnd - (int)table.Range.Paragraphs.Count + 1) + "–" + tableEnd + " of " + (int)doc.Paragraphs.Count;
         }
         if (type == "set_cell")
         {
             int n = op.Int("table", 1);
             if (n < 1 || n > (int)doc.Tables.Count) throw new Fail("ANCHOR_MISSING", "There is no table " + n + ".");
-            doc.Tables[n].Cell(op.Int("row", 1), op.Int("col", 1)).Range.Text = Lines(op.Raw("text") ?? "");
-            return "cell set";
+            dynamic cell = doc.Tables[n].Cell(op.Int("row", 1), op.Int("col", 1));
+            Follow(doc, cell.Range);
+            cell.Range.Text = "";
+            Write(doc, (int)cell.Range.Start, Lines(op.Raw("text") ?? ""));
+            int built = Mathify(doc, doc.Tables[n].Cell(op.Int("row", 1), op.Int("col", 1)).Range);
+            return "cell set" + (built > 0 ? ", " + built + " equation(s)" : "");
         }
         if (type == "insert_image")
         {
             string path = op.Need("path");
             if (!File.Exists(path)) throw new Fail("BAD_ARGS", "Image \"" + path + "\" does not exist.");
             dynamic p = NewParagraph(doc, op);
+            string bodyFont = null, bodyFarEast = null;
+            try { if ((int)p.OutlineLevel == 10) { bodyFont = (string)p.Range.Font.Name; bodyFarEast = (string)p.Range.Font.NameFarEast; } } catch (Exception) { }
             Plain(p, "Normal");
+            Follow(doc, p.Range);
             dynamic picture = p.Range.InlineShapes.AddPicture(FileName: path, LinkToFile: false, SaveWithDocument: true);
             if (op.Has("width")) { picture.LockAspectRatio = -1; picture.Width = (float)op.Num("width", 300); }
+            try { p.Range.ParagraphFormat.CharacterUnitFirstLineIndent = 0; p.Range.ParagraphFormat.FirstLineIndent = 0; p.Range.ParagraphFormat.Alignment = 1; } catch (COMException) { }
             WordFormat(p.Range, StyleLess(op));
+            p.Range.ParagraphFormat.SpaceBefore = Air;
+            if (op.Has("caption")) Caption(doc, picture.Range, false, op.Need("caption"), bodyFont, bodyFarEast);
+            else p.Range.ParagraphFormat.SpaceAfter = Air;
             return "image inserted";
         }
         throw new Fail("BAD_ARGS", "Unknown Word operation \"" + type + "\".");
@@ -953,6 +1499,23 @@ static class Program
         if (op.Has("rowHeight")) range.RowHeight = op.Num("rowHeight", 15);
     }
 
+    /// Bring the cells being worked on into view, without touching the selection.
+    static void Show(dynamic book, dynamic sheet, dynamic range)
+    {
+        if (!Following) return;
+        try
+        {
+            sheet.Activate();
+            dynamic window = book.Windows[1];
+            dynamic visible = window.VisibleRange;
+            int row = (int)range.Row, column = (int)range.Column;
+            int top = (int)visible.Row, left = (int)visible.Column;
+            if (row < top || row >= top + (int)visible.Rows.Count - 1) window.ScrollRow = Math.Max(1, row - 3);
+            if (column < left || column >= left + (int)visible.Columns.Count - 1) window.ScrollColumn = Math.Max(1, column - 1);
+        }
+        catch (Exception) { }
+    }
+
     static string ExcelOp(dynamic app, dynamic book, string type, Bag op)
     {
         if (type == "add_sheet")
@@ -977,7 +1540,18 @@ static class Program
                 for (int c = 0; c < cells.Count; c++) grid[r, c] = Scalar(cells[c]);
             }
             dynamic target = Cells(ws, op.Str("range", "A1")).Cells[1, 1].Resize[rows.Count, width];
-            target.Formula = grid;
+            Show(book, ws, target);
+            if (Typing && rows.Count > 1 && rows.Count <= 60)
+            {
+                for (int r = 0; r < rows.Count; r++)
+                {
+                    object[,] line = new object[1, width];
+                    for (int c = 0; c < width; c++) line[0, c] = grid[r, c];
+                    target.Rows[r + 1].Formula = line;
+                    Thread.Sleep(35);
+                }
+            }
+            else target.Formula = grid;
             ExcelFormat(target, op);
             return "wrote " + (string)target.Address[false, false];
         }
@@ -1103,9 +1677,22 @@ static class Program
         return result;
     }
 
+    static void PptWrite(dynamic textRange, string text)
+    {
+        if (!Typing || text.Length < 4) { textRange.Text = text; return; }
+        textRange.Text = "";
+        foreach (string piece in Pieces(text)) { textRange.InsertAfter(piece); Thread.Sleep(22); }
+    }
+
+    static void GoTo(dynamic deck, int slide)
+    {
+        if (!Following) return;
+        try { deck.Windows[1].View.GotoSlide(slide); } catch (Exception) { }
+    }
+
     static void PptText(dynamic shape, Bag op)
     {
-        if (op.Has("text")) shape.TextFrame.TextRange.Text = Lines(op.Raw("text"));
+        if (op.Has("text")) PptWrite(shape.TextFrame.TextRange, Lines(op.Raw("text")));
         if (!(op.Has("font") || op.Has("size") || op.Has("bold") || op.Has("italic") || op.Has("color") || op.Has("align"))) return;
         dynamic range = shape.TextFrame.TextRange;
         if (op.Has("font")) { string font = op.Need("font"); range.Font.Name = font; try { range.Font.NameFarEast = font; } catch (COMException) { } }
@@ -1144,12 +1731,14 @@ static class Program
             string name = op.Str("layout", "title_content");
             if (!Layouts.TryGetValue(name, out layout)) throw new Fail("BAD_ARGS", "Unknown layout \"" + name + "\": use " + string.Join(", ", new List<string>(Layouts.Keys).ToArray()) + ".");
             dynamic slide = deck.Slides.Add(index, layout);
-            if (op.Has("title")) slide.Shapes.Title.TextFrame.TextRange.Text = Lines(op.Raw("title"));
-            if (op.Has("body")) slide.Shapes.Placeholders[2].TextFrame.TextRange.Text = Lines(op.Raw("body"));
+            GoTo(deck, index);
+            if (op.Has("title")) PptWrite(slide.Shapes.Title.TextFrame.TextRange, Lines(op.Raw("title")));
+            if (op.Has("body")) PptWrite(slide.Shapes.Placeholders[2].TextFrame.TextRange, Lines(op.Raw("body")));
             if (op.Has("notes")) slide.NotesPage.Shapes.Placeholders[2].TextFrame.TextRange.Text = Lines(op.Raw("notes"));
             return "slide " + index + " added";
         }
         dynamic target = Slide(deck, op);
+        GoTo(deck, op.Int("slide", 0));
         if (type == "delete_slide") { target.Delete(); return "slide deleted"; }
         if (type == "move_slide") { target.MoveTo(op.Int("to", 1)); return "slide moved to " + op.Int("to", 1); }
         if (type == "set_notes") { target.NotesPage.Shapes.Placeholders[2].TextFrame.TextRange.Text = Lines(op.Raw("text") ?? ""); return "notes set"; }
@@ -1189,6 +1778,12 @@ static class Program
         if (ops == null || ops.Count == 0) throw new Fail("BAD_ARGS", "\"ops\" must list at least one operation.");
         List<object> done = new List<object>();
         Dictionary<string, object> result = new Dictionary<string, object>();
+        // The settings give the two modes, until the user flips one on the card.
+        if (!Card.FollowChosen) Following = a.Flag("follow", false);
+        if (!Card.TypingChosen) Typing = a.Flag("typing", false);
+        bool card = a.Flag("card", false);
+        if (card && !cardStarted) { cardStarted = true; Card.Start(); }
+        string docName = (string)doc.Name;
         dynamic undo = null;
         // One undo step for the whole batch: the user takes it back with a single Ctrl+Z.
         if (kind == "word") { try { undo = app.UndoRecord; undo.StartCustomRecord("AI edit"); } catch (COMException) { undo = null; } }
@@ -1201,6 +1796,7 @@ static class Program
                 {
                     Bag op = new Bag(ops[i]);
                     type = op.Need("op");
+                    if (card) Card.Report("AI 正在编辑 " + docName + (ops.Count > 1 ? " · " + (i + 1) + "/" + ops.Count : ""));
                     string line = kind == "word" ? WordOp(doc, type, op) : kind == "excel" ? ExcelOp(app, doc, type, op) : PptOp(doc, type, op);
                     string ignored = op.Unread();
                     done.Add(ignored.Length == 0 ? line : line + " — IGNORED field(s) " + ignored + ": " + type + " does not take them, check the operation list");
@@ -1222,6 +1818,7 @@ static class Program
         {
             if (undo != null) { try { undo.EndCustomRecord(); } catch (COMException) { } }
         }
+        if (card) Card.Report(result.ContainsKey("failed") ? "AI 的修改停在第 " + (done.Count + 1) + " 项" : "AI 已改好 " + docName);
         result["done"] = done;
         result["total"] = ops.Count;
         return result;
@@ -1252,13 +1849,21 @@ static class Program
             using (Metafile meta = new Metafile(stream))
             {
                 int height = (int)Math.Round(width * (double)meta.Height / meta.Width);
+                // Drawn straight at the final size, hairlines (table borders) fall between pixels and vanish:
+                // draw the page large first, then scale the picture down.
+                int factor = Math.Max(2, (int)Math.Ceiling(3000.0 / width));
+                using (Bitmap large = new Bitmap(width * factor, height * factor))
                 using (Bitmap bitmap = new Bitmap(width, height))
                 {
-                    using (Graphics g = Graphics.FromImage(bitmap))
+                    using (Graphics g = Graphics.FromImage(large))
                     {
                         g.Clear(Color.White);
+                        g.DrawImage(meta, 0, 0, large.Width, large.Height);
+                    }
+                    using (Graphics g = Graphics.FromImage(bitmap))
+                    {
                         g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
-                        g.DrawImage(meta, 0, 0, width, height);
+                        g.DrawImage(large, 0, 0, width, height);
                     }
                     bitmap.Save(path, ImageFormat.Png);
                 }