From Cargo to a Mac Application: a Rust Program with an AppKit Window and No Crates

objc_msgSend(window, sel_registerName("setTitle:"), title);

extern "C" { fn objc_msgSend(); }

unsafe fn send1<A, R>(o: Id, s: Sel, a: A) -> R {
    let f: unsafe extern "C" fn(Id, Sel, A) -> R =
        std::mem::transmute(objc_msgSend as unsafe extern "C" fn());
    f(o, s, a)
}

// kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Little
const BITMAP_INFO: u32 = 6 | (2 << 12);

loop {
    poll()      take every queued event; hand each to [NSApp sendEvent:]
    update      the program's state from the inputs
    draw        into the buffer
    present()   wrap the buffer as an image; give it to the view
    sleep       1/30 s (orbit), 1/12 s (orrery)
}

fn present(&mut self) {
    unsafe {
        let pool = objc_autoreleasePoolPush();
        // ... CGImageCreate, NSImage, setImage: ...
        objc_autoreleasePoolPop(pool);
    }
}

Orbit.app/
  Contents/
    Info.plist          name, identifier, which file to run, icon, version
    MacOS/orbit         the executable named by CFBundleExecutable
    Resources/orbit.icns
    _CodeSignature/     written by codesign

#!/bin/sh
export PATH="$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"
exec "$(dirname "$0")/orrery" --gui --operator paul ... >>"$HOME/Library/Logs/orrery.log" 2>&1

                 +------------------------------------------+
   the program   |  main.rs: the loop  poll > update > draw   |
                 |           > present > sleep                |
                 +------------------+-----------------------+
                                    | Surface (surface.rs)
                 +------------------+-------------------+
                 |                                     |
        +--------v---------+                 +---------v--------+
        | mac.rs (macOS)   |                 | Offscreen        |
        | NSApplication,   |                 | a Vec<u32>;      |
        | NSWindow,        |                 | --frame F.ppm    |
        | NSImageView,     |                 +------------------+
        | CGImage, events, |    (orrery: wl.rs, a Wayland client,
        | autorelease pool |     is a third implementation)
        +--------+---------+
                 | objc_msgSend, Core Graphics
        +--------v---------+
        | AppKit, libobjc, |    on every Mac; declared, not fetched
        | CoreGraphics     |
        +------------------+

   draw.rs: fn frame(px: &mut [u32], w, h, &State)   no platform at all

   mac-app.sh:  cargo build --release > Orbit.app/{Info.plist, MacOS, Resources}
                > codesign (binary, then bundle) > ~/Applications

orbit/
  Cargo.toml          [dependencies] empty; release: lto, one codegen unit, strip
  src/main.rs         the loop, the --frame mode, the platform choice (#[cfg])
  src/surface.rs      Input, the Surface trait, Offscreen
  src/draw.rs         State, and frame(): pixels from state
  src/mac.rs          #![cfg(target_os = "macos")]: the AppKit window
  mac-app.sh          the bundle, the icon, the signature

cargo new orbit && cd orbit

cargo run -- --frame frame.ppm && open frame.ppm

cargo run --release      # Escape, Command-Q or the close button quits

./target/release/orbit & P=$!
for i in 1 2 3 4 5 6; do ps -o rss= -p $P; sleep 5; done; kill $P

sh mac-app.sh            # ~/Applications/Orbit.app
codesign -v --deep ~/Applications/Orbit.app && open ~/Applications/Orbit.app

# orbit -- the smallest program with orrery's shape: a Rust loop that draws
# into its own pixels and shows them in an AppKit window, with no crates.
# docs/appkit-gui-lab-report.md teaches it a part at a time.
[package]
name = "orbit"
version = "0.1.0"
edition = "2021"
license = "MIT"

# Empty, and that is the point: AppKit, Foundation, CoreGraphics and the
# Objective-C runtime are on every Mac, and src/mac.rs declares what it uses.
[dependencies]

[profile.release]
lto = true
codegen-units = 1
strip = true

//! orbit: a Rust program with a Mac window and no crates.
//!
//!     orbit                 the window (Escape, Command-Q or the close button quits;
//!                           a click stops and starts the turning)
//!     orbit --frame F.ppm   one frame to a file, no window
//!
//! The loop is the program's: poll, change the state, draw, present, sleep.
//! AppKit is only asked for a window, events and a place to put pixels.

mod draw;
#[cfg(target_os = "macos")]
mod mac;
mod surface;

use surface::{Input, Offscreen, Surface};
use std::time::{Duration, Instant};

const FPS: u64 = 30;

/// The window's loop, written once against `Surface`.
fn run<S: Surface>(mut s: S) {
    let mut st = draw::State::default();
    let mut last = Instant::now();
    loop {
        for input in s.poll() {
            match input {
                Input::Closed | Input::Escape | Input::Key { ch: 'q', cmd: true } => return,
                Input::Moved { x, y } => st.pointer = Some((x, y)),
                Input::Clicked { x, y } => {
                    st.pointer = Some((x, y));
                    st.paused = !st.paused;
                }
                Input::Resized => s.apply_resize(),
                Input::Key { .. } => {}
            }
        }
        let now = Instant::now();
        if !st.paused {
            st.turned += (now - last).as_secs_f64();
        }
        last = now;
        let (w, h) = s.size();
        draw::frame(s.pixels(), w, h, &st);
        s.present();
        std::thread::sleep(Duration::from_millis(1000 / FPS));
    }
}

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if let Some(i) = args.iter().position(|a| a == "--frame") {
        let path = args.get(i + 1).expect("--frame needs a file");
        let mut s = Offscreen::new(800, 500);
        let st = draw::State { pointer: Some((560, 140)), paused: false, turned: 3.0 };
        let (w, h) = s.size();
        draw::frame(s.pixels(), w, h, &st);
        s.write_ppm(path).expect("write the frame");
        return;
    }
    #[cfg(target_os = "macos")]
    run(mac::Window::open("orbit", 800, 500));
    #[cfg(not(target_os = "macos"))]
    {
        let _ = run::<Offscreen>;
        eprintln!("orbit: the window is macOS's; --frame works anywhere");
    }
}

//! The seam between the drawing and whatever shows it.
//!
//! The drawing (`draw.rs`) knows nothing about windows: it writes pixels into
//! a buffer. A platform is anything that can hand over a buffer, take it back
//! to show, and say what the person did. The Mac window is one (`mac.rs`); a
//! file is another (`Offscreen`), which is how a frame is looked at with no
//! window at all.

/// What the person did, in the program's own words, not AppKit's.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Input {
    /// The pointer, in canvas pixels, top left at (0, 0).
    Moved { x: i32, y: i32 },
    Clicked { x: i32, y: i32 },
    /// A typed character; `cmd` when Command was held.
    Key { ch: char, cmd: bool },
    Escape,
    Resized,
    Closed,
}

pub trait Surface {
    /// `width * height` words of `0x00RRGGBB`, native-endian.
    fn pixels(&mut self) -> &mut [u32];
    fn size(&self) -> (usize, usize);
    /// Everything that happened since the last call. Never blocks.
    fn poll(&mut self) -> Vec<Input>;
    /// Adopt the size the platform asked for.
    fn apply_resize(&mut self);
    /// Hand the pixels over to be shown.
    fn present(&mut self);
}

/// A surface that is only a buffer: `--frame PATH` draws into it and writes
/// a PPM, so every picture can be made without a screen.
pub struct Offscreen {
    pub w: usize,
    pub h: usize,
    pub px: Vec<u32>,
}

impl Offscreen {
    pub fn new(w: usize, h: usize) -> Offscreen {
        Offscreen { w, h, px: vec![0; w * h] }
    }

    pub fn write_ppm(&self, path: &str) -> std::io::Result<()> {
        let mut out = format!("P6\n{} {}\n255\n", self.w, self.h).into_bytes();
        for &p in &self.px {
            out.extend_from_slice(&[(p >> 16) as u8, (p >> 8) as u8, p as u8]);
        }
        std::fs::write(path, out)
    }
}

impl Surface for Offscreen {
    fn pixels(&mut self) -> &mut [u32] {
        &mut self.px
    }
    fn size(&self) -> (usize, usize) {
        (self.w, self.h)
    }
    fn poll(&mut self) -> Vec<Input> {
        Vec::new()
    }
    fn apply_resize(&mut self) {}
    fn present(&mut self) {}
}

//! The drawing: a software canvas, no platform in sight.
//!
//! An orrery: a sun and three bodies on their orbits, turning with time, and
//! a ring where the pointer is. A click stops and starts it.

pub const PAPER: u32 = 0xFCE2AB;
pub const INK: u32 = 0x121212;
pub const LINE: u32 = 0xC4A870;
pub const ACCENT: u32 = 0x87704F;
pub const SUN: u32 = 0xF0A03A;
pub const BRASS: u32 = 0xB06A24;

/// What the drawing remembers between frames.
pub struct State {
    pub pointer: Option<(i32, i32)>,
    pub paused: bool,
    /// Seconds of turning, which stops while paused.
    pub turned: f64,
}

impl Default for State {
    fn default() -> Self {
        State { pointer: None, paused: false, turned: 0.0 }
    }
}

/// Fill a disc, clipped to the canvas.
fn disc(px: &mut [u32], w: usize, h: usize, cx: f64, cy: f64, r: f64, c: u32) {
    let (x0, x1) = ((cx - r).floor().max(0.0) as usize, ((cx + r).ceil() as usize).min(w));
    let (y0, y1) = ((cy - r).floor().max(0.0) as usize, ((cy + r).ceil() as usize).min(h));
    for y in y0..y1 {
        for x in x0..x1 {
            let (dx, dy) = (x as f64 + 0.5 - cx, y as f64 + 0.5 - cy);
            if dx * dx + dy * dy <= r * r {
                px[y * w + x] = c;
            }
        }
    }
}

/// An ellipse's outline, as dots close enough to read as a line.
fn ring(px: &mut [u32], w: usize, h: usize, cx: f64, cy: f64, a: f64, b: f64, c: u32) {
    let steps = (a.max(b) * 8.0) as usize;
    for i in 0..steps {
        let t = i as f64 / steps as f64 * std::f64::consts::TAU;
        let (x, y) = (cx + a * t.cos(), cy + b * t.sin());
        if x >= 0.0 && y >= 0.0 && (x as usize) < w && (y as usize) < h {
            px[y as usize * w + x as usize] = c;
        }
    }
}

/// One frame, from the state alone. Called by the window and by `--frame`.
pub fn frame(px: &mut [u32], w: usize, h: usize, st: &State) {
    px.fill(PAPER);
    let (cx, cy) = (w as f64 / 2.0, h as f64 / 2.0);
    let unit = w.min(h) as f64 / 400.0;
    // (orbit radius, period in seconds, body radius, colour)
    let bodies = [(70.0, 4.0, 8.0, ACCENT), (120.0, 9.0, 12.0, INK), (175.0, 17.0, 7.0, BRASS)];
    for &(r, _, _, _) in &bodies {
        ring(px, w, h, cx, cy, r * unit, r * unit * 0.45, LINE);
    }
    disc(px, w, h, cx, cy, 30.0 * unit, BRASS);
    disc(px, w, h, cx, cy, 26.0 * unit, SUN);
    for &(r, period, size, c) in &bodies {
        let t = st.turned / period * std::f64::consts::TAU;
        let (x, y) = (cx + r * unit * t.cos(), cy + r * unit * 0.45 * t.sin());
        disc(px, w, h, x, y, size * unit, c);
    }
    if let Some((x, y)) = st.pointer {
        ring(px, w, h, x as f64, y as f64, 14.0 * unit, 14.0 * unit, if st.paused { BRASS } else { ACCENT });
    }
}

//! An AppKit window, by message sends alone.
//!
//! No Objective-C class is defined: AppKit never calls into Rust. The program
//! owns the loop, and everything it needs is a message it sends or a thing
//! it polls:
//!
//!     a window          NSWindow initWithContentRect:styleMask:backing:defer:
//!     pixels on it      an NSImageView, given a new NSImage each frame
//!     the pixels        CGDataProviderCreateWithData -> CGImageCreate
//!     events            nextEventMatchingMask: with a date in the past
//!     closed            [window isVisible] went false
//!     resized           the view's frame no longer matches the canvas
//!
//! Every poll and present runs inside an autorelease pool, because AppKit's
//! own run loop, which would drain one each turn, is not running.
//!
//! arm64: an NSRect comes back in registers through plain objc_msgSend. On
//! Intel a struct that large needs objc_msgSend_stret, which this does not
//! declare.
#![cfg(target_os = "macos")]

use crate::surface::{Input, Surface};
use std::ffi::{c_char, c_void, CStr, CString};

type Id = *mut c_void;
type Sel = *const c_void;

#[link(name = "AppKit", kind = "framework")]
#[link(name = "Foundation", kind = "framework")]
#[link(name = "CoreGraphics", kind = "framework")]
extern "C" {
    fn objc_getClass(name: *const c_char) -> Id;
    fn sel_registerName(name: *const c_char) -> Sel;
    /// Never called with this prototype: each send below casts it to the
    /// exact signature of that message. (Its header calls it variadic, and
    /// calling it as variadic corrupts arguments.)
    fn objc_msgSend();
    fn objc_autoreleasePoolPush() -> *mut c_void;
    fn objc_autoreleasePoolPop(pool: *mut c_void);

    fn CGColorSpaceCreateDeviceRGB() -> Id;
    fn CGDataProviderCreateWithData(info: *mut c_void, data: *const c_void, size: usize, release: *const c_void) -> Id;
    fn CGDataProviderRelease(p: Id);
    #[allow(clippy::too_many_arguments)]
    fn CGImageCreate(
        width: usize,
        height: usize,
        bits_per_component: usize,
        bits_per_pixel: usize,
        bytes_per_row: usize,
        space: Id,
        bitmap_info: u32,
        provider: Id,
        decode: *const f64,
        should_interpolate: bool,
        intent: i32,
    ) -> Id;
    fn CGImageRelease(img: Id);
}

// One function per argument count, each a cast of objc_msgSend.
unsafe fn send<R>(o: Id, s: Sel) -> R {
    let f: unsafe extern "C" fn(Id, Sel) -> R = std::mem::transmute(objc_msgSend as unsafe extern "C" fn());
    f(o, s)
}
unsafe fn send1<A, R>(o: Id, s: Sel, a: A) -> R {
    let f: unsafe extern "C" fn(Id, Sel, A) -> R = std::mem::transmute(objc_msgSend as unsafe extern "C" fn());
    f(o, s, a)
}
unsafe fn send2<A, B, R>(o: Id, s: Sel, a: A, b: B) -> R {
    let f: unsafe extern "C" fn(Id, Sel, A, B) -> R = std::mem::transmute(objc_msgSend as unsafe extern "C" fn());
    f(o, s, a, b)
}
unsafe fn send4<A, B, C, D, R>(o: Id, s: Sel, a: A, b: B, c: C, d: D) -> R {
    let f: unsafe extern "C" fn(Id, Sel, A, B, C, D) -> R = std::mem::transmute(objc_msgSend as unsafe extern "C" fn());
    f(o, s, a, b, c, d)
}

fn class(name: &str) -> Id {
    let c = CString::new(name).unwrap();
    unsafe { objc_getClass(c.as_ptr()) }
}
fn sel(name: &str) -> Sel {
    let c = CString::new(name).unwrap();
    unsafe { sel_registerName(c.as_ptr()) }
}
/// An autoreleased NSString: used at once, inside a pool.
unsafe fn nsstring(s: &str) -> Id {
    let c = CString::new(s).unwrap();
    send1(class("NSString"), sel("stringWithUTF8String:"), c.as_ptr())
}

#[repr(C)]
#[derive(Clone, Copy, Default)]
struct Point {
    x: f64,
    y: f64,
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct Size {
    w: f64,
    h: f64,
}
#[repr(C)]
#[derive(Clone, Copy, Default)]
struct Rect {
    origin: Point,
    size: Size,
}

const STYLE: u64 = 1 | 2 | 4 | 8; // titled, closable, miniaturizable, resizable
const BACKING_BUFFERED: u64 = 2;
const ACTIVATION_REGULAR: i64 = 0;
/// The canvas word 0x00RRGGBB, little-endian, is B G R 0 in memory: read as
/// "alpha first, skipped" in 32-bit little-endian order it needs no
/// conversion (kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Little).
const BITMAP_INFO: u32 = 6 | (2 << 12);
const EV_LEFT_DOWN: u64 = 1;
const EV_MOUSE_MOVED: u64 = 5;
const EV_KEY_DOWN: u64 = 10;
const MOD_CMD: u64 = 1 << 20;
const KEY_ESCAPE: u16 = 53;

pub struct Window {
    app: Id,
    window: Id,
    view: Id,
    space: Id,
    px: Vec<u32>,
    w: usize,
    h: usize,
    scale: f64,
    resized: bool,
    closed: bool,
    last_image: Id,
    mode: Id,
    past: Id,
}

impl Window {
    /// A window `w` x `h` points; its canvas is in device pixels.
    pub fn open(title: &str, w: usize, h: usize) -> Window {
        unsafe {
            let app: Id = send(class("NSApplication"), sel("sharedApplication"));
            // Regular: a Dock icon and keyboard focus, even run from a terminal.
            let _: bool = send1(app, sel("setActivationPolicy:"), ACTIVATION_REGULAR);
            let _: () = send(app, sel("finishLaunching"));

            let frame = Rect { origin: Point::default(), size: Size { w: w as f64, h: h as f64 } };
            let window: Id = send(class("NSWindow"), sel("alloc"));
            let window: Id = send4(window, sel("initWithContentRect:styleMask:backing:defer:"), frame, STYLE, BACKING_BUFFERED, false);
            let pool = objc_autoreleasePoolPush();
            let _: () = send1(window, sel("setTitle:"), nsstring(title));
            let mode = nsstring("kCFRunLoopDefaultMode");
            let _: Id = send(mode, sel("retain"));
            objc_autoreleasePoolPop(pool);
            let _: () = send1(window, sel("setAcceptsMouseMovedEvents:"), true);
            let _: () = send1(window, sel("setReleasedWhenClosed:"), false);

            let view: Id = send(class("NSImageView"), sel("alloc"));
            let view: Id = send1(view, sel("initWithFrame:"), frame);
            let _: () = send1(view, sel("setImageScaling:"), 3u64); // axes independently
            let _: () = send1(window, sel("setContentView:"), view);
            let _: () = send(window, sel("center"));
            let _: () = send1(window, sel("makeKeyAndOrderFront:"), std::ptr::null_mut::<c_void>());
            let _: () = send1(app, sel("activateIgnoringOtherApps:"), true);

            let scale: f64 = send(window, sel("backingScaleFactor"));
            let scale = scale.max(1.0);
            let (dw, dh) = ((w as f64 * scale) as usize, (h as f64 * scale) as usize);
            Window {
                app,
                window,
                view,
                space: CGColorSpaceCreateDeviceRGB(),
                px: vec![0; dw * dh],
                w: dw,
                h: dh,
                scale,
                resized: false,
                closed: false,
                last_image: std::ptr::null_mut(),
                mode,
                past: send(class("NSDate"), sel("distantPast")),
            }
        }
    }

    /// The view's size in device pixels.
    unsafe fn view_size(&self) -> (usize, usize) {
        let r: Rect = send(self.view, sel("frame"));
        ((r.size.w * self.scale) as usize, (r.size.h * self.scale) as usize)
    }

    /// One NSEvent, in the program's words. AppKit's origin is bottom left;
    /// the canvas's is top left, so y is flipped here and only here.
    unsafe fn translate(&self, e: Id, out: &mut Vec<Input>) {
        let kind: u64 = send(e, sel("type"));
        let at = || {
            let p: Point = send(e, sel("locationInWindow"));
            let r: Rect = send(self.view, sel("frame"));
            ((p.x * self.scale) as i32, ((r.size.h - p.y) * self.scale) as i32)
        };
        match kind {
            EV_MOUSE_MOVED => {
                let (x, y) = at();
                out.push(Input::Moved { x, y });
            }
            EV_LEFT_DOWN => {
                let (x, y) = at();
                out.push(Input::Clicked { x, y });
            }
            EV_KEY_DOWN => {
                let code: u16 = send(e, sel("keyCode"));
                let flags: u64 = send(e, sel("modifierFlags"));
                if code == KEY_ESCAPE {
                    out.push(Input::Escape);
                } else {
                    let s: Id = send(e, sel("charactersIgnoringModifiers"));
                    let p: *const c_char = send(s, sel("UTF8String"));
                    if !p.is_null() {
                        if let Some(ch) = CStr::from_ptr(p).to_str().unwrap_or("").chars().next() {
                            out.push(Input::Key { ch, cmd: flags & MOD_CMD != 0 });
                        }
                    }
                }
                // A key the program took is not handed on: with no menu,
                // AppKit would only beep at it.
                return;
            }
            _ => {}
        }
        // Everything else goes on to AppKit, so the title bar still drags and
        // the close button still closes.
        let _: () = send1(self.app, sel("sendEvent:"), e);
    }
}

impl Surface for Window {
    fn pixels(&mut self) -> &mut [u32] {
        &mut self.px
    }
    fn size(&self) -> (usize, usize) {
        (self.w, self.h)
    }

    fn poll(&mut self) -> Vec<Input> {
        let mut out = Vec::new();
        unsafe {
            let pool = objc_autoreleasePoolPush();
            loop {
                let e: Id = send4(
                    self.app,
                    sel("nextEventMatchingMask:untilDate:inMode:dequeue:"),
                    u64::MAX,
                    self.past,
                    self.mode,
                    true,
                );
                if e.is_null() {
                    break;
                }
                self.translate(e, &mut out);
            }
            let _: () = send(self.app, sel("updateWindows"));
            let visible: bool = send(self.window, sel("isVisible"));
            if !visible && !self.closed {
                self.closed = true;
                out.push(Input::Closed);
            }
            let (vw, vh) = self.view_size();
            if vw > 0 && vh > 0 && (vw, vh) != (self.w, self.h) {
                self.resized = true;
                out.push(Input::Resized);
            }
            objc_autoreleasePoolPop(pool);
        }
        out
    }

    fn apply_resize(&mut self) {
        if self.resized {
            let (w, h) = unsafe { self.view_size() };
            self.w = w;
            self.h = h;
            self.px = vec![0; w * h];
            self.resized = false;
        }
    }

    fn present(&mut self) {
        unsafe {
            let pool = objc_autoreleasePoolPush();
            // The image reads the canvas in place: no copy, no conversion.
            let provider = CGDataProviderCreateWithData(
                std::ptr::null_mut(),
                self.px.as_ptr() as *const c_void,
                self.w * self.h * 4,
                std::ptr::null(),
            );
            let image = CGImageCreate(self.w, self.h, 8, 32, self.w * 4, self.space, BITMAP_INFO, provider, std::ptr::null(), false, 0);
            CGDataProviderRelease(provider);
            // The size is in points, the image in device pixels: that is the
            // whole of Retina support.
            let size = Size { w: self.w as f64 / self.scale, h: self.h as f64 / self.scale };
            let ns: Id = send(class("NSImage"), sel("alloc"));
            let ns: Id = send2(ns, sel("initWithCGImage:size:"), image, size);
            let _: () = send1(self.view, sel("setImage:"), ns);
            let _: () = send(ns, sel("release"));
            // The view holds the new image; the one before can go.
            if !self.last_image.is_null() {
                CGImageRelease(self.last_image);
            }
            self.last_image = image;
            objc_autoreleasePoolPop(pool);
        }
    }
}

#!/bin/sh
# mac-app.sh -- build orbit and make Orbit.app in APPDIR (default
# ~/Applications): opened from Finder, Launchpad, Spotlight and the Dock.
#
# A bundle is a folder with a fixed shape:
#   Orbit.app/Contents/Info.plist      what it is, and which file to run
#   Orbit.app/Contents/MacOS/orbit     that file
#   Orbit.app/Contents/Resources/      its icon, if it has one
# orbit needs no arguments, so the binary itself is the bundle's executable.
# A program that does (orrery) puts a small launcher script there instead,
# named differently from the binary: a Mac's disk ignores case.
set -eu
cd "$(dirname "$0")"
APPDIR=${APPDIR:-$HOME/Applications}
APP="$APPDIR/Orbit.app"

cargo build --release

NEW="$APP.new"
rm -rf "$NEW"
mkdir -p "$NEW/Contents/MacOS" "$NEW/Contents/Resources"
install -m 755 target/release/orbit "$NEW/Contents/MacOS/orbit"
cat > "$NEW/Contents/Info.plist" <<'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>CFBundleName</key><string>Orbit</string>
    <key>CFBundleIdentifier</key><string>org.example.orbit</string>
    <key>CFBundleExecutable</key><string>orbit</string>
    <key>CFBundlePackageType</key><string>APPL</string>
    <key>CFBundleVersion</key><string>0.1.0</string>
    <key>CFBundleShortVersionString</key><string>0.1.0</string>
    <key>LSMinimumSystemVersion</key><string>11.0</string>
    <key>NSHighResolutionCapable</key><true/>
</dict>
</plist>
EOF
# An icon, if there is a 1024-pixel PNG beside this script: sips makes the
# iconset's sizes, iconutil the .icns, and Info.plist names it.
if [ -f icon.png ]; then
    SET=$(mktemp -d)/orbit.iconset
    mkdir -p "$SET"
    for s in 16 32 128 256 512; do
        sips -z $s $s icon.png --out "$SET/icon_${s}x${s}.png" >/dev/null
        sips -z $((s * 2)) $((s * 2)) icon.png --out "$SET/icon_${s}x${s}@2x.png" >/dev/null
    done
    iconutil -c icns "$SET" -o "$NEW/Contents/Resources/orbit.icns"
    /usr/libexec/PlistBuddy -c "Add :CFBundleIconFile string orbit" "$NEW/Contents/Info.plist"
fi
# Ad hoc: no certificate. The binary, then the bundle that seals it.
codesign --force --sign - "$NEW/Contents/MacOS/orbit"
codesign --force --sign - "$NEW"

mkdir -p "$APPDIR"
rm -rf "$APP"
mv "$NEW" "$APP"
echo "made $APP"