4c264b8c697dbad81bf8f06c822f8fef8e8a97e3
7
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
4c264b8c69 |
Port the PlanarEllipse tangent-geom variant and full OSNAP ellipse fix
Completes the OSNAP intersection port from
|
||
|
|
44deee2ac9 |
Port 6 audit-found bugs from the upstream OSNAP fix branch
Ports the fixes from fix/osnap-circle-arc-ellipse-intersection (and this session's audit follow-up) onto this branch. All are independent correctness/reliability fixes, unrelated to the parametric-constraint- system work also in progress here. 1. OSNAP Intersection snap used a tessellated approximation instead of exact geometry (GitHub discussion #1052): a circle/arc always tessellates at a fixed 48 segments in the resident wire set regardless of radius or zoom, so every circle/arc intersection snap was off by construction. Added exact_circle_intersections, a closed-form, frame-independent circle/arc-vs-circle/arc solver, wired into both Intersection-snap code paths ahead of the tessellated sweep. This branch's TangentGeom predates the PlanarEllipse variant added upstream, so the ellipse/line generalization from the upstream fix isn't ported here — this covers the literal reported bug (a circle-circle case) using only variants this branch already has. 2. Unbounded MINSERT allocation: array_offsets() reserved one Vec element per array instance with row/column counts parsed as unchecked u16s — a corrupt 65535x65535 pair requests ~96 GiB. Fixed with a documented instance budget (20,000), enforced at both the load-time corrupt-entity filter and a render-graph failsafe. 3. MINSERT spacing was scaled by the block's own scale: insert_instance_transform composed the offset translation before the instance transform, so x/y block scale multiplied the row/ column spacing too. Fixed by orienting the offset with rotation + OCS only, then translating the already-scaled instance transform. 4. Automation "open" skipped the finalization (block-origin normalization, raster-path resolution, source_path) and corrupt- entity purge a UI open always runs. Added io::load_bytes_finalized(path, bytes), used by automation's "open" handler, which now also reports the purge count. 5. Material maps were uploaded without checking device.limits().max_texture_dimension_2d, unlike raster-image rendering (which already tiles to that limit). A mesh material is sampled by UV, so it can't use the same tiling trick — instead, upload_rgba_texture now downscales an oversized image before upload, falling back to the 1x1 material color if malformed. 6. Sketch-constraint persistence/undo, audit-found while reviewing this branch's own constraint system: - Clearing every constraint in a scope after a prior non-empty save left the stale XRecord in place, resurrecting the deleted constraints on the next load. materialize_sketch_constraints_for_ save now actively removes the XRecord when a scope goes back to empty. - ERASE removing an entity took its constraints with it (design doc's deletion policy), but sketch_constraints lives on Scene, outside document/document.objects, so nothing captured that mutation for undo — the erased geometry came back on undo, but its constraints didn't. refresh_sketch_constraints's deletion pass now records the touched scope's before-image into the same UndoRecording the entity removal rides in, threaded through a new sketch_constraints channel on DeltaSnapshot, so one undo restores both together. HistorySnapshot::Delta is now boxed (clippy flagged the resulting size skew across undo/redo stack variants). 31 new/adapted tests across all six fixes. Full workspace suite passes except the one pre-existing, unrelated font-test failure also present on main. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
|
63a74b19a9 |
Add persistent sketch-constraint system (ocs_gcs port) and named-parameters handoff docs
Ports FreeCAD's planegcs 2D geometric constraint solver to Rust as a new crates/ocs_gcs workspace member, and wires it into the document/scene model as a persistent SketchConstraintSet: Coincident, Horizontal/Vertical, Parallel/Perpendicular, Equal, Tangent, Distance, Angle and Radius constraints that re-solve live (including mid-drag, not just on release), render glyphs and a DOF badge, flag conflicts with a one-click resolver pill, and round-trip through save/load via an XRecord blob. Also includes docs/command_reference.md (a statically generated reference of every registered command and its prompt sequence) and docs/named_parameters_design.md + docs/backlog.md, which hand off the next queued feature (a named-parameter/expression table) and consolidate every deliberate scope-down and open gap found along the way, so a fresh session has a complete starting point. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
|
a39c7b8f71 |
macOS launcher: re-assert Accessory policy after handling an event
Handling a document-open Apple Event (a warm "Open With" while the app is already running) silently promotes this process from NSApplicationActivationPolicyAccessory to a normal foreground app — confirmed with lsappinfo, not assumed: its own entry flips from type="UIElement" to type="Foreground" the instant it handles a second Apple Event (a cold launch's own first event doesn't trigger this). That gave the launcher its own, contentless Dock icon sitting next to the real editor's, both apparently "the same app" to the user but actually two separate Dock entries. Re-set Accessory explicitly right after relaying, in the one place every open (cold fallback, document open, and reopen-while-running) already funnels through. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
|
24e9a7663d |
macOS launcher: handle reopen while already running with no window
Quitting the real GUI binary (Cmd+Q) leaves the launcher itself still running — that's by design, so it can keep relaying opens for the session. But reopening the app afterward (Dock icon, double-clicking it in Finder again) reactivates that same long-lived launcher process rather than triggering a fresh cold launch, since Launch Services still considers the bundle running. Neither of the delegate methods already handled covered that: applicationDidFinishLaunching: only fires once, at the launcher's own original cold start, and application:openURLs: only fires when a document was named. The net effect: the Dock icon would appear, but no window ever showed. applicationShouldHandleReopen:hasVisibleWindows: is exactly the callback AppKit fires for this reactivation case. Reproduced and verified the fix against the real sequence (cold launch, kill only the GUI process to simulate Cmd+Q, reopen) rather than assuming it from the delegate method's docs alone. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
|
e767507850 |
macOS: add a launcher shim so a cold Finder open also works (#1039)
The previous commit's Apple Event handler only ever catches an open sent to an already-running process. A cold double-click (app not running yet) still failed: every registration point tried inside the real binary — before app::run(), on the Subscription's first poll, even the literal first statement of main() — reliably caught a warm open but never the original cold-launch event. A raw AEInstallEventHandler in a separate, minimal, non-AppKit process (no winit/iced, just a manual CFRunLoopRunInMode pump) still missed it too, ruling out "the real binary's heavy dependency graph loading before main() wins the race" as the explanation. What does reliably catch a cold launch, verified against real Finder-equivalent opens: a from-scratch NSApplication with its own delegate implementing application:openURLs: — in a process where we own setDelegate: from the start, with no contention over the single delegate slot winit already claims. That has to be a separate process from the real GUI binary (only one -[NSApplication run] call can own a process), so src/bin/ocs_launcher.rs is now the .app's actual CFBundleExecutable: a small, dependency-light binary (no iced, wgpu, or cadkernel) whose only job is to catch the open and relay it. Relaying by replacing this process's image (exec, same PID) or by spawning a child and exiting turned out to both be dead ends: Launch Services tracks "the running instance of this bundle" by the Application Serial Number it handed out to whichever process it actually launched — this launcher, not whatever it execs into or spawns. Once the launcher's own ASN stopped pointing at a live, listening process, every later open Finder tried to deliver silently went nowhere (measured with lsappinfo against a real second "Open With", not assumed). So the launcher now stays running for the app's session — invisible, via NSApplicationActivationPolicyAccessory, since it owns no window — and relays every open (cold or warm) over the same channel a second CLI invocation already uses: io::single_instance. That relay only worked once single_instance's rendezvous key stopped being computed from the running executable's own path. That was fine when one binary always did the job, but the launcher and the real binary are different executables and independently computed different ports, so they could never find each other. Anchor the key on the enclosing .app bundle instead, shared by both. packaging/build_macos_signed.sh and .github/workflows/release.yml now build ocs_launcher and place it at Contents/MacOS/OpenCADStudio (the CFBundleExecutable Info.plist already names), with the real GUI binary renamed to Contents/MacOS/OpenCADStudio-App alongside it. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |
||
|
|
b617734d5c |
macOS: catch a Finder open aimed at the already-running app (#1039)
Double-click / "Open With" never puts the file on argv — Finder always delivers it as a kAEOpenDocuments Apple Event instead, which nothing in this app listened for, so it just showed "cannot open files in this format" even though the file association itself was registered correctly. The standard fix, implementing application:openURLs: on this app's own NSApplicationDelegate, isn't available here: winit already installs its own delegate to own window/lifecycle events, NSApplication has exactly one delegate slot, and winit's class doesn't implement the open-document method. This bypasses the delegate protocol and registers directly with the lower-level Apple Event Manager (AEInstallEventHandler) instead — the same mechanism AppKit's delegate forwarding is itself built on, and independent of who owns the delegate. Registration happens on the iced Subscription's first poll rather than in main() before app::run() — registering earlier gets silently overwritten by winit's own NSApplication startup, confirmed by testing against a real `open -a` rather than assumed from Apple's docs. This handles a file opened while the app is already running. A cold launch (app not running yet) needs a different mechanism, in the following commit. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> |