645 lines
29 KiB
C#
645 lines
29 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using System.Windows.Interop;
|
|
using System.Windows.Media;
|
|
using WF = System.Windows.Forms;
|
|
|
|
namespace QuickClaude
|
|
{
|
|
public class MainWindow : Window
|
|
{
|
|
readonly Settings settings;
|
|
readonly ClaudeRunner runner = new ClaudeRunner();
|
|
readonly TextBox transcript = new TextBox();
|
|
readonly TextBox input = new TextBox();
|
|
readonly TextBlock status = new TextBlock();
|
|
readonly TextBlock grip = new TextBlock();
|
|
// Holds the transcript. The transcript inside is always sized to a whole number of lines
|
|
// and sits at the bottom, so no line is ever shown cut in half (see FitTranscript).
|
|
readonly Border transcriptHost = new Border { ClipToBounds = true };
|
|
double lineHeight = 13;
|
|
WF.NotifyIcon tray;
|
|
WF.ToolStripMenuItem fontMenu, sizeMenu, snapItem, topItem, blackItem, whiteItem, lookItem, editItem, autoItem, folderItem;
|
|
bool lastWasTool;
|
|
bool quitting;
|
|
|
|
// Nearly invisible fill so the window still catches the mouse (fully clear pixels click through)
|
|
static readonly Brush HitFill = new SolidColorBrush(Color.FromArgb(1, 0, 0, 0));
|
|
// The current font (picked from the tray's Font menu). Still called Mono since
|
|
// ConfirmWindow and DarkMenu read it when they open.
|
|
internal static FontFamily Mono = new FontFamily("Consolas, Courier New");
|
|
// Picked from the tray's Font size menu, 10 to 18 (same units as wIRC's font size
|
|
// slider: 10sp = 10 WPF units). ConfirmWindow and DarkMenu read it when they open.
|
|
internal const double MinTextSize = 10, MaxTextSize = 18;
|
|
internal static double TextSize = 10;
|
|
const double ResizeEdge = 6;
|
|
|
|
public MainWindow()
|
|
{
|
|
settings = Settings.Load();
|
|
Mono = Fonts.Find(settings.Font).Family;
|
|
TextSize = Math.Clamp(Math.Round(settings.FontSize), MinTextSize, MaxTextSize);
|
|
|
|
Title = "QuickClaude";
|
|
WindowStyle = WindowStyle.None;
|
|
AllowsTransparency = true;
|
|
Background = HitFill;
|
|
ShowInTaskbar = false;
|
|
ResizeMode = ResizeMode.CanResize;
|
|
MinWidth = 240;
|
|
MinHeight = 160;
|
|
FontFamily = Mono;
|
|
FontSize = TextSize;
|
|
Width = Math.Max(240, settings.Width);
|
|
Height = Math.Max(160, settings.Height);
|
|
Topmost = settings.Topmost;
|
|
if (double.IsNaN(settings.Left) || double.IsNaN(settings.Top) || !OnScreen(settings.Left, settings.Top))
|
|
WindowStartupLocation = WindowStartupLocation.CenterScreen;
|
|
else { Left = settings.Left; Top = settings.Top; }
|
|
|
|
BuildLayout();
|
|
ApplyColor();
|
|
BuildTray();
|
|
|
|
runner.TextDelta += t => Dispatcher.InvokeAsync(() => OnText(t));
|
|
runner.ToolUsed += t => Dispatcher.InvokeAsync(() => OnTool(t));
|
|
runner.SessionStarted += id => Dispatcher.InvokeAsync(() => { settings.SessionId = id; settings.Save(); });
|
|
runner.Finished += err => Dispatcher.InvokeAsync(() => OnFinished(err));
|
|
|
|
try { if (File.Exists(Settings.TranscriptPath)) transcript.Text = File.ReadAllText(Settings.TranscriptPath); } catch { }
|
|
if (transcript.Text.Length == 0)
|
|
transcript.Text = "QuickClaude. Type below and press Enter. Shift+Enter for a new line, Esc stops Claude, Ctrl+Alt+C hides or shows this note.\n";
|
|
|
|
Loaded += (s, e) => { MeasureLineHeight(); transcript.ScrollToEnd(); input.Focus(); };
|
|
PreviewMouseLeftButtonUp += ClickToInput;
|
|
SourceInitialized += (s, e) => RegisterHotkey();
|
|
LocationChanged += (s, e) => SavePlace();
|
|
Closing += (s, e) =>
|
|
{
|
|
if (!quitting) { e.Cancel = true; Hide(); return; }
|
|
runner.Stop();
|
|
SavePlace();
|
|
SaveTranscript();
|
|
tray.Visible = false;
|
|
tray.Dispose();
|
|
};
|
|
}
|
|
|
|
void BuildLayout()
|
|
{
|
|
var rootGrid = new Grid { Background = HitFill, Margin = new Thickness(4) };
|
|
rootGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
|
|
rootGrid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
|
|
rootGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
|
|
|
|
// Top row: a solid "clod" label that moves the window, plus a quiet status line
|
|
grip.Text = "clod";
|
|
grip.FontSize = TextSize;
|
|
grip.FontFamily = Mono;
|
|
grip.Background = HitFill;
|
|
grip.Cursor = Cursors.SizeAll;
|
|
grip.ToolTip = "Drag to move";
|
|
grip.MouseLeftButtonDown += (s, e) => { try { DragMove(); } catch { } SavePlace(); };
|
|
|
|
status.FontSize = TextSize;
|
|
status.FontFamily = Mono;
|
|
status.Margin = new Thickness(8, 0, 0, 0);
|
|
|
|
var top = new StackPanel { Orientation = Orientation.Horizontal, Margin = new Thickness(0, 0, 0, 4) };
|
|
top.Children.Add(grip);
|
|
top.Children.Add(status);
|
|
Grid.SetRow(top, 0);
|
|
rootGrid.Children.Add(top);
|
|
|
|
// Conversation: read-only, selectable text with no border or fill
|
|
StyleBox(transcript);
|
|
transcript.IsReadOnly = true;
|
|
transcript.TextWrapping = TextWrapping.Wrap;
|
|
transcript.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden;
|
|
transcript.IsUndoEnabled = false;
|
|
transcript.VerticalAlignment = VerticalAlignment.Bottom;
|
|
transcriptHost.Background = HitFill;
|
|
transcriptHost.Child = transcript;
|
|
transcriptHost.SizeChanged += (s, e) => FitTranscript();
|
|
Grid.SetRow(transcriptHost, 1);
|
|
rootGrid.Children.Add(transcriptHost);
|
|
|
|
// Input line
|
|
var bottom = new Grid { Margin = new Thickness(0, 6, 0, 0) };
|
|
|
|
StyleBox(input);
|
|
input.AcceptsReturn = true;
|
|
input.TextWrapping = TextWrapping.Wrap;
|
|
input.MaxHeight = 120;
|
|
input.VerticalScrollBarVisibility = ScrollBarVisibility.Hidden;
|
|
input.Padding = new Thickness(0, 4, 0, 0);
|
|
input.PreviewKeyDown += InputKeyDown;
|
|
|
|
bottom.Children.Add(input);
|
|
Grid.SetRow(bottom, 2);
|
|
rootGrid.Children.Add(bottom);
|
|
|
|
Content = rootGrid;
|
|
BuildContextMenus();
|
|
}
|
|
|
|
// Right-click menus: Copy (and Cut/Paste in the input) plus New conversation; blank areas get just the latter.
|
|
// Rebuilt when the font changes so they use it too.
|
|
void BuildContextMenus()
|
|
{
|
|
transcript.ContextMenu = DarkMenu.Make(transcript, NewConversation);
|
|
input.ContextMenu = DarkMenu.Make(input, NewConversation);
|
|
((Grid)Content).ContextMenu = DarkMenu.Make(null, NewConversation);
|
|
}
|
|
|
|
// Height of one line of transcript text at the current font and size. Measured as the
|
|
// difference between two lines and one, so it's exactly what the text box steps by.
|
|
void MeasureLineHeight()
|
|
{
|
|
var probe = new TextBlock { FontFamily = Mono, FontSize = TextSize, Text = "Mg" };
|
|
probe.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
|
|
double one = probe.DesiredSize.Height;
|
|
probe.Text = "Mg\nMg";
|
|
probe.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
|
|
double two = probe.DesiredSize.Height;
|
|
lineHeight = two - one > 1 ? two - one : Math.Max(1, one);
|
|
FitTranscript();
|
|
}
|
|
|
|
// Make the transcript exactly as tall as the whole lines that fit, bottom-aligned, and keep
|
|
// it scrolled to the end so the top line is whole too. Runs on every size change (window
|
|
// resize, the input box growing, font changes).
|
|
void FitTranscript()
|
|
{
|
|
double avail = transcriptHost.ActualHeight;
|
|
if (avail <= 0 || lineHeight <= 0) return;
|
|
int lines = Math.Max(1, (int)Math.Floor((avail + 0.01) / lineHeight));
|
|
transcript.Height = lines * lineHeight;
|
|
transcript.ScrollToEnd();
|
|
}
|
|
|
|
// Leftover space under the last whole line, in WPF units
|
|
double TranscriptGap() => Math.Max(0, transcriptHost.ActualHeight - (double.IsNaN(transcript.Height) ? 0 : transcript.Height));
|
|
|
|
void SetFontSize(double size)
|
|
{
|
|
size = Math.Clamp(size, MinTextSize, MaxTextSize);
|
|
settings.FontSize = size;
|
|
settings.Save();
|
|
TextSize = size;
|
|
FontSize = size;
|
|
transcript.FontSize = size;
|
|
input.FontSize = size;
|
|
status.FontSize = size;
|
|
grip.FontSize = size;
|
|
MeasureLineHeight();
|
|
BuildContextMenus();
|
|
transcript.ScrollToEnd();
|
|
if (sizeMenu != null)
|
|
foreach (WF.ToolStripMenuItem item in sizeMenu.DropDownItems)
|
|
item.Checked = item.Text == size.ToString();
|
|
}
|
|
|
|
void SetFont(string name)
|
|
{
|
|
var choice = Fonts.Find(name);
|
|
settings.Font = choice.Name;
|
|
settings.Save();
|
|
Mono = choice.Family;
|
|
FontFamily = Mono;
|
|
transcript.FontFamily = Mono;
|
|
input.FontFamily = Mono;
|
|
status.FontFamily = Mono;
|
|
grip.FontFamily = Mono;
|
|
MeasureLineHeight();
|
|
BuildContextMenus();
|
|
if (fontMenu != null)
|
|
foreach (WF.ToolStripMenuItem item in fontMenu.DropDownItems)
|
|
item.Checked = item.Text == choice.Name;
|
|
}
|
|
|
|
static void StyleBox(TextBox tb)
|
|
{
|
|
tb.Background = Brushes.Transparent;
|
|
tb.BorderThickness = new Thickness(0);
|
|
tb.FontFamily = Mono;
|
|
tb.FontSize = TextSize;
|
|
tb.Padding = new Thickness(0);
|
|
tb.FocusVisualStyle = null;
|
|
tb.Template = BareTextBoxTemplate;
|
|
}
|
|
|
|
// Just the text host: no border, so the theme's blue focus/hover border never shows
|
|
internal static readonly ControlTemplate BareTextBoxTemplate = MakeBareTextBoxTemplate();
|
|
|
|
static ControlTemplate MakeBareTextBoxTemplate()
|
|
{
|
|
var host = new FrameworkElementFactory(typeof(ScrollViewer), "PART_ContentHost");
|
|
host.SetValue(ScrollViewer.FocusableProperty, false);
|
|
host.SetValue(ScrollViewer.HorizontalScrollBarVisibilityProperty, ScrollBarVisibility.Hidden);
|
|
host.SetValue(ScrollViewer.VerticalScrollBarVisibilityProperty, ScrollBarVisibility.Hidden);
|
|
var root = new FrameworkElementFactory(typeof(Border));
|
|
root.SetValue(Border.BackgroundProperty, new TemplateBindingExtension(Control.BackgroundProperty));
|
|
root.SetValue(Border.PaddingProperty, new TemplateBindingExtension(Control.PaddingProperty));
|
|
root.AppendChild(host);
|
|
var t = new ControlTemplate(typeof(TextBox)) { VisualTree = root };
|
|
t.Seal();
|
|
return t;
|
|
}
|
|
|
|
void ApplyColor()
|
|
{
|
|
var c = settings.TextColor == "White" ? Colors.White : Colors.Black;
|
|
var solid = new SolidColorBrush(c);
|
|
var faint = new SolidColorBrush(Color.FromArgb(110, c.R, c.G, c.B));
|
|
transcript.Foreground = solid;
|
|
input.Foreground = solid;
|
|
input.CaretBrush = solid;
|
|
transcript.CaretBrush = solid;
|
|
status.Foreground = faint;
|
|
grip.Foreground = solid;
|
|
if (blackItem != null) { blackItem.Checked = c == Colors.Black; whiteItem.Checked = c == Colors.White; }
|
|
}
|
|
|
|
// A click anywhere puts the cursor in the input. Clicks on the input itself and on "clod"
|
|
// keep their own behavior, and a drag that selected conversation text keeps the selection
|
|
// (and focus) so it can be copied. Edge resizing never gets here: it's non-client.
|
|
void ClickToInput(object sender, MouseButtonEventArgs e)
|
|
{
|
|
var src = e.OriginalSource as DependencyObject;
|
|
if (IsWithin(src, input) || IsWithin(src, grip)) return;
|
|
bool inTranscript = IsWithin(src, transcript);
|
|
Dispatcher.BeginInvoke(new Action(() =>
|
|
{
|
|
if (inTranscript && transcript.SelectionLength > 0) return;
|
|
input.Focus();
|
|
Keyboard.Focus(input);
|
|
}), System.Windows.Threading.DispatcherPriority.Input);
|
|
}
|
|
|
|
static bool IsWithin(DependencyObject node, DependencyObject target)
|
|
{
|
|
while (node != null)
|
|
{
|
|
if (node == target) return true;
|
|
node = node is Visual || node is System.Windows.Media.Media3D.Visual3D
|
|
? VisualTreeHelper.GetParent(node)
|
|
: LogicalTreeHelper.GetParent(node);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void InputKeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.Key == Key.Escape)
|
|
{
|
|
if (runner.Running) runner.Stop(); else Hide();
|
|
e.Handled = true;
|
|
}
|
|
else if (e.Key == Key.Enter && (Keyboard.Modifiers & ModifierKeys.Shift) == 0)
|
|
{
|
|
e.Handled = true;
|
|
Send();
|
|
}
|
|
}
|
|
|
|
async void Send()
|
|
{
|
|
var prompt = input.Text.Trim();
|
|
if (prompt.Length == 0 || runner.Running) return;
|
|
|
|
var claude = ClaudeRunner.FindClaude(settings.ClaudePath);
|
|
if (claude == null)
|
|
{
|
|
Append((transcript.Text.Length > 0 ? "\n" : "") +
|
|
"Can't find Claude Code on this computer. Install it, or use the tray menu's \"Find claude.exe...\" to point at it.\n");
|
|
return;
|
|
}
|
|
|
|
input.Clear();
|
|
var lead = transcript.Text.Length == 0 ? "" : (transcript.Text.EndsWith("\n") ? "\n" : "\n\n");
|
|
Append(lead + "> " + prompt.Replace("\n", "\n ") + "\n\n");
|
|
lastWasTool = false;
|
|
status.Text = "working... (Esc to stop)";
|
|
|
|
await runner.RunAsync(claude, prompt, settings.WorkDir, settings.SessionId, settings.Mode);
|
|
}
|
|
|
|
void OnText(string t)
|
|
{
|
|
if (t == "\u0001")
|
|
{
|
|
if (lastWasTool && !transcript.Text.EndsWith("\n")) Append("\n");
|
|
lastWasTool = false;
|
|
return;
|
|
}
|
|
Append(t);
|
|
}
|
|
|
|
void OnTool(string line)
|
|
{
|
|
if (transcript.Text.Length > 0 && !transcript.Text.EndsWith("\n")) Append("\n");
|
|
Append(line + "\n");
|
|
lastWasTool = true;
|
|
}
|
|
|
|
void OnFinished(string err)
|
|
{
|
|
if (err != null)
|
|
{
|
|
if (!transcript.Text.EndsWith("\n")) Append("\n");
|
|
Append("(" + err.Trim() + ")\n");
|
|
}
|
|
else if (!transcript.Text.EndsWith("\n")) Append("\n");
|
|
status.Text = "";
|
|
SaveTranscript();
|
|
}
|
|
|
|
void Append(string text)
|
|
{
|
|
transcript.AppendText(text);
|
|
transcript.ScrollToEnd();
|
|
}
|
|
|
|
void SaveTranscript()
|
|
{
|
|
try
|
|
{
|
|
Directory.CreateDirectory(Settings.Folder);
|
|
var t = transcript.Text;
|
|
if (t.Length > 200000) t = t.Substring(t.Length - 200000);
|
|
File.WriteAllText(Settings.TranscriptPath, t, new UTF8Encoding(false));
|
|
}
|
|
catch { }
|
|
}
|
|
|
|
void SavePlace()
|
|
{
|
|
if (WindowState != WindowState.Normal) return;
|
|
settings.Left = Left; settings.Top = Top; settings.Width = Width; settings.Height = Height;
|
|
settings.Save();
|
|
}
|
|
|
|
static bool OnScreen(double left, double top)
|
|
{
|
|
foreach (var s in WF.Screen.AllScreens)
|
|
if (s.WorkingArea.Contains((int)left + 20, (int)top + 20)) return true;
|
|
return false;
|
|
}
|
|
|
|
public void Toggle()
|
|
{
|
|
if (IsVisible) Hide();
|
|
else
|
|
{
|
|
Show();
|
|
Activate();
|
|
input.Focus();
|
|
Keyboard.Focus(input);
|
|
}
|
|
}
|
|
|
|
void NewConversation()
|
|
{
|
|
if (runner.Running) runner.Stop();
|
|
settings.SessionId = "";
|
|
settings.Save();
|
|
transcript.Clear();
|
|
Append("New conversation.\n");
|
|
SaveTranscript();
|
|
if (!IsVisible) Toggle();
|
|
}
|
|
|
|
void SetMode(string mode)
|
|
{
|
|
settings.Mode = mode;
|
|
settings.Save();
|
|
lookItem.Checked = mode == "default";
|
|
editItem.Checked = mode == "acceptEdits";
|
|
autoItem.Checked = mode == "auto";
|
|
}
|
|
|
|
void BuildTray()
|
|
{
|
|
var menu = new WF.ContextMenuStrip();
|
|
menu.Items.Add("Show / hide (Ctrl+Alt+C)", null, (s, e) => Toggle());
|
|
menu.Items.Add("New conversation", null, (s, e) => NewConversation());
|
|
menu.Items.Add(new WF.ToolStripSeparator());
|
|
|
|
var color = new WF.ToolStripMenuItem("Text color");
|
|
blackItem = new WF.ToolStripMenuItem("Black", null, (s, e) => { settings.TextColor = "Black"; settings.Save(); ApplyColor(); });
|
|
whiteItem = new WF.ToolStripMenuItem("White", null, (s, e) => { settings.TextColor = "White"; settings.Save(); ApplyColor(); });
|
|
color.DropDownItems.Add(blackItem);
|
|
color.DropDownItems.Add(whiteItem);
|
|
menu.Items.Add(color);
|
|
|
|
fontMenu = new WF.ToolStripMenuItem("Font");
|
|
var current = Fonts.Find(settings.Font).Name;
|
|
foreach (var choice in Fonts.All)
|
|
{
|
|
var name = choice.Name;
|
|
fontMenu.DropDownItems.Add(new WF.ToolStripMenuItem(name, null, (s, e) => SetFont(name)) { Checked = name == current });
|
|
}
|
|
menu.Items.Add(fontMenu);
|
|
|
|
sizeMenu = new WF.ToolStripMenuItem("Font size");
|
|
for (int px = (int)MinTextSize; px <= (int)MaxTextSize; px++)
|
|
{
|
|
double sz = px;
|
|
sizeMenu.DropDownItems.Add(new WF.ToolStripMenuItem(px.ToString(), null, (s, e) => SetFontSize(sz)) { Checked = sz == TextSize });
|
|
}
|
|
menu.Items.Add(sizeMenu);
|
|
|
|
snapItem = new WF.ToolStripMenuItem("Snap to desktop grid", null, (s, e) =>
|
|
{
|
|
settings.SnapToGrid = !settings.SnapToGrid; snapItem.Checked = settings.SnapToGrid; settings.Save();
|
|
}) { Checked = settings.SnapToGrid };
|
|
menu.Items.Add(snapItem);
|
|
|
|
topItem = new WF.ToolStripMenuItem("Always on top", null, (s, e) =>
|
|
{
|
|
settings.Topmost = !settings.Topmost; Topmost = settings.Topmost; topItem.Checked = settings.Topmost; settings.Save();
|
|
}) { Checked = settings.Topmost };
|
|
menu.Items.Add(topItem);
|
|
menu.Items.Add(new WF.ToolStripSeparator());
|
|
|
|
var can = new WF.ToolStripMenuItem("Claude can");
|
|
lookItem = new WF.ToolStripMenuItem("Only look (read files, no changes)", null, (s, e) => SetMode("default"));
|
|
editItem = new WF.ToolStripMenuItem("Edit files in the work folder", null, (s, e) => SetMode("acceptEdits"));
|
|
autoItem = new WF.ToolStripMenuItem("Auto (Claude Code's auto mode)", null, (s, e) => SetMode("auto"));
|
|
can.DropDownItems.Add(lookItem);
|
|
can.DropDownItems.Add(editItem);
|
|
can.DropDownItems.Add(autoItem);
|
|
menu.Items.Add(can);
|
|
|
|
folderItem = new WF.ToolStripMenuItem("Work folder: " + settings.WorkDir, null, (s, e) =>
|
|
{
|
|
using var dlg = new WF.FolderBrowserDialog { SelectedPath = settings.WorkDir, Description = "Folder Claude works in" };
|
|
if (dlg.ShowDialog() == WF.DialogResult.OK)
|
|
{
|
|
settings.WorkDir = dlg.SelectedPath;
|
|
settings.Save();
|
|
folderItem.Text = "Work folder: " + settings.WorkDir;
|
|
}
|
|
});
|
|
menu.Items.Add(folderItem);
|
|
menu.Items.Add("Find claude.exe...", null, (s, e) =>
|
|
{
|
|
using var dlg = new WF.OpenFileDialog { Filter = "Claude Code|claude.exe;claude.cmd|All files|*.*", Title = "Find Claude Code" };
|
|
if (dlg.ShowDialog() == WF.DialogResult.OK) { settings.ClaudePath = dlg.FileName; settings.Save(); }
|
|
});
|
|
menu.Items.Add(new WF.ToolStripSeparator());
|
|
menu.Items.Add("Exit", null, (s, e) => { quitting = true; Close(); System.Windows.Application.Current.Shutdown(); });
|
|
|
|
tray = new WF.NotifyIcon
|
|
{
|
|
Icon = TrayIcon.Make(),
|
|
Text = "QuickClaude",
|
|
ContextMenuStrip = menu,
|
|
Visible = true
|
|
};
|
|
tray.MouseClick += (s, e) => { if (e.Button == WF.MouseButtons.Left) Toggle(); };
|
|
|
|
SetMode(settings.Mode);
|
|
ApplyColor();
|
|
}
|
|
|
|
// Global hotkey: Ctrl+Alt+C
|
|
[DllImport("user32.dll")] static extern bool RegisterHotKey(IntPtr hWnd, int id, uint mods, uint vk);
|
|
const int HotkeyId = 0x5143;
|
|
|
|
void RegisterHotkey()
|
|
{
|
|
var helper = new WindowInteropHelper(this);
|
|
RegisterHotKey(helper.Handle, HotkeyId, 0x0001 | 0x0002 | 0x4000, 0x43);
|
|
HwndSource.FromHwnd(helper.Handle)?.AddHook((IntPtr hwnd, int msg, IntPtr w, IntPtr l, ref bool handled) =>
|
|
{
|
|
if (msg == 0x0312 && w.ToInt32() == HotkeyId) { Toggle(); handled = true; }
|
|
else if (msg == WM_NCHITTEST)
|
|
{
|
|
var hit = EdgeHit(hwnd, l);
|
|
if (hit != 0) { handled = true; return new IntPtr(hit); }
|
|
}
|
|
else if (msg == WM_ENTERSIZEMOVE) GetWindowRect(hwnd, out moveStart);
|
|
else if (msg == WM_EXITSIZEMOVE) { AfterMoveOrResize(hwnd); SavePlace(); }
|
|
return IntPtr.Zero;
|
|
});
|
|
}
|
|
|
|
// Resize from any edge or corner: report a ~6px border strip as the matching hit code
|
|
[DllImport("user32.dll")] static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
|
|
[StructLayout(LayoutKind.Sequential)] struct RECT { public int Left, Top, Right, Bottom; }
|
|
const int WM_NCHITTEST = 0x0084, WM_ENTERSIZEMOVE = 0x0231, WM_EXITSIZEMOVE = 0x0232;
|
|
RECT moveStart;
|
|
|
|
[DllImport("user32.dll")] static extern bool SetWindowPos(IntPtr hWnd, IntPtr after, int x, int y, int cx, int cy, uint flags);
|
|
[DllImport("user32.dll")] static extern IntPtr MonitorFromWindow(IntPtr hwnd, uint flags);
|
|
[DllImport("user32.dll", CharSet = CharSet.Auto)] static extern bool GetMonitorInfo(IntPtr mon, ref MONITORINFO info);
|
|
[DllImport("user32.dll")] static extern bool SystemParametersInfo(uint action, uint param, out int value, uint ini);
|
|
[StructLayout(LayoutKind.Sequential)] struct MONITORINFO { public int cbSize; public RECT rcMonitor, rcWork; public uint dwFlags; }
|
|
const uint SWP_NOSIZE = 0x1, SWP_NOMOVE = 0x2, SWP_NOZORDER = 0x4, SWP_NOACTIVATE = 0x10;
|
|
const uint SPI_ICONHORIZONTALSPACING = 0x000D, SPI_ICONVERTICALSPACING = 0x0018;
|
|
|
|
[DllImport("user32.dll", CharSet = CharSet.Unicode)] static extern IntPtr FindWindow(string cls, string name);
|
|
[DllImport("user32.dll", CharSet = CharSet.Unicode)] static extern IntPtr FindWindowEx(IntPtr parent, IntPtr after, string cls, string name);
|
|
[DllImport("user32.dll")] static extern IntPtr SendMessage(IntPtr h, int msg, IntPtr w, IntPtr l);
|
|
const int LVM_GETITEMSPACING = 0x1033;
|
|
|
|
// The desktop icon grid, asked of the desktop's own icon view so it follows the icon size
|
|
// and spacing Windows is really using (wIRC asks the same way, so both line up), falling
|
|
// back to the system icon spacing. In physical pixels.
|
|
static bool DesktopGridSpacing(out int sx, out int sy)
|
|
{
|
|
sx = sy = 0;
|
|
try
|
|
{
|
|
var view = FindWindowEx(FindWindow("Progman", null), IntPtr.Zero, "SHELLDLL_DefView", null);
|
|
var worker = IntPtr.Zero;
|
|
while (view == IntPtr.Zero)
|
|
{
|
|
worker = FindWindowEx(IntPtr.Zero, worker, "WorkerW", null);
|
|
if (worker == IntPtr.Zero) break;
|
|
view = FindWindowEx(worker, IntPtr.Zero, "SHELLDLL_DefView", null);
|
|
}
|
|
var list = view == IntPtr.Zero ? IntPtr.Zero : FindWindowEx(view, IntPtr.Zero, "SysListView32", null);
|
|
if (list != IntPtr.Zero)
|
|
{
|
|
long r = SendMessage(list, LVM_GETITEMSPACING, IntPtr.Zero, IntPtr.Zero).ToInt64();
|
|
sx = (int)(r & 0xFFFF); sy = (int)((r >> 16) & 0xFFFF);
|
|
if (sx > 8 && sy > 8) return true;
|
|
}
|
|
}
|
|
catch { }
|
|
return SystemParametersInfo(SPI_ICONHORIZONTALSPACING, 0, out sx, 0) && sx > 8 &&
|
|
SystemParametersInfo(SPI_ICONVERTICALSPACING, 0, out sy, 0) && sy > 8;
|
|
}
|
|
|
|
// After a drag or resize ends: a resize trims the window to whole transcript lines, and a
|
|
// plain move snaps the top-left corner to the desktop icon grid (same spacing Windows uses
|
|
// for desktop icons, counted from the top-left of the screen's work area).
|
|
void AfterMoveOrResize(IntPtr hwnd)
|
|
{
|
|
if (!GetWindowRect(hwnd, out var r)) return;
|
|
bool resized = (r.Right - r.Left) != (moveStart.Right - moveStart.Left) ||
|
|
(r.Bottom - r.Top) != (moveStart.Bottom - moveStart.Top);
|
|
double scale = PresentationSource.FromVisual(this)?.CompositionTarget?.TransformToDevice.M22 ?? 1;
|
|
|
|
if (resized)
|
|
{
|
|
UpdateLayout();
|
|
double gap = TranscriptGap();
|
|
int gapPx = (int)Math.Floor(gap * scale);
|
|
int h = r.Bottom - r.Top;
|
|
int minPx = (int)Math.Ceiling(MinHeight * scale);
|
|
if (gapPx > 0 && h - gapPx >= minPx)
|
|
{
|
|
// Keep whichever edge didn't move: resizing from the top keeps the bottom fixed
|
|
bool fromTop = r.Top != moveStart.Top && r.Bottom == moveStart.Bottom;
|
|
int top = fromTop ? r.Top + gapPx : r.Top;
|
|
SetWindowPos(hwnd, IntPtr.Zero, r.Left, top, r.Right - r.Left, h - gapPx, SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!settings.SnapToGrid) return;
|
|
if (r.Left == moveStart.Left && r.Top == moveStart.Top) return;
|
|
if (!DesktopGridSpacing(out int sx, out int sy)) return;
|
|
var info = new MONITORINFO { cbSize = Marshal.SizeOf<MONITORINFO>() };
|
|
if (!GetMonitorInfo(MonitorFromWindow(hwnd, 2 /* nearest */), ref info)) return;
|
|
var w = info.rcWork;
|
|
int x = w.Left + (int)Math.Round((r.Left - w.Left) / (double)sx) * sx;
|
|
int y = w.Top + (int)Math.Round((r.Top - w.Top) / (double)sy) * sy;
|
|
if (x != r.Left || y != r.Top)
|
|
SetWindowPos(hwnd, IntPtr.Zero, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
const int HTLEFT = 10, HTRIGHT = 11, HTTOP = 12, HTTOPLEFT = 13, HTTOPRIGHT = 14, HTBOTTOM = 15, HTBOTTOMLEFT = 16, HTBOTTOMRIGHT = 17;
|
|
|
|
int EdgeHit(IntPtr hwnd, IntPtr l)
|
|
{
|
|
if (!GetWindowRect(hwnd, out var r)) return 0;
|
|
long lp = l.ToInt64();
|
|
int x = (short)(lp & 0xFFFF), y = (short)((lp >> 16) & 0xFFFF);
|
|
double scale = PresentationSource.FromVisual(this)?.CompositionTarget?.TransformToDevice.M11 ?? 1;
|
|
int edge = (int)Math.Ceiling(ResizeEdge * scale);
|
|
|
|
bool left = x < r.Left + edge, right = x >= r.Right - edge;
|
|
bool top = y < r.Top + edge, bottom = y >= r.Bottom - edge;
|
|
if (top && left) return HTTOPLEFT;
|
|
if (top && right) return HTTOPRIGHT;
|
|
if (bottom && left) return HTBOTTOMLEFT;
|
|
if (bottom && right) return HTBOTTOMRIGHT;
|
|
if (left) return HTLEFT;
|
|
if (right) return HTRIGHT;
|
|
if (top) return HTTOP;
|
|
if (bottom) return HTBOTTOM;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|