Merge branch 'gtk4-port'

1 files changed, 300 insertions, 255 deletions

diff --git a/src/tree.c b/src/tree.c
index 7d98ad2..644274d 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -1,64 +1,67 @@
+/* vim: colorcolumn=80 ts=4 sw=4
+ */
 /*
  * tree.c
  *
- * Copyright (C) 2002 Sun Microsystems, Inc.
+ * Copyright © 2002 Sun Microsystems, Inc.
+ * Copyright © 2021-2023 Logan Rathbone
  *
  * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
- * Authors: Glynn Foster <glynn.foster@sun.com>
+ * Original Authors: Glynn Foster <glynn.foster@sun.com>
  *          Jonathan Blanford <jrb@redhat.com>
  *          Kristian Rietveld <kris@gtk.org>
  */
 
-#include "config.h"
 
 #include "util.h"
 #include "zenity.h"
+
 #include <stdlib.h>
 #include <string.h>
 
-#define MAX_ELEMENTS_BEFORE_SCROLLING 5
+#include <config.h>
+
 #define PRINT_HIDE_COLUMN_SEPARATOR ","
 
-static GtkBuilder *builder;
+static GtkTreeView *tree_view;
 static GSList *selected;
-static gchar *separator;
+static char *separator;
 static gboolean print_all_columns = FALSE;
-static gint *print_columns = NULL;
-static gint *hide_columns = NULL;
+static int *print_columns = NULL;
+static int *hide_columns = NULL;
 static GIOChannel *channel;
 
-static int *zenity_tree_extract_column_indexes (char *indexes, gint n_columns);
-static gboolean zenity_tree_column_is_hidden (gint column_index);
-static void zenity_tree_dialog_response (
-	GtkWidget *widget, int response, gpointer data);
+static int *zenity_tree_extract_column_indexes (char *indexes, int n_columns);
+static gboolean zenity_tree_column_is_hidden (int column_index);
+static void zenity_tree_dialog_response (GtkWidget *widget, char *rstr, gpointer data);
 static void zenity_tree_row_activated (GtkTreeView *tree_view,
 	GtkTreePath *tree_path, GtkTreeViewColumn *tree_col, gpointer data);
 
 static gboolean
-zenity_tree_dialog_untoggle (
-	GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) {
-	GValue toggle_value = {
-		0,
-	};
+zenity_tree_dialog_untoggle (GtkTreeModel *model, GtkTreePath *path,
+		GtkTreeIter *iter, gpointer data)
+{
+	GValue toggle_value = G_VALUE_INIT;
 
 	gtk_tree_model_get_value (model, iter, 0, &toggle_value);
 
 	if (g_value_get_boolean (&toggle_value))
 		gtk_list_store_set (GTK_LIST_STORE (model), iter, 0, FALSE, -1);
+	
 	return FALSE;
 }
 
@@ -73,10 +76,14 @@ check_or_radio_label_activated_cb (GtkTreeView *tree_view,
 	gboolean value;
 
 	/* Because this is a radio list, we should untoggle the previous toggle so
-	 * that
-	 * we only have one selection at any given time
+	 * that we only have one selection at any given time
 	 */
+<<<<<<< HEAD
 	if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model), "radio")) == 1) {
+=======
+	if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model), "radio")) == 1)
+	{
+>>>>>>> gtk4-port
 		gtk_tree_model_foreach (model, zenity_tree_dialog_untoggle, NULL);
 	}
 
@@ -89,27 +96,31 @@ check_or_radio_label_activated_cb (GtkTreeView *tree_view,
 
 static void
 zenity_load_pixbuf (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
-	GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) {
+	GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
+{
 	static GHashTable *pixbuf_cache = NULL;
 	GError *error = NULL;
 	GdkPixbuf *pixbuf;
-	gchar *str;
+	g_autofree char *str = NULL;
 
 	gtk_tree_model_get (tree_model, iter, 0, &str, -1);
 
-	if (!str)
+	if (! str)
 		return;
 
-	if (!pixbuf_cache) {
+	if (! pixbuf_cache)
+	{
 		pixbuf_cache = g_hash_table_new (g_str_hash, g_str_equal);
 		g_assert (pixbuf_cache);
 	}
 
 	pixbuf = g_hash_table_lookup (pixbuf_cache, str);
 
-	if (!pixbuf) {
+	if (! pixbuf)
+	{
 		pixbuf = gdk_pixbuf_new_from_file (str, &error);
-		if (!pixbuf)
+
+		if (! pixbuf)
 			g_warning ("Failed to load '%s'", str);
 
 		g_hash_table_insert (pixbuf_cache, g_strdup (str), pixbuf);
@@ -117,25 +128,25 @@ zenity_load_pixbuf (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
 
 	if (pixbuf)
 		g_object_set (cell, "pixbuf", pixbuf, NULL);
-
-	g_free (str);
 }
 
 static gboolean
-zenity_tree_handle_stdin (
-	GIOChannel *channel, GIOCondition condition, gpointer data) {
-	static GtkTreeView *tree_view;
+zenity_tree_handle_stdin (GIOChannel *channel, GIOCondition condition,
+		gpointer data)
+{
 	GtkTreeModel *model;
 	static GtkTreeIter iter;
-	static gint column_count = 0;
-	static gint row_count = 0;
-	static gint n_columns;
+	static int column_count = 0;
+	static int row_count = 0;
+	static int n_columns;
 	static gboolean editable;
 	static gboolean toggles;
 	static gboolean first_time = TRUE;
 	GIOStatus status = G_IO_STATUS_NORMAL;
 
-	tree_view = GTK_TREE_VIEW (data);
+	/* Make sure global is properly defined */
+	g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), FALSE);
+
 	n_columns =
 		GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
 	editable =
@@ -145,14 +156,16 @@ zenity_tree_handle_stdin (
 
 	model = gtk_tree_view_get_model (tree_view);
 
-	if (first_time) {
+	if (first_time)
+	{
 		first_time = FALSE;
 		gtk_list_store_append (GTK_LIST_STORE (model), &iter);
 	}
 
-	if ((condition & G_IO_IN) == G_IO_IN) {
-		GString *string;
-		GError *error = NULL;
+	if ((condition & G_IO_IN) == G_IO_IN)
+	{
+		g_autoptr(GString) string = NULL;
+		g_autoptr(GError) error = NULL;
 
 		string = g_string_new (NULL);
 
@@ -161,47 +174,55 @@ zenity_tree_handle_stdin (
 			;
 		do {
 			do {
-				if (g_io_channel_get_flags (channel) & G_IO_FLAG_IS_READABLE)
-					status = g_io_channel_read_line_string (
-						channel, string, NULL, &error);
-				else
+				if (g_io_channel_get_flags (channel) & G_IO_FLAG_IS_READABLE) {
+					status = g_io_channel_read_line_string (channel,
+							string, NULL, &error);
+				} else {
 					return FALSE;
+				}
 
-				while (gtk_events_pending ())
-					gtk_main_iteration ();
-
-				// TODO: Find a better way to avoid 100% cpu utilization
+				while (g_main_context_pending (NULL)) {
+					g_main_context_iteration (NULL, FALSE);
+				}
+				/* FIXME: Find a better way to avoid 100% cpu utilization */
 				g_usleep (10000);
 
 			} while (status == G_IO_STATUS_AGAIN);
 
-			if (status != G_IO_STATUS_NORMAL) {
+			if (status != G_IO_STATUS_NORMAL)
+			{
 				if (error) {
-					g_warning (
-						"zenity_tree_handle_stdin () : %s", error->message);
-					g_error_free (error);
+					g_warning ("%s: %s",
+						__func__, error->message);
 					error = NULL;
 				}
 				continue;
 			}
 
-			if (column_count == n_columns) {
+			if (column_count == n_columns)
+			{
 				/* We're starting a new row */
 				column_count = 0;
 				row_count++;
 				gtk_list_store_append (GTK_LIST_STORE (model), &iter);
 			}
 
-			if (toggles && column_count == 0) {
+			if (toggles && column_count == 0)
+			{
 				if (strcmp (g_ascii_strdown (
 								zenity_util_strip_newline (string->str), -1),
 						"true") == 0)
-					gtk_list_store_set (
-						GTK_LIST_STORE (model), &iter, column_count, TRUE, -1);
-				else
+				{
+					gtk_list_store_set (GTK_LIST_STORE(model),
+							&iter, column_count, TRUE, -1);
+				}
+				else {
 					gtk_list_store_set (
 						GTK_LIST_STORE (model), &iter, column_count, FALSE, -1);
-			} else {
+				}
+			}
+			else
+			{
 				gtk_list_store_set (GTK_LIST_STORE (model),
 					&iter,
 					column_count,
@@ -210,35 +231,19 @@ zenity_tree_handle_stdin (
 			}
 
 			if (editable) {
-				gtk_list_store_set (
-					GTK_LIST_STORE (model), &iter, n_columns, TRUE, -1);
-			}
-
-			if (row_count == MAX_ELEMENTS_BEFORE_SCROLLING) {
-				GtkWidget *scrolled_window;
-				GtkRequisition rectangle;
-
-				gtk_widget_get_preferred_size (
-					GTK_WIDGET (tree_view), &rectangle, NULL);
-				scrolled_window = GTK_WIDGET (
-					gtk_builder_get_object (builder, "zenity_tree_window"));
-				gtk_widget_set_size_request (
-					scrolled_window, -1, rectangle.height);
-				gtk_scrolled_window_set_policy (
-					GTK_SCROLLED_WINDOW (scrolled_window),
-					GTK_POLICY_AUTOMATIC,
-					GTK_POLICY_AUTOMATIC);
+				gtk_list_store_set (GTK_LIST_STORE(model),
+						&iter, n_columns, TRUE, -1);
 			}
 
 			column_count++;
 
 		} while ((g_io_channel_get_buffer_condition (channel) & G_IO_IN) ==
 				G_IO_IN &&
-			status != G_IO_STATUS_EOF);
-		g_string_free (string, TRUE);
+			status != G_IO_STATUS_EOF);	/* !do while */
 	}
 
-	if ((condition & G_IO_IN) != G_IO_IN || status == G_IO_STATUS_EOF) {
+	if ((condition & G_IO_IN) != G_IO_IN || status == G_IO_STATUS_EOF)
+	{
 		g_io_channel_shutdown (channel, TRUE, NULL);
 		return FALSE;
 	}
@@ -246,8 +251,13 @@ zenity_tree_handle_stdin (
 }
 
 static void
-zenity_tree_fill_entries_from_stdin (GtkTreeView *tree_view, gint n_columns,
-	gboolean toggles, gboolean editable) {
+zenity_tree_fill_entries_from_stdin (GtkTreeView *loc_tv, int n_columns,
+	gboolean toggles, gboolean editable)
+{
+	/* No reason this should fail. Sanity check. */
+	g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
+	g_assert (loc_tv == tree_view);
+
 	g_object_set_data (
 		G_OBJECT (tree_view), "n_columns", GINT_TO_POINTER (n_columns));
 	g_object_set_data (
@@ -258,16 +268,21 @@ zenity_tree_fill_entries_from_stdin (GtkTreeView *tree_view, gint n_columns,
 	channel = g_io_channel_unix_new (0);
 	g_io_channel_set_encoding (channel, NULL, NULL);
 	g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
-	g_io_add_watch (
-		channel, G_IO_IN | G_IO_HUP, zenity_tree_handle_stdin, tree_view);
+	g_io_add_watch (channel,
+			G_IO_IN | G_IO_HUP, zenity_tree_handle_stdin, NULL);
 }
 
 static void
-zenity_tree_fill_entries (GtkTreeView *tree_view, const gchar **args,
-	gint n_columns, gboolean toggles, gboolean editable) {
+zenity_tree_fill_entries (GtkTreeView *loc_tv, const char **args,
+	int n_columns, gboolean toggles, gboolean editable)
+{
 	GtkTreeModel *model;
 	GtkTreeIter iter;
-	gint i = 0;
+	int i = 0;
+
+	/* No reason this should fail. Sanity check. */
+	g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
+	g_assert (loc_tv == tree_view);
 
 	model = gtk_tree_view_get_model (tree_view);
 
@@ -275,7 +290,7 @@ zenity_tree_fill_entries (GtkTreeView *tree_view, const gchar **args,
 		G_OBJECT (tree_view), "n_columns", GINT_TO_POINTER (n_columns));
 
 	while (args[i] != NULL) {
-		gint j;
+		int j;
 
 		gtk_list_store_append (GTK_LIST_STORE (model), &iter);
 
@@ -294,45 +309,34 @@ zenity_tree_fill_entries (GtkTreeView *tree_view, const gchar **args,
 					GTK_LIST_STORE (model), &iter, j, args[i + j], -1);
 		}
 
-		if (editable)
-			gtk_list_store_set (
-				GTK_LIST_STORE (model), &iter, n_columns, TRUE, -1);
-
-		if (i == MAX_ELEMENTS_BEFORE_SCROLLING) {
-			GtkWidget *scrolled_window;
-			GtkRequisition rectangle;
-
-			gtk_widget_get_preferred_size (
-				GTK_WIDGET (tree_view), &rectangle, NULL);
-			scrolled_window = GTK_WIDGET (
-				gtk_builder_get_object (builder, "zenity_tree_window"));
-			gtk_widget_set_size_request (scrolled_window, -1, rectangle.height);
-			gtk_scrolled_window_set_policy (
-				GTK_SCROLLED_WINDOW (scrolled_window),
-				GTK_POLICY_AUTOMATIC,
-				GTK_POLICY_AUTOMATIC);
+		if (editable) {
+			gtk_list_store_set (GTK_LIST_STORE(model),
+					&iter, n_columns, TRUE, -1);
 		}
-
 		i += n_columns;
 	}
 }
 
 static gboolean
-zenity_mid_search_func (GtkTreeModel *model, gint column, const gchar *key,
-	GtkTreeIter *iter, gpointer search_data) {
-	gchar *iter_string = NULL;
+zenity_mid_search_func (GtkTreeModel *model, int column, const char *key,
+	GtkTreeIter *iter, gpointer search_data)
+{
+	char *iter_string = NULL;
+
 	gtk_tree_model_get (model, iter, column, &iter_string, -1);
+
 	return !(g_strrstr (g_utf8_strdown (iter_string, -1),
 				 g_utf8_strdown (key, -1)) != NULL);
 }
 
 static void
 zenity_cell_edited_callback (GtkCellRendererText *cell,
-	const gchar *path_string, const gchar *new_text, gpointer data) {
+	const char *path_string, const char *new_text, gpointer data)
+{
 	GtkTreeModel *model;
-	GtkTreePath *path;
+	g_autoptr(GtkTreePath) path = NULL;
 	GtkTreeIter iter;
-	gint column;
+	int column;
 
 	model = GTK_TREE_MODEL (data);
 	path = gtk_tree_path_new_from_string (path_string);
@@ -341,24 +345,22 @@ zenity_cell_edited_callback (GtkCellRendererText *cell,
 	gtk_tree_model_get_iter (model, &iter, path);
 
 	gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, new_text, -1);
-
-	gtk_tree_path_free (path);
 }
 
 void
-zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
+zenity_tree (ZenityData *data, ZenityTreeData *tree_data)
+{
+	g_autoptr(GtkBuilder) builder = NULL;
 	GtkWidget *dialog;
-	GtkWidget *button;
-	GObject *tree_view;
 	GObject *text;
 	GtkTreeViewColumn *column;
 	GtkListStore *model;
 	GType *column_types;
 	GSList *tmp;
 	gboolean first_column = FALSE;
-	gint i, column_index, n_columns;
+	int i, column_index, n_columns;
 
-	builder = zenity_util_load_ui_file ("zenity_tree_dialog", NULL);
+	builder = zenity_util_load_ui_file ("zenity_tree_dialog", "zenity_tree_box", NULL);
 
 	if (builder == NULL) {
 		data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
@@ -369,43 +371,44 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 
 	n_columns = g_slist_length (tree_data->columns);
 
-	if (tree_data->print_column) {
+	if (tree_data->print_column)
+	{
 		if (strcmp (g_ascii_strdown (tree_data->print_column, -1), "all") == 0)
 			print_all_columns = TRUE;
 		else
 			print_columns = zenity_tree_extract_column_indexes (
 				tree_data->print_column, n_columns);
-	} else {
+	}
+	else
+	{
 		print_columns = g_new (gint, 2);
 		print_columns[0] = (tree_data->radiobox || tree_data->checkbox ? 2 : 1);
 		print_columns[1] = 0;
 	}
 
-	if (tree_data->hide_column)
-		hide_columns = zenity_tree_extract_column_indexes (
-			tree_data->hide_column, n_columns);
+	if (tree_data->hide_column) {
+		hide_columns =
+			zenity_tree_extract_column_indexes (tree_data->hide_column,
+					n_columns);
+	}
 
 	if (n_columns == 0) {
-		g_printerr (_ ("No column titles specified for List dialog.\n"));
+		g_printerr (_("No column titles specified for List dialog.\n"));
 		data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
 		return;
 	}
 
-	if (tree_data->checkbox + tree_data->radiobox + tree_data->imagebox > 1) {
+	if (tree_data->checkbox + tree_data->radiobox + tree_data->imagebox > 1)
+	{
 		g_printerr (_ ("You should use only one List dialog type.\n"));
 		data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
 		return;
 	}
 
-	gtk_builder_connect_signals (builder, NULL);
-
-	dialog =
-		GTK_WIDGET (gtk_builder_get_object (builder, "zenity_tree_dialog"));
+	dialog = GTK_WIDGET(gtk_builder_get_object (builder,
+				"zenity_tree_dialog"));
 
-	g_signal_connect (G_OBJECT (dialog),
-		"response",
-		G_CALLBACK (zenity_tree_dialog_response),
-		data);
+	g_signal_connect (dialog, "response", G_CALLBACK(zenity_tree_dialog_response), data);
 
 	if (data->dialog_title)
 		gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
@@ -413,41 +416,36 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 	if (data->modal)
 		gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
 
-	if (data->extra_label) {
-		gint i = 0;
-		while (data->extra_label[i] != NULL) {
-			gtk_dialog_add_button (
-				GTK_DIALOG (dialog), data->extra_label[i], i);
-			i++;
-		}
+	if (data->extra_label)
+	{
+		ZENITY_UTIL_ADD_EXTRA_LABELS (dialog)
 	}
 
 	if (data->ok_label) {
-		button = GTK_WIDGET (
-			gtk_builder_get_object (builder, "zenity_tree_ok_button"));
-		gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
+		ZENITY_UTIL_SETUP_OK_BUTTON_LABEL (dialog)
 	}
 
 	if (data->cancel_label) {
-		button = GTK_WIDGET (
-			gtk_builder_get_object (builder, "zenity_tree_cancel_button"));
-		gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
+		ZENITY_UTIL_SETUP_CANCEL_BUTTON_LABEL (dialog)
 	}
 
 	text = gtk_builder_get_object (builder, "zenity_tree_text");
 
 	if (tree_data->dialog_text)
-		gtk_label_set_markup (
-			GTK_LABEL (text), g_strcompress (tree_data->dialog_text));
+		gtk_label_set_markup (GTK_LABEL(text),
+				g_strcompress (tree_data->dialog_text));
 
-	zenity_util_set_window_icon (
-		dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-list.png"));
+	gtk_window_set_icon_name (GTK_WINDOW(dialog),
+			"view-sort-ascending");
 
-	if (data->width > -1 || data->height > -1)
-		gtk_window_set_default_size (
-			GTK_WINDOW (dialog), data->width, data->height);
+	if (data->width > -1 || data->height > -1) {
+		gtk_window_set_default_size (GTK_WINDOW(dialog),
+				data->width, data->height);
+	}
 
-	tree_view = gtk_builder_get_object (builder, "zenity_tree_view");
+	/* Define global tree_view. */
+	tree_view = GTK_TREE_VIEW(gtk_builder_get_object (builder,
+				"zenity_tree_view"));
 
 	if (tree_data->radiobox || tree_data->checkbox)
 	{
@@ -475,7 +473,8 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 	else
 		column_types = g_new (GType, n_columns);
 
-	for (i = 0; i < n_columns; i++) {
+	for (i = 0; i < n_columns; i++)
+	{
 		/* Have the limitation that the radioboxes and checkboxes are in the
 		 * first column */
 		if (i == 0 && (tree_data->checkbox || tree_data->radiobox))
@@ -492,7 +491,7 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 	else
 		gtk_list_store_set_column_types (model, n_columns, column_types);
 
-	gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model));
+	gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL(model));
 
 	if (tree_data->radiobox || tree_data->checkbox)
 	{
@@ -504,19 +503,22 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 	{
 		if (tree_data->multi)
 			gtk_tree_selection_set_mode (
-				gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+				gtk_tree_view_get_selection (tree_view),
 				GTK_SELECTION_MULTIPLE);
 		else
 			gtk_tree_selection_set_mode (
-				gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
+				gtk_tree_view_get_selection (tree_view),
 				GTK_SELECTION_SINGLE);
 	}
 
 	column_index = 0;
 
-	for (tmp = tree_data->columns; tmp; tmp = tmp->next) {
-		if (!first_column) {
-			if (tree_data->checkbox || tree_data->radiobox) {
+	for (tmp = tree_data->columns; tmp; tmp = tmp->next)
+	{
+		if (! first_column)
+		{
+			if (tree_data->checkbox || tree_data->radiobox)
+			{
 				GtkCellRenderer *cell_renderer;
 
 				cell_renderer = gtk_cell_renderer_toggle_new ();
@@ -530,22 +532,28 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 
 				column = gtk_tree_view_column_new_with_attributes (
 					tmp->data, cell_renderer, "active", column_index, NULL);
-			} else if (tree_data->imagebox) {
+			}
+			else if (tree_data->imagebox)
+			{
 				GtkCellRenderer *cell_renderer =
 					gtk_cell_renderer_pixbuf_new ();
+
 				column = gtk_tree_view_column_new_with_attributes (
 					tmp->data, cell_renderer, NULL);
 				gtk_tree_view_column_set_cell_data_func (
 					column, cell_renderer, zenity_load_pixbuf, NULL, NULL);
-			} else {
-				if (tree_data->editable) {
+			}
+			else
+			{
+				if (tree_data->editable)
+				{
 					GtkCellRenderer *cell_renderer;
 
 					cell_renderer = gtk_cell_renderer_text_new ();
-					g_signal_connect (G_OBJECT (cell_renderer),
-						"edited",
+					g_signal_connect (cell_renderer, "edited",
 						G_CALLBACK (zenity_cell_edited_callback),
-						gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)));
+						gtk_tree_view_get_model (tree_view));
+
 					g_object_set_data (G_OBJECT (cell_renderer),
 						"column",
 						GINT_TO_POINTER (column_index));
@@ -558,7 +566,9 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 							"editable",
 							n_columns,
 							NULL);
-				} else {
+				}
+				else
+				{
 					column =
 						gtk_tree_view_column_new_with_attributes (tmp->data,
 							gtk_cell_renderer_text_new (),
@@ -574,15 +584,18 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 				gtk_tree_view_column_set_visible (column, FALSE);
 
 			first_column = TRUE;
-		} else {
-			if (tree_data->editable) {
+		}
+		else
+		{
+			if (tree_data->editable)
+			{
 				GtkCellRenderer *cell_renderer;
 
 				cell_renderer = gtk_cell_renderer_text_new ();
-				g_signal_connect (G_OBJECT (cell_renderer),
-					"edited",
+				g_signal_connect (cell_renderer, "edited",
 					G_CALLBACK (zenity_cell_edited_callback),
-					gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)));
+					gtk_tree_view_get_model (tree_view));
+
 				g_object_set_data (G_OBJECT (cell_renderer),
 					"column",
 					GINT_TO_POINTER (column_index));
@@ -594,7 +607,9 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 					"editable",
 					n_columns,
 					NULL);
-			} else {
+			}
+			else
+			{
 				column = gtk_tree_view_column_new_with_attributes (tmp->data,
 					gtk_cell_renderer_text_new (),
 					"text",
@@ -609,37 +624,43 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 				gtk_tree_view_column_set_visible (column, FALSE);
 		}
 
-		gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
+		gtk_tree_view_append_column (tree_view, column);
 		column_index++;
 	}
 
 	if (tree_data->hide_header)
-		gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
+		gtk_tree_view_set_headers_visible (tree_view, FALSE);
 
-	if (tree_data->radiobox || tree_data->checkbox) {
-		if (tree_data->data && *tree_data->data)
-			zenity_tree_fill_entries (GTK_TREE_VIEW (tree_view),
+	if (tree_data->radiobox || tree_data->checkbox)
+	{
+		if (tree_data->data && *tree_data->data) {
+			zenity_tree_fill_entries (tree_view,
 				tree_data->data,
 				n_columns,
 				TRUE,
 				tree_data->editable);
-		else
-			zenity_tree_fill_entries_from_stdin (GTK_TREE_VIEW (tree_view),
+		}
+		else {
+			zenity_tree_fill_entries_from_stdin (tree_view,
 				n_columns,
 				TRUE,
 				tree_data->editable);
-	} else {
-		if (tree_data->data && *tree_data->data)
-			zenity_tree_fill_entries (GTK_TREE_VIEW (tree_view),
+		}
+	}
+	else
+	{
+		if (tree_data->data && *tree_data->data) {
+			zenity_tree_fill_entries (tree_view,
 				tree_data->data,
 				n_columns,
 				FALSE,
 				tree_data->editable);
-		else
-			zenity_tree_fill_entries_from_stdin (GTK_TREE_VIEW (tree_view),
+		} else {
+			zenity_tree_fill_entries_from_stdin (tree_view,
 				n_columns,
 				FALSE,
 				tree_data->editable);
+		}
 	}
 
 	/* GTK will automatically pick the image column as the search column
@@ -650,13 +671,14 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 			1);
 	}
 
-	zenity_util_show_dialog (dialog, data->attach);
+	zenity_util_show_dialog (dialog);
 
-	if (tree_data->mid_search)
-		gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (tree_view),
+	if (tree_data->mid_search) {
+		gtk_tree_view_set_search_equal_func (tree_view,
 			(GtkTreeViewSearchEqualFunc) zenity_mid_search_func,
 			model,
 			NULL);
+	}
 
 	if (data->timeout_delay > 0) {
 		g_timeout_add_seconds (data->timeout_delay,
@@ -664,24 +686,23 @@ zenity_tree (ZenityData *data, ZenityTreeData *tree_data) {
 			dialog);
 	}
 
-	gtk_main ();
-
-	g_object_unref (builder);
+	zenity_util_gapp_main (GTK_WINDOW(dialog));
 }
 
 static void
 zenity_tree_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf,
-	GtkTreeIter *iter, GtkTreeView *tree_view) {
-	GValue value = {
-		0,
-	};
-	gint n_columns, i;
+	GtkTreeIter *iter, gpointer user_data)
+{
+	GValue value = G_VALUE_INIT;
+	int n_columns, i;
 
 	n_columns =
 		GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
 
-	if (print_all_columns) {
-		for (i = 0; i < n_columns; i++) {
+	if (print_all_columns)
+	{
+		for (i = 0; i < n_columns; i++)
+		{
 			gtk_tree_model_get_value (model, iter, i, &value);
 
 			selected = g_slist_append (selected, g_value_dup_string (&value));
@@ -690,34 +711,35 @@ zenity_tree_dialog_get_selected (GtkTreeModel *model, GtkTreePath *path_buf,
 		return;
 	}
 
-	for (i = 0; print_columns[i] != 0; i++) {
+	for (i = 0; print_columns[i] != 0; i++)
+	{
 		gtk_tree_model_get_value (model, iter, print_columns[i] - 1, &value);
-
 		selected = g_slist_append (selected, g_value_dup_string (&value));
+
 		g_value_unset (&value);
 	}
 }
 
 static gboolean
 zenity_tree_dialog_toggle_get_selected (GtkTreeModel *model, GtkTreePath *path,
-	GtkTreeIter *iter, GtkTreeView *tree_view) {
-	GValue toggle_value = {
-		0,
-	};
-	gint n_columns, i;
+	GtkTreeIter *iter, gpointer user_data)
+{
+	GValue toggle_value = G_VALUE_INIT;
+	int n_columns, i;
 
 	n_columns =
 		GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tree_view), "n_columns"));
 
 	gtk_tree_model_get_value (model, iter, 0, &toggle_value);
 
-	if (g_value_get_boolean (&toggle_value)) {
-		GValue value = {
-			0,
-		};
+	if (g_value_get_boolean (&toggle_value))
+	{
+		GValue value = G_VALUE_INIT;
 
-		if (print_all_columns) {
-			for (i = 1; i < n_columns; i++) {
+		if (print_all_columns)
+		{
+			for (i = 1; i < n_columns; i++)
+			{
 				gtk_tree_model_get_value (model, iter, i, &value);
 
 				selected =
@@ -728,7 +750,8 @@ zenity_tree_dialog_toggle_get_selected (GtkTreeModel *model, GtkTreePath *path,
 			return FALSE;
 		}
 
-		for (i = 0; print_columns[i] != 0; i++) {
+		for (i = 0; print_columns[i] != 0; i++)
+		{
 			gtk_tree_model_get_value (
 				model, iter, print_columns[i] - 1, &value);
 
@@ -736,59 +759,65 @@ zenity_tree_dialog_toggle_get_selected (GtkTreeModel *model, GtkTreePath *path,
 			g_value_unset (&value);
 		}
 	}
-
 	g_value_unset (&toggle_value);
 
 	return FALSE;
 }
 
 static void
-zenity_tree_dialog_output (void) {
-	GObject *tree_view;
+zenity_tree_dialog_output (void)
+{
 	GtkTreeSelection *selection;
 	GtkTreeModel *model;
 
-	tree_view = gtk_builder_get_object (builder, "zenity_tree_view");
-	model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
+	g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
+
+	model = gtk_tree_view_get_model (tree_view);
 
 	if (gtk_tree_model_get_column_type (model, 0) == G_TYPE_BOOLEAN)
+	{
 		gtk_tree_model_foreach (model,
 			(GtkTreeModelForeachFunc) zenity_tree_dialog_toggle_get_selected,
-			GTK_TREE_VIEW (tree_view));
-	else {
-		selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
+			NULL);
+	}
+	else
+	{
+		selection = gtk_tree_view_get_selection (tree_view);
 		gtk_tree_selection_selected_foreach (selection,
 			(GtkTreeSelectionForeachFunc) zenity_tree_dialog_get_selected,
-			GTK_TREE_VIEW (tree_view));
+			NULL);
 	}
 
-	GSList *tmp;
 
-	for (tmp = selected; tmp; tmp = tmp->next) {
+	for (GSList *tmp = selected; tmp != NULL; tmp = tmp->next)
+	{
 		if (tmp->next != NULL) {
-			g_print ("%s%s", (gchar *) tmp->data, separator);
-		} else
-			g_print ("%s\n", (gchar *) tmp->data);
+			g_print ("%s%s", (char *)tmp->data, separator);
+		} else {
+			g_print ("%s\n", (char *)tmp->data);
+		}
 	}
 
 	g_free (print_columns);
 	g_free (hide_columns);
 	g_free (separator);
-	g_slist_foreach (selected, (GFunc) g_free, NULL);
-	selected = NULL;
+	g_slist_free_full (g_steal_pointer (&selected), g_free);
 }
 
 static void
-zenity_tree_dialog_response (GtkWidget *widget, int response, gpointer data) {
+zenity_tree_dialog_response (GtkWidget *widget, char *rstr, gpointer data)
+{
 	ZenityData *zen_data = data;
+	ZenityExitCode response = zenity_util_parse_dialog_response (rstr);
 
-	switch (response) {
-		case GTK_RESPONSE_OK:
+	switch (response)
+	{
+		case ZENITY_OK:
 			zenity_tree_dialog_output ();
 			zenity_util_exit_code_with_data (ZENITY_OK, zen_data);
 			break;
 
-		case GTK_RESPONSE_CANCEL:
+		case ZENITY_CANCEL:
 			zen_data->exit_code = zenity_util_return_exit_code (ZENITY_CANCEL);
 			break;
 
@@ -799,62 +828,78 @@ zenity_tree_dialog_response (GtkWidget *widget, int response, gpointer data) {
 
 		default:
 			if (zen_data->extra_label &&
-				response < g_strv_length (zen_data->extra_label))
+				response < (int)g_strv_length (zen_data->extra_label))
+			{
 				printf ("%s\n", zen_data->extra_label[response]);
+			}
 			zen_data->exit_code = zenity_util_return_exit_code (ZENITY_ESC);
 			break;
 	}
 	if (channel != NULL &&
 		g_io_channel_get_flags (channel) & G_IO_FLAG_IS_READABLE)
+	{
 		g_io_channel_shutdown (channel, TRUE, NULL);
+	}
 
-	gtk_main_quit ();
+	zenity_util_gapp_quit (GTK_WINDOW(widget), zen_data);
 }
 
 static void
-zenity_tree_row_activated (GtkTreeView *tree_view, GtkTreePath *tree_path,
-	GtkTreeViewColumn *tree_col, gpointer data) {
+zenity_tree_row_activated (GtkTreeView *loc_tv, GtkTreePath *tree_path,
+	GtkTreeViewColumn *tree_col, gpointer data)
+{
+	GtkWindow *parent;
 	ZenityData *zen_data = data;
 
+	/* No reason this should fail. Sanity check. */
+	g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
+	g_assert (loc_tv == tree_view);
+
 	zenity_tree_dialog_output ();
 	zen_data->exit_code = zenity_util_return_exit_code (ZENITY_OK);
-	gtk_main_quit ();
+
+	parent = GTK_WINDOW(gtk_widget_get_native (GTK_WIDGET(tree_view)));
+
+	zenity_util_gapp_quit (parent, zen_data);
 }
 
 static gboolean
-zenity_tree_column_is_hidden (gint column_index) {
-	gint i;
-
+zenity_tree_column_is_hidden (int column_index)
+{
 	if (hide_columns != NULL)
-		for (i = 0; hide_columns[i] != 0; i++)
+	{
+		for (int i = 0; hide_columns[i] != 0; i++)
+		{
 			if (hide_columns[i] == column_index)
 				return TRUE;
-
+		}
+	}
 	return FALSE;
 }
 
-static gint *
-zenity_tree_extract_column_indexes (char *indexes, int n_columns) {
-	char **tmp;
-	gint *result;
-	gint i, j, index;
+static int *
+zenity_tree_extract_column_indexes (char *indexes, int n_columns)
+{
+	g_auto(GStrv) tmp;
+	int *result;
+	int i, j, index;
 
 	tmp = g_strsplit (indexes, PRINT_HIDE_COLUMN_SEPARATOR, 0);
 
-	result = g_new (gint, 1);
+	result = g_new (int, 1);
 
-	for (j = i = 0; tmp[i] != NULL; i++) {
+	for (j = i = 0; tmp[i] != NULL; i++)
+	{
 		index = atoi (tmp[i]);
 
-		if (index > 0 && index <= n_columns) {
+		if (index > 0 && index <= n_columns)
+		{
 			result[j] = index;
 			j++;
-			result = g_renew (gint, result, j + 1);
+			result = g_renew (int, result, j + 1);
 		}
 	}
 	result[j] = 0;
 
-	g_strfreev (tmp);
-
 	return result;
 }