Phrases.cs

// The phrase panel: a few short hidden strings kept around for repeated typing
// through a workday - rotated passwords being the motivating case. Each row is
// a label the user can word however they like, a masked single-line field, and
// a "Type after delay" button that runs the same countdown-and-send path as
// the main box.
//
// Phrase contents are held in memory only and are NEVER written to disk. The
// labels and the row count are settings; the secrets are not. The app lives in
// the tray, so "fetch once in the morning, type all day" works without ever
// storing anything - a reboot costs one re-paste.
//
// Unlike the main box, these fields mask natively: UseSystemPasswordChar works
// on a single-line TextBox, so hand-editing a masked phrase is safe here and
// needs none of the shadow-copy machinery the multiline box required.
//
// C# 5 only (in-box csc).

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

namespace RSPaster
{
    public class PhraseTypeEventArgs : EventArgs
    {
        public string Label;
        public string Text;
    }

    // A single-line box that pastes only the first line of the clipboard.
    // Password managers append a trailing newline; without this guard it would
    // survive into the phrase and be typed as a stray Enter mid-password. The
    // dedicated Paste button that used to carry this guard is gone - one
    // button per row, and it is the one that types - so the box itself now
    // holds the rule for plain Ctrl+V.
    public class PhraseBox : TextBox
    {
        const int WM_PASTE = 0x0302;

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == WM_PASTE && !ReadOnly)
            {
                string t = null;
                try
                {
                    if (Clipboard.ContainsText()) t = Clipboard.GetText();
                }
                catch (System.Runtime.InteropServices.ExternalException) { }   // clipboard locked
                if (t != null)
                {
                    int cut = t.IndexOfAny(new char[] { '\r', '\n' });
                    if (cut >= 0) t = t.Substring(0, cut);
                    SelectedText = t;
                }
                return;
            }
            base.WndProc(ref m);
        }
    }

    public class PhraseRow : Panel
    {
        public TextBox LabelBox;
        public PhraseBox SecretBox;
        InputHost _labelHost;
        InputHost _secretHost;
        ThemedButton _type;

        public event EventHandler<PhraseTypeEventArgs> TypeRequested;

        public PhraseRow(string label)
        {
            Height = Dpi.S(34);

            LabelBox = new TextBox();
            LabelBox.BorderStyle = BorderStyle.None;
            LabelBox.Text = label;
            _labelHost = new InputHost(LabelBox, Dpi.S(6), Dpi.S(4));

            SecretBox = new PhraseBox();
            SecretBox.BorderStyle = BorderStyle.None;
            SecretBox.UseSystemPasswordChar = true;
            _secretHost = new InputHost(SecretBox, Dpi.S(6), Dpi.S(4));

            // Worded identically to the main form's action button, because two
            // buttons labeled Paste and Type left users unsure which one
            // actually sends keystrokes.
            _type = new ThemedButton();
            _type.Text = "Type after delay";
            _type.TakesFocus = false;   // see ThemedButton.TakesFocus
            _type.Click += delegate(object s, EventArgs e) { RaiseType(); };

            Controls.Add(_labelHost);
            Controls.Add(_secretHost);
            Controls.Add(_type);
        }

        public void RaiseType()
        {
            if (TypeRequested == null) return;
            PhraseTypeEventArgs e = new PhraseTypeEventArgs();
            e.Label = LabelBox.Text;
            e.Text = SecretBox.Text;
            TypeRequested(this, e);
        }

        public void SetLocked(bool locked)
        {
            LabelBox.ReadOnly = locked;
            SecretBox.ReadOnly = locked;
            _type.Enabled = !locked;
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            // Setting Height in the constructor raises this before the child
            // controls exist.
            if (_labelHost == null) return;
            int h = Dpi.S(26);
            int y = (Height - h) / 2;
            int gap = Dpi.S(6);
            int btnW = Dpi.S(112);
            int labelW = Dpi.S(120);

            _labelHost.SetBounds(0, y, labelW, h);
            _type.SetBounds(Width - btnW, y, btnW, h);
            _secretHost.SetBounds(labelW + gap, y,
                Math.Max(Dpi.S(40), Width - labelW - btnW - gap * 2), h);
        }
    }

    public class PhrasePanel : Panel
    {
        // Six rows is where the panel starts crowding the main text box out of
        // a default-height window; past that this is a password manager, which
        // is a different tool.
        public const int MAX_ROWS = 6;
        public const int MIN_ROWS = 1;

        readonly List<PhraseRow> _rows = new List<PhraseRow>();
        ThemedButton _add;
        ThemedButton _remove;
        Label _note;

        public event EventHandler<PhraseTypeEventArgs> TypeRequested;

        public PhrasePanel()
        {
            Dock = DockStyle.Top;

            _add = new ThemedButton();
            _add.Text = "Add";
            _add.Click += delegate(object s, EventArgs e)
            {
                if (_rows.Count < MAX_ROWS) { AddRow("Phrase " + (_rows.Count + 1)); Relayout(); }
            };

            _remove = new ThemedButton();
            _remove.Text = "Remove";
            _remove.Click += delegate(object s, EventArgs e)
            {
                if (_rows.Count > MIN_ROWS) { RemoveLastRow(); Relayout(); }
            };

            _note = new Label();
            _note.AutoSize = false;
            _note.TextAlign = ContentAlignment.MiddleRight;
            _note.Text = "Phrases are kept in memory only - never saved to disk.";

            Controls.Add(_add);
            Controls.Add(_remove);
            Controls.Add(_note);

            Th.Changed += OnThemeChanged;
            OnThemeChanged(null, EventArgs.Empty);
        }

        void OnThemeChanged(object sender, EventArgs e)
        {
            BackColor = Th.T.Panel2;
            _note.BackColor = Th.T.Panel2;
            _note.ForeColor = Th.T.TxtDim;
            Invalidate();
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing) Th.Changed -= OnThemeChanged;
            base.Dispose(disposing);
        }

        public int RowCount { get { return _rows.Count; } }

        public List<string> Labels
        {
            get
            {
                List<string> l = new List<string>();
                foreach (PhraseRow r in _rows) l.Add(r.LabelBox.Text);
                return l;
            }
        }

        public PhraseRow Row(int i) { return _rows[i]; }

        public void Build(List<string> labels)
        {
            while (_rows.Count > 0) RemoveLastRow();
            foreach (string l in labels)
            {
                if (_rows.Count >= MAX_ROWS) break;
                AddRow(l);
            }
            if (_rows.Count == 0) AddRow("Phrase 1");
            Relayout();
        }

        void AddRow(string label)
        {
            PhraseRow row = new PhraseRow(label);
            row.TypeRequested += delegate(object s, PhraseTypeEventArgs e)
            {
                if (TypeRequested != null) TypeRequested(s, e);
            };
            _rows.Add(row);
            Controls.Add(row);
        }

        void RemoveLastRow()
        {
            PhraseRow row = _rows[_rows.Count - 1];
            _rows.RemoveAt(_rows.Count - 1);
            Controls.Remove(row);
            row.Dispose();   // its InputHosts unhook their theme handlers here
        }

        public void SetLocked(bool locked)
        {
            foreach (PhraseRow r in _rows) r.SetLocked(locked);
            _add.Enabled = !locked && _rows.Count < MAX_ROWS;
            _remove.Enabled = !locked && _rows.Count > MIN_ROWS;
        }

        // Manual stacking rather than per-row Dock=Top, whose top-to-bottom
        // order depends on z-order and reads exactly backwards in code.
        void Relayout()
        {
            int pad = Dpi.S(8);
            int rowH = Dpi.S(34);
            int y = pad;
            foreach (PhraseRow r in _rows)
            {
                r.SetBounds(pad, y, Math.Max(Dpi.S(100), Width - pad * 2), rowH);
                y += rowH;
            }
            int btnH = Dpi.S(26);
            _add.SetBounds(pad, y + Dpi.S(4), Dpi.S(60), btnH);
            _remove.SetBounds(pad + Dpi.S(66), y + Dpi.S(4), Dpi.S(76), btnH);
            _note.SetBounds(pad + Dpi.S(150), y + Dpi.S(4),
                Math.Max(Dpi.S(80), Width - pad * 2 - Dpi.S(150)), btnH);
            Height = y + btnH + Dpi.S(12);
            _add.Enabled = _rows.Count < MAX_ROWS;
            _remove.Enabled = _rows.Count > MIN_ROWS;
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            Relayout();
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            e.Graphics.Clear(Th.T.Panel2);
            using (Pen p = new Pen(Th.T.Border))
                e.Graphics.DrawLine(p, 0, Height - 1, Width, Height - 1);
        }
    }
}