Merge pull request #419 from ZoiteChat/xtext-modernize

modernize rendering and fix scrollback resizing

plugins/fishlim/plugin_zoitechat.c

@@ -710,6 +710,7 @@ static int handle_fishlim(char *word[], char *word_eol[], void *userdata) {
     gtk_box_pack_start(GTK_BOX(content), grid, TRUE, TRUE, 0);
 
     fishlim_target_entry = gtk_entry_new();
+    gtk_widget_set_hexpand(fishlim_target_entry, TRUE);
     if (target)
         gtk_entry_set_text(GTK_ENTRY(fishlim_target_entry), target);
     gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Target nick or channel"), 0, 0, 1, 1);
@@ -760,6 +761,7 @@ static int handle_fishlim(char *word[], char *word_eol[], void *userdata) {
     g_signal_connect(view, "row-activated", G_CALLBACK(fishlim_gui_row_activated), NULL);
 
     scroll = gtk_scrolled_window_new(NULL, NULL);
+    gtk_widget_set_hexpand(scroll, TRUE);
     gtk_widget_set_vexpand(scroll, TRUE);
     gtk_container_add(GTK_CONTAINER(scroll), view);
     gtk_grid_attach(GTK_GRID(grid), scroll, 0, 6, 3, 1);

src/common/cfgfiles.c

@@ -430,8 +430,6 @@ const struct prefs vars[] =
 	{"gui_lang", P_OFFINT (hex_gui_lang), TYPE_INT},
 	{"gui_mode_buttons", P_OFFINT (hex_gui_mode_buttons), TYPE_BOOL},
 	{"gui_mode_buttons_inline", P_OFFINT (hex_gui_mode_buttons_inline), TYPE_BOOL},
-	{"gui_onboarding_disable", P_OFFINT (hex_gui_onboarding_disable), TYPE_BOOL},
-	{"gui_onboarding_pending", P_OFFINT (hex_gui_onboarding_pending), TYPE_BOOL},
 	{"gui_pane_divider_position", P_OFFINT (hex_gui_pane_divider_position), TYPE_INT},
 	{"gui_pane_left_size", P_OFFINT (hex_gui_pane_left_size), TYPE_INT},
 	{"gui_pane_right_size", P_OFFINT (hex_gui_pane_right_size), TYPE_INT},

src/common/inbound.c

@@ -1880,38 +1880,51 @@ inbound_toggle_caps (server *serv, const char *extensions_str, gboolean enable)
 	char **extensions;
 	gsize i;
 
+	if (!extensions_str)
+		return;
+
 	extensions = g_strsplit (extensions_str, " ", 0);
 
 	for (i = 0; extensions[i]; i++)
 	{
 		const char *extension = extensions[i];
+		gboolean cap_enable = enable;
+
+		/* ACK prefixes disabled capabilities with '-', unlike CAP DEL. */
+		if (*extension == '-')
+		{
+			cap_enable = FALSE;
+			extension++;
+		}
 
 		if (!strcmp (extension, "solanum.chat/identify-msg"))
-			serv->have_idmsg = enable;
+			serv->have_idmsg = cap_enable;
 		else if (!strcmp (extension, "multi-prefix"))
-			serv->have_namesx = enable;
+			serv->have_namesx = cap_enable;
 		else if (!strcmp (extension, "account-notify"))
-			serv->have_accnotify = enable;
+			serv->have_accnotify = cap_enable;
 		else if (!strcmp (extension, "extended-join"))
-			serv->have_extjoin = enable;
+			serv->have_extjoin = cap_enable;
 		else if (!strcmp (extension, "userhost-in-names"))
-			serv->have_uhnames = enable;
+			serv->have_uhnames = cap_enable;
 		else if (!strcmp (extension, "server-time")
 				|| !strcmp (extension, "znc.in/server-time")
 				|| !strcmp (extension, "znc.in/server-time-iso"))
-			serv->have_server_time = enable;
+			serv->have_server_time = cap_enable;
 		else if (!strcmp (extension, "away-notify"))
-			serv->have_awaynotify = enable;
+			serv->have_awaynotify = cap_enable;
 		else if (!strcmp (extension, "account-tag"))
-			serv->have_account_tag = enable;
+			serv->have_account_tag = cap_enable;
 		else if (!strcmp (extension, "message-tags"))
-			serv->have_message_tags = enable;
+			serv->have_message_tags = cap_enable;
 		else if (!strcmp (extension, "echo-message"))
-			serv->have_echo_message = enable;
+			serv->have_echo_message = cap_enable;
 		else if (!strcmp (extension, "sasl"))
 		{
-			serv->have_sasl = enable;
+			gboolean start_auth = cap_enable && !serv->have_sasl;
-			if (enable)
+
+			serv->have_sasl = cap_enable;
+			if (start_auth)
 			{
 #ifdef USE_OPENSSL
 				if (serv->loginmethod == LOGIN_SASLEXTERNAL)
@@ -1962,10 +1975,15 @@ inbound_cap_ack (server *serv, char *nick, char *extensions,
 	inbound_toggle_caps (serv, extensions, TRUE);
 }
 
+static void inbound_request_new_caps (server *serv, const char *extensions_str,
+									 const message_tags_data *tags_data);
+
 void
 inbound_cap_new (server *serv, char *nick, char *extensions,
 					 const message_tags_data *tags_data)
 {
+	gboolean sts_upgrade_triggered = FALSE;
+
 	if (extensions)
 	{
 		char **tokens = g_strsplit (extensions, " ", 0);
@@ -1977,7 +1995,7 @@ inbound_cap_new (server *serv, char *nick, char *extensions,
 
 			if (!g_strcmp0 (parts[0], "sts") && parts[1] && parts[1][0])
 			{
-				sts_handle_capability (serv, parts[1]);
+				sts_upgrade_triggered |= sts_handle_capability (serv, parts[1]);
 			}
 
 			g_strfreev (parts);
@@ -1986,38 +2004,22 @@ inbound_cap_new (server *serv, char *nick, char *extensions,
 		g_strfreev (tokens);
 	}
 
-	EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPACK, serv->server_session, nick, extensions,
+	EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPLIST, serv->server_session, nick, extensions,
 								  NULL, NULL, 0, tags_data->timestamp);
 
-	inbound_toggle_caps (serv, extensions, TRUE);
+	/* NEW advertises availability; only ACK confirms an enabled capability. */
+	if (!sts_upgrade_triggered)
+		inbound_request_new_caps (serv, extensions, tags_data);
 }
 
 void
 inbound_cap_del (server *serv, char *nick, char *extensions,
 					 const message_tags_data *tags_data)
 {
-	if (extensions)
-	{
-		char **tokens = g_strsplit (extensions, " ", 0);
-		int i;
-
-		for (i = 0; tokens[i]; i++)
-		{
-			if (!g_strcmp0 (tokens[i], "sts") ||
-				g_str_has_prefix (tokens[i], "sts="))
-			{
-				/* STS cannot be disabled via CAP DEL. */
-				g_strfreev (tokens);
-				return;
-			}
-		}
-
-		g_strfreev (tokens);
-	}
-
 	EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPDEL, serv->server_session, nick, extensions,
 								  NULL, NULL, 0, tags_data->timestamp);
 
+	/* STS has no toggle, but must not prevent other capabilities being removed. */
 	inbound_toggle_caps (serv, extensions, FALSE);
 }
 
@@ -2053,6 +2055,44 @@ static const char * const supported_caps[] = {
 	"solanum.chat/identify-msg",
 };
 
+static void
+inbound_request_new_caps (server *serv, const char *extensions_str,
+							 const message_tags_data *tags_data)
+{
+	char **extensions;
+	gsize i, x;
+
+	if (!extensions_str)
+		return;
+
+	extensions = g_strsplit (extensions_str, " ", 0);
+	for (i = 0; extensions[i]; i++)
+	{
+		char *value = strchr (extensions[i], '=');
+
+		if (value)
+			*value = '\0';
+	}
+
+	/* Request each supported capability once, keeping every IRC line bounded.
+	 * SASL is negotiated during login and is not in supported_caps. */
+	for (x = 0; x < G_N_ELEMENTS (supported_caps); x++)
+	{
+		for (i = 0; extensions[i]; i++)
+		{
+			if (!strcmp (extensions[i], supported_caps[x]))
+			{
+				EMIT_SIGNAL_TIMESTAMP (XP_TE_CAPREQ, serv->server_session,
+										  extensions[i], NULL, NULL, NULL, 0,
+										  tags_data->timestamp);
+				tcp_sendf (serv, "CAP REQ :%s\r\n", extensions[i]);
+				break;
+			}
+		}
+	}
+	g_strfreev (extensions);
+}
+
 static int
 get_supported_mech (server *serv, const char *list)
 {

src/common/servlist.c

@@ -191,8 +191,6 @@ struct defaultserver
 	gboolean ssl;
 };
 
-static gboolean servlist_needs_onboarding_flag;
-
 static const struct defaultserver def[] =
 {
 	{"2600net",	0},
@@ -1183,10 +1181,7 @@ servlist_load (void)
 
 	fp = zoitechat_fopen_file ("servlist.conf", "r", 0);
 	if (!fp)
-	{
-		servlist_needs_onboarding_flag = TRUE;
 		return FALSE;
-	}
 
 	while (fgets (buf, sizeof (buf) - 2, fp))
 	{
@@ -1250,7 +1245,6 @@ servlist_load (void)
 			net = servlist_net_add (buf + 2, NULL, FALSE);
 	}
 	fclose (fp);
-	servlist_needs_onboarding_flag = (network_list == NULL);
 
 	return TRUE;
 }
@@ -1259,16 +1253,8 @@ void
 servlist_init (void)
 {
 	if (!network_list)
-	{
+		if (!servlist_load ())
-		if (!servlist_load () || !network_list)
 			servlist_load_defaults ();
-	}
-}
-
-gboolean
-servlist_needs_onboarding (void)
-{
-	return servlist_needs_onboarding_flag;
 }
 
 /* check if a charset is known by Iconv */
@@ -1409,7 +1395,6 @@ servlist_save (void)
 	}
 
 	fclose (fp);
-	servlist_needs_onboarding_flag = FALSE;
 	return TRUE;
 }
 

src/common/servlist.h

@@ -93,7 +93,6 @@ extern GSList *network_list;
 #define IRC_DEFAULT_CHARSET		"UTF-8 (Unicode)"
 
 void servlist_init (void);
-gboolean servlist_needs_onboarding (void);
 int servlist_save (void);
 int servlist_cycle (server *serv);
 void servlist_connect (session *sess, ircnet *net, gboolean join);

src/common/zoitechat.h

@@ -134,8 +134,6 @@ struct zoitechatprefs
 	unsigned int hex_gui_join_dialog;
 	unsigned int hex_gui_mode_buttons;
 	unsigned int hex_gui_mode_buttons_inline;
-	unsigned int hex_gui_onboarding_disable;
-	unsigned int hex_gui_onboarding_pending;
 	unsigned int hex_gui_quit_dialog;
 	/* unsigned int hex_gui_single; */
 	unsigned int hex_gui_slist_fav;

src/fe-gtk/ascii.c

@@ -138,7 +138,7 @@ ascii_open (void)
 		{
 			table_pos++;
 			hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-			gtk_container_add (GTK_CONTAINER (vbox), hbox);
+			gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 			gtk_widget_show (hbox);
 			i++;
 			continue;
@@ -155,14 +155,14 @@ ascii_open (void)
 								G_CALLBACK (ascii_click), NULL);
 		g_signal_connect (G_OBJECT (but), "enter-notify-event",
 								G_CALLBACK (ascii_enter), label);
-		gtk_box_pack_start (GTK_BOX (hbox), but, 0, 0, 0);
+		gtk_box_pack_start (GTK_BOX (hbox), but, TRUE, TRUE, 0);
 		gtk_widget_show (but);
 
 		table_pos += len;
 	}
 
 	frame = gtk_frame_new ("");
-	gtk_container_add (GTK_CONTAINER (hbox), frame);
+	gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
 	gtk_container_add (GTK_CONTAINER (frame), label);
 	gtk_widget_show (label);
 	gtk_widget_show (frame);

src/fe-gtk/fkeys.c

@@ -1221,7 +1221,7 @@ key_dialog_load (GtkListStore *store)
 void
 key_dialog_show ()
 {
-	GtkWidget *vbox, *box;
+	GtkWidget *vbox, *box, *pane, *scroll;
 	GtkWidget *view, *xtext, *delete_button;
 	GtkListStore *store;
 	XTextColor xtext_palette[XTEXT_COLS];
@@ -1237,10 +1237,20 @@ key_dialog_show ()
 	key_dialog = mg_create_generic_tab ("editkeys", buf, TRUE, FALSE, key_dialog_close,
 									NULL, 600, 360, &vbox, 0);
 
-	view = key_dialog_treeview_new (vbox);
+	pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
+	gtk_box_pack_start (GTK_BOX (vbox), pane, TRUE, TRUE, 0);
+	box = gtkutil_box_new (GTK_ORIENTATION_VERTICAL, FALSE, 0);
+	gtk_paned_pack1 (GTK_PANED (pane), box, TRUE, FALSE);
+	view = key_dialog_treeview_new (box);
+	scroll = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
+	                                GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (scroll), 80);
+	gtk_paned_pack2 (GTK_PANED (pane), scroll, TRUE, FALSE);
+	gtk_paned_set_position (GTK_PANED (pane), 220);
 	theme_get_xtext_colors (xtext_palette, XTEXT_COLS);
 	xtext = gtk_xtext_new (xtext_palette, 0);
-	gtk_box_pack_start (GTK_BOX (vbox), xtext, FALSE, TRUE, 2);
+	gtk_container_add (GTK_CONTAINER (scroll), xtext);
 	gtk_xtext_set_font (GTK_XTEXT (xtext), prefs.hex_text_font);
 
 	g_object_set_data (G_OBJECT (key_dialog), "view", view);

src/fe-gtk/gtkutil.c

@@ -641,9 +641,8 @@ gtkutil_get_str (char *msg, char *def, void *callback, void *userdata, gboolean
 	if (parent_window && GTK_IS_WINDOW (parent_window))
 		gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
 	gtkutil_place_dialog (dialog);
-	gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE);
 
-	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, TRUE, 0);
+	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 6);
 
 	g_object_set_data (G_OBJECT (dialog), "cb", callback);
 	g_object_set_data (G_OBJECT (dialog), "ud", userdata);
@@ -653,7 +652,8 @@ gtkutil_get_str (char *msg, char *def, void *callback, void *userdata, gboolean
 						 	G_CALLBACK (gtkutil_str_enter), dialog);
 	gtk_entry_set_text (GTK_ENTRY (entry), def ? def : "");
 	gtk_entry_set_visibility (GTK_ENTRY (entry), visible);
-	gtk_box_pack_end (GTK_BOX (hbox), entry, 0, 0, 0);
+	gtk_widget_set_valign (entry, GTK_ALIGN_CENTER);
+	gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 
 	label = gtk_label_new (msg);
 	gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
@@ -661,7 +661,8 @@ gtkutil_get_str (char *msg, char *def, void *callback, void *userdata, gboolean
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (gtkutil_get_str_response), entry);
 
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    hbox, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 }
@@ -742,9 +743,8 @@ fe_get_int (char *msg, int def, void *callback, void *userdata)
 	if (parent_window && GTK_IS_WINDOW (parent_window))
 		gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
 	gtkutil_place_dialog (dialog);
-	gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE);
 
-	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, TRUE, 0);
+	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 6);
 
 	g_object_set_data (G_OBJECT (dialog), "cb", callback);
 	g_object_set_data (G_OBJECT (dialog), "ud", userdata);
@@ -755,7 +755,8 @@ fe_get_int (char *msg, int def, void *callback, void *userdata)
 	gtk_adjustment_set_upper (adj, 1024);
 	gtk_adjustment_set_step_increment (adj, 1);
 	gtk_spin_button_set_value ((GtkSpinButton*)spin, def);
-	gtk_box_pack_end (GTK_BOX (hbox), spin, 0, 0, 0);
+	gtk_widget_set_valign (spin, GTK_ALIGN_CENTER);
+	gtk_box_pack_end (GTK_BOX (hbox), spin, TRUE, TRUE, 0);
 
 	label = gtk_label_new (msg);
 	gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
@@ -763,7 +764,8 @@ fe_get_int (char *msg, int def, void *callback, void *userdata)
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (gtkutil_get_number_response), spin);
 
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    hbox, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 }
@@ -783,17 +785,18 @@ fe_get_bool (char *title, char *prompt, void *callback, void *userdata)
 	if (parent_window && GTK_IS_WINDOW (parent_window))
 		gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
 	gtkutil_place_dialog (dialog);
-	gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE);
 
 	g_object_set_data (G_OBJECT (dialog), "cb", callback);
 	g_object_set_data (G_OBJECT (dialog), "ud", userdata);
 
 	prompt_label = gtk_label_new (prompt);
+	gtk_label_set_line_wrap (GTK_LABEL (prompt_label), TRUE);
 
 	g_signal_connect (G_OBJECT (dialog), "response",
 		G_CALLBACK (gtkutil_get_bool_response), NULL);
 
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), prompt_label);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    prompt_label, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 }
@@ -885,7 +888,10 @@ gtkutil_window_new (char *title, char *role, int width, int height, int flags)
 	gtk_window_set_wmclass (GTK_WINDOW (win), "ZoiteChat", "zoitechat");
 #endif
 	gtk_window_set_title (GTK_WINDOW (win), title);
-	gtk_window_set_default_size (GTK_WINDOW (win), width, height);
+	/* Zero means content-sized to callers; GTK requires -1 for that. */
+	gtk_window_set_default_size (GTK_WINDOW (win),
+	                             width > 0 ? width : -1,
+	                             height > 0 ? height : -1);
 	gtk_window_set_role (GTK_WINDOW (win), role);
 	if (flags & 1)
 		gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_MOUSE);

src/fe-gtk/inline-image.c

@@ -1848,10 +1848,33 @@ image_viewer_button_press (GtkWidget *widget, GdkEventButton *event,
 	return TRUE;
 }
 
+static gboolean
+image_viewer_draw (GtkWidget *widget, cairo_t *cr, gpointer data)
+{
+	GdkPixbuf *pixbuf = data;
+	int width = gdk_pixbuf_get_width (pixbuf);
+	int height = gdk_pixbuf_get_height (pixbuf);
+	int available_width = gtk_widget_get_allocated_width (widget);
+	int available_height = gtk_widget_get_allocated_height (widget);
+	double scale = MIN ((double) available_width / width,
+	                    (double) available_height / height);
+
+	/* Draw from the original so repeated resizing never degrades the image. */
+	cairo_save (cr);
+	cairo_translate (cr, (available_width - width * scale) / 2,
+	                 (available_height - height * scale) / 2);
+	cairo_scale (cr, scale, scale);
+	gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
+	cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_BILINEAR);
+	cairo_paint (cr);
+	cairo_restore (cr);
+	return FALSE;
+}
+
 void
 inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 {
-	GdkPixbuf *pixbuf, *scaled = NULL;
+	GdkPixbuf *pixbuf;
 	GtkWidget *window, *eventbox, *image, *toplevel;
 	const char *url;
 	int width, height, max_width = 1280, max_height = 960;
@@ -1885,18 +1908,15 @@ inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 		double scale = MIN ((double) max_width / width,
 								  (double) max_height / height);
 
-		scaled = gdk_pixbuf_scale_simple (pixbuf,
+		width = MAX (1, (int) (width * scale));
-			MAX (1, (int) (width * scale)), MAX (1, (int) (height * scale)),
+		height = MAX (1, (int) (height * scale));
-			GDK_INTERP_BILINEAR);
-		if (scaled)
-			pixbuf = scaled;
 	}
 
 	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 	url = gtk_xtext_entry_get_image_url (xtext, ent);
 	gtk_window_set_title (GTK_WINDOW (window), url ? url : _("Image"));
 	gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
-	gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+	gtk_window_set_default_size (GTK_WINDOW (window), width, height);
 
 	toplevel = gtk_widget_get_toplevel (GTK_WIDGET (xtext));
 	if (GTK_IS_WINDOW (toplevel))
@@ -1908,7 +1928,10 @@ inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 	}
 
 	eventbox = gtk_event_box_new ();
-	image = gtk_image_new_from_pixbuf (pixbuf);
+	image = gtk_drawing_area_new ();
+	g_object_set_data_full (G_OBJECT (image), "zoitechat-viewer-image",
+	                        g_object_ref (pixbuf), g_object_unref);
+	g_signal_connect (G_OBJECT (image), "draw", G_CALLBACK (image_viewer_draw), pixbuf);
 	gtk_container_add (GTK_CONTAINER (eventbox), image);
 	gtk_container_add (GTK_CONTAINER (window), eventbox);
 
@@ -1918,7 +1941,4 @@ inline_image_show_viewer (GtkXText *xtext, textentry *ent)
 							G_CALLBACK (image_viewer_button_press), window);
 
 	gtk_widget_show_all (window);
-
-	if (scaled)
-		g_object_unref (scaled);
 }

src/fe-gtk/joind.c

@@ -137,7 +137,6 @@ joind_show_dialog (server *serv)
 	gtk_window_set_position (GTK_WINDOW (dialog1), GTK_WIN_POS_CENTER_ON_PARENT);
 	gtk_window_set_transient_for (GTK_WINDOW(dialog1), GTK_WINDOW(serv->front_session->gui->window));
 	gtk_window_set_modal (GTK_WINDOW (dialog1), TRUE);
-	gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE);
 
 	dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (dialog1));
 	gtk_widget_show (dialog_vbox1);

src/fe-gtk/maingui.c

@@ -2330,7 +2330,6 @@ mg_open_quit_dialog (gboolean minimize_button)
         gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
         gtk_window_set_title (GTK_WINDOW (dialog), _("Quit ZoiteChat?"));
         gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent_window));
-        gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
 
         dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
         gtk_widget_show (dialog_vbox1);

src/fe-gtk/menu.c

@@ -1595,16 +1595,16 @@ menu_join (GtkWidget * wid, gpointer none)
 									NULL);
 	theme_manager_attach_window (dialog);
 	content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
-	gtk_box_set_homogeneous (GTK_BOX (content_area), TRUE);
 	gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
-	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, TRUE, 0);
+	hbox = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 6);
 
 	entry = gtk_entry_new ();
 	gtk_editable_set_editable (GTK_EDITABLE (entry), FALSE);	/* avoid auto-selection */
 	gtk_entry_set_text (GTK_ENTRY (entry), "#");
 	g_signal_connect (G_OBJECT (entry), "activate",
 						 	G_CALLBACK (menu_join_entry_cb), dialog);
-	gtk_box_pack_end (GTK_BOX (hbox), entry, 0, 0, 0);
+	gtk_widget_set_valign (entry, GTK_ALIGN_CENTER);
+	gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
 
 	label = gtk_label_new (_("Enter Channel to Join:"));
 	gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
@@ -1612,7 +1612,7 @@ menu_join (GtkWidget * wid, gpointer none)
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (menu_join_cb), entry);
 
-	gtk_container_add (GTK_CONTAINER (content_area), hbox);
+	gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
 
 	gtk_widget_show_all (dialog);
 

src/fe-gtk/meson.build

@@ -95,7 +95,6 @@ zoitechat_gtk_ldflags = []
 if host_machine.system() == 'windows'
   zoitechat_gtk_sources += 'notifications/notification-windows.c'
   zoitechat_gtk_deps += cc.find_library('dwmapi', required: true)
-  zoitechat_gtk_deps += cc.find_library('winhttp', required: true)
   zoitechat_theme_deps += cc.find_library('dwmapi', required: true)
 
 else
@@ -279,3 +278,10 @@ test('Emoji Font Tests', emoji_font_tests,
   protocol: 'tap',
   timeout: 120,
 )
+
+xtext_tests = executable('xtext_tests',
+  'tests/test-xtext.c',
+  include_directories: [config_h_include],
+  dependencies: [gtk_dep],
+)
+test('XText Tests', xtext_tests, protocol: 'tap', timeout: 120)

src/fe-gtk/notifygui.c

@@ -391,34 +391,39 @@ fe_notify_ask (char *nick, char *networks)
 	gtk_container_set_border_width (GTK_CONTAINER (table), 12);
 	gtk_grid_set_row_spacing (GTK_GRID (table), 3);
 	gtk_grid_set_column_spacing (GTK_GRID (table), 8);
-	gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), table);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+	                    table, TRUE, TRUE, 0);
 
 	label = gtk_label_new (msg);
-	gtkutil_grid_attach_defaults (table, label, 0, 1, 0, 1);
+	gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
+	gtkutil_grid_attach (table, label, 0, 1, 0, 1, GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	entry = gtk_entry_new ();
 	gtk_entry_set_text (GTK_ENTRY (entry), nick);
 	g_signal_connect (G_OBJECT (entry), "activate",
 						 	G_CALLBACK (notifygui_add_enter), dialog);
-	gtkutil_grid_attach_defaults (table, entry, 1, 2, 0, 1);
+	gtkutil_grid_attach (table, entry, 1, 2, 0, 1,
+	                     GTKUTIL_ATTACH_EXPAND | GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	g_signal_connect (G_OBJECT (dialog), "response",
 						   G_CALLBACK (notifygui_add_cb), entry);
 
 	label = gtk_label_new (_("Notify on these networks:"));
-	gtkutil_grid_attach_defaults (table, label, 0, 1, 2, 3);
+	gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
+	gtkutil_grid_attach (table, label, 0, 1, 2, 3, GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	wid = gtk_entry_new ();
 	g_object_set_data (G_OBJECT (entry), "net", wid);
 	g_signal_connect (G_OBJECT (wid), "activate",
 						 	G_CALLBACK (notifygui_add_enter), dialog);
 	gtk_entry_set_text (GTK_ENTRY (wid), networks ? networks : "ALL");
-	gtkutil_grid_attach_defaults (table, wid, 1, 2, 2, 3);
+	gtkutil_grid_attach (table, wid, 1, 2, 2, 3,
+	                     GTKUTIL_ATTACH_EXPAND | GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	label = gtk_label_new (NULL);
 	g_snprintf (buf, sizeof (buf), "<i><span size=\"smaller\">%s</span></i>", _("Comma separated list of networks is accepted."));
 	gtk_label_set_markup (GTK_LABEL (label), buf);
-	gtkutil_grid_attach_defaults (table, label, 1, 2, 3, 4);
+	gtkutil_grid_attach (table, label, 1, 2, 3, 4, GTKUTIL_ATTACH_FILL, 0, 0, 0);
 
 	gtk_widget_show_all (dialog);
 }

src/fe-gtk/setup.c

@@ -648,9 +648,6 @@ static const char *const proxyuse[] =
 
 static const setting network_settings[] =
 {
-        {ST_HEADER,     N_("Startup"), 0, 0, 0, 0},
-        {ST_TOGGLE,     N_("Disable first-run assistant"), P_OFFINTNL(hex_gui_onboarding_disable), 0, 0, 0},
-
         {ST_HEADER,     N_("Your Address"), 0, 0, 0, 0},
         {ST_ENTRY,      N_("Bind to:"), P_OFFSETNL(hex_net_bind_host), 0, 0, sizeof prefs.hex_net_bind_host},
         {ST_LABEL,      N_("Only useful for computers with multiple addresses.")},
@@ -1259,7 +1256,7 @@ setup_create_id_menu (GtkWidget *table, char *label, int row, char *dest)
 static void
 setup_create_menu (GtkWidget *table, int row, const setting *set)
 {
-        GtkWidget *wid, *cbox, *box;
+        GtkWidget *wid, *cbox;
         const char **text = (const char **)set->list;
         int i;
 
@@ -1280,9 +1277,7 @@ setup_create_menu (GtkWidget *table, int row, const setting *set)
         g_signal_connect (G_OBJECT (cbox), "changed",
                                                         G_CALLBACK (setup_menu_cb), (gpointer)set);
 
-        box = gtkutil_box_new (GTK_ORIENTATION_HORIZONTAL, FALSE, 0);
+        setup_table_attach (table, cbox, 3, 6, row, row + 1, TRUE, FALSE,
-        gtk_box_pack_start (GTK_BOX (box), cbox, 0, 0, 0);
-        setup_table_attach (table, box, 3, 4, row, row + 1, TRUE, FALSE,
                             SETUP_ALIGN_FILL, SETUP_ALIGN_FILL, 0, 0);
 }
 
@@ -1966,7 +1961,8 @@ setup_add_page (const char *title, GtkWidget *book, GtkWidget *tab)
 
         sw = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new (NULL, NULL));
         gtk_scrolled_window_set_shadow_type (sw, GTK_SHADOW_IN);
-        gtk_scrolled_window_set_policy (sw, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+        gtk_scrolled_window_set_policy (sw, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+        gtk_scrolled_window_set_propagate_natural_width (sw, TRUE);
         gtk_container_add (GTK_CONTAINER (sw), vvbox);
 
         viewport = gtk_bin_get_child (GTK_BIN(sw));
@@ -2010,7 +2006,9 @@ setup_ensure_page_created (int page)
         }
 
         page_widget = setup_page_factories[page] (setup_page_settings[page]);
-        gtk_container_add (GTK_CONTAINER (container), page_widget);
+        /* Lazy pages must pass the notebook's spare space to their content,
+           particularly the independently scrolling Sounds list. */
+        gtk_box_pack_start (GTK_BOX (container), page_widget, TRUE, TRUE, 0);
         gtk_widget_show_all (container);
 }
 
@@ -2188,9 +2186,14 @@ setup_create_tree (GtkWidget *box, GtkWidget *book)
                                                             -1, _("Categories"), renderer, "text", 0, NULL);
         gtk_tree_view_expand_all (GTK_TREE_VIEW (tree));
 
-        frame = gtk_frame_new (NULL);
+        frame = gtk_scrolled_window_new (NULL, NULL);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (frame),
+                                       GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
+        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (frame), GTK_SHADOW_IN);
+        gtk_scrolled_window_set_propagate_natural_width (GTK_SCROLLED_WINDOW (frame), TRUE);
+        gtk_widget_set_vexpand (frame, TRUE);
         gtk_container_add (GTK_CONTAINER (frame), tree);
-        gtk_box_pack_start (GTK_BOX (box), frame, 0, 0, 0);
+        gtk_box_pack_start (GTK_BOX (box), frame, FALSE, TRUE, 0);
         gtk_box_reorder_child (GTK_BOX (box), frame, 0);
 
         if (sel_iter)

src/fe-gtk/tests/test-xtext.c

@@ -0,0 +1,597 @@
+/* XText regression tests. Distributed under GPL-2.0-or-later; see COPYING.
+ * Include the implementation to check layout/selection invariants without
+ * adding test-only symbols to the widget's public API. Application services
+ * are stubbed; GTK, Pango, Cairo and the widget itself are exercised normally. */
+#include "../xtext.c"
+#include <glib/gstdio.h>
+
+struct zoitechatprefs prefs;
+
+void emoji_font_apply (GtkWidget *widget) { }
+int url_last (int *start, int *end) { return 0; }
+gsize strftime_utf8 (char *dest, gsize size, const char *format, time_t stamp)
+{
+	return strftime (dest, size, format, localtime (&stamp));
+}
+int xtext_get_stamp_str (time_t stamp, char **out)
+{
+	*out = g_strdup ("[12:34] ");
+	return strlen (*out);
+}
+void theme_get_xtext_colors_for_widget (GtkWidget *widget, XTextColor *colors, size_t len)
+{
+	size_t i;
+	for (i = 0; i < len; i++)
+	{
+		colors[i].red = colors[i].green = colors[i].blue = 0.0;
+		colors[i].alpha = 1.0;
+	}
+	colors[XTEXT_FG].red = colors[XTEXT_FG].green = colors[XTEXT_FG].blue = 1.0;
+	colors[XTEXT_MARK_BG].blue = 1.0;
+	colors[XTEXT_MARK_FG] = colors[XTEXT_FG];
+	colors[XTEXT_MARKER].red = 1.0;
+}
+
+typedef struct { GtkWidget *window; GtkXText *xtext; } Fixture;
+
+static void drain_events (void)
+{
+	while (g_main_context_iteration (NULL, FALSE)) { }
+}
+
+static void fixture_setup (Fixture *f, gconstpointer data)
+{
+	XTextColor colors[XTEXT_COLS];
+	GtkWidget *scrolled = gtk_scrolled_window_new (NULL, NULL);
+	theme_get_xtext_colors_for_widget (NULL, colors, G_N_ELEMENTS (colors));
+	f->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+	gtk_window_set_default_size (GTK_WINDOW (f->window), 640, 360);
+	f->xtext = GTK_XTEXT (gtk_xtext_new (colors, TRUE));
+	g_object_ref (f->xtext);
+	gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (f->xtext));
+	gtk_container_add (GTK_CONTAINER (f->window), scrolled);
+	g_assert_true (gtk_xtext_set_font (f->xtext, "monospace 12"));
+	gtk_widget_show_all (f->window);
+	drain_events ();
+}
+
+static void fixture_teardown (Fixture *f, gconstpointer data)
+{
+	gtk_widget_destroy (f->window);
+	g_object_unref (f->xtext);
+	drain_events ();
+	g_assert_null (image_pending_list);
+}
+
+static void append (Fixture *f, const char *text)
+{
+	gtk_xtext_append (f->xtext->buffer, (guchar *)text, -1, 1234);
+}
+
+static cairo_surface_t *snapshot (Fixture *f, gboolean partial)
+{
+	GtkWidget *widget = GTK_WIDGET (f->xtext);
+	int width = gtk_widget_get_allocated_width (widget);
+	int height = gtk_widget_get_allocated_height (widget);
+	cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+	cairo_t *cr = cairo_create (surface);
+	if (partial)
+	{
+		cairo_rectangle (cr, 0, f->xtext->fontsize, width, height - f->xtext->fontsize);
+		cairo_clip (cr);
+	}
+	gtk_widget_draw (widget, cr);
+	g_assert_cmpint (cairo_status (cr), ==, CAIRO_STATUS_SUCCESS);
+	cairo_destroy (cr);
+	cairo_surface_flush (surface);
+	return surface;
+}
+
+static void test_empty_and_bounded_append (Fixture *f, gconstpointer data)
+{
+	const guchar bytes[] = {'a', 'b', 'c'}; /* deliberately no terminating NUL */
+	append (f, "");
+	g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "");
+	g_assert_cmpint (f->xtext->buffer->text_last->subline_count, ==, 1);
+	append (f, "\n");
+	g_assert_cmpint (f->xtext->buffer->text_last->str_len, ==, 0);
+	gtk_xtext_append (f->xtext->buffer, (guchar *)bytes, sizeof (bytes), 1234);
+	g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "abc");
+	gtk_xtext_append_indent (f->xtext->buffer, (guchar *)"", 0, (guchar *)"", 0, 1234);
+	g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, " ");
+}
+
+static void test_utf8_limits (Fixture *f, gconstpointer data)
+{
+	GString *text = g_string_new (NULL);
+	int i;
+	for (i = 0; i < 1500; i++) g_string_append (text, "猫");
+	gtk_xtext_append (f->xtext->buffer, (guchar *)text->str, text->len, 1234);
+	g_assert_cmpint (f->xtext->buffer->text_last->str_len, ==, 4095);
+	g_assert_true (g_utf8_validate ((char *)f->xtext->buffer->text_last->str, -1, NULL));
+	gtk_xtext_append_indent (f->xtext->buffer, (guchar *)text->str, text->len,
+		(guchar *)"猫", -1, 1234);
+	g_assert_cmpint (f->xtext->buffer->text_last->str_len, <=, 4095);
+	g_assert_true (g_utf8_validate ((char *)f->xtext->buffer->text_last->str, -1, NULL));
+	gtk_xtext_append (f->xtext->buffer, (guchar *)"hello 猫", 8, 1234);
+	g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "hello ");
+	gtk_xtext_append (f->xtext->buffer, (guchar *)"ok\xff" "bad", 6, 1234);
+	g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "ok");
+	g_string_free (text, TRUE);
+}
+
+static void test_null_empty_prefix (Fixture *f, gconstpointer data)
+{
+	xtext_buffer *buf = f->xtext->buffer;
+	/* PrintTextLine passes NULL/0 for indented server text without a tab. */
+	gtk_xtext_append_indent (buf, NULL, 0, (guchar *)"server notice", -1, 1234);
+	g_assert_cmpstr ((char *)buf->text_last->str, ==, " server notice");
+	g_assert_cmpint (buf->text_last->left_len, ==, 0);
+	g_assert_cmpint (buf->text_last->stamp, ==, 1234);
+	gtk_xtext_append_indent (buf, (guchar *)"nick", -1, NULL, 0, 1234);
+	g_assert_cmpstr ((char *)buf->text_last->str, ==, "nick ");
+	gtk_xtext_append_indent (buf, NULL, 0, NULL, 0, 1234);
+	g_assert_cmpstr ((char *)buf->text_last->str, ==, " ");
+	g_assert_cmpint (buf->num_lines, ==, 3);
+	cairo_surface_destroy (snapshot (f, FALSE));
+}
+
+static void test_wrapping (Fixture *f, gconstpointer data)
+{
+	xtext_buffer *buf = f->xtext->buffer;
+	textentry *ent;
+	int start = 0, i;
+	append (f, "猫猫猫猫猫猫猫猫猫猫");
+	ent = buf->text_last;
+	/* A character wider than the row must still be kept whole. */
+	buf->window_width = 3;
+	gtk_xtext_lines_taken (buf, ent);
+	g_assert_cmpint (ent->subline_count, ==, 10);
+	for (i = 0; i < ent->subline_count; i++)
+	{
+		int end = gtk_xtext_subline_end (ent, i);
+		g_assert_cmpint (end, >, start);
+		g_assert_true (g_utf8_validate ((char *)ent->str + start, end - start, NULL));
+		start = end;
+	}
+	buf->window_width = 120;
+	gtk_xtext_lines_taken (buf, ent);
+	g_assert_cmpint (ent->subline_count, >, 1);
+	buf->window_width = 640;
+	gtk_xtext_lines_taken (buf, ent);
+	g_assert_cmpint (ent->subline_count, ==, 1);
+}
+
+static void test_font_isolation (Fixture *f, gconstpointer data)
+{
+	Fixture second;
+	int original = gtk_xtext_text_width (f->xtext, (guchar *)"WWii hello", 10);
+	fixture_setup (&second, NULL);
+	g_assert_true (gtk_xtext_set_font (second.xtext, "sans 30"));
+	g_assert_cmpint (gtk_xtext_text_width (second.xtext, (guchar *)"WWii hello", 10), >, original);
+	g_assert_cmpint (gtk_xtext_text_width (f->xtext, (guchar *)"WWii hello", 10), ==, original);
+	fixture_teardown (&second, NULL);
+	g_assert_cmpint (gtk_xtext_text_width (f->xtext, (guchar *)"WWii hello", 10), ==, original);
+}
+
+static void test_wide_metrics (Fixture *f, gconstpointer data)
+{
+	char *text = g_strnfill (4000, 'W');
+	g_assert_true (gtk_xtext_set_font (f->xtext, "sans 40"));
+	append (f, text);
+	g_assert_cmpint (f->xtext->buffer->text_last->str_width, >, 65535);
+	g_assert_cmpint (f->xtext->buffer->text_last->subline_count, >, 1);
+	g_free (text);
+}
+
+static void test_formatting (Fixture *f, gconstpointer data)
+{
+	const char *formatted = "a\002bold\002 \035italic\035 \00304,02red\017 \037u\037 \036s\036 \026r\026";
+	char *plain;
+	GSList *runs = NULL;
+	int len;
+	plain = (char *)gtk_xtext_strip_color ((guchar *)formatted, strlen (formatted), NULL, &len, &runs, FALSE);
+	g_assert_cmpstr (plain, ==, "abold italic red u s r");
+	g_assert_cmpint (len, ==, strlen (plain));
+	g_assert_cmpint (((offlen_t *)runs->data)->off, ==, 0);
+	g_slist_free_full (runs, g_free);
+	g_free (plain);
+	plain = (char *)gtk_xtext_strip_color ((guchar *)"a\010secret\010b", 10, NULL, &len, NULL, TRUE);
+	g_assert_cmpstr (plain, ==, "ab");
+	g_free (plain);
+	append (f, formatted);
+	gtk_xtext_append_indent (f->xtext->buffer, (guchar *)"nick", -1, (guchar *)formatted, -1, 1234);
+	f->xtext->auto_indent = TRUE;
+	f->xtext->buffer->time_stamp = TRUE;
+	f->xtext->buffer->indent = 130;
+	gtk_xtext_recalc_widths (f->xtext->buffer, FALSE);
+	cairo_surface_destroy (snapshot (f, FALSE));
+	g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==,
+		"nick a\002bold\002 \035italic\035 \00304,02red\017 \037u\037 \036s\036 \026r\026");
+}
+
+static void select_entries (Fixture *f, textentry *start, textentry *end)
+{
+	textentry *ent;
+	for (ent = start; ent; ent = ent->next)
+	{
+		ent->mark_start = 0;
+		ent->mark_end = ent->str_len;
+		if (ent == end) break;
+	}
+	gtk_xtext_selection_render (f->xtext, start, end);
+	f->xtext->selection_buffer = f->xtext->buffer;
+}
+
+static void test_selection_and_clipboard (Fixture *f, gconstpointer data)
+{
+	char *selected;
+	int len;
+	append (f, "");
+	append (f, "\002bold\002 猫");
+	append (f, "last");
+	select_entries (f, f->xtext->buffer->text_first, f->xtext->buffer->text_last);
+	selected = gtk_xtext_selection_get_text (f->xtext, &len);
+	g_assert_cmpstr (selected, ==, "\nbold 猫\nlast");
+	g_assert_cmpint (len, ==, strlen (selected));
+	g_free (selected);
+	f->xtext->color_paste = TRUE;
+	f->xtext->mark_stamp = TRUE;
+	selected = gtk_xtext_selection_get_text (f->xtext, &len);
+	g_assert_cmpstr (selected, ==, "\n[12:34] \002bold\002 猫\n[12:34] last");
+	g_free (selected);
+	f->xtext->color_paste = f->xtext->mark_stamp = FALSE;
+	gtk_xtext_copy_selection (f->xtext);
+	selected = gtk_clipboard_wait_for_text (gtk_widget_get_clipboard (GTK_WIDGET (f->xtext), GDK_SELECTION_CLIPBOARD));
+	g_assert_cmpstr (selected, ==, "\nbold 猫\nlast");
+	g_free (selected);
+	selected = gtk_clipboard_wait_for_text (gtk_widget_get_clipboard (GTK_WIDGET (f->xtext), GDK_SELECTION_PRIMARY));
+	g_assert_cmpstr (selected, ==, "\nbold 猫\nlast");
+	g_free (selected);
+	gtk_xtext_unselect (f->xtext);
+	g_assert_false (gtk_xtext_is_selecting (f->xtext));
+}
+
+static void test_search (Fixture *f, gconstpointer data)
+{
+	GError *error = NULL;
+	textentry *first;
+	xtext_buffer *buf = f->xtext->buffer;
+	append (f, "one \002needle\002 then NEEDLE");
+	first = buf->text_last;
+	append (f, "second needle");
+	g_assert_true (gtk_xtext_search (f->xtext, "needle", highlight, &error) == first);
+	g_assert_no_error (error);
+	g_assert_cmpint (g_list_length (first->marks), ==, 2);
+	g_assert_true (gtk_xtext_search (f->xtext, "needle", highlight, &error) == first);
+	g_assert_true (gtk_xtext_search (f->xtext, "needle", highlight, &error) == buf->text_last);
+	gtk_xtext_search (f->xtext, "", 0, &error);
+	g_assert_null (buf->search_found);
+	g_assert_true (gtk_xtext_search (f->xtext, "needle", backward | case_match, &error) == buf->text_last);
+	gtk_xtext_search (f->xtext, "n[a-z]+", regexp | case_match, &error);
+	g_assert_no_error (error);
+	g_assert_nonnull (buf->search_re);
+	gtk_xtext_search (f->xtext, "[", regexp, &error);
+	g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
+	g_clear_error (&error);
+	/* A no-match search must also release its regex/text on clear. */
+	gtk_xtext_search (f->xtext, "nomatch", regexp, &error);
+	g_assert_null (buf->search_found);
+	gtk_xtext_clear (buf, 0);
+	g_assert_null (buf->search_re);
+	g_assert_null (buf->search_text);
+}
+
+static void test_follow_search (Fixture *f, gconstpointer data)
+{
+	xtext_buffer *buf = f->xtext->buffer;
+	append (f, "match first");
+	gtk_xtext_search (f->xtext, "match", 0, NULL);
+	append (f, "match second");
+	gtk_xtext_search (f->xtext, NULL, follow, NULL);
+	g_assert_cmpint (g_list_length (buf->search_found), ==, 2);
+	GList *current = buf->curmark;
+	gtk_xtext_search (f->xtext, NULL, 0, NULL);
+	gtk_xtext_search (f->xtext, NULL, follow, NULL);
+	g_assert_cmpint (g_list_length (buf->search_found), ==, 2);
+	g_assert_true (buf->curmark == current);
+	append (f, "match third");
+	g_assert_cmpint (g_list_length (buf->search_found), ==, 3);
+}
+
+static void test_search_unicode_offsets (Fixture *f, gconstpointer data)
+{
+	xtext_buffer *buf = f->xtext->buffer;
+	offsets_t mark;
+	append (f, "İ \002NEEDLE\002 Straße");
+	gtk_xtext_search (f->xtext, "needle", 0, NULL);
+	mark.u = GPOINTER_TO_UINT (buf->text_first->marks->data);
+	g_assert_cmpint (mark.o.start, ==, 4);
+	/* The established color-offset mapping includes the closing control. */
+	g_assert_cmpint (mark.o.end, ==, 11);
+	gtk_xtext_search (f->xtext, "ss", 0, NULL);
+	mark.u = GPOINTER_TO_UINT (buf->text_first->marks->data);
+	g_assert_cmpint (mark.o.start, ==, 16);
+	g_assert_cmpint (mark.o.end, ==, 18);
+	gtk_xtext_clear (buf, 0);
+	append (f, "ſ needle");
+	gtk_xtext_search (f->xtext, "needle", 0, NULL);
+	mark.u = GPOINTER_TO_UINT (buf->text_first->marks->data);
+	g_assert_cmpint (mark.o.start, ==, 3);
+	g_assert_cmpint (mark.o.end, ==, 9);
+}
+
+static void test_rawlog_hidden_text (Fixture *f, gconstpointer data)
+{
+	int hidden, visible;
+	append (f, "a\010secret\010b");
+	hidden = f->xtext->buffer->text_last->str_width;
+	f->xtext->ignore_hidden = TRUE;
+	gtk_xtext_recalc_widths (f->xtext->buffer, TRUE);
+	visible = f->xtext->buffer->text_last->str_width;
+	g_assert_cmpint (visible, >, hidden);
+	g_assert_cmpint (visible, ==, gtk_xtext_text_width (f->xtext, (guchar *)"asecretb", 8));
+}
+
+static void test_save (Fixture *f, gconstpointer data)
+{
+	char *path, *saved;
+	GError *error = NULL;
+	int fd = g_file_open_tmp ("zoitechat-xtext-XXXXXX", &path, &error);
+	g_assert_no_error (error);
+	append (f, "\002bold\002 猫");
+	append (f, "");
+	append (f, "last");
+	gtk_xtext_save (f->xtext, fd);
+	close (fd);
+	g_assert_true (g_file_get_contents (path, &saved, NULL, &error));
+	g_assert_no_error (error);
+	g_assert_cmpstr (saved, ==, "bold 猫\n\nlast\n");
+	g_free (saved);
+	g_unlink (path);
+	g_free (path);
+}
+
+static void test_scrollable_ownership (Fixture *f, gconstpointer data)
+{
+	GtkAdjustment *horizontal = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 1, 1, 1, 1));
+	GtkAdjustment *vertical = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 10, 10));
+	GtkAdjustment *old = g_object_ref (f->xtext->adj);
+	g_object_set (f->xtext, "hadjustment", horizontal, "vadjustment", vertical, NULL);
+	g_assert_false (g_object_is_floating (horizontal));
+	g_assert_false (g_object_is_floating (vertical));
+	g_assert_true (f->xtext->hadj == horizontal);
+	g_assert_true (f->xtext->adj == vertical);
+	/* A replaced adjustment must no longer call into the widget. */
+	g_assert_cmpuint (g_signal_handler_find (old, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, f->xtext), ==, 0);
+	g_signal_emit_by_name (f->xtext, "set-scroll-adjustments", horizontal, vertical);
+	g_assert_true (f->xtext->adj == vertical);
+	g_object_set (f->xtext, "hadjustment", NULL, "vadjustment", NULL, NULL);
+	g_assert_true (GTK_IS_ADJUSTMENT (f->xtext->hadj));
+	g_assert_true (GTK_IS_ADJUSTMENT (f->xtext->adj));
+	g_object_unref (old);
+}
+
+static void test_clear_and_marker (Fixture *f, gconstpointer data)
+{
+	xtext_buffer *buf = f->xtext->buffer;
+	append (f, "first"); append (f, "second"); append (f, "third");
+	buf->marker_pos = buf->text_first;
+	buf->marker_state = MARKER_IS_SET;
+	gtk_xtext_clear (buf, 1);
+	g_assert_cmpstr ((char *)buf->text_first->str, ==, "second");
+	g_assert_cmpint (buf->marker_state, ==, MARKER_RESET_BY_CLEAR);
+	gtk_xtext_clear (buf, -1);
+	g_assert_cmpstr ((char *)buf->text_last->str, ==, "second");
+	select_entries (f, buf->text_first, buf->text_last);
+	f->xtext->hilight_ent = buf->text_first;
+	gtk_xtext_clear (buf, 0);
+	g_assert_null (f->xtext->hilight_ent);
+	g_assert_null (buf->pagetop_ent);
+	g_assert_null (buf->last_ent_start);
+	g_assert_cmpint (buf->num_lines, ==, 0);
+	g_assert_true (gtk_xtext_is_empty (buf));
+	append (f, "after clear");
+	g_assert_cmpint (buf->num_lines, ==, 1);
+}
+
+static void test_scrollback_limit (Fixture *f, gconstpointer data)
+{
+	int i;
+	xtext_buffer *buf = f->xtext->buffer;
+	gtk_xtext_set_max_lines (f->xtext, 10);
+	for (i = 0; i < 100; i++) append (f, "line");
+	g_assert_cmpint (buf->num_lines, ==, 10);
+	g_assert_null (buf->text_first->prev);
+	g_assert_null (buf->text_last->next);
+	g_assert_cmpfloat (gtk_adjustment_get_value (f->xtext->adj), >=, 0);
+}
+
+static void test_follow_trim_oversized_entry (Fixture *f, gconstpointer data)
+{
+	char *long_text = g_strnfill (4000, 'W');
+	gtk_xtext_set_max_lines (f->xtext, 3);
+	append (f, "needle");
+	gtk_xtext_search (f->xtext, "W", follow, NULL);
+	gtk_xtext_clear (f->xtext->buffer, 1);
+	append (f, long_text);
+	g_assert_true (gtk_xtext_is_empty (f->xtext->buffer));
+	g_assert_null (f->xtext->buffer->search_found);
+	g_free (long_text);
+	append (f, "after oversized");
+	gtk_xtext_clear (f->xtext->buffer, G_MININT);
+	g_assert_true (gtk_xtext_is_empty (f->xtext->buffer));
+}
+
+static void test_stress (Fixture *f, gconstpointer data)
+{
+	static const char *tokens[] = {"text ", "猫", "😀", "\002bold\002", "\00304,02red\017", "\010hidden\010", "\037u\037", "\036s\036"};
+	GRand *random = g_rand_new_with_seed (0x78746578);
+	xtext_buffer *buf = f->xtext->buffer;
+	int i;
+	gtk_xtext_set_max_lines (f->xtext, 80);
+	for (i = 0; i < 2000; i++)
+	{
+		GString *text = g_string_new (NULL);
+		textentry *ent;
+		int j, lines = 0;
+		for (j = 0; j < 30; j++)
+			g_string_append (text, tokens[g_rand_int_range (random, 0, G_N_ELEMENTS (tokens))]);
+		if (i % 2)
+			gtk_xtext_append_indent (buf, (guchar *)"nick", -1, (guchar *)text->str, text->len, 1234);
+		else
+			gtk_xtext_append (buf, (guchar *)text->str, text->len, 1234);
+		g_string_free (text, TRUE);
+		if (i % 29 == 0) gtk_xtext_search (f->xtext, "text", follow | highlight, NULL);
+		if (i % 31 == 0) gtk_xtext_clear (buf, 1);
+		if (i % 37 == 0) gtk_xtext_clear (buf, -1);
+		if (i % 101 == 0) gtk_xtext_clear (buf, 0);
+		for (ent = buf->text_first; ent; ent = ent->next)
+		{
+			g_assert_true (g_utf8_validate ((char *)ent->str, ent->str_len, NULL));
+			g_assert_cmpint (ent->subline_count, >, 0);
+			lines += ent->subline_count;
+		}
+		g_assert_cmpint (buf->num_lines, ==, lines);
+		if (i % 43 == 0) cairo_surface_destroy (snapshot (f, FALSE));
+	}
+	g_rand_free (random);
+}
+
+static void test_buffers (Fixture *f, gconstpointer data)
+{
+	xtext_buffer *original = f->xtext->buffer;
+	xtext_buffer *second = gtk_xtext_buffer_new (f->xtext);
+	append (f, "original");
+	gtk_xtext_append (second, (guchar *)"alternate", -1, 1234);
+	gtk_xtext_buffer_show (f->xtext, second, TRUE);
+	g_assert_true (f->xtext->buffer == second);
+	cairo_surface_destroy (snapshot (f, FALSE));
+	gtk_xtext_buffer_show (f->xtext, original, TRUE);
+	g_assert_cmpstr ((char *)f->xtext->buffer->text_first->str, ==, "original");
+	gtk_xtext_buffer_free (second);
+}
+
+static void test_partial_draw_after_scroll (Fixture *f, gconstpointer data)
+{
+	cairo_surface_t *partial, *full;
+	int i, stride, height, y;
+	for (i = 0; i < 80; i++)
+	{
+		char *line = g_strdup_printf ("line %d — 猫 \002bold\002", i);
+		append (f, line);
+		g_free (line);
+	}
+	cairo_surface_destroy (snapshot (f, FALSE));
+	gtk_adjustment_set_value (f->xtext->adj, 12.5);
+	partial = snapshot (f, TRUE);
+	full = snapshot (f, FALSE);
+	stride = cairo_image_surface_get_stride (full);
+	height = cairo_image_surface_get_height (full);
+	for (y = f->xtext->fontsize; y < height; y++)
+		g_assert_cmpmem (cairo_image_surface_get_data (partial) + y * stride, stride,
+			cairo_image_surface_get_data (full) + y * stride, stride);
+	cairo_surface_destroy (partial);
+	cairo_surface_destroy (full);
+}
+
+static void test_image_lifecycle (Fixture *f, gconstpointer data)
+{
+	GdkPixbuf *image = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 800, 600);
+	xtext_buffer *buf = f->xtext->buffer;
+	textentry *ent;
+	guint handle;
+	int before;
+	gdk_pixbuf_fill (image, 0xff0000ff);
+	append (f, "image");
+	ent = buf->text_last;
+	before = buf->num_lines;
+	handle = gtk_xtext_image_load_begin (f->xtext, ent, "https://example.invalid/image.png");
+	g_assert_cmpuint (handle, !=, 0);
+	g_assert_cmpuint (gtk_xtext_image_load_begin (f->xtext, ent, "duplicate"), ==, 0);
+	g_assert_true (gtk_xtext_image_load_finish (handle, image));
+	g_assert_cmpint (buf->num_lines, >, before);
+	g_assert_true (gtk_xtext_entry_has_image (f->xtext, ent));
+	g_assert_cmpint (gdk_pixbuf_get_width (ent->image), <=, XTEXT_IMAGE_MAX_WIDTH);
+	g_assert_true (gtk_xtext_entry_get_full_image (f->xtext, ent) == image);
+	cairo_surface_destroy (snapshot (f, FALSE));
+	g_assert_true (gtk_xtext_image_remove (f->xtext, ent));
+	g_assert_cmpint (buf->num_lines, ==, before);
+	handle = gtk_xtext_image_load_begin (f->xtext, ent, "late");
+	gtk_xtext_clear (buf, 0);
+	g_assert_false (gtk_xtext_image_load_finish (handle, image));
+	g_assert_false (gtk_xtext_entry_has_image (f->xtext, ent));
+	g_assert_null (gtk_xtext_entry_get_full_image (f->xtext, ent));
+	g_object_unref (image);
+}
+
+static void test_background (Fixture *f, gconstpointer data)
+{
+	cairo_surface_t *background = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 32, 32);
+	cairo_t *cr = cairo_create (background);
+	cairo_set_source_rgb (cr, 0.2, 0.3, 0.4);
+	cairo_paint (cr);
+	cairo_destroy (cr);
+	gtk_xtext_set_background (f->xtext, background);
+	cairo_surface_destroy (background);
+	gtk_xtext_set_background (f->xtext, f->xtext->background_surface);
+	append (f, "background text");
+	cairo_surface_destroy (snapshot (f, FALSE));
+	gtk_xtext_set_background (f->xtext, NULL);
+	cairo_surface_destroy (snapshot (f, FALSE));
+}
+
+static void test_destroy_pending_sources (Fixture *f, gconstpointer data)
+{
+	guint image;
+	append (f, "pending");
+	image = gtk_xtext_image_load_begin (f->xtext, f->xtext->buffer->text_last, "late");
+	f->xtext->io_tag = g_timeout_add (10000, gtk_xtext_adjustment_timeout, f->xtext);
+	f->xtext->add_io_tag = g_timeout_add (10000, gtk_xtext_render_page_timeout, f->xtext);
+	f->xtext->scroll_tag = g_timeout_add (10000, gtk_xtext_scrollup_timeout, f->xtext);
+	gtk_widget_destroy (f->window);
+	g_assert_cmpint (f->xtext->io_tag, ==, 0);
+	g_assert_cmpint (f->xtext->add_io_tag, ==, 0);
+	g_assert_cmpint (f->xtext->scroll_tag, ==, 0);
+	g_assert_false (gtk_xtext_image_load_finish (image, NULL));
+	/* GtkWidget destruction must be safe if GObject dispose runs again. */
+	g_object_run_dispose (G_OBJECT (f->xtext));
+	f->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+}
+
+int main (int argc, char **argv)
+{
+	g_test_init (&argc, &argv, NULL);
+	if (!gtk_init_check (&argc, &argv))
+	{
+		g_test_message ("GTK display unavailable; run under Xvfb for widget coverage");
+		return 77;
+	}
+	prefs.hex_gui_mouse_scroll_speed = 10;
+#define ADD(name, function) g_test_add ("/xtext/" name, Fixture, NULL, fixture_setup, function, fixture_teardown)
+	ADD ("append/empty-bounded", test_empty_and_bounded_append);
+	ADD ("append/utf8-limits", test_utf8_limits);
+	ADD ("append/null-empty-prefix", test_null_empty_prefix);
+	ADD ("layout/wrapping", test_wrapping);
+	ADD ("layout/font-isolation", test_font_isolation);
+	ADD ("layout/wide-metrics", test_wide_metrics);
+	ADD ("render/formatting-timestamps", test_formatting);
+	ADD ("selection/clipboard", test_selection_and_clipboard);
+	ADD ("search/navigation-regex-clear", test_search);
+	ADD ("search/follow", test_follow_search);
+	ADD ("search/unicode-offsets", test_search_unicode_offsets);
+	ADD ("render/rawlog-hidden", test_rawlog_hidden_text);
+	ADD ("buffer/save", test_save);
+	ADD ("lifecycle/scrollable-ownership", test_scrollable_ownership);
+	ADD ("buffer/clear-marker", test_clear_and_marker);
+	ADD ("buffer/scrollback-limit", test_scrollback_limit);
+	ADD ("buffer/follow-trim-oversized", test_follow_trim_oversized_entry);
+	ADD ("buffer/stress", test_stress);
+	ADD ("buffer/switch", test_buffers);
+	ADD ("render/partial-scroll", test_partial_draw_after_scroll);
+	ADD ("images/lifecycle", test_image_lifecycle);
+	ADD ("render/background", test_background);
+	ADD ("lifecycle/pending-sources", test_destroy_pending_sources);
+#undef ADD
+	return g_test_run ();
+}

src/fe-gtk/textgui.c

@@ -400,7 +400,6 @@ pevent_treeview_new (GtkWidget *box)
 	scroll = gtk_scrolled_window_new (NULL, NULL);
 	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
-	gtk_widget_set_size_request (GTK_WIDGET (scroll), -1, 250);
 
 	store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 	g_return_val_if_fail (store != NULL, NULL);
@@ -437,7 +436,7 @@ pevent_treeview_new (GtkWidget *box)
 	gtk_tree_view_column_set_min_width (col, 100);
 
 	gtk_container_add (GTK_CONTAINER (scroll), view);
-	gtk_container_add (GTK_CONTAINER (box), scroll);
+	gtk_paned_pack1 (GTK_PANED (box), scroll, TRUE, FALSE);
 
 	return view;
 }
@@ -481,7 +480,7 @@ pevent_hlist_treeview_new (GtkWidget *box)
 	gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 
 	gtk_container_add (GTK_CONTAINER (scroll), view);
-	gtk_container_add (GTK_CONTAINER (box), scroll);
+	gtk_paned_pack2 (GTK_PANED (box), scroll, TRUE, FALSE);
 
 	return view;
 }
@@ -489,7 +488,7 @@ pevent_hlist_treeview_new (GtkWidget *box)
 void
 pevent_dialog_show ()
 {
-	GtkWidget *vbox, *hbox, *wid, *pane;
+	GtkWidget *vbox, *hbox, *wid, *pane, *preview_pane;
 	XTextColor xtext_palette[XTEXT_COLS];
 
 	if (pevent_dialog)
@@ -503,8 +502,12 @@ pevent_dialog_show ()
 											 TRUE, FALSE, pevent_dialog_close, NULL,
 											 600, 455, &vbox, 0);
 
+	preview_pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
+	gtk_box_pack_start (GTK_BOX (vbox), preview_pane, TRUE, TRUE, 0);
 	pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
-	gtk_box_pack_start (GTK_BOX (vbox), pane, TRUE, TRUE, 0);
+	gtk_paned_pack1 (GTK_PANED (preview_pane), pane, TRUE, FALSE);
+	gtk_paned_set_position (GTK_PANED (pane), 220);
+	gtk_paned_set_position (GTK_PANED (preview_pane), 330);
 	
 	pevent_dialog_list = pevent_treeview_new (pane);
 	pevent_dialog_fill (pevent_dialog_list);
@@ -513,12 +516,12 @@ pevent_dialog_show ()
 
 	wid = gtk_scrolled_window_new (NULL, NULL);
 	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (wid), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
-	gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, TRUE, 0);
+	gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (wid), 75);
+	gtk_paned_pack2 (GTK_PANED (preview_pane), wid, TRUE, FALSE);
 
 	theme_get_xtext_colors_for_widget (wid, xtext_palette, XTEXT_COLS);
 	pevent_dialog_twid = gtk_xtext_new (xtext_palette, 0);
 	gtk_widget_set_sensitive (pevent_dialog_twid, FALSE);
-	gtk_widget_set_size_request (pevent_dialog_twid, -1, 75);
 	gtk_container_add (GTK_CONTAINER (wid), pevent_dialog_twid);
 	gtk_xtext_set_font (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_font);
 	g_object_set_data (G_OBJECT (pevent_dialog), "xtext", pevent_dialog_twid);

src/fe-gtk/theme/theme-preferences.c

@@ -1911,6 +1911,7 @@ theme_preferences_create_page (GtkWindow *parent,
                                          G_TYPE_STRING,
                                          G_TYPE_INT);
         ui->gtk3_combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (gtk3_store));
+        gtk_widget_set_hexpand (ui->gtk3_combo, TRUE);
         g_object_unref (gtk3_store);
         renderer = gtk_cell_renderer_text_new ();
         gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->gtk3_combo), renderer, TRUE);