menus.c

#include "zterm.h"
#include <alloca.h>

void do_reload_config (GSimpleAction *self, GVariant *parameter, gpointer user_data)
{
	int old_n_active = terms.n_active;

	if (!zterm_parse_config ()) {
		errorf ("Unable to read new config, falling back to legacy config.");
		temu_parse_config ();
	}
	if (!terms.n_active) {
		errorf ("Unable to read config file, or no terminals defined.");
		return;
	}

	// We actively don't want to worry about the number shrinking.  That just makes too much pain.
	// But we absolutely have to handle it growing.
	if (terms.n_active > old_n_active) {
		debugf ("old_n_active: %d, terms.n_active: %d", old_n_active, terms.n_active);
		terms.active = realloc (terms.active, terms.n_active * sizeof (*terms.active));
		memset (&terms.active[old_n_active], 0, (terms.n_active - old_n_active) * sizeof (*terms.active));
	}

	for (int i = 0; i < terms.n_active; i++) {
		if (terms.active[i].term) {
			term_config (terms.active[i].term, terms.active[i].window);
			// vte_terminal_set_geometry_hints_for_window(VTE_TERMINAL (terms.active[i].term), GTK_WINDOW
			// (windows[terms.active[i].window].window));
		}
	}

	rebuild_menus ();
}

void do_copy (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i = (long int) data;

	debugf ("parameter: %p, user_data: %p", parameter, data);

	GtkWidget *widget = gtk_notebook_get_nth_page (windows[i].notebook, gtk_notebook_get_current_page (windows[i].notebook));
	vte_terminal_copy_clipboard_format (VTE_TERMINAL (widget), VTE_FORMAT_TEXT);
}

void do_copy_uri (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int window_i = (long int) data;
	int		 n;

	debugf ("parameter: %p, user_data: %p", parameter, data);

	window_t *window = &windows[window_i];

	GtkWidget *widget = gtk_notebook_get_nth_page (window->notebook, gtk_notebook_get_current_page (window->notebook));

	if (term_find (widget, &n)) {
		process_uri (n, window, BIND_ACT_CUT_URI, window->menu_x, window->menu_y, true);
	}
}

void do_open_uri (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int window_i = (long int) data;
	int		 n;

	debugf ("parameter: %p, user_data: %p", parameter, data);

	window_t *window = &windows[window_i];

	GtkWidget *widget = gtk_notebook_get_nth_page (window->notebook, gtk_notebook_get_current_page (window->notebook));

	if (term_find (widget, &n)) {
		process_uri (n, window, BIND_ACT_OPEN_URI, window->menu_x, window->menu_y, true);
	}
}

void do_paste (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i = (long int) data;

	debugf ("parameter: %p, user_data: %p", parameter, data);

	GtkWidget *widget = gtk_notebook_get_nth_page (windows[i].notebook, gtk_notebook_get_current_page (windows[i].notebook));
	vte_terminal_paste_clipboard (VTE_TERMINAL (widget));
}

void do_t_decorate (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i = (long int) data;

	gboolean decorated = gtk_window_get_decorated (GTK_WINDOW (windows[i].window));
	debugf ("setting decorated: %d", !decorated);
	gtk_window_set_decorated (GTK_WINDOW (windows[i].window), !decorated);
}

void do_t_fullscreen (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i = (long int) data;

	debugf ("");

	if (gtk_window_is_fullscreen (GTK_WINDOW (windows[i].window))) {
		gtk_window_unfullscreen (GTK_WINDOW (windows[i].window));
	} else {
		gtk_window_fullscreen (GTK_WINDOW (windows[i].window));
	}
}

void do_t_tab_bar (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i = (long int) data;

	debugf ("");

	gboolean show_tabs = gtk_notebook_get_show_tabs (GTK_NOTEBOOK (windows[i].notebook));
	gtk_notebook_set_show_tabs (GTK_NOTEBOOK (windows[i].notebook), !show_tabs);
}

void do_next_term (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i = (long int) data;

	debugf ("");

	gtk_notebook_next_page (GTK_NOTEBOOK (windows[i].notebook));
}

void do_prev_term (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i = (long int) data;

	debugf ("");

	gtk_notebook_prev_page (GTK_NOTEBOOK (windows[i].notebook));
}

void do_move_to_window (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int   window_i		= ((long int) data) & ((1 << 8) - 1);
	long int   new_window_i = (long int) data >> 8;
	int		   i;
	GtkWidget *widget;

	debugf ("window_i: %ld, new_window_i: %ld, data: 0x%p", window_i, new_window_i, data);

	widget = gtk_notebook_get_nth_page (windows[window_i].notebook, gtk_notebook_get_current_page (windows[window_i].notebook));

	if (term_find (widget, &i)) {
		term_set_window (i, new_window_i);
		term_switch (i, NULL, NULL, NULL, window_i);
	}
}

void do_switch_terminal (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int i		  = ((long int) data) >> 8;
	long int window_i = ((long int) data) & ((1 << 8) - 1);

	term_switch (i, NULL, NULL, NULL, window_i);
}

void do_set_window_color_scheme (GSimpleAction *self, GVariant *parameter, gpointer data)
{
	long int color_scheme = ((long int) data) >> 8;
	long int window_i	  = ((long int) data) & ((1 << 8) - 1);
	int		 i;

	debugf ("");

	windows[window_i].color_scheme = color_scheme;

	for (i = 0; i < terms.n_active; i++) {
		if (terms.active[i].term && terms.active[i].window == window_i) {
			vte_terminal_set_colors (VTE_TERMINAL (terms.active[i].term),
									 &terms.color_schemes[windows[window_i].color_scheme].foreground,
									 &terms.color_schemes[windows[window_i].color_scheme].background, &colors[0],
									 MIN (256, sizeof (colors) / sizeof (colors[0])));
		}
	}
}

/*
 * Ideally, we would free menu_hyperlink_uri here.
 *
 * Sadly, if someone opens the menu, and then selects something like 'Copy
 * URI', we get the closed signal before we get told that a menu item was
 * selected.
 *
 * As such, this is far less useful at the moment.
 */
static void menu_closed (GtkPopover *menu, gpointer user_data)
{
	long int i = (long int) user_data;

	debugf ("window %ld", i);
}

// This is really strdupa.
// It really must be a macro, not a function, so that alloca gets called with
// the caller function's stack.
// And we're using the gcc statement expression syntax, because nothing else
// gives us the ability to have both temporary variables and return values.
#define dupstr(str)                                                                                                              \
	({                                                                                                                           \
		char *in  = str;                                                                                                         \
		char *new = alloca (strlen (in) + 1);                                                                                    \
		char *ret = strcpy (new, in);                                                                                            \
		ret;                                                                                                                     \
	})

typedef struct {
	GActionEntry entry;
	gpointer	 user_data;
} ZActionEntry;

static void z_menu_append (GMenu *menu, ZActionEntry *actions, int *n_actions, char *prefix, char *label, char *_name,
						   void (*function) (GSimpleAction *, GVariant *, gpointer), long int _user_data)
{
	char buf[256] = {0};
	snprintf (buf, sizeof (buf) - 1, "%s%s", prefix, _name);
	g_menu_append (menu, label, buf);
	debugf ("label: %s, action: %s, name: %s", label, buf, _name);
	ZActionEntry tmp = {
	  .entry = {_name, function},
		  .user_data = (gpointer) _user_data
	};
	actions[(*n_actions)++] = tmp;
	debugf ("action: %d, name: %s", *n_actions - 1, actions[*n_actions - 1].entry.name);
}

void rebuild_term_list (long int window_n)
{
	ZActionEntry add_actions[64];
	int			 n_add_actions = 0;
	int			 i, j;

	if (!windows[window_n].window) {
		return;
	}

	if (windows[window_n].menu_model_term_list != NULL) {
		g_menu_remove_all (G_MENU (windows[window_n].menu_model_term_list));
	} else {
		windows[window_n].menu_model_term_list = G_MENU_MODEL (g_menu_new ());
	}

	GMenu *list = G_MENU (windows[window_n].menu_model_term_list);

	for (i = j = 0; i < terms.n_active; i++) {
		if (terms.active[i].term && terms.active[i].window == window_n) {

			char action[64] = {0};

			snprintf (action, sizeof (action), "terms.term_%d", i);
			char *_action = dupstr (action);
			z_menu_append (list, add_actions, &n_add_actions, "terms.", terms.active[i].title, _action, do_switch_terminal,
						   ((i << 8) + window_n));
			debugf ("Window %ld, term %d, n %d", window_n, i, j++);
		}
	}

	GSimpleActionGroup *group = g_simple_action_group_new ();

	for (int i = 0; i < n_add_actions; i++) {
		g_action_map_add_action_entries (G_ACTION_MAP (group), &add_actions[i].entry, 1, add_actions[i].user_data);
		debugf ("action: %d, name: %s", i, add_actions[i].entry.name);
	}
	gtk_widget_insert_action_group (windows[window_n].window, "terms", G_ACTION_GROUP (group));
}

static void rebuild_window_menu (long int window_n)
{
	ZActionEntry add_actions[64];
	int			 n_add_actions = 0;

	debugf ("windows[%ld].menu: %p", window_n, windows[window_n].menu);
	if (windows[window_n].menu_model != NULL) {
		g_menu_remove_all (G_MENU (windows[window_n].menu_model));
	} else {
		windows[window_n].menu_model = G_MENU_MODEL (g_menu_new ());
	}

	GMenu *main = G_MENU (windows[window_n].menu_model);

	GMenu *actions = g_menu_new ();
	z_menu_append (actions, add_actions, &n_add_actions, "menu.", "_Copy", "copy", do_copy, window_n);
	z_menu_append (actions, add_actions, &n_add_actions, "menu.", "_Paste", "paste", do_paste, window_n);
	z_menu_append (actions, add_actions, &n_add_actions, "menu.", "Copy _URI", "copy_uri", do_copy_uri, window_n);
	z_menu_append (actions, add_actions, &n_add_actions, "menu.", "_Open URI", "open_uri", do_open_uri, window_n);
	g_menu_append_section (main, "Actions", G_MENU_MODEL (actions));

	GMenu *terminals = g_menu_new ();
	rebuild_term_list (window_n);
	g_menu_append_submenu (terminals, "Terminal List", windows[window_n].menu_model_term_list);
	z_menu_append (terminals, add_actions, &n_add_actions, "menu.", "_Previous Terminal", "prev_terminal", do_prev_term,
				   window_n);
	z_menu_append (terminals, add_actions, &n_add_actions, "menu.", "_Next Terminal", "next_terminal", do_next_term, window_n);
	g_menu_append_section (main, "Terminals", G_MENU_MODEL (terminals));

	GMenu *config = g_menu_new ();
	z_menu_append (config, add_actions, &n_add_actions, "menu.", "_Preferences...", "preferences", do_preferences, window_n);
	z_menu_append (config, add_actions, &n_add_actions, "menu.", "_Decorations", "decorations", do_t_decorate, window_n);
	z_menu_append (config, add_actions, &n_add_actions, "menu.", "_Fullscreen", "fullscreen", do_t_fullscreen, window_n);
	z_menu_append (config, add_actions, &n_add_actions, "menu.", "_Tab bar", "tab_bar", do_t_tab_bar, window_n);
	z_menu_append (config, add_actions, &n_add_actions, "menu.", "_Reload config file", "reload_config", do_reload_config,
				   window_n);
	g_menu_append_section (main, "Config", G_MENU_MODEL (config));

	/*
	z_menu_append(config, add_actions, &n_add_actions, "menu.", "_", "", do_, window_n);
	z_menu_append(config, add_actions, &n_add_actions, "menu.", "_", "", do_, window_n);
	z_menu_append(config, add_actions, &n_add_actions, "menu.", "_", "", do_, window_n);
	*/

	GMenu *schemes = g_menu_new ();
	for (long int j = 0; j < MAX_COLOR_SCHEMES && terms.color_schemes[j].name[0]; j++) {
		debugf ("name: %s, action: %s", terms.color_schemes[j].name, terms.color_schemes[j].action);
		z_menu_append (schemes, add_actions, &n_add_actions, "menu.", terms.color_schemes[j].name, terms.color_schemes[j].action,
					   do_set_window_color_scheme, ((j << 8) + window_n));
	}
	g_menu_append_section (main, "Color schemes", G_MENU_MODEL (schemes));

	GMenu *window = g_menu_new ();

	long first_empty = -1;
	for (long n = 0; n < MAX_WINDOWS; n++) {
		if (n == window_n) { // Don't offer to move to the same window, that's just weird.
			continue;
		} else if (windows[n].window) {
			char action[64] = {0};
			char title[64]	= {0};

			snprintf (title, sizeof (title), "Move to window _%ld", n);
			snprintf (action, sizeof (action), "window.move_%ld", n);
			char *_title  = dupstr (title);
			char *_action = dupstr (action);
			z_menu_append (window, add_actions, &n_add_actions, "menu.", _title, _action, do_move_to_window,
						   ((n << 8) + window_n));
		} else if (first_empty == -1) {
			first_empty = n;
		}
	}

	if (first_empty != -1) {
		char action[64] = {0};
		char title[64]	= {0};

		snprintf (title, sizeof (title), "Move to _new window %ld", first_empty);
		snprintf (action, sizeof (action), "window.move_%ld", first_empty);

		char *_title  = dupstr (title);
		char *_action = dupstr (action);
		z_menu_append (window, add_actions, &n_add_actions, "menu.", _title, _action, do_move_to_window,
					   ((first_empty << 8) + window_n));
	} else {
		debugf ("first_empty: %ld", first_empty);
		for (long n = 0; n < MAX_WINDOWS; n++) {
			debugf ("windows[%ld].window: %p", n, windows[n].window);
		}
	}

	g_menu_append_section (main, "Window", G_MENU_MODEL (window));

	windows[window_n].menu_model = G_MENU_MODEL (main);
	GtkWidget *menu				 = gtk_popover_menu_new_from_model (G_MENU_MODEL (main));
	gtk_popover_set_autohide (GTK_POPOVER (menu), TRUE);
	gtk_popover_set_has_arrow (GTK_POPOVER (menu), FALSE);
	gtk_popover_set_position (GTK_POPOVER (menu), GTK_POS_BOTTOM);
	gtk_widget_set_halign (menu, GTK_ALIGN_START);
	gtk_widget_set_valign (menu, GTK_ALIGN_END);

	GSimpleActionGroup *group = g_simple_action_group_new ();

	for (int i = 0; i < n_add_actions; i++) {
		g_action_map_add_action_entries (G_ACTION_MAP (group), &add_actions[i].entry, 1, add_actions[i].user_data);
		debugf ("action: %d, name: %s", i, add_actions[i].entry.name);
	}
	gtk_widget_insert_action_group (windows[window_n].window, "menu", G_ACTION_GROUP (group));

	windows[window_n].menu = menu;
	// gtk_widget_set_parent (menu, windows[window_n].window);
	debugf ("windows[%ld].menu: %p", window_n, windows[window_n].menu);
	g_signal_connect_after (menu, "closed", G_CALLBACK (menu_closed), (void *) window_n);

	return;
}

void rebuild_menus (void)
{
	for (int i = 0; i < MAX_WINDOWS; i++) {
		if (windows[i].window) {
			rebuild_window_menu (i);
		}
	}
}

// vim: set ts=4 sw=4 noexpandtab :