Cell

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
primitive CellAttrs
  """
  Bitfield constants for cell text attributes.
  """
  fun bold(): U8 =>
    """
    Bold attribute bit.
    """
    0x01
  fun dim(): U8 =>
    """
    Dim attribute bit.
    """
    0x02
  fun underline(): U8 =>
    """
    Underline attribute bit.
    """
    0x04
  fun blink(): U8 =>
    """
    Blink attribute bit.
    """
    0x08
  fun reverse(): U8 =>
    """
    Reverse video attribute bit.
    """
    0x10

class val Cell is Equatable[Cell]
  """
  A single styled terminal character.
  """
  let char: U32
  let width: U8
  let fg: Color
  let bg: Color
  let attrs: U8

  new val create(
    char': U32,
    width': U8,
    fg': Color,
    bg': Color,
    attrs': U8)
  =>
    """
    Create a cell with explicit character, width, colors, and attributes.
    """
    char = char'
    width = width'
    fg = fg'
    bg = bg'
    attrs = attrs'

  new val empty() =>
    """
    A blank cell: space character, normal width, default colors, no attrs.
    """
    char = ' '
    width = 1
    fg = Default
    bg = Default
    attrs = 0

  new val continuation() =>
    """
    A continuation cell placed after a wide character.
    Width 0 signals the renderer to skip this column.
    """
    char = 0
    width = 0
    fg = Default
    bg = Default
    attrs = 0

  fun eq(that: box->Cell): Bool =>
    """
    Two cells are equal when all fields match.
    """
    (char == that.char)
      and (width == that.width)
      and (_color_eq(fg, that.fg))
      and (_color_eq(bg, that.bg))
      and (attrs == that.attrs)

  fun ne(that: box->Cell): Bool =>
    """
    Negation of eq.
    """
    not eq(that)

  fun tag _color_eq(a: Color, b: Color): Bool =>
    a is b