reflex-terminal 0.1.0 → 0.2.0

data/src/terminal.cpp

@@ -3,7 +3,9 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <math.h>
 #include <string>
+#include <algorithm>
 #include <ghostty/vt.h>
 #include <rays/color.h>
 #include <reflex/exception.h>
@@ -47,25 +49,31 @@ namespace Reflex
 
 		GhosttyOptionAsAlt option_as_alt           = GHOSTTY_OPTION_AS_ALT_TRUE;
 
-		bool any_button_pressed                    = false;
+		PTY pty;
+
+		RowList spans;
+
+		std::vector<uint> cell_offsets;
 
 		int columns = 0, rows = 0;
 
-		int   cell_width = 8,   cell_height = 16;
+		coord cell_width = 8,   cell_height = 16;
 
 		int screen_width = 0, screen_height = 0;
 
-		PTY pty;
+		uint pressed_buttons = 0;
 
-		String pending_input;
+		float wheel_rows     = 0;
 
-		String title;
+		longlong bells       = 0;
 
-		longlong bells = 0;
+		bool spans_blink     = false;
 
-		RowList spans;
+		Cursor last_cursor;
 
-		std::vector<uint> cell_offsets;
+		String pending_input;
+
+		String title;
 
 		~Data ()
 		{
@@ -110,6 +118,13 @@ namespace Reflex
 		write_input(self, (const char*) data, len);
 	}
 
+	static void
+	set_option (GhosttyTerminal terminal, GhosttyTerminalOption option, const void* value)
+	{
+		if (ghostty_terminal_set(terminal, option, value) != GHOSTTY_SUCCESS)
+			system_error(__FILE__, __LINE__, "failed to set the terminal option %d", (int) option);
+	}
+
 	static void
 	set_default_modes (GhosttyTerminal terminal)
 	{
@@ -120,7 +135,8 @@ namespace Reflex
 		// and the child that was told they are four columns wide disagree
 		// about where the next character goes.
 		// a reset clears the modes, so this has to be said again after one
-		ghostty_terminal_mode_set(terminal, GHOSTTY_MODE_GRAPHEME_CLUSTER, true);
+		GhosttyTerminalModeConfig mode = {GHOSTTY_MODE_GRAPHEME_CLUSTER, true};
+		set_option(terminal, GHOSTTY_TERMINAL_OPT_MODE, &mode);
 	}
 
 	static void
@@ -150,9 +166,15 @@ namespace Reflex
 	to_attribs (const GhosttyStyle& style)
 	{
 		// INVERSE is reported rather than applied: swapping fg/bg is left to
-		// the renderer, which is the one that knows the theme's default colors.
-		// UNDERLINE_MASK is a 3-bit field holding ghostty's style number --
-		// 0: none, 1: single, 2: double, 3: curly, 4: dotted, 5: dashed
+		// the renderer, which is the one that knows the theme's default colors
+
+		// the mask carries ghostty's style number as is
+		static_assert(Terminal::Span::UNDERLINE_NONE   == (int) GHOSTTY_SGR_UNDERLINE_NONE);
+		static_assert(Terminal::Span::UNDERLINE_SINGLE == (int) GHOSTTY_SGR_UNDERLINE_SINGLE);
+		static_assert(Terminal::Span::UNDERLINE_DOUBLE == (int) GHOSTTY_SGR_UNDERLINE_DOUBLE);
+		static_assert(Terminal::Span::UNDERLINE_CURLY  == (int) GHOSTTY_SGR_UNDERLINE_CURLY);
+		static_assert(Terminal::Span::UNDERLINE_DOTTED == (int) GHOSTTY_SGR_UNDERLINE_DOTTED);
+		static_assert(Terminal::Span::UNDERLINE_DASHED == (int) GHOSTTY_SGR_UNDERLINE_DASHED);
 
 		uint attribs = 0;
 		if (style.bold)          attribs |= Terminal::Span::BOLD;
@@ -174,6 +196,47 @@ namespace Reflex
 		return (color.r << 16) | (color.g << 8) | color.b;
 	}
 
+	enum {PALETTE_SIZE = Terminal::COLOR_PALETTE_LAST - Terminal::COLOR_PALETTE_FIRST + 1};
+
+	static bool
+	is_palette (Terminal::ColorIndex index)
+	{
+		return Terminal::COLOR_PALETTE_FIRST <= index && index <= Terminal::COLOR_PALETTE_LAST;
+	}
+
+	static void
+	get_palette (GhosttyTerminal terminal, GhosttyColorRgb* palette, bool default_)
+	{
+		GhosttyTerminalData data = default_
+			? GHOSTTY_TERMINAL_DATA_COLOR_PALETTE_DEFAULT
+			: GHOSTTY_TERMINAL_DATA_COLOR_PALETTE;
+
+		if (ghostty_terminal_get(terminal, data, palette) != GHOSTTY_SUCCESS)
+			system_error(__FILE__, __LINE__, "failed to get a terminal palette");
+	}
+
+	static void
+	set_palette (GhosttyTerminal terminal, const GhosttyColorRgb* palette)
+	{
+		set_option(terminal, GHOSTTY_TERMINAL_OPT_COLOR_PALETTE, palette);
+	}
+
+	static int
+	to_underline_color (const GhosttyStyle& style, const GhosttyColorRgb* palette)
+	{
+		switch (style.underline_color.tag)
+		{
+			case GHOSTTY_STYLE_COLOR_PALETTE:
+				return to_rgb(palette[style.underline_color.value.palette]);
+
+			case GHOSTTY_STYLE_COLOR_RGB:
+				return to_rgb(style.underline_color.value.rgb);
+
+			default:
+				return Terminal::Span::COLOR_NONE;
+		}
+	}
+
 	static GhosttyKey
 	to_ghostty_key (int code)
 	{
@@ -304,6 +367,15 @@ namespace Reflex
 		return mods;
 	}
 
+	static int
+	to_ghostty_button (uint types)
+	{
+		if (types & Pointer::MOUSE_LEFT)   return GHOSTTY_MOUSE_BUTTON_LEFT;
+		if (types & Pointer::MOUSE_RIGHT)  return GHOSTTY_MOUSE_BUTTON_RIGHT;
+		if (types & Pointer::MOUSE_MIDDLE) return GHOSTTY_MOUSE_BUTTON_MIDDLE;
+		return 0;
+	}
+
 	static uint32_t
 	to_unshifted_codepoint (GhosttyKey key)
 	{
@@ -344,6 +416,17 @@ namespace Reflex
 		{
 			unsigned char c = (unsigned char) *p;
 			if (c < 0x20 || c == 0x7f) return false;
+
+			// U+F700-U+F8FF (utf-8 "\xEF\x9C\x80"-"\xEF\xA3\xBF"): the private
+			// use range where macos hands over its function keys, arrows
+			// included -- a key rather than text, and the kitty protocol
+			// would otherwise send it out as the key's text
+			if (
+				c == 0xef &&
+				0x9c <= (unsigned char) p[1] && (unsigned char) p[1] <= 0xa3)
+			{
+				return false;
+			}
 		}
 		return true;
 	}
@@ -387,10 +470,13 @@ namespace Reflex
 		GhosttyKey key   = to_ghostty_key(event.code());
 		GhosttyMods mods = to_ghostty_mods(event.modifiers());
 
-		// send the composed text only when it is printable and no
-		// command/meta modifier is in effect
+		// send the composed text only on a press -- text goes with presses
+		// alone, and the encoder writes a release's text out again as if it
+		// were typed -- and only when it is printable and no command/meta
+		// modifier is in effect
 		const char* chars = event.chars();
 		bool use_utf8 =
+			action != GHOSTTY_KEY_ACTION_RELEASE &&
 			is_printable(chars) &&
 			!(mods & GHOSTTY_MODS_SUPER) &&
 			!((mods & GHOSTTY_MODS_ALT) && self->option_as_alt != GHOSTTY_OPTION_AS_ALT_FALSE);
@@ -435,16 +521,31 @@ namespace Reflex
 	{
 		ghostty_mouse_encoder_setopt_from_terminal(self->mouse_encoder, self->terminal);
 
+		// the encoder's cell size is integral, so handing it the position and
+		// a rounded cell width would drift by a cell or more toward the right
+		// edge. the cell is settled here with the fractional size instead, and
+		// the position is projected onto an integer grid of the encoder's own,
+		// where its division cannot miss: the offset inside the cell is scaled
+		// to the integral cell and clamped so that rounding cannot carry it
+		// into the next cell, keeping the sub-cell precision that SGR-Pixels
+		// mode reports
+		uint32_t cell_width  = (uint32_t) std::max(1L, lround(self->cell_width));
+		uint32_t cell_height = (uint32_t) std::max(1L, lround(self->cell_height));
+		int      cell_x      = (int) (x / self->cell_width);
+		int      cell_y      = (int) (y / self->cell_height);
+		float    offset_x    = (x - cell_x * self->cell_width)  * (cell_width  / self->cell_width);
+		float    offset_y    = (y - cell_y * self->cell_height) * (cell_height / self->cell_height);
+
 		GhosttyMouseEncoderSize size = init_sized<GhosttyMouseEncoderSize>();
-		size.screen_width  = self->screen_width  > 0
-			? self->screen_width  : self->columns * self->cell_width;
-		size.screen_height = self->screen_height > 0
-			? self->screen_height : self->rows    * self->cell_height;
-		size.cell_width    = self->cell_width;
-		size.cell_height   = self->cell_height;
+		size.screen_width  = cell_width  * self->columns;
+		size.screen_height = cell_height * self->rows;
+		size.cell_width    = cell_width;
+		size.cell_height   = cell_height;
 		ghostty_mouse_encoder_setopt(self->mouse_encoder, GHOSTTY_MOUSE_ENCODER_OPT_SIZE, &size);
+
+		bool any_button_pressed = self->pressed_buttons != 0;
 		ghostty_mouse_encoder_setopt(
-			self->mouse_encoder, GHOSTTY_MOUSE_ENCODER_OPT_ANY_BUTTON_PRESSED, &self->any_button_pressed);
+			self->mouse_encoder, GHOSTTY_MOUSE_ENCODER_OPT_ANY_BUTTON_PRESSED, &any_button_pressed);
 
 		GhosttyMouseEvent e = self->mouse_event;
 		ghostty_mouse_event_set_action(e, action);
@@ -454,7 +555,10 @@ namespace Reflex
 			ghostty_mouse_event_clear_button(e);
 		ghostty_mouse_event_set_mods(e, mods);
 
-		GhosttyMousePosition position = {x, y};
+		GhosttyMousePosition position = {
+			cell_x * cell_width  + std::clamp(offset_x, 0.f, cell_width  - 1.f),
+			cell_y * cell_height + std::clamp(offset_y, 0.f, cell_height - 1.f)
+		};
 		ghostty_mouse_event_set_position(e, position);
 
 		char buffer[64];
@@ -471,11 +575,14 @@ namespace Reflex
 	{
 		self->spans.clear();
 		self->cell_offsets.clear();
+		self->spans_blink = false;
 
 		GhosttyResult result = ghostty_render_state_get(
 			self->render_state, GHOSTTY_RENDER_STATE_DATA_ROW_ITERATOR, &self->row_iterator);
 		if (result != GHOSTTY_SUCCESS) return;
 
+		GhosttyColorRgb *palette = NULL, palette_data[PALETTE_SIZE];
+
 		String utf8;
 		while (ghostty_render_state_row_iterator_next(self->row_iterator))
 		{
@@ -524,6 +631,7 @@ namespace Reflex
 				if (result == GHOSTTY_SUCCESS) bg = to_rgb(color);
 
 				uint attribs      = 0;
+				int ul            = Terminal::Span::COLOR_NONE;
 				bool has_styling  = false;
 				ghostty_render_state_row_cells_get(
 					self->row_cells, GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_HAS_STYLING, &has_styling);
@@ -533,7 +641,18 @@ namespace Reflex
 					result = ghostty_render_state_row_cells_get(
 						self->row_cells, GHOSTTY_RENDER_STATE_ROW_CELLS_DATA_STYLE, &style);
 					if (result == GHOSTTY_SUCCESS)
+					{
 						attribs = to_attribs(style);
+						if (attribs & Terminal::Span::BLINK)
+							self->spans_blink = true;
+
+						if (style.underline_color.tag == GHOSTTY_STYLE_COLOR_PALETTE && !palette)
+						{
+							get_palette(self->terminal, palette_data, false);
+							palette = palette_data;
+						}
+						ul = to_underline_color(style, palette);
+					}
 				}
 
 				// a wide cell answers for the spacer that follows it, which
@@ -576,8 +695,8 @@ namespace Reflex
 
 				if (
 					!span ||
-					span->fg != fg || span->bg != bg || span->attribs != attribs ||
-					span_is_wide != is_wide)
+					span->fg != fg || span->bg != bg || span->ul != ul ||
+					span->attribs != attribs || span_is_wide != is_wide)
 				{
 					row.emplace_back();
 					span              = &row.back();
@@ -587,6 +706,7 @@ namespace Reflex
 					span->cell_size   = 0;
 					span->fg          = fg;
 					span->bg          = bg;
+					span->ul          = ul;
 					span->attribs     = attribs;
 					span_is_wide      = is_wide;
 				}
@@ -652,24 +772,28 @@ namespace Reflex
 				__FILE__, __LINE__, "invalid terminal size: %dx%d", columns, rows);
 		}
 
-		GhosttyTerminalOptions options = {};
-		options.cols                   = (uint16_t) columns;
-		options.rows                   = (uint16_t) rows;
-		options.max_scrollback         = scrollback_bytes;
-		if (ghostty_terminal_new(NULL, &self->terminal, options) != GHOSTTY_SUCCESS)
+		if (ghostty_terminal_new(
+			NULL, &self->terminal, (uint16_t) columns, (uint16_t) rows) != GHOSTTY_SUCCESS)
+		{
 			system_error(__FILE__, __LINE__, "failed to create a terminal");
+		}
+
+		set_option(self->terminal, GHOSTTY_TERMINAL_OPT_SCROLLBACK_MAX_BYTES, &scrollback_bytes);
 
 		// register the cell pixel size (required right after creation)
-		ghostty_terminal_resize(
-			self->terminal, options.cols, options.rows, self->cell_width, self->cell_height);
+		if (ghostty_terminal_resize(
+			self->terminal, (uint16_t) columns, (uint16_t) rows,
+			self->cell_width, self->cell_height) != GHOSTTY_SUCCESS)
+		{
+			system_error(__FILE__, __LINE__, "failed to resize a terminal");
+		}
 
 		set_default_modes(self->terminal);
 
-		ghostty_terminal_set(self->terminal, GHOSTTY_TERMINAL_OPT_USERDATA, self.get());
-		ghostty_terminal_set(self->terminal, GHOSTTY_TERMINAL_OPT_WRITE_PTY, (const void*) write_pty);
-		ghostty_terminal_set(self->terminal, GHOSTTY_TERMINAL_OPT_BELL,      (const void*) bell_rang);
-		ghostty_terminal_set(
-			self->terminal, GHOSTTY_TERMINAL_OPT_TITLE_CHANGED, (const void*) title_changed);
+		set_option(self->terminal, GHOSTTY_TERMINAL_OPT_USERDATA,      self.get());
+		set_option(self->terminal, GHOSTTY_TERMINAL_OPT_WRITE_PTY,     (const void*) write_pty);
+		set_option(self->terminal, GHOSTTY_TERMINAL_OPT_BELL,          (const void*) bell_rang);
+		set_option(self->terminal, GHOSTTY_TERMINAL_OPT_TITLE_CHANGED, (const void*) title_changed);
 		if (
 			ghostty_render_state_new(NULL, &self->render_state)              != GHOSTTY_SUCCESS ||
 			ghostty_render_state_row_iterator_new(NULL, &self->row_iterator) != GHOSTTY_SUCCESS ||
@@ -735,20 +859,37 @@ namespace Reflex
 			system_error(__FILE__, __LINE__, "failed to update a render state");
 
 		uint16_t columns = 0, rows = 0;
-		ghostty_render_state_get(self->render_state, GHOSTTY_RENDER_STATE_DATA_COLS, &columns);
-		ghostty_render_state_get(self->render_state, GHOSTTY_RENDER_STATE_DATA_ROWS, &rows);
+		result = ghostty_render_state_get(
+			self->render_state, GHOSTTY_RENDER_STATE_DATA_COLS, &columns);
+		if (result != GHOSTTY_SUCCESS)
+			system_error(__FILE__, __LINE__, "failed to get the columns of a render state");
+		result = ghostty_render_state_get(
+			self->render_state, GHOSTTY_RENDER_STATE_DATA_ROWS, &rows);
+		if (result != GHOSTTY_SUCCESS)
+			system_error(__FILE__, __LINE__, "failed to get the rows of a render state");
 		if (columns > 0) self->columns = columns;
 		if (rows    > 0) self->rows    = rows;
 
 		GhosttyRenderStateDirty dirty = GHOSTTY_RENDER_STATE_DIRTY_FALSE;
-		ghostty_render_state_get(self->render_state, GHOSTTY_RENDER_STATE_DATA_DIRTY, &dirty);
+		result = ghostty_render_state_get(
+			self->render_state, GHOSTTY_RENDER_STATE_DATA_DIRTY, &dirty);
+		if (result != GHOSTTY_SUCCESS)
+			system_error(__FILE__, __LINE__, "failed to get the dirty state of a render state");
+
+		Cursor cursor     = this->cursor();
+		bool cursor_moved = cursor != self->last_cursor;
+		self->last_cursor = cursor;
+
 		if (dirty == GHOSTTY_RENDER_STATE_DIRTY_FALSE && !self->spans.empty())
-			return false;
+			return cursor_moved;// moving the cursor dirties no cell, but a renderer draws it
 
 		rebuild_spans(self.get());
 
 		GhosttyRenderStateDirty clean = GHOSTTY_RENDER_STATE_DIRTY_FALSE;
-		ghostty_render_state_set(self->render_state, GHOSTTY_RENDER_STATE_OPTION_DIRTY, &clean);
+		result = ghostty_render_state_set(
+			self->render_state, GHOSTTY_RENDER_STATE_OPTION_DIRTY, &clean);
+		if (result != GHOSTTY_SUCCESS)
+			system_error(__FILE__, __LINE__, "failed to clear the dirty state of a render state");
 
 		return true;
 	}
@@ -766,7 +907,7 @@ namespace Reflex
 	void
 	Terminal::resize (
 		int columns, int rows,
-		int cell_width, int cell_height,
+		coord cell_width, coord cell_height,
 		int screen_width, int screen_height)
 	{
 		if (
@@ -776,7 +917,7 @@ namespace Reflex
 			argument_error(__FILE__, __LINE__, "invalid terminal size: %dx%d", columns, rows);
 		}
 		if (cell_width <= 0 || cell_height <= 0)
-			argument_error(__FILE__, __LINE__, "invalid cell size: %dx%d", cell_width, cell_height);
+			argument_error(__FILE__, __LINE__, "invalid cell size: %gx%g", cell_width, cell_height);
 		if (!*this)
 			invalid_state_error(__FILE__, __LINE__);
 
@@ -785,10 +926,13 @@ namespace Reflex
 		self->screen_width  = screen_width;
 		self->screen_height = screen_height;
 
+		// rounded the same way as encode_mouse rounds, so that the terminal
+		// and the mouse encoder agree on the integral cell size
 		GhosttyResult result = ghostty_terminal_resize(
 			self->terminal,
 			(uint16_t) columns, (uint16_t) rows,
-			(uint32_t) cell_width, (uint32_t) cell_height);
+			(uint32_t) std::max(1L, lround(cell_width)),
+			(uint32_t) std::max(1L, lround(cell_height)));
 		if (result != GHOSTTY_SUCCESS)
 			system_error(__FILE__, __LINE__, "failed to resize a terminal");
 
@@ -796,7 +940,7 @@ namespace Reflex
 		self->rows    = rows;
 
 		// sends SIGWINCH to the child process
-		self->pty.set_size(columns, rows, cell_width, cell_height);
+		self->pty.set_size(columns, rows, (int) cell_width, (int) cell_height);
 	}
 
 	void
@@ -903,37 +1047,40 @@ namespace Reflex
 		uint types             = pointer.types();
 		if (!(types & Pointer::MOUSE)) return;// touch/pen: not supported yet
 
-		int button = 0;
-		if      (types & Pointer::MOUSE_LEFT)   button = GHOSTTY_MOUSE_BUTTON_LEFT;
-		else if (types & Pointer::MOUSE_RIGHT)  button = GHOSTTY_MOUSE_BUTTON_RIGHT;
-		else if (types & Pointer::MOUSE_MIDDLE) button = GHOSTTY_MOUSE_BUTTON_MIDDLE;
-
 		GhosttyMouseAction action;
 		switch (pointer.action())
 		{
-			case Pointer::DOWN:
-				action                   = GHOSTTY_MOUSE_ACTION_PRESS;
-				self->any_button_pressed = true;
-				break;
-
+			case Pointer::DOWN:   action = GHOSTTY_MOUSE_ACTION_PRESS;   break;
 			case Pointer::UP:
-				action = GHOSTTY_MOUSE_ACTION_RELEASE;
-				break;
+			case Pointer::CANCEL: action = GHOSTTY_MOUSE_ACTION_RELEASE; break;
+			case Pointer::MOVE:   action = GHOSTTY_MOUSE_ACTION_MOTION;  break;
+			default: return;
+		}
 
-			case Pointer::MOVE:
-				action = GHOSTTY_MOUSE_ACTION_MOTION;
-				break;
+		GhosttyMods mods = to_ghostty_mods(pointer.modifiers());
+		coord x          = pointer.position().x;
+		coord y          = pointer.position().y;
 
-			default: return;
+		if (action == GHOSTTY_MOUSE_ACTION_MOTION)
+		{
+			encode_mouse(self.get(), action, to_ghostty_button(types), mods, x, y);
+			return;
 		}
 
-		encode_mouse(
-			self.get(), action, button,
-			to_ghostty_mods(pointer.modifiers()),
-			pointer.position().x, pointer.position().y);
+		// a press or a release names the one button that changed, but a cancel
+		// names every button being pressed, and each of them ends here
+
+		bool press = action == GHOSTTY_MOUSE_ACTION_PRESS;
+		for (uint button : {Pointer::MOUSE_LEFT, Pointer::MOUSE_RIGHT, Pointer::MOUSE_MIDDLE})
+		{
+			if (!(types & button)) continue;
+
+			if (press) self->pressed_buttons |= button;
 
-		if (pointer.action() == Pointer::UP)
-			self->any_button_pressed = false;
+			encode_mouse(self.get(), action, to_ghostty_button(button), mods, x, y);
+
+			if (!press) self->pressed_buttons &= ~button;
+		}
 	}
 
 	void
@@ -942,16 +1089,18 @@ namespace Reflex
 		if (!*this)
 			invalid_state_error(__FILE__, __LINE__);
 
-		int dy = (int) event.dposition().y;
-		if (dy == 0) return;
+		self->wheel_rows += event.dposition().y / self->cell_height;
+		int rows          = (int) self->wheel_rows;
+		if (rows == 0) return;
+		self->wheel_rows -= rows;
 
-		int button       = dy > 0 ? GHOSTTY_MOUSE_BUTTON_FIVE : GHOSTTY_MOUSE_BUTTON_FOUR;
+		int button       = rows > 0 ? GHOSTTY_MOUSE_BUTTON_FIVE : GHOSTTY_MOUSE_BUTTON_FOUR;
 		GhosttyMods mods = to_ghostty_mods(event.modifiers());
 		float x          = event.position().x;
 		float y          = event.position().y;
 
 		enum {MAX_STEPS = 8};
-		int steps                    = dy > 0 ? dy : -dy;
+		int steps                    = rows > 0 ? rows : -rows;
 		if (steps > MAX_STEPS) steps = MAX_STEPS;
 
 		for (int i = 0; i < steps; ++i)
@@ -969,8 +1118,9 @@ namespace Reflex
 		if (!*this)
 			invalid_state_error(__FILE__, __LINE__);
 
-		bool bracketed = false;
-		ghostty_terminal_mode_get(self->terminal, GHOSTTY_MODE_BRACKETED_PASTE, &bracketed);
+		GhosttyTerminalModeConfig mode = {GHOSTTY_MODE_BRACKETED_PASTE, false};
+		ghostty_terminal_get(self->terminal, GHOSTTY_TERMINAL_DATA_MODE, &mode);
+		bool bracketed = mode.value;
 
 		// ghostty sanitizes the text in place
 		String input(text, size);
@@ -996,14 +1146,21 @@ namespace Reflex
 		return self && self->pty.is_child_alive();
 	}
 
+	bool
+	Terminal::is_blinking () const
+	{
+		return self->spans_blink;
+	}
+
 	bool
 	Terminal::is_mouse_tracking () const
 	{
 		if (!*this) return false;
 
-		bool tracking = false;
-		ghostty_terminal_get(self->terminal, GHOSTTY_TERMINAL_DATA_MOUSE_TRACKING, &tracking);
-		return tracking;
+		bool tracking        = false;
+		GhosttyResult result =
+			ghostty_terminal_get(self->terminal, GHOSTTY_TERMINAL_DATA_MOUSE_TRACKING, &tracking);
+		return result == GHOSTTY_SUCCESS && tracking;
 	}
 
 	static GhosttyTerminalScrollbar
@@ -1035,7 +1192,7 @@ namespace Reflex
 	{
 		// the terminal copies it and takes to tracking the text it covers,
 		// so the snapshot is ours to drop once this returns
-		ghostty_terminal_set(self->terminal, GHOSTTY_TERMINAL_OPT_SELECTION, selection);
+		set_option(self->terminal, GHOSTTY_TERMINAL_OPT_SELECTION, selection);
 	}
 
 	static void
@@ -1228,7 +1385,7 @@ namespace Reflex
 	Terminal::Cursor
 	Terminal::cursor () const
 	{
-		Cursor cursor = {0, 0, Cursor::BLOCK, false};
+		Cursor cursor;
 		if (!*this) return cursor;
 
 		bool has_value = false;
@@ -1256,14 +1413,6 @@ namespace Reflex
 		return cursor;
 	}
 
-	enum {PALETTE_SIZE = Terminal::COLOR_PALETTE_LAST - Terminal::COLOR_PALETTE_FIRST + 1};
-
-	static bool
-	is_palette (Terminal::ColorIndex index)
-	{
-		return Terminal::COLOR_PALETTE_FIRST <= index && index <= Terminal::COLOR_PALETTE_LAST;
-	}
-
 	static GhosttyColorRgb
 	to_ghostty_color (const Color& color)
 	{
@@ -1314,23 +1463,6 @@ namespace Reflex
 		return GHOSTTY_TERMINAL_DATA_COLOR_FOREGROUND;
 	}
 
-	static void
-	get_palette (GhosttyTerminal terminal, GhosttyColorRgb* palette, bool default_)
-	{
-		GhosttyTerminalData data = default_
-			? GHOSTTY_TERMINAL_DATA_COLOR_PALETTE_DEFAULT
-			: GHOSTTY_TERMINAL_DATA_COLOR_PALETTE;
-
-		if (ghostty_terminal_get(terminal, data, palette) != GHOSTTY_SUCCESS)
-			system_error(__FILE__, __LINE__, "failed to get a terminal palette");
-	}
-
-	static void
-	set_palette (GhosttyTerminal terminal, const GhosttyColorRgb* palette)
-	{
-		ghostty_terminal_set(terminal, GHOSTTY_TERMINAL_OPT_COLOR_PALETTE, palette);
-	}
-
 	static bool
 	get_terminal_color (
 		const Terminal& terminal, Terminal::ColorIndex index, Color* color, bool default_)
@@ -1373,7 +1505,7 @@ namespace Reflex
 			set_palette(self->terminal, palette);
 		}
 		else
-			ghostty_terminal_set(self->terminal, to_color_option(index), &rgb);
+			set_option(self->terminal, to_color_option(index), &rgb);
 	}
 
 	void
@@ -1394,7 +1526,7 @@ namespace Reflex
 			set_palette(self->terminal, palette);
 		}
 		else
-			ghostty_terminal_set(self->terminal, to_color_option(index), NULL);
+			set_option(self->terminal, to_color_option(index), NULL);
 	}
 
 	bool

data/src/win32/pty.cpp

@@ -1,6 +1,7 @@
 // ConPTY needs windows 10 1809
 #define XOT_WIN32_WINNT 0x0A00// for <xot/windows.h>
 #define NTDDI_VERSION   0x0A000006// NTDDI_WIN10_RS5
+#include <xot/windows.h>
 
 #include "../terminal.h"
 
@@ -11,7 +12,6 @@
 #include <string>
 #include <vector>
 #include <map>
-#include <xot/windows.h>
 #include <reflex/exception.h>
 
 
@@ -200,7 +200,7 @@ namespace Reflex
 
 		STARTUPINFOEXW startup  = {};
 		startup.StartupInfo.cb  = sizeof(startup);
-		startup.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST) &attrs[0];
+		startup.lpAttributeList = (LPPROC_THREAD_ATTRIBUTE_LIST) attrs.data();
 
 		if (
 			!InitializeProcThreadAttributeList(startup.lpAttributeList, 1, 0, &attrs_size) ||