From 0c1cf19ab2e1d372971b58b9ecc90148f9470d18 Mon Sep 17 00:00:00 2001
From: snekxs <26660858+snekxs@users.noreply.github.com>
Date: Wed, 21 Oct 2026 18:13:58 -0600
Subject: [PATCH 1/2] Add angle tuning and magnetic button controls

- Angle tuning: a -30 to +30 degree slider on the Performance tab for
  every mouse whose driver reports an angle.
- Magnetic buttons (G-Wolves, Lamzu): per-button switch type, trigger
  point, release point, rapid trigger toggle and sensitivity on the
  Advanced tab. Flipping rapid trigger rebuilds the page so the
  sensitivity slider appears or disappears.
- OPENMOUSE_MOCK=mag adds a fake Hall-effect mouse for looking at these.
---
 gpui/js/controls.ts | 128 +++++++++++++++++++++++++++++++++++++++++++-
 gpui/js/entry.ts    |   7 +--
 gpui/js/mock.ts     |  40 ++++++++++++--
 3 files changed, 168 insertions(+), 7 deletions(-)

diff --git a/gpui/js/controls.ts b/gpui/js/controls.ts
index ed0ac68..f0c0297 100644
--- a/gpui/js/controls.ts
+++ b/gpui/js/controls.ts
@@ -400,6 +400,114 @@ const GENERIC: GenericSpec[] = [
 
 const titleCase = (value: string) => value.charAt(0).toUpperCase() + value.slice(1);
 
+/**
+ * Hall-effect primary buttons (G-Wolves, Lamzu): where the click registers,
+ * rapid trigger, and which switch each button uses. `mag.<field>.<button>`,
+ * with button 0 the left and 1 the right.
+ */
+function magneticControls(s: any): Section[] {
+  const m = s.magneticButtons;
+  if (!m || !Array.isArray(m.buttons) || m.buttons.length === 0) return [];
+  const rtUnit = m.rapidTriggerUnit === "ms" ? "ms" : undefined;
+  return m.buttons.map((b: any, i: number): Section => {
+    const controls: Control[] = [];
+    if (m.canChooseSwitchType && b.switchType) {
+      controls.push({
+        id: `mag.switch.${i}`,
+        label: "Switch",
+        description: "Magnetic needs a calibrated mouse.",
+        kind: "choice",
+        options: [{ value: "magnetic", label: "Magnetic" }, { value: "optical", label: "Optical" }],
+        current: b.switchType,
+      });
+    }
+    if (b.triggerPoint != null && m.triggerPointRange) {
+      controls.push({
+        id: `mag.trigger.${i}`,
+        label: "Trigger point",
+        description: "How far the button travels before it clicks. Lower is lighter.",
+        kind: "number",
+        min: m.triggerPointRange.min,
+        max: m.triggerPointRange.max,
+        step: 1,
+        current: b.triggerPoint,
+      });
+    }
+    if (m.releasePointRange) {
+      controls.push({
+        id: `mag.release.${i}`,
+        label: "Release point",
+        description: "How far the button travels back before it releases.",
+        kind: "number",
+        min: m.releasePointRange.min,
+        max: m.releasePointRange.max,
+        step: 1,
+        current: b.releasePoint ?? b.triggerPoint ?? m.releasePointRange.min,
+      });
+    }
+    if (m.rapidTriggerRange) {
+      const on = b.rapidTriggerEnabled ?? (b.rapidTrigger != null && b.rapidTrigger > 0);
+      controls.push({ id: `mag.rtOn.${i}`, label: "Rapid trigger", description: "Re-clicks the moment the button moves back up.", kind: "toggle", current: Boolean(on) });
+      if (on) {
+        controls.push({
+          id: `mag.rt.${i}`,
+          label: "Rapid trigger sensitivity",
+          kind: "number",
+          min: m.rapidTriggerRange.min,
+          max: m.rapidTriggerRange.max,
+          step: 1,
+          unit: rtUnit,
+          current: b.rapidTrigger ?? m.rapidTriggerRange.min,
+        });
+      }
+    } else if (m.rapidTriggerSwitch === false || b.rapidTrigger != null) {
+      controls.push({ id: `mag.info.rt${i}`, label: "Rapid trigger", description: "Can only be changed with the mouse on its cable.", kind: "info", current: b.rapidTriggerEnabled ? "On" : "Off" });
+    }
+    return { title: m.buttons.length === 2 ? `${i === 0 ? "Left" : "Right"} button` : `Button ${i + 1}`, controls };
+  }).filter((section: Section) => section.controls.length > 0);
+}
+
+/** Writes one magnetic control; the driver confirms by reading the value back. */
+async function writeMagnetic(info: HidInterfaceInfo, status: any, id: string, value: any) {
+  const [, field, rawButton] = id.split(".");
+  const button = Number(rawButton) as 0 | 1;
+  const m = status.magneticButtons;
+  const b = m?.buttons?.[button];
+  if (!m || !b) throw new Error("This mouse's button settings aren't loaded yet.");
+  const min = m.rapidTriggerRange?.min ?? 1;
+  switch (field) {
+    case "trigger":
+      await callClientMethod(info, "setMagneticTriggerPoint", button, Math.round(Number(value)));
+      b.triggerPoint = Math.round(Number(value));
+      return;
+    case "release":
+      await callClientMethod(info, "setMagneticReleasePoint", button, Math.round(Number(value)));
+      b.releasePoint = Math.round(Number(value));
+      return;
+    case "rtOn": {
+      const level = b.rapidTrigger != null && b.rapidTrigger >= min ? b.rapidTrigger : min;
+      await callClientMethod(info, "setMagneticRapidTrigger", button, Boolean(value), level);
+      b.rapidTriggerEnabled = Boolean(value);
+      b.rapidTrigger = level;
+      return;
+    }
+    case "rt":
+      await callClientMethod(info, "setMagneticRapidTrigger", button, true, Math.round(Number(value)));
+      b.rapidTriggerEnabled = true;
+      b.rapidTrigger = Math.round(Number(value));
+      return;
+    case "switch": {
+      const types = m.buttons.map((x: any) => x.switchType);
+      types[button] = String(value);
+      await callClientMethod(info, "setMagneticSwitchTypes", types);
+      b.switchType = String(value);
+      return;
+    }
+    default:
+      throw new Error(`Unknown magnetic control ${id}`);
+  }
+}
+
 function genericFeatures(status: any): Section[] {
   const sections = new Map<string, Control[]>();
   for (const spec of GENERIC) {
@@ -500,6 +608,22 @@ function performanceExtras(status: any, caps: DeviceCapabilities): Section[] {
     }
   }
 
+  // Rotates the sensor's idea of "straight". Every driver that reports it takes
+  // whole degrees and checks its own limits when written.
+  if (typeof status.angleTuning === "number") {
+    c.push({
+      id: "perf.angleTuning",
+      label: "Angle tuning",
+      description: "Rotates the sensor to correct for how you hold the mouse. 0° is off.",
+      kind: "number",
+      min: -30,
+      max: 30,
+      step: 1,
+      unit: "°",
+      current: status.angleTuning,
+    });
+  }
+
   if (Array.isArray(status.dpiStages) && status.dpiStages.length > 1) {
     c.push({
       id: "perf.dpiStage",
@@ -590,7 +714,7 @@ function performanceExtras(status: any, caps: DeviceCapabilities): Section[] {
 export function describeControls(brand: string, status: any, caps: DeviceCapabilities) {
   return {
     buttons: [...razerAndEgg(brand, status), ...genericButtons(status)],
-    advanced: [...advanced(status, brand), ...hits(status, brand), ...extras(status), ...genericFeatures(status), ...deviceInfo(status)],
+    advanced: [...advanced(status, brand), ...hits(status, brand), ...magneticControls(status), ...extras(status), ...genericFeatures(status), ...deviceInfo(status)],
     performance: performanceExtras(status, caps),
     lighting: status.lighting ?? null,
   };
@@ -637,6 +761,7 @@ export async function writeControl(info: HidInterfaceInfo, status: any, id: stri
   // The shared remapper: the button's display label is the part after the slash.
   if (id.startsWith("gen.button/")) return w.setButtonMapping(info, id.slice("gen.button/".length), value);
   if (id.startsWith("hits.")) return writeHits(info, status, id, value);
+  if (id.startsWith("mag.") && !id.startsWith("mag.info.")) return writeMagnetic(info, status, id, value);
   // Table-driven generic setting: `gen.set/<field>/<method>`.
   if (id.startsWith("gen.set/")) return callClientMethod(info, id.split("/")[2], value);
   const [family, kind, rest] = id.split(".");
@@ -723,6 +848,7 @@ export async function writeControl(info: HidInterfaceInfo, status: any, id: stri
     case "perf.sleep": return w.setSleepTimeout(info, Number(value));
     case "perf.motionSync": return w.setMotionSync(info, Boolean(value));
     case "perf.angleSnapping": return w.setAngleSnapping(info, Boolean(value));
+    case "perf.angleTuning": await callClientMethod(info, "setAngleTuning", Math.round(Number(value))); status.angleTuning = Math.round(Number(value)); return;
     case "perf.rippleControl": return w.setRippleControl(info, Boolean(value));
     case "perf.performanceMode": return w.setPerformanceMode(info, Boolean(value));
     case "perf.dpiStage": return w.setActiveDpiStage(info, Number(value));
diff --git a/gpui/js/entry.ts b/gpui/js/entry.ts
index 2905057..c94cd23 100644
--- a/gpui/js/entry.ts
+++ b/gpui/js/entry.ts
@@ -146,9 +146,10 @@ const mockWanted = (): string => String((globalThis as any).__mock ?? "");
       const status = lastStatus.get(key) ?? {};
       const id = action.slice("control:".length);
       await writeControl(info, status, id, value);
-      // A few controls decide which others are shown (an Starlight X switch in
-      // TMR mode gains its analog settings); their write returns the new layout.
-      if (id.startsWith("slx.mode") || id === "slx.link" || id === "hits.link") return JSON.stringify({ tabs: describeControls(brand, status, lastCaps.get(key)) });
+      // A few controls decide which others are shown (a Starlight X switch in
+      // TMR mode gains its analog settings, a magnetic button's rapid trigger its
+      // sensitivity); their write returns the new layout.
+      if (id.startsWith("slx.mode") || id === "slx.link" || id === "hits.link" || id.startsWith("mag.rtOn.")) return JSON.stringify({ tabs: describeControls(brand, status, lastCaps.get(key)) });
       return JSON.stringify(value);
     }
     if (action === "lighting") {
diff --git a/gpui/js/mock.ts b/gpui/js/mock.ts
index 4b1bb9b..5eba859 100644
--- a/gpui/js/mock.ts
+++ b/gpui/js/mock.ts
@@ -1,5 +1,5 @@
 // A fake Finalmouse Starlight X for looking at the UI without hardware
-// (OPENMOUSE_MOCK=slx, ulx or x3; a trailing "!" hides the real devices). Nothing here talks to a device: writes are accepted
+// (OPENMOUSE_MOCK=slx, ulx, x3 or mag; a trailing "!" hides the real devices). Nothing here talks to a device: writes are accepted
 // and only the in-memory status changes.
 
 export const isMockKey = (key: string) => key.startsWith("mock:");
@@ -14,15 +14,19 @@ export const mockCandidates = (wanted: string) => [
     info: { key: "mock:ulx", vendorId: 0x361d, productId: 0x0100, productString: "Finalmouse UltralightX (mock)", manufacturerString: "Finalmouse", collections: [] },
     brands: ["Finalmouse"],
   }] : []),
+  ...(wanted.includes("mag") ? [{
+    info: { key: "mock:mag", vendorId: 0x373b, productId: 0x1000, productString: "Magnetic mouse (mock)", manufacturerString: "Lamzu", collections: [] },
+    brands: ["Lamzu"],
+  }] : []),
   ...(wanted.includes("x3") ? [{
     info: { key: "mock:x3", vendorId: 0x046d, productId: 0xc0a9, productString: "PRO X 3 Superstrike (mock)", manufacturerString: "Logitech", collections: [] },
     brands: ["Logitech"],
   }] : []),
 ];
 
-export const mockBrand = (key: string) => (key === "mock:x3" ? "Logitech" : "Finalmouse");
+export const mockBrand = (key: string) => (key === "mock:x3" ? "Logitech" : key === "mock:mag" ? "Lamzu" : "Finalmouse");
 
-export const mockStatus = (key: string) => (key === "mock:x3" ? mockX3() : key === "mock:ulx" ? mockUlx() : mockSlx());
+export const mockStatus = (key: string) => (key === "mock:x3" ? mockX3() : key === "mock:mag" ? mockMag() : key === "mock:ulx" ? mockUlx() : mockSlx());
 
 // Ultralight X as FinalmouseHidClient.readStatus() reports it: the whole
 // polling ladder and Motion Sync are adjustable, lift-off is the legacy 1/2 mm
@@ -53,6 +57,36 @@ const mockUlx = () => ({
   firmware: ["Mouse 1.0.8", "Dongle RF 1.0.3", "Dongle USB 1.0.5"],
 });
 
+// A Hall-effect mouse as the Lamzu driver reports it: per-button trigger and
+// release travel, rapid trigger in ms with no switch of its own, selectable
+// switch type, and a sensor angle.
+const mockMag = () => ({
+  brand: "Lamzu",
+  name: "Magnetic mouse",
+  batteryPercent: 77,
+  batteryState: "Discharging",
+  connectionType: "Wireless",
+  dpi: 1600,
+  pollingRateHz: 1000,
+  supportedPollingRates: [500, 1000, 2000, 4000],
+  activeProfile: 1,
+  angleTuning: 5,
+  magneticButtons: {
+    buttons: [
+      { switchType: "magnetic", triggerPoint: 3, releasePoint: 3, rapidTrigger: 4, rapidTriggerEnabled: true },
+      { switchType: "magnetic", triggerPoint: 5, releasePoint: null, rapidTrigger: null, rapidTriggerEnabled: false },
+    ],
+    triggerPointRange: { min: 1, max: 10 },
+    releasePointRange: { min: 1, max: 10 },
+    rapidTriggerRange: { min: 1, max: 15 },
+    rapidTriggerUnit: "ms",
+    rapidTriggerSwitch: false,
+    canChooseSwitchType: true,
+    calibration: "calibrated",
+    liveDepth: false,
+  },
+});
+
 const mockX3 = () => ({
   brand: "Logitech",
   name: "PRO X 3 Superstrike",

From c8dcccf0ec70116e5befe61fe85c26329d394fd3 Mon Sep 17 00:00:00 2001
From: snekxs <26660858+snekxs@users.noreply.github.com>
Date: Thu, 22 Oct 2026 01:26:08 -0600
Subject: [PATCH 2/2] Only show angle tuning for drivers that can write it

ATK, Ninjutso, Orbital, Wallhack, Endgame Gear and the other brands report the
angle but have no setAngleTuning, so the slider would fail on every write.
Gate on the brands whose drivers implement it (MCHOSE, Pulsar Pro, WLMouse);
the mock still shows it.
---
 gpui/js/controls.ts | 17 ++++++++++++-----
 gpui/js/mock.ts     |  1 +
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/gpui/js/controls.ts b/gpui/js/controls.ts
index f0c0297..ee0b1a6 100644
--- a/gpui/js/controls.ts
+++ b/gpui/js/controls.ts
@@ -578,7 +578,14 @@ function withCurrent(steps: readonly number[], current: number | null | undefine
  * field the driver reports, minus whatever the driver's own `ui` hints hide — and
  * all of them apply immediately, as they do there.
  */
-function performanceExtras(status: any, caps: DeviceCapabilities): Section[] {
+/** Brands whose drivers implement `setAngleTuning` (the others only report the angle). */
+const ANGLE_TUNING_WRITERS = new Set(["MCHOSE", "Pulsar", "WLMouse"]);
+
+function canWriteAngleTuning(brand: string, status: any): boolean {
+  return ANGLE_TUNING_WRITERS.has(brand) || status.mockAngleTuningWritable === true;
+}
+
+function performanceExtras(brand: string, status: any, caps: DeviceCapabilities): Section[] {
   const ui = status.ui ?? {};
   const c: Control[] = [];
 
@@ -608,9 +615,9 @@ function performanceExtras(status: any, caps: DeviceCapabilities): Section[] {
     }
   }
 
-  // Rotates the sensor's idea of "straight". Every driver that reports it takes
-  // whole degrees and checks its own limits when written.
-  if (typeof status.angleTuning === "number") {
+  // Rotates the sensor's idea of "straight", in whole degrees; the driver checks
+  // its own limits when written. Only some drivers that report it can write it.
+  if (typeof status.angleTuning === "number" && canWriteAngleTuning(brand, status)) {
     c.push({
       id: "perf.angleTuning",
       label: "Angle tuning",
@@ -715,7 +722,7 @@ export function describeControls(brand: string, status: any, caps: DeviceCapabil
   return {
     buttons: [...razerAndEgg(brand, status), ...genericButtons(status)],
     advanced: [...advanced(status, brand), ...hits(status, brand), ...magneticControls(status), ...extras(status), ...genericFeatures(status), ...deviceInfo(status)],
-    performance: performanceExtras(status, caps),
+    performance: performanceExtras(brand, status, caps),
     lighting: status.lighting ?? null,
   };
 }
diff --git a/gpui/js/mock.ts b/gpui/js/mock.ts
index 5eba859..3dfe0ab 100644
--- a/gpui/js/mock.ts
+++ b/gpui/js/mock.ts
@@ -71,6 +71,7 @@ const mockMag = () => ({
   supportedPollingRates: [500, 1000, 2000, 4000],
   activeProfile: 1,
   angleTuning: 5,
+  mockAngleTuningWritable: true,
   magneticButtons: {
     buttons: [
       { switchType: "magnetic", triggerPoint: 3, releasePoint: 3, rapidTrigger: 4, rapidTriggerEnabled: true },