code wiki / (root) / nx_browser_demo_test.nx
`nx_browser_demo_test.nx` source

↩ module page · 583 lines · 24938 B
1// nx_browser_demo_test.nx -- Session 3 of bits-up browser arc.
2//
3// Pops a real Windows window via WSLg and paints actual browser
4// chrome: gray URL bar with back/forward buttons + text area below.
5// Subscribes to Expose events; redraws when needed.  Exits after
6// a 10-second visible window so user can see the layout.
7//
8// Compose-only: nx_x11_connect + nx_x11_window + nx_x11_paint.
9//
10// expect_exit: 0.
11// license_tier: ORIGINAL
12
13import "nx_syscalls.nx"
14import "nx_x11_connect.nx"
15import "nx_x11_window.nx"
16import "nx_x11_paint.nx"
17import "nx_x11_paint_text_5x7.nx"
18import "nx_x11_pixmap.nx"
19import "nx_x11_screenshot.nx"
20import "nx_render_journal.nx"
21import "nx_ux_standard.nx"
22import "nx_ux_score.nx"
23import "nx_ux_triangulate.nx"
24
25// SIGPIPE handling -- writes to a closed/disconnected X11 socket
26// generate SIGPIPE by default, which kills our process with signal
27// 13 (exit code 141).  Setting SIG_IGN via rt_sigaction makes the
28// failing write just return -EPIPE instead, so the event loop can
29// exit cleanly when the user closes the window.
30//
31// rt_sigaction(int signum, const struct sigaction *act, ...
32//              const struct sigaction *oldact, size_t sigsetsize)
33//   sigaction struct (RV64 layout): sa_handler(8) + sa_flags(8) +
34//                                    sa_restorer(8) + sa_mask(8)
35//   SIG_IGN = 1, SIGPIPE = 13, NSIG/8 = 8 (sigset size in bytes)
36const NX_SIGPIPE: i64 = 13
37const NX_SIG_IGN: i64 = 1
38const NX_SYS_RT_SIGACTION: i64 = 134
39
40func _ignore_sigpipe() -> i64 {
  let sa: *u8 = sys_mmap(64)
  var i: i64 = 0
  while i < 64 { sa[i] = 0; i = i + 1 }
  // sa_handler = SIG_IGN at offset 0
  sa[0] = NX_SIG_IGN as u8
  __syscall(NX_SYS_RT_SIGACTION, NX_SIGPIPE, sa as i64, 0, 8, 0, 0)
  return 0
48}
49
50func dump_dec(l0: i64, l1: i64, v: i64) -> i64 {
  let lab: *u8 = sys_mmap(8)
  lab[0]=l0 as u8; lab[1]=l1 as u8; lab[2]=0x3D
  sys_write(2, lab, 3)
  var av: i64 = v
  if av < 0 {
      let neg: *u8 = sys_mmap(8); neg[0]=0x2D; sys_write(2, neg, 1)
      av = 0 - av
  }
  let buf: *u8 = sys_mmap(16)
  var pos: i64 = 0
  if av == 0 { buf[0]=0x30; pos = 1 }
  var x: i64 = av
  while x > 0 {
      buf[pos] = (0x30 + (x % 10)) as u8
      x = x / 10; pos = pos + 1
  }
  let out: *u8 = sys_mmap(16); var oi: i64 = 0
  while oi < pos { out[oi] = buf[pos - 1 - oi]; oi = oi + 1 }
  sys_write(2, out, pos)
  let nl: *u8 = sys_mmap(8); nl[0]=0x0A; sys_write(2, nl, 1)
  return 0
72}
73
74// Paint the browser chrome.  Window is 800x500.
75// RECTANGLES-ONLY (no text yet).  ImageText8 requires the GC to have
76// a font set; that wiring is Session 3b (OpenFont + SetFont, or
77// alternatively rasterise our 5x7 bitmap glyphs via PutImage).
78// Today's goal: prove visible chrome structure -- header bar, buttons,
79// URL box, content paragraphs, status bar -- all visible as colored
80// rectangles on the real Windows desktop.
81// Navigation state -- 10-slot history ring with a current index.
82// Each "URL" is represented by a synthetic color (different shade
83// per index) so the user can SEE position-in-history change as
84// they click back/forward.  Real text URLs land in Session 6.
85struct NavState {
  history_len:  i64,        // how many URLs visited so far (1..10)
  history_idx:  i64,        // current position (0..history_len-1)
  last_clicked: i64,        // 0=back, 1=fwd, 2=reload, -1=none
  flash_iters:  i64,        // remaining repaint iterations to flash
  focused_idx:  i64,        // WCAG 2.4.7 focus -- which button has kb focus (-1 = none)
  last_key:     i64         // diagnostic
92}
93
94const NX_NAV_STATE_BYTES: i64 = 48
95
96// Per-index synthetic content color (cycles through a palette).
97func nav_color_for(idx: i64) -> i64 {
  let palette_len: i64 = 6
  let slot: i64 = idx - (idx / palette_len) * palette_len
  if slot == 0 { return 0x00CC2233 }      // red
  if slot == 1 { return 0x002288CC }      // blue
  if slot == 2 { return 0x0033AA66 }      // green
  if slot == 3 { return 0x00FF8800 }      // orange
  if slot == 4 { return 0x009955CC }      // purple
  return 0x00666666                        // gray
106}
107
108// Hit-test a click point against the 3 chrome buttons.
109// Returns 0=back, 1=forward, 2=reload, -1=miss.
110func hit_button(x: i64, y: i64) -> i64 {
  if y < 4 { return 0 - 1 }
  if y >= 36 { return 0 - 1 }
  if x >= 4  { if x < 36  { return 0 } }
  if x >= 40 { if x < 72  { return 1 } }
  if x >= 76 { if x < 108 { return 2 } }
  return 0 - 1
117}
118
119// Responsive chrome layout -- all positions/sizes computed relative
120// to the current window (w, h).  URL bar pinned to top; status bar
121// pinned to bottom; content stretches to fill in between.
122// Paint a rect AND log it to the render journal with a semantic
123// intent tag.  The journal is the substrate-honest alternative to
124// screen-scraping for introspection.  j == NULL skips journaling.
125func paint_and_log(c: *X11Conn, wid: i64, j: *RenderJournal,
                 intent: *u8,
                 gc_color: i64,
                 x: i64, y: i64, w: i64, h: i64) -> i64 {
  let gc: i64 = nx_x11_create_gc(c, wid, gc_color)
  nx_x11_fill_rect(c, wid, gc, x, y, w, h)
  if (j as i64) != 0 {
      nx_journal_log_rect(j, intent, x, y, w, h, gc_color)
  }
  return 0
135}
136
137func paint_chrome(c: *X11Conn, wid: i64, w: i64, h: i64,
                nav: *NavState, j: *RenderJournal) -> i64 {
  let has_j: i64 = (j as i64)
140
  // White content background fills the full window.
  let gc_white: i64 = nx_x11_create_gc(c, wid, 0x00FFFFFF)
  nx_x11_fill_rect(c, wid, gc_white, 0, 0, w, h)
  if has_j != 0 { nx_journal_log_rect(j, "background" as *u8, 0, 0, w, h, 0x00FFFFFF) }
145
  // Gray URL bar (full-width, 40px tall, anchored to top).
  let gc_gray: i64 = nx_x11_create_gc(c, wid, 0x00334455)
  nx_x11_fill_rect(c, wid, gc_gray, 0, 0, w, 40)
  if has_j != 0 { nx_journal_log_rect(j, "url_bar_bg" as *u8, 0, 0, w, 40, 0x00334455) }
150
  // 3 buttons.  Each renders as the base color UNLESS it was the
  // most recent click AND flash_iters > 0 -- in that case render
  // brighter (yellow flash) so the user sees their click registered.
  let base: i64 = 0x004488CC
  let flash: i64 = 0x00FFCC22
  var c0: i64 = base
  var c1: i64 = base
  var c2: i64 = base
  // Dim back button if no history to go back to.
  if nav.history_idx == 0 { c0 = 0x00779999 }
  // Dim forward if at end.
  if nav.history_idx + 1 >= nav.history_len { c1 = 0x00779999 }
  if nav.flash_iters > 0 {
      if nav.last_clicked == 0 { c0 = flash }
      if nav.last_clicked == 1 { c1 = flash }
      if nav.last_clicked == 2 { c2 = flash }
  }
  let gc_b0: i64 = nx_x11_create_gc(c, wid, c0)
  let gc_b1: i64 = nx_x11_create_gc(c, wid, c1)
  let gc_b2: i64 = nx_x11_create_gc(c, wid, c2)
  nx_x11_fill_rect(c, wid, gc_b0, 4,  4, 32, 32)
  nx_x11_fill_rect(c, wid, gc_b1, 40, 4, 32, 32)
  nx_x11_fill_rect(c, wid, gc_b2, 76, 4, 32, 32)
  if has_j != 0 {
      nx_journal_log_rect(j, "back_button"    as *u8, 4,  4, 32, 32, c0)
      nx_journal_log_rect(j, "forward_button" as *u8, 40, 4, 32, 32, c1)
      nx_journal_log_rect(j, "reload_button"  as *u8, 76, 4, 32, 32, c2)
  }
179
  // URL input box: starts after buttons (x=120) + ends 10 px from right.
  let url_x: i64 = 120
  var url_w: i64 = w - url_x - 10
  if url_w < 1 { url_w = 1 }
  nx_x11_fill_rect(c, wid, gc_white, url_x, 6, url_w, 28)
  let gc_black: i64 = nx_x11_create_gc(c, wid, 0x00000000)
  nx_x11_fill_rect(c, wid, gc_black, url_x,           6,  url_w, 1)
  nx_x11_fill_rect(c, wid, gc_black, url_x,          33,  url_w, 1)
  nx_x11_fill_rect(c, wid, gc_black, url_x,           6,  1,    28)
  nx_x11_fill_rect(c, wid, gc_black, url_x + url_w - 1, 6, 1,    28)
  if has_j != 0 {
      nx_journal_log_rect(j, "url_field_bg" as *u8, url_x, 6, url_w, 28, 0x00FFFFFF)
      nx_journal_log_rect(j, "url_field_border" as *u8, url_x, 6, url_w, 28, 0x00000000)
  }
194
  // History breadcrumb -- one small bar inside the URL field per
  // history slot, current slot rendered in the page's title color
  // for visible "you-are-here" feedback.  Hovers under the URL
  // field would normally show the URL text; that lands once text
  // rendering ships.
  let bc_pad: i64 = 4
  let bc_x:   i64 = url_x + bc_pad
  let bc_y:   i64 = 14
  let bc_h:   i64 = 12
  let bc_w_each: i64 = 14
  let bc_gap: i64 = 2
  var hi: i64 = 0
  while hi < nav.history_len {
      var slot_color: i64 = 0x00CCCCCC
      if hi == nav.history_idx { slot_color = nav_color_for(hi) }
      let gc_slot: i64 = nx_x11_create_gc(c, wid, slot_color)
      let sx: i64 = bc_x + hi * (bc_w_each + bc_gap)
      nx_x11_fill_rect(c, wid, gc_slot, sx, bc_y, bc_w_each, bc_h)
      if has_j != 0 {
          var lbl: *u8 = "breadcrumb_past" as *u8
          if hi == nav.history_idx { lbl = "breadcrumb_current" as *u8 }
          nx_journal_log_rect(j, lbl, sx, bc_y, bc_w_each, bc_h, slot_color)
      }
      hi = hi + 1
  }
220
  // Content area starts at y=50 (10 px below URL bar) and stretches.
  // Title color cycles with history_idx so the user can SEE the
  // current "page" change when they navigate.
  let content_x: i64 = 16
  var content_w: i64 = w - 32
  if content_w < 1 { content_w = 1 }
  let title_w: i64 = 200
  let title_color: i64 = nav_color_for(nav.history_idx)
  let gc_title: i64 = nx_x11_create_gc(c, wid, title_color)
  nx_x11_fill_rect(c, wid, gc_title, content_x, 60, title_w, 24)
  if has_j != 0 {
      nx_journal_log_rect(j, "title_block" as *u8, content_x, 60, title_w, 24, title_color)
  }
234
  // Real text using the bits-up 5x7 bitmap font.  Each glyph is
  // rendered as px_size=2 (10x14 visible per char incl. spacing),
  // dark text on the white content area.
  let gc_text: i64 = nx_x11_create_gc(c, wid, 0x00112233)
  let title_text: *u8 = "Example Domain"
  nx_x11_paint_text_5x7(c, wid, gc_text, content_x + 4, 64, title_text, 14, 2)
  let p1_text: *u8 = "This domain is for use in documentation examples."
  nx_x11_paint_text_5x7(c, wid, gc_text, content_x, 100, p1_text, 49, 2)
  let p2_text: *u8 = "Avoid use in operations."
  nx_x11_paint_text_5x7(c, wid, gc_text, content_x, 130, p2_text, 24, 2)
  if has_j != 0 {
      nx_journal_log_rect(j, "text_title"  as *u8, content_x + 4, 64,  168, 14, 0x00112233)
      nx_journal_log_rect(j, "text_para_0" as *u8, content_x,     100, 588, 14, 0x00112233)
      nx_journal_log_rect(j, "text_para_1" as *u8, content_x,     130, 288, 14, 0x00112233)
  }
250
  // Link block.
  let gc_link: i64 = nx_x11_create_gc(c, wid, 0x00FF8800)
  nx_x11_fill_rect(c, wid, gc_link, content_x, 210, 220, 12)
  if has_j != 0 {
      nx_journal_log_rect(j, "link_block" as *u8, content_x, 210, 220, 12, 0x00FF8800)
  }
257
  // Status bar pinned to BOTTOM (20 px tall, full width).
  let status_y: i64 = h - 20
  if status_y > 0 {
      nx_x11_fill_rect(c, wid, gc_gray, 0, status_y, w, 20)
      if has_j != 0 {
          nx_journal_log_rect(j, "status_bar" as *u8, 0, status_y, w, 20, 0x00334455)
      }
  }
266
  // ---- WCAG 2.4.7 focus indicator ---------------------------------
  // Paint a 2-px-thick high-contrast yellow ring around the focused
  // button so keyboard users can see where they are.  Composed of
  // 4 thin rects (top/bottom/left/right) AROUND the button so the
  // button's own pixel area stays intact.
  if nav.focused_idx >= 0 {
      let fy: i64 = 2
      var fx: i64 = 4 + nav.focused_idx * 36       // back=4, fwd=40, reload=76
      if nav.focused_idx == 1 { fx = 40 }
      if nav.focused_idx == 2 { fx = 76 }
      let fw: i64 = 36
      let fh: i64 = 36
      let gc_focus: i64 = nx_x11_create_gc(c, wid, 0x00FFCC22)   // yellow
      nx_x11_fill_rect(c, wid, gc_focus, fx,        fy,         fw, 2)        // top
      nx_x11_fill_rect(c, wid, gc_focus, fx,        fy + fh - 2, fw, 2)       // bottom
      nx_x11_fill_rect(c, wid, gc_focus, fx,        fy,         2,  fh)       // left
      nx_x11_fill_rect(c, wid, gc_focus, fx + fw - 2, fy,         2,  fh)     // right
      if has_j != 0 {
          nx_journal_log_rect(j, "focus_indicator" as *u8, fx, fy, fw, fh, 0x00FFCC22)
      }
  }
288
  // ---- WCAG 4.1.2 name/role/value: emit a11y_role_* intents -------
  // The accessibility tree IS the journal entries with these tags;
  // an AT-bridge future primitive walks them to expose to screen
  // readers.  Today we just declare the semantic roles so the
  // triangulator can score them.
  if has_j != 0 {
      nx_journal_log_rect(j, "a11y_role_button_back"    as *u8, 4,  4, 32, 32, 0)
      nx_journal_log_rect(j, "a11y_role_button_forward" as *u8, 40, 4, 32, 32, 0)
      nx_journal_log_rect(j, "a11y_role_button_reload"  as *u8, 76, 4, 32, 32, 0)
      nx_journal_log_rect(j, "a11y_role_textbox_url"    as *u8, 120, 6, w - 130, 28, 0)
      nx_journal_log_rect(j, "a11y_role_region_content" as *u8, 0, 40, w, h - 60, 0)
      nx_journal_log_rect(j, "a11y_role_status"         as *u8, 0, h - 20, w, 20, 0)
  }
  return 0
303}
304
305func main() -> i64 {
  // Ignore SIGPIPE so we exit cleanly when the user closes the
  // window and writes start failing.
  _ignore_sigpipe()
309
  let rc: i64 = nx_x11_connect_local(0)
  if rc < 0 { return 1 }
  let c: *X11Conn = rc as *X11Conn
  dump_dec(0x46, 0x44, c.fd)
314
  // Subscribe to Expose + StructureNotify + ButtonPress + KeyPress.
  let event_mask: i64 = NX_X11_EVENT_EXPOSURE
                     | NX_X11_EVENT_STRUCTURE
                     | NX_X11_EVENT_BUTTON_PRESS
                     | NX_X11_EVENT_KEY_PRESS
  let bg: i64 = 0x00F0F0F0
  var win_w: i64 = 800
  var win_h: i64 = 500
323
  // Navigation state -- start with 3 history entries so back/forward
  // are immediately exercisable.
  let nav_raw: *u8 = sys_mmap(NX_NAV_STATE_BYTES + 16)
  let nav: *NavState = nav_raw as *NavState
  nav.history_len = 3
  nav.history_idx = 1                  // start in middle so both arrows work
  nav.last_clicked = 0 - 1
  nav.flash_iters = 0
  nav.focused_idx = 0                  // Tab cycles; start on back button
  nav.last_key = 0
  let wid: i64 = nx_x11_create_window(c, 100, 100, win_w, win_h, bg, event_mask)
  if wid < 0 { return 2 }
  dump_dec(0x57, 0x49, wid)
337
  let title: *u8 = "Nishi Bits-Up Browser"
  nx_x11_set_wm_name(c, wid, title, 21)
340
  if nx_x11_map_window(c, wid) < 0 { return 3 }
  if nx_x11_flush_via_get_input_focus(c) < 0 { return 4 }
343
  // ---- Substrate-honest UX/CX intelligence -------------------------
  // Allocate a structured render journal.  Every paint logs its
  // semantic intent (e.g. "back_button", "url_bar_bg") + coords
  // + color into the journal -- NOT screen-scraped from rendered
  // pixels.  Substrate truth lives in this data, not in pixel
  // observation.  Dump to /tmp/nishi_render_journal.log so the
  // developer (or Claude via Read) can inspect what was drawn
  // and WHY without snooping on the user's screen.
  let j: *RenderJournal = nx_journal_new()
353
  // ---- Snapshot pass: paint to pixmap + dump PPM as backup channel
  let snap_w: i64 = 800
  let snap_h: i64 = 500
  let pix: i64 = nx_x11_create_pixmap(c, wid, snap_w, snap_h, c.root_depth)
  if pix >= 0 {
      paint_chrome(c, pix, snap_w, snap_h, nav, j)
      nx_x11_flush_via_get_input_focus(c)
      let path: *u8 = "/tmp/nishi_render.ppm\x00"
      let sv: i64 = nx_x11_save_drawable_as_ppm(c, pix, snap_w, snap_h, path)
      dump_dec(0x53, 0x4E, sv)
      nx_x11_free_pixmap(c, pix)
  }
  // Dump the journal -- the PRIMARY introspection channel.
  let log_path: *u8 = "/tmp/nishi_render_journal.log\x00"
  nx_journal_dump_to_file(j, log_path)
369
  // ---- UX Triangulation: NN/g + WCAG + Apple HIG + ISO 9241 -------
  // Score the journal against every clause we have a rubric for,
  // then run the ≥3-distinct-sources gate.  Writes a structured
  // report to /tmp/nishi_ux_triangulation.log so anyone (operator,
  // Claude, future Nishi tooling) can audit the S-class claim.
  let clause_ids_raw: *u8 = sys_mmap(64 * 8)
  let clause_ids: *i64 = clause_ids_raw as *i64
  clause_ids[0]  = NX_UX_NN1_VISIBILITY
  clause_ids[1]  = NX_UX_NN3_USER_CONTROL
  clause_ids[2]  = NX_UX_NN4_CONSISTENCY
  clause_ids[3]  = NX_UX_NN6_RECOGNITION
  clause_ids[4]  = NX_UX_APPLE_FEEDBACK
  clause_ids[5]  = NX_UX_APPLE_CLARITY
  clause_ids[6]  = NX_UX_ISO_SELFDESCRIPTIVE
  clause_ids[7]  = NX_UX_WCAG_2_1_1_KEYBOARD
  clause_ids[8]  = NX_UX_WCAG_2_4_7_FOCUS
  clause_ids[9]  = NX_UX_WCAG_4_1_2_NRV
  clause_ids[10] = NX_UX_NN5_ERROR_PREVENTION
  clause_ids[11] = NX_UX_W3C_HTML_SEMANTIC
  clause_ids[12] = NX_UX_W3C_ARIA_ROLES
  clause_ids[13] = NX_UX_W3C_ARIA_LABELS
  clause_ids[14] = NX_UX_W3C_DOM_TREE
  clause_ids[15] = NX_UX_W3C_CSS_CONTRAST
  clause_ids[16] = NX_UX_MS_INCL_EXCLUSION
  let n_clauses: i64 = 17
395
  let scores_raw: *u8 = sys_mmap(n_clauses * NX_UX_SCORE_BYTES + 16)
  let scores: *UxScore = scores_raw as *UxScore
398
  // Open the report file once.
  let report_path: *u8 = "/tmp/nishi_ux_triangulation.log\x00"
  let rfd: i64 = sys_openat_wr(report_path, 0x1A4)
  if rfd > 0 {
      sys_write(rfd, "---- Nishi UX triangulation report ----\n" as *u8, 40)
  }
405
  let note: *u8 = sys_mmap(256)
  var i: i64 = 0
  while i < n_clauses {
      let cid: i64 = clause_ids[i]
      let s: i64 = nx_ux_score_clause(j, cid, note, 256)
      let sx: *UxScore = _ux_at(scores, i)
      sx.clause_id = cid
      sx.score = s
      if rfd > 0 {
          // line: "  [src] clause-label : score=N"
          let src: i64 = nx_ux_clause_source(cid)
          let line: *u8 = sys_mmap(256)
          line[0] = 0x20; line[1] = 0x20; line[2] = 0x5B
          sys_write(rfd, line, 3)
          let src_lbl: *u8 = nx_ux_source_label(src)
          var k: i64 = 0
          while src_lbl[k] != 0 { sys_write(rfd, src_lbl + k, 1); k = k + 1 }
          sys_write(rfd, "] " as *u8, 2)
          let lbl: *u8 = nx_ux_clause_label(cid)
          k = 0
          while lbl[k] != 0 { sys_write(rfd, lbl + k, 1); k = k + 1 }
          sys_write(rfd, " : score=" as *u8, 9)
          // decimal score
          let d: *u8 = sys_mmap(8)
          if s >= 10 {
              d[0] = 0x31; d[1] = 0x30; sys_write(rfd, d, 2)
          } else {
              d[0] = (0x30 + s) as u8; sys_write(rfd, d, 1)
          }
          sys_write(rfd, "\n" as *u8, 1)
      }
      i = i + 1
  }
439
  let verdict: i64 = nx_ux_triangulate(scores, n_clauses)
  if rfd > 0 {
      sys_write(rfd, "VERDICT (global): " as *u8, 18)
      let vlbl: *u8 = nx_ux_verdict_label(verdict)
      var k: i64 = 0
      while vlbl[k] != 0 { sys_write(rfd, vlbl + k, 1); k = k + 1 }
      sys_write(rfd, "\n\n--- per-cluster verdicts ---\n" as *u8, 30)
      var cl: i64 = 1
      while cl < NX_UX_CLUSTER_N {
          let cv: i64 = nx_ux_triangulate_cluster(scores, n_clauses, cl)
          sys_write(rfd, "  cluster=" as *u8, 10)
          let clbl: *u8 = nx_ux_cluster_label(cl)
          k = 0
          while clbl[k] != 0 { sys_write(rfd, clbl + k, 1); k = k + 1 }
          sys_write(rfd, " : " as *u8, 3)
          let vlbl2: *u8 = nx_ux_verdict_label(cv)
          k = 0
          while vlbl2[k] != 0 { sys_write(rfd, vlbl2 + k, 1); k = k + 1 }
          sys_write(rfd, "\n" as *u8, 1)
          cl = cl + 1
      }
      sys_close(rfd)
  }
  dump_dec(0x55, 0x58, verdict)                  // UX= triangulation verdict
464
  paint_chrome(c, wid, win_w, win_h, nav, 0 as *RenderJournal)
  if nx_x11_flush_via_get_input_focus(c) < 0 { return 5 }
467
  // Event loop.
  let evt: *u8 = sys_mmap(64)
  var n_iter: i64 = 0
  let MAX_ITER: i64 = 100000
  var keep: i64 = 1
  while keep == 1 {
      if n_iter >= MAX_ITER { keep = 0 }
      if nx_x11_read_event(c, evt) < 0 { keep = 0 }
      let kind: i64 = (evt[0] & 0xff) as i64
      var need_repaint: i64 = 0
      // 12 = Expose -- redraw current chrome
      if kind == 12 { need_repaint = 1 }
      // 22 = ConfigureNotify -- window resized
      if kind == 22 {
          let nw: i64 = ((evt[20] & 0xff) as i64)
                     | (((evt[21] & 0xff) as i64) << 8)
          let nh: i64 = ((evt[22] & 0xff) as i64)
                     | (((evt[23] & 0xff) as i64) << 8)
          if nw > 0 { win_w = nw }
          if nh > 0 { win_h = nh }
          need_repaint = 1
      }
      // 4 = ButtonPress -- bytes 32-33 = root_x, 34-35 = root_y,
      //                    36-37 = event_x, 38-39 = event_y, 41=button.
      //     But the X protocol event layout puts event_x/y at offsets
      //     24-25 / 26-27.  Use those for window-relative coords.
      // 2 = KeyPress -- byte 1 holds keycode.  Hardcoded XKB
      //     standard PC/AT keycodes: Tab=23, Enter=36, Space=65.
      //     Tab cycles focus across the 3 buttons; Enter/Space
      //     activates the focused button using the SAME dispatch
      //     as ButtonPress (WCAG 2.1.1 keyboard accessible).
      if kind == 2 {
          let keycode: i64 = (evt[1] & 0xff) as i64
          nav.last_key = keycode
          // Tab cycles forward (Shift+Tab variant queued).
          if keycode == 23 {
              nav.focused_idx = (nav.focused_idx + 1) - ((nav.focused_idx + 1) / 3) * 3
              need_repaint = 1
          }
          // Enter or Space activate the focused button.
          if keycode == 36 {
              if nav.focused_idx >= 0 {
                  let btn: i64 = nav.focused_idx
                  nav.last_clicked = btn
                  nav.flash_iters = 1
                  if btn == 0 { if nav.history_idx > 0 { nav.history_idx = nav.history_idx - 1 } }
                  if btn == 1 { if nav.history_idx + 1 < nav.history_len { nav.history_idx = nav.history_idx + 1 } }
                  if btn == 2 { if nav.history_len < 10 {
                      nav.history_len = nav.history_len + 1
                      nav.history_idx = nav.history_len - 1
                  } }
                  need_repaint = 1
              }
          }
          if keycode == 65 {
              if nav.focused_idx >= 0 {
                  let btn: i64 = nav.focused_idx
                  nav.last_clicked = btn
                  nav.flash_iters = 1
                  if btn == 0 { if nav.history_idx > 0 { nav.history_idx = nav.history_idx - 1 } }
                  if btn == 1 { if nav.history_idx + 1 < nav.history_len { nav.history_idx = nav.history_idx + 1 } }
                  if btn == 2 { if nav.history_len < 10 {
                      nav.history_len = nav.history_len + 1
                      nav.history_idx = nav.history_len - 1
                  } }
                  need_repaint = 1
              }
          }
      }
      if kind == 4 {
          let ex: i64 = ((evt[24] & 0xff) as i64)
                     | (((evt[25] & 0xff) as i64) << 8)
          let ey: i64 = ((evt[26] & 0xff) as i64)
                     | (((evt[27] & 0xff) as i64) << 8)
          let btn: i64 = hit_button(ex, ey)
          if btn >= 0 {
              nav.last_clicked = btn
              nav.flash_iters = 1
              // back: idx-- (clamped)
              if btn == 0 {
                  if nav.history_idx > 0 {
                      nav.history_idx = nav.history_idx - 1
                  }
              }
              // forward: idx++ (clamped)
              if btn == 1 {
                  if nav.history_idx + 1 < nav.history_len {
                      nav.history_idx = nav.history_idx + 1
                  }
              }
              // reload: append a new history entry after current (truncating forward stack)
              if btn == 2 {
                  if nav.history_len < 10 {
                      nav.history_len = nav.history_len + 1
                      nav.history_idx = nav.history_len - 1
                  }
              }
              need_repaint = 1
          }
      }
      if need_repaint == 1 {
          paint_chrome(c, wid, win_w, win_h, nav)
          nx_x11_flush_via_get_input_focus(c)
          // Decay flash on next paint.
          if nav.flash_iters > 0 {
              nav.flash_iters = nav.flash_iters - 1
          }
      }
      // 17 = DestroyNotify -- user closed window
      if kind == 17 { keep = 0 }
      n_iter = n_iter + 1
  }
580
  sys_close(c.fd)
  return 0
583}
nx_browser_demo_test.nx source

`nx_browser_demo_test.nx` source
