menu.c

The major functionality added in this release includes: - Rootless mode in X11 - Widget Templt

void
menu_urlmenu (GdkEventButton *event, char *url)
{
	GtkWidget *menu;
	int i;
	char *tmp;

	if (str_copy)
		free (str_copy);

	/* replace all commas with %2c */
	str_copy = malloc ((strlen (url) * 3) + 1);
	i = 0;
	while (*url)
	{
		if (*url == ',')
		{
			str_copy[i++] = '%';
			str_copy[i++] = '2';
			str_copy[i] = 'c';
#ifdef WIN32
		} else if (*url == '\\')
		{
			str_copy[i++] = '\\';
			str_copy[i] = '\\';
#endif
		} else
			str_copy[i] = *url;
		i++;
		url++;
	}
	str_copy[i] = 0;

	menu = gtk_menu_new ();
	if (strlen (str_copy) > 51)
	{
		tmp = strdup (str_copy);
		tmp[47] = tmp[48] = tmp[49] = '.';
		tmp[50] = 0;
		menu_quick_item (0, tmp, menu, 1, 0);
		free (tmp);
	} else
	{
		menu_quick_item (0, str_copy, menu, 1, 0);
	}
	menu_quick_item (0, 0, menu, 1, 0);

	menu_create (menu, urlhandler_list, str_copy);
	menu_popup (menu, event);
}

static void
menu_chan_cycle (GtkWidget * menu, char *chan)
{
	char tbuf[256];

	if (menu_sess)
	{
		snprintf (tbuf, sizeof tbuf, "PART %s\r\nJOIN %s\r\n", chan, chan);
		tcp_send (menu_sess->server, tbuf);
	}
}

static void
menu_chan_part (GtkWidget * menu, char *chan)
{
	char tbuf[256];

	if (menu_sess)
	{
		snprintf (tbuf, sizeof tbuf, "PART %s\r\n", chan);
		tcp_send (menu_sess->server, tbuf);
	}
}

static void
menu_chan_join (GtkWidget * menu, char *chan)
{
	char tbuf[256];

	if (menu_sess)
	{
		snprintf (tbuf, sizeof tbuf, "JOIN %s\r\n", chan);
		tcp_send (menu_sess->server, tbuf);
	}
}

void
menu_chanmenu (struct session *sess, GdkEventButton * event, char *chan)
{
	GtkWidget *menu;
	GSList *list = sess_list;
	int is_joined = FALSE;
	struct session *s;

	while (list)
	{
		s = (struct session *) list->data;
		if (s->server == sess->server)
		{
			if (!strcasecmp (chan, s->channel))
			{
				is_joined = TRUE;
				break;
			}
		}
		list = list->next;
	}

	if (str_copy)
		free (str_copy);
	str_copy = strdup (chan);

	menu = gtk_menu_new ();

	menu_quick_item (0, chan, menu, 1, str_copy);
	menu_quick_item (0, 0, menu, 1, str_copy);

	if (!is_joined)
		menu_quick_item_with_callback (menu_chan_join, _("Join Channel"), menu,
												 str_copy);
	else
	{
		menu_quick_item_with_callback (menu_chan_part, _("Part Channel"), menu,
												 str_copy);
		menu_quick_item_with_callback (menu_chan_cycle, _("Cycle Channel"), menu,
												 str_copy);
	}

	menu_popup (menu, event);
}

static void
menu_open_server_list (GtkWidget *wid, gpointer none)
{
	fe_open_serverlist (menu_sess, FALSE, FALSE);
}

static void
menu_settings (GtkWidget * wid, gpointer none)
{
	settings_opengui (menu_sess);
}

#ifdef USE_ZVT

static int
shell_exit (ZvtTerm * term, struct session *sess)
{
	gtk_widget_destroy (sess->gui->window);
	return 0;
}

static void
menu_shell_title (ZvtTerm * term, int type, char *newtitle, session * sess)
{
	switch (type)
	{
	case VTTITLE_WINDOW:
	case VTTITLE_WINDOWICON:
		gtk_entry_set_text (GTK_ENTRY (sess->gui->topicgad), newtitle);
	}
}

#ifdef USE_XLIB
#include <gdk/gdkx.h>
#endif

/*                  30 31 32 33 34 35 36  37  30  31 32 33 34  35  36  37 */
static
	int color_conv[] =
	{ 1, 4, 3, 5, 2, 6, 10, 15, 14, 7, 9, 8, 12, 13, 11, 0, 18, 19 };

static gushort zvt_red[18];
static gushort zvt_grn[18];
static gushort zvt_blu[18];

void
menu_newshell_set_palette (session *sess)
{
	int i;

	for (i = 17;; i--)
	{
		zvt_red[i] = colors[color_conv[i]].red;
		zvt_grn[i] = colors[color_conv[i]].green;
		zvt_blu[i] = colors[color_conv[i]].blue;
		if (!i)
			break;
	}
	zvt_term_set_color_scheme ((ZvtTerm *) sess->gui->textgad,
										zvt_red, zvt_grn, zvt_blu);
}

static void
menu_newshell_tab (GtkWidget * wid, struct session *sess)
{
	int oldb = prefs.chanmodebuttons;
	int oldp = prefs.paned_userlist;
	int oldu = prefs.use_server_tab;
	char *shell, *name;
	char buf[16];
	ZvtTerm *zvt;

	prefs.chanmodebuttons = prefs.paned_userlist = prefs.use_server_tab = 0;
	sess = new_ircwindow (NULL, NULL, SESS_SHELL);
	prefs.chanmodebuttons = oldb;
	prefs.paned_userlist = oldp;
	prefs.use_server_tab = oldu;

	fe_set_title (sess);

#ifdef USE_GNOME
	shell = gnome_util_user_shell ();
#else
	shell = strdup (getenv ("SHELL"));
#endif
	name = strrchr (shell, '/');
	if (!name)
		name = shell;
	else
		name++;
	strcpy (sess->channel, name);
	fe_set_channel (sess);

	gtk_widget_destroy (sess->gui->textgad);
	gtk_widget_destroy (sess->gui->vscrollbar);

	sess->gui->textgad = zvt_term_new ();
	zvt = (ZvtTerm *) sess->gui->textgad;

	zvt_term_set_blink (zvt, FALSE);
	if (prefs.font_shell[0] == 0)
		zvt_term_set_fonts (zvt, font_normal, NULL);
	else
		zvt_term_set_font_name (zvt, prefs.font_shell);
	zvt_term_set_scrollback (zvt, 720);
	zvt_term_set_scroll_on_keystroke (zvt, TRUE);
	zvt_term_set_background (zvt, prefs.background, prefs.transparent, 0);
	gtk_container_add (GTK_CONTAINER (sess->gui->leftpane), GTK_WIDGET (zvt));
	gtk_widget_show (GTK_WIDGET (zvt));
	menu_newshell_set_palette (sess);

	sess->gui->vscrollbar = gtk_vscrollbar_new (zvt->adjustment);
	gtk_box_pack_start (GTK_BOX (sess->gui->leftpane), sess->gui->vscrollbar,
							  0, 0, 1);
	show_and_unfocus (sess->gui->vscrollbar);

	GTK_WIDGET_UNSET_FLAGS (sess->gui->topicgad, GTK_CAN_FOCUS);

	if (sess->gui->userlistbox)
	{
		gtk_widget_destroy (sess->gui->userlistbox);
		sess->gui->userlistbox = 0;
	}

	gtk_signal_connect (GTK_OBJECT (sess->gui->textgad), "child_died",
							  GTK_SIGNAL_FUNC (shell_exit), sess);
	gtk_signal_connect (GTK_OBJECT (sess->gui->textgad), "title_changed",
							  GTK_SIGNAL_FUNC (menu_shell_title), sess);
	gtk_widget_destroy (sess->gui->inputgad->parent);

	sess->gui->inputgad = 0;
	sess->gui->toolbox = 0;
	gtk_widget_grab_focus (sess->gui->textgad);

	switch (zvt_term_forkpty ((ZvtTerm *) sess->gui->textgad, 0))
	{
	case -1:
		break;

	case 0:
#ifdef USE_XLIB
		sprintf (buf, "%d",
					(int) GDK_WINDOW_XWINDOW (GTK_WIDGET (sess->gui->textgad)->
													  window));
#endif
#ifdef HAVE_SETENV				  /* solaris is lame */
		setenv ("WINDOWID", buf, 1);
		setenv ("COLORTERM", "zterm", 0);
#endif
		execl (shell, name, NULL);
		_exit (127);
	}

	if (main_window)
		gdk_window_set_back_pixmap (main_book->window, 0, 0);

#ifdef USE_GNOME
	g_free (shell);				/* FIXME: is this a race condition ???? */
#else
	free (shell);
#endif
}
#endif

static void
menu_newserver_window (GtkWidget * wid, gpointer none)
{
	int old = prefs.tabchannels;

	prefs.tabchannels = 0;
	new_ircwindow (NULL, NULL, SESS_SERVER);
	prefs.tabchannels = old;
}

static void
menu_newchannel_window (GtkWidget * wid, gpointer none)
{
	int old = prefs.tabchannels;

	prefs.tabchannels = 0;
	new_ircwindow (menu_sess->server, NULL, SESS_CHANNEL);
	prefs.tabchannels = old;
}

static void
menu_newserver_tab (GtkWidget * wid, gpointer none)
{
	int old = prefs.tabchannels;

	prefs.tabchannels = 1;
	new_ircwindow (NULL, NULL, SESS_SERVER);
	prefs.tabchannels = old;
}

static void
menu_newchannel_tab (GtkWidget * wid, gpointer none)
{
	int old = prefs.tabchannels;

	prefs.tabchannels = 1;
	new_ircwindow (menu_sess->server, NULL, SESS_CHANNEL);
	prefs.tabchannels = old;
}

static void
menu_rawlog (GtkWidget * wid, gpointer none)
{
	open_rawlog (menu_sess->server);
}

static void
menu_autodccsend (GtkWidget * wid, gpointer none)
{
	prefs.autodccsend = !prefs.autodccsend;
#ifndef WIN32
	if (prefs.autodccsend)
	{
		if (!strcasecmp (g_get_home_dir (), prefs.dccdir))
		{
			gtkutil_simpledialog (_("*WARNING*\n"
										 "Auto accepting DCC to your home directory\n"
										 "can be dangerous and is exploitable. Eg:\n"
										 "Someone could send you a .bash_profile"));
		}
	}
#endif
}

static void
menu_close (GtkWidget * wid, gpointer none)
{
	gtk_widget_destroy (menu_sess->gui->window);
}

static void
menu_search ()
{
	search_open (menu_sess);
}

static void
menu_flushbuffer (GtkWidget * wid, gpointer none)
{
	fe_text_clear (menu_sess);
}

static void
savebuffer_req_done (session *sess, void *arg2, char *file)
{
	int fh, newlen;
	char *buf;
	textentry *ent;

	if (!file)
		return;

	fh = open (file, O_TRUNC | O_WRONLY | O_CREAT, 0600);
	if (fh != -1)
	{
		ent = GTK_XTEXT(sess->gui->textgad)->text_first;
		while (ent)
		{
			buf = gtk_xtext_strip_color (ent->str, ent->str_len, NULL,
							&newlen, GTK_XTEXT(sess->gui->textgad)->fonttype, NULL);
			write (fh, buf, strlen (buf));
			write (fh, "\n", 1);
			free (buf);
			ent = ent->next;
		}
		close (fh);
	}
	free (file);
}

static void
menu_savebuffer (GtkWidget * wid, gpointer none)
{
	gtkutil_file_req (_("Select an output filename"), savebuffer_req_done,
							menu_sess, 0, TRUE);
}

static void
menu_wallops (GtkWidget * wid, gpointer none)
{
	char tbuf[128];
	prefs.wallops = !prefs.wallops;
	if (menu_sess->server->connected)
	{
		if (prefs.wallops)
			sprintf (tbuf, "MODE %s +w\r\n", menu_sess->server->nick);
		else
			sprintf (tbuf, "MODE %s -w\r\n", menu_sess->server->nick);
		tcp_send (menu_sess->server, tbuf);
	}
}

static void
menu_servernotice (GtkWidget * wid, gpointer none)
{
	char tbuf[128];
	prefs.servernotice = !prefs.servernotice;
	if (menu_sess->server->connected)
	{
		if (prefs.servernotice)
			sprintf (tbuf, "MODE %s +s\r\n", menu_sess->server->nick);
		else
			sprintf (tbuf, "MODE %s -s\r\n", menu_sess->server->nick);
		tcp_send (menu_sess->server, tbuf);
	}
}

static void
menu_away (GtkWidget * wid, gpointer none)
{
	handle_command ("/away", menu_sess, FALSE, FALSE);
}

static void
menu_invisible (GtkWidget * wid, gpointer none)
{
	char tbuf[128];
	prefs.invisible = !prefs.invisible;
	if (menu_sess->server->connected)
	{
		if (prefs.invisible)
			sprintf (tbuf, "MODE %s +i\r\n", menu_sess->server->nick);
		else
			sprintf (tbuf, "MODE %s -i\r\n", menu_sess->server->nick);
		tcp_send (menu_sess->server, tbuf);
	}
}

static void
menu_savedefault (GtkWidget * wid, gpointer none)
{
	palette_save ();
	if (save_config ())
		gtkutil_simpledialog (_("Settings saved."));
}

static void
menu_chanlist (GtkWidget * wid, gpointer none)
{
	chanlist_opengui (menu_sess->server);
}

static void
menu_banlist (GtkWidget * wid, gpointer none)
{
	banlist_opengui (menu_sess);
}


#ifdef USE_PERL