serverlist.c

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

	if (!is_group (editnode))
	{
		strcpy (editentry->server,
				  gtk_entry_get_text (GTK_ENTRY (entry_server)));
		strcpy (editentry->channel,
				  gtk_entry_get_text (GTK_ENTRY (entry_channel)));
		strcpy (editentry->password,
				  gtk_entry_get_text (GTK_ENTRY (entry_password)));
		strcpy (editentry->nick,
				  gtk_entry_get_text (GTK_ENTRY (entry_nick)));
		strcpy (editentry->eom_cmd,
				  gtk_entry_get_text (GTK_ENTRY (entry_eomcmd)));
		editentry->port = gtk_spin_button_get_value_as_int (
														(GtkSpinButton *)entry_port);

		if (!gtk_toggle_button_get_active
			 (GTK_TOGGLE_BUTTON (entry_autoconnect)))
			editentry->flags &= ~AUTOCONNECT;
		else
			editentry->flags |= AUTOCONNECT;

		if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (entry_use_proxy)))
			editentry->flags &= ~DONT_USE_PROXY;
		else
			editentry->flags |= DONT_USE_PROXY;

		if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (entry_use_ssl)))
			editentry->flags &= ~USE_SSL;
		else
			editentry->flags |= USE_SSL;

		if (!gtk_toggle_button_get_active
			 (GTK_TOGGLE_BUTTON (entry_accept_invalid_cert)))
			editentry->flags &= ~ACCEPT_INVALID_CERT;
		else
			editentry->flags |= ACCEPT_INVALID_CERT;
	}
	strcpy (editentry->comment,
			  gtk_entry_get_text (GTK_ENTRY (entry_comment)));
	new_entry = 0;
	close_edit_entry ();
}

#ifdef USE_OPENSSL

static void
entry_use_ssl_toggled (GtkWidget * w, gpointer entry_accept_invalid_cert)
{
	gtk_widget_set_sensitive (GTK_WIDGET (entry_accept_invalid_cert),
									  gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON
																			  (w)) ? TRUE :
									  FALSE);
}

#endif

/* creates one entry box for the Edit-Server window */

static GtkWidget *
table_entry (char *labeltext, GtkWidget *table, int max, char *def,
				 int row, int col)
{
	GtkWidget *entry;
	GtkWidget *label;

	label = gtk_label_new (labeltext);
	gtk_table_attach_defaults (GTK_TABLE (table), label, row-1, row, col, col+1);
	gtk_widget_show (label);

	entry = gtk_entry_new_with_max_length (max);
	gtk_entry_set_text (GTK_ENTRY (entry), def);
	gtk_table_attach_defaults (GTK_TABLE (table), entry, row, row+1, col, col+1);
	gtk_widget_show (entry);

	return entry;
}


/*
 * edit_entry_clicked:
 * called when the users clicks on the "edit" button in the serverlist GUI
 */
static void
edit_entry_clicked (GtkWidget * wid, GtkCTreeNode * temp)
{
	GtkWidget *label, *tab, *vbox, *hbox, *box1, *frame, *wid1, *pbox;
	GtkAdjustment *adj;

	if (sleditwin)
	{
		close_edit_entry ();
		return;
	}
	if (temp)
		editnode = temp;
	else
		editnode = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (sltree)->row_list,
															GTK_CLIST (sltree)->focus_row));
	if (!editnode)
		return;

	sleditwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	wins_set_icon (sleditwin);
	gtk_window_set_title (GTK_WINDOW (sleditwin), _("X-Chat: Edit entry"));
	gtk_signal_connect (GTK_OBJECT (sleditwin), "delete_event",
							  GTK_SIGNAL_FUNC (close_edit_entry), 0);
	editentry =
		(struct slentry *) gtk_ctree_node_get_row_data (GTK_CTREE (sltree),
																		editnode);
	vbox = gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (sleditwin), vbox);
	gtk_container_border_width (GTK_CONTAINER (sleditwin), 5);
	gtk_widget_show (vbox);

	hbox = gtk_hbox_new (TRUE, 0);
	gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
	gtk_widget_show (hbox);
	if (is_group (editnode))
		wid1 = gtk_pixmap_new (pix_globe, mask_globe);
	else
		wid1 = gtk_pixmap_new (pix_server, mask_server);
	gtk_box_pack_start (GTK_BOX (hbox), wid1, FALSE, FALSE, 0);
	gtk_widget_show (wid1);

	frame = gtk_frame_new (_("Edit entry:"));
	gtk_container_add (GTK_CONTAINER (vbox), frame);
/*	if (!is_group (editnode))
		gtk_widget_set_usize (frame, 400, 150);
	else
		gtk_widget_set_usize (frame, 400, 70);*/
	gtk_widget_show (frame);

	hbox = gtk_hbox_new (FALSE, 0);
	gtk_container_border_width (GTK_CONTAINER (hbox), 5);
	gtk_container_add (GTK_CONTAINER (frame), hbox);
	gtk_widget_show (hbox);

	tab = gtk_table_new (6, 2, FALSE);
	gtk_container_add (GTK_CONTAINER (hbox), tab);
	gtk_widget_show (tab);

	entry_comment = table_entry (_("Name:"), tab, 99, editentry->comment, 1, 0);

	if (!is_group (editnode))
	{
		label = gtk_label_new (_("Server:"));
		gtk_table_attach_defaults (GTK_TABLE (tab), label, 0, 1, 1, 2);
		gtk_widget_show (label);

		pbox = gtk_hbox_new (0, 0);
		gtk_table_attach_defaults (GTK_TABLE (tab), pbox, 1, 2, 1, 2);
		gtk_widget_show (pbox);

		entry_server = gtkutil_entry_new (131, pbox, NULL, NULL);
		gtk_entry_set_text (GTK_ENTRY (entry_server), editentry->server);

		gtkutil_label_new (_("Port:"), pbox);
		entry_port = gtk_spin_button_new (0, 0, 0);
		adj = gtk_spin_button_get_adjustment ((GtkSpinButton*)entry_port);
		adj->lower = 1;
		adj->upper = 65535;
		adj->step_increment = 1;
		gtk_adjustment_changed (adj);
		gtk_spin_button_set_value ((GtkSpinButton*)entry_port, editentry->port);
		gtk_widget_set_usize (entry_port, 58, 0);
		gtk_box_pack_start (GTK_BOX (pbox), entry_port, 0, 0, 0);
		gtk_widget_show (entry_port);

		entry_password = table_entry (_("Password:"), tab, 85,
												editentry->password, 1, 2);

		entry_channel = table_entry (_("Channels:"), tab, CHANLEN,
											  editentry->channel, 1, 3);

		entry_nick = table_entry (_("Nickname:"), tab, NICKLEN,
										  editentry->nick, 1, 4);

		entry_eomcmd = table_entry (_("Connect Cmd:"), tab, 71,
											 editentry->eom_cmd, 1, 5);
		add_tip (entry_eomcmd, _("Command to execute after the connection is complete"));

		box1 = gtk_hbox_new (FALSE, 0);
		entry_autoconnect = gtk_check_button_new_with_label (_("Autoconnect"));
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry_autoconnect),
												(editentry->flags & AUTOCONNECT));

		entry_use_proxy = gtk_check_button_new_with_label (_("Use Proxy"));
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry_use_proxy),
												!(editentry->flags & DONT_USE_PROXY));
		add_tip (entry_use_proxy, _("Use proxy server if one is set in Setup->Proxy Server"));

		entry_use_ssl = gtk_check_button_new_with_label (_("Use SSL"));
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (entry_use_ssl),
												(editentry->flags & USE_SSL));
#ifndef USE_OPENSSL
		gtk_widget_set_sensitive (entry_use_ssl, FALSE);
#endif

		entry_accept_invalid_cert =
			gtk_check_button_new_with_label (_("Accept invalid cert."));
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
												(entry_accept_invalid_cert),
												(editentry->flags & ACCEPT_INVALID_CERT));
#ifndef USE_OPENSSL
		gtk_widget_set_sensitive (entry_accept_invalid_cert, FALSE);
#endif

#ifdef USE_OPENSSL
		entry_use_ssl_toggled (entry_use_ssl, entry_accept_invalid_cert);
		gtk_signal_connect (GTK_OBJECT (entry_use_ssl), "toggled",
								  GTK_SIGNAL_FUNC (entry_use_ssl_toggled),
								  entry_accept_invalid_cert);
#endif

		gtk_box_pack_start (GTK_BOX (box1), entry_autoconnect, TRUE, FALSE, 0);
		gtk_box_pack_start (GTK_BOX (box1), entry_use_proxy, TRUE, FALSE, 0);
		gtk_box_pack_start (GTK_BOX (box1), entry_use_ssl, TRUE, FALSE, 0);
		gtk_box_pack_start (GTK_BOX (box1), entry_accept_invalid_cert, TRUE,
								  FALSE, 0);
		gtk_box_pack_start (GTK_BOX (vbox), box1, FALSE, TRUE, 0);
		gtk_widget_show (entry_autoconnect);
		gtk_widget_show (entry_use_proxy);
		gtk_widget_show (entry_use_ssl);
		gtk_widget_show (entry_accept_invalid_cert);
		gtk_widget_show (box1);
	}

	box1 = gtk_hbox_new (TRUE, 2);
	gtkutil_button (slwin, GNOME_STOCK_BUTTON_OK, _("Ok"),
						 done_edit_entry, 0, box1);
	gtkutil_button (slwin, GNOME_STOCK_BUTTON_CANCEL, _("Cancel"),
						 close_edit_entry, 0, box1);
	gtk_box_pack_start (GTK_BOX (vbox), box1, FALSE, TRUE, 0);
	gtk_widget_show (box1);

	gtk_widget_show (sleditwin);
}

/*
 * new_server_clicked:
 * called when the user clicks the "New Server" button
 */
static void
new_server_clicked (GtkWidget * wid, struct session *sess)
{
	struct slentry *new;
	GtkCTreeNode *node;
	GtkCTreeNode *sibling;
	GtkCTreeNode *parent = 0;
	gchar *text[] = { "" };

	parent = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (sltree)->row_list,
													 GTK_CLIST (sltree)->focus_row));

	new = malloc (sizeof (struct slentry));
	memset (new, 0, sizeof (struct slentry));
	new->port = 6667;
	strcpy (new->comment, _("New Server"));
	text[0] = new->comment;

	if (!parent)
		node = gtk_ctree_insert_node (GTK_CTREE (sltree), NULL,
												NULL, text, 4, pix_server, mask_server,
												pix_server, mask_server, FALSE, FALSE);
	else if (is_group (parent))
		node = gtk_ctree_insert_node (GTK_CTREE (sltree), parent,
												NULL, text, 4, pix_server, mask_server,
												pix_server, mask_server, FALSE, FALSE);
	else
	{
		sibling = parent;
		parent = ((GTK_CTREE_ROW (parent))->parent);
		node = gtk_ctree_insert_node (GTK_CTREE (sltree), parent,
												sibling, text, 4, pix_server,
												mask_server, pix_server, mask_server,
												FALSE, FALSE);
	}

	gtk_ctree_node_set_row_data (GTK_CTREE (sltree), node, new);
	server_malloc_list = g_slist_prepend (server_malloc_list, new);
	if (parent)
		gtk_ctree_expand_recursive (GTK_CTREE (sltree), parent);
	gtk_ctree_select (GTK_CTREE (sltree), node);
	new_entry = TRUE;
	edit_entry_clicked (NULL, node);
}

/*
 * new_group_clicked:
 * same as new_server_clicked but applies to group instead
 */
static void
new_group_clicked (GtkWidget * wid, struct session *sess)
{
	struct slentry *new;
	GtkCTreeNode *node;
	GtkCTreeNode *sibling;
	GtkCTreeNode *parent = 0;
	gchar *text[] = { "" };

	sibling = GTK_CTREE_NODE (g_list_nth (GTK_CLIST (sltree)->row_list,
													  GTK_CLIST (sltree)->focus_row));

	new = malloc (sizeof (struct slentry));
	memset (new, 0, sizeof (struct slentry));
	strcpy (new->comment, _("New Group"));
	strcpy (new->server, "SUB");
	text[0] = new->comment;

	if (!sibling)
		node = gtk_ctree_insert_node (GTK_CTREE (sltree), NULL,
												NULL, text, 4, pix_globe, mask_globe,
												pix_globe, mask_globe, FALSE, FALSE);
	else
	{
		parent = ((GTK_CTREE_ROW (sibling))->parent);
		node = gtk_ctree_insert_node (GTK_CTREE (sltree), parent,
												sibling, text, 4, pix_globe, mask_globe,
												pix_globe, mask_globe, FALSE, FALSE);
	}

	gtk_ctree_node_set_row_data (GTK_CTREE (sltree), node, new);
	server_malloc_list = g_slist_prepend (server_malloc_list, new);
	if (parent)
		gtk_ctree_expand_recursive (GTK_CTREE (sltree), parent);
	gtk_ctree_select (GTK_CTREE (sltree), node);
	new_entry = TRUE;
	edit_entry_clicked (NULL, node);
}

/* 
 * no_servlist:
 * called when the state of the servlist toggle button is changed 
 */
static void
no_servlist (GtkWidget * igad, gpointer serv)
{
	if (GTK_TOGGLE_BUTTON (igad)->active)
		prefs.skipserverlist = TRUE;
	else
		prefs.skipserverlist = FALSE;
}


/* 
 * skip_motd:
 * called when the state of the skip motd toggle button is changed 
 */
static void
skip_motd (GtkWidget * igad, gpointer serv)
{
	if (GTK_TOGGLE_BUTTON (igad)->active)
		prefs.skipmotd = TRUE;
	else
		prefs.skipmotd = FALSE;
}

/* 
 * channelbox_toggled:
 * called when the state of the channelbox toggle button is changed 
 */
static void
channelbox_toggled (GtkWidget * igad, gpointer serv)
{
	if (GTK_TOGGLE_BUTTON (igad)->active)
	{
		gtk_widget_show (quickview);
		prefs.channelbox = TRUE;
	} else
	{
		gtk_widget_hide (slwin);
		gtk_widget_hide (quickview);
		gtk_widget_show (slwin);
		prefs.channelbox = FALSE;
	}
}

/*
 * close_server_list:
 * self explainatory?
 */
static void
close_server_list (int dont_save)
{
	if (!dont_save)
	{
		strcpy (prefs.nick1, gtk_entry_get_text ((GtkEntry *) nick1gad));
		strcpy (prefs.nick2, gtk_entry_get_text ((GtkEntry *) nick2gad));
		strcpy (prefs.nick3, gtk_entry_get_text ((GtkEntry *) nick3gad));
		strcpy (prefs.username, gtk_entry_get_text ((GtkEntry *) usernamegad));
		strcpy (prefs.realname, gtk_entry_get_text ((GtkEntry *) realnamegad));
		save_serverentrys ();
	}

	if (slwin)
	{
		gtk_widget_destroy (slwin);
		if (sleditwin)
			gtk_widget_destroy (sleditwin);
		slwin = 0;
		sleditwin = 0;
		sltree = 0;
	}

	while (server_malloc_list)
	{
		free (server_malloc_list->data);
		server_malloc_list = g_slist_remove (server_malloc_list, server_malloc_list->data);
	}
}

/*
 * connect_auto:
 * called when the autoconnect parser finds an entry
 */
static void
connect_auto (struct slentry *conn, struct session *sess)
{
	server *serv;

	if (conn->server[0] == 0)
		return;

	if (!sess)
		sess = new_ircwindow (NULL, NULL, SESS_SERVER);

	serv = sess->server;

	strcpy (sess->willjoinchannel, conn->channel);
	strcpy (serv->password, conn->password);
	if (conn->nick[0] == 0)
		strcpy (serv->nick, prefs.nick1);
	else
		strcpy (serv->nick, conn->nick);
	serv->dont_use_proxy = (conn->flags & DONT_USE_PROXY) ? TRUE : FALSE;
#ifdef USE_OPENSSL
	serv->use_ssl = (conn->flags & USE_SSL) ? TRUE : FALSE;
	serv->accept_invalid_cert =
		(conn->flags & ACCEPT_INVALID_CERT) ? TRUE : FALSE;
#endif

	if (conn->eom_cmd[0])
	{
		if (serv->eom_cmd)
			free (serv->eom_cmd);
		serv->eom_cmd = strdup (conn->eom_cmd);
	}

	connect_server (sess, conn->server, conn->port, FALSE);
}

/*
 * autoconnect_parser:
 * checks each entry to see if it should be autoconnected to or not
 */
static void
autoconnect_parser (GtkCTree * ctree, GtkCTreeNode * node,
						  struct session *sess)
{
	struct slentry *conn;

	if (is_group (node))
		return;

	conn = gtk_ctree_node_get_row_data (GTK_CTREE (sltree), node);
	if (!(conn->flags & AUTOCONNECT))
		return;