maingui.c

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

tree_build ()
{
	GSList *serv;
	GSList *ret = NULL;
	struct server *server;

	serv = serv_list;
	while (serv)
	{
		server = serv->data;
		ret = g_slist_prepend (ret, server);
		ret = g_slist_prepend (ret, NULL);
		tree_add_sess (&ret, server);
		ret = g_slist_prepend (ret, NULL);
		serv = serv->next;
	}

	ret = g_slist_reverse (ret);
	return ret;
}

static gpointer
tree_new_entry (int type, void *data)
{
	struct tree_data *td;

	td = g_new (struct tree_data, 1);
	td->type = type;
	td->data = data;

	return td;
}

static void
tree_populate (GtkCTree * tree, GSList * l)
{
	int state = 0;
	void *data;
	gchar *text[1];
	GtkCTreeNode *parent = NULL, *leaf;

	gtk_clist_freeze (GTK_CLIST (tree));
	gtk_clist_clear (GTK_CLIST (tree));
	for (; l; l = l->next)
	{
		data = l->data;
		if (data == NULL)
		{
			if (!state)
			{
				state = 1;
				continue;
			} else
			{
				state = 0;
				continue;
			}
		}
		if (!state)
		{
			text[0] = ((struct server *) data)->servername;
			if (text[0][0])
			{
				parent = gtk_ctree_insert_node (tree, NULL, NULL, text, 0, NULL,
														  NULL, NULL, NULL, 0, 1);
				((GtkCListRow *) ((GList *) parent)->data)->data =
					tree_new_entry (TREE_SERVER, data);
				((GtkCListRow *) ((GList *) parent)->data)->destroy =
					(GtkDestroyNotify) tree_row_destroy;
			}
			continue;
		} else
		{
			text[0] = ((struct session *) data)->channel;
			if (text[0][0])
			{
				leaf = gtk_ctree_insert_node (tree, parent, NULL, text, 0, NULL,
														NULL, NULL, NULL, 1, 1);
				((GtkCListRow *) ((GList *) leaf)->data)->data =
					tree_new_entry (TREE_SESSION, data);
				((GtkCListRow *) ((GList *) leaf)->data)->destroy =
					(GtkDestroyNotify) tree_row_destroy;
			}
			continue;
		}
	}
	gtk_clist_thaw (GTK_CLIST (tree));
}

static void
tree_destroy (GtkWidget * tree)
{
	tree_list = g_list_remove (tree_list, tree);
}

static void
tree_select_row (GtkWidget * tree, GList * row)
{
	struct tree_data *td;
	struct session *sess = NULL;
	struct server *serv = NULL;

	td = ((struct tree_data *) ((GtkCListRow *) row->data)->data);
	if (!td)
		return;
	if (td->type == TREE_SESSION)
	{
		sess = td->data;
		if (sess->is_tab)
		{
			if (main_window)		  /* this fixes a little refresh glitch */
			{
				wins_bring_tofront (sess->gui->window);
			}
		} else
		{
			gtk_widget_hide (sess->gui->window);
			gtk_widget_show (sess->gui->window);
		}
	} else if (td->type == TREE_SERVER)
	{
		serv = td->data;
		sess = serv->front_session;
		if (serv->front_session)
		{
			if (serv->front_session->is_tab)
			{
				if (main_window)
				{
					wins_bring_tofront (sess->gui->window);
				}
			} else
			{
				gtk_widget_hide (sess->gui->window);
				gtk_widget_show (sess->gui->window);
			}
		}
	}
}

static GtkWidget *
new_tree_view ()
{
	GtkWidget *tree;
	GSList *data;

	tree = gtk_ctree_new_with_titles (1, 0, NULL);
	gtk_clist_set_selection_mode (GTK_CLIST (tree), GTK_SELECTION_BROWSE);
	gtk_clist_set_column_width (GTK_CLIST (tree), 0, 80);
	gtk_signal_connect (GTK_OBJECT (tree), "destroy", tree_destroy, NULL);
	gtk_signal_connect (GTK_OBJECT (tree), "tree_select_row", tree_select_row,
							  0);
	data = tree_build ();
	tree_populate (GTK_CTREE (tree), data);
	tree_list = g_list_prepend (tree_list, tree);
	g_slist_free (data);

	return tree;
}

void
tree_update ()
{
	GList *tree;
	GSList *data = tree_build ();

	for (tree = tree_list; tree; tree = tree->next)
		tree_populate (GTK_CTREE (tree->data), data);

	g_slist_free (data);
}

static void
tree_set_color (session *sess, int col)
{
	GList *tree;
	GList *rows;
	struct tree_data *td;
	int row = 0;

	for (tree = tree_list; tree; tree = tree->next)
	{
		for (rows = (GTK_CLIST (tree->data)->row_list); rows; rows = rows->next)
		{
			td = ((struct tree_data *) ((GtkCListRow *) rows->data)->data);
			if (td->data == sess ||
				 (sess->type == SESS_SERVER && sess->server == td->data))
			{
				gtk_clist_set_foreground (GTK_CLIST (tree->data), row, &colors[col]);
				return;
			}
			row++;
		}
	}
}

static void
tree_default_style (session *sess)
{
	tree_set_color (sess, 1);
}

void
tree_red_style (session *sess)
{
	tree_set_color (sess, 4);
}

void
tree_blue_style (session *sess)
{
	tree_set_color (sess, 2);
}

void
maingui_set_tab_pos (int pos)
{
	gtk_notebook_set_show_tabs ((GtkNotebook *) main_book, TRUE);
	switch (pos)
	{
	case 0:
		gtk_notebook_set_tab_pos ((GtkNotebook *) main_book, GTK_POS_BOTTOM);
		break;
	case 1:
		gtk_notebook_set_tab_pos ((GtkNotebook *) main_book, GTK_POS_TOP);
		break;
	case 2:
		gtk_notebook_set_tab_pos ((GtkNotebook *) main_book, GTK_POS_LEFT);
		break;
	case 3:
		gtk_notebook_set_tab_pos ((GtkNotebook *) main_book, GTK_POS_RIGHT);
		break;
	case 4:
		gtk_notebook_set_show_tabs ((GtkNotebook *) main_book, FALSE);
		break;
	}
}

void
gui_make_tab_window (session *sess, GtkWidget *win)
{
	GtkWidget *main_box, *main_hbox = NULL, *trees;
	GSList *list;
#ifndef USE_GNOME
	GtkWidget *wid;
#endif

	/* YUK! FIXME */
	if (sess == NULL)
	{
		list = sess_list;
		while (list)
		{
			sess = list->data;
			if (sess->gui->window == win)
				break;
			list = list->next;
		}
	}

	current_tab = 0;

	main_window = wins_new ("X-Chat", "X-Chat", gui_main_window_kill, NULL,
									NULL, NULL, FALSE, FALSE, NULL);
	gtk_widget_set_usize (main_window, prefs.mainwindow_width,
									prefs.mainwindow_height);
	gtk_signal_connect ((GtkObject *) main_window, "focus_in_event",
							  GTK_SIGNAL_FUNC (focus_in), 0);
	gtk_signal_connect_object (GTK_OBJECT (main_window), "configure_event",
										GTK_SIGNAL_FUNC (maingui_configure), 0);

	main_box = wins_get_vbox (main_window);

#ifdef USE_GNOME
	main_menu = createmenus (main_window, sess, 1);
	main_menu_bar = main_menu->parent;
#else
	main_menu = createmenus (0, sess, 1);
	gtk_widget_show (main_menu);

	main_menu_bar = wid = gtk_handle_box_new ();
	gtk_container_add (GTK_CONTAINER (wid), main_menu);
	gtk_box_pack_start (GTK_BOX (main_box), wid, FALSE, TRUE, 0);
	if (!prefs.hidemenu)
		gtk_widget_show (wid);
#endif
	main_menu_away_item = sess->gui->awaymenuitem;
	if (prefs.treeview)
	{
		main_hbox = gtk_hpaned_new ();
		trees = new_tree_view ();
		gtk_widget_show (trees);
		gtk_paned_add1 (GTK_PANED (main_hbox), trees);
	}

	main_book = gtk_notebook_new ();
	gtk_notebook_set_show_border (GTK_NOTEBOOK (main_book), FALSE);
	maingui_set_tab_pos (prefs.tabs_position);
	gtk_notebook_set_scrollable ((GtkNotebook *) main_book, TRUE);
	gtk_signal_connect ((GtkObject *) main_book, "switch_page",
							  GTK_SIGNAL_FUNC (gui_new_tab_callback), 0);
	if (prefs.treeview)
	{
		gtk_container_add (GTK_CONTAINER (main_box), main_hbox);
		gtk_paned_add2 (GTK_PANED (main_hbox), main_book);
		gtk_widget_show (main_hbox);
	} else
		gtk_container_add (GTK_CONTAINER (main_box), main_book);

	if (prefs.inputgad_superfocus)
		show_and_unfocus (main_book);
	else
		gtk_widget_show (main_book);
}

#ifdef USE_GNOME
GtkTargetEntry dnd_targets[] = {
	{"text/uri-list", 0, 1}
};
#endif

static void
maingui_init_styles (GtkStyle *style)
{
	redtab_style = gtk_style_new ();
	gdk_font_unref (redtab_style->font);
	redtab_style->font = style->font;
	redtab_style->fg[0] = colors[4];
	gdk_font_ref (redtab_style->font);

	bluetab_style = gtk_style_new ();
	gdk_font_unref (bluetab_style->font);
	bluetab_style->font = style->font;
	bluetab_style->fg[0] = colors[12];
	gdk_font_ref (bluetab_style->font);
}

static void
maingui_toolbox (GtkWidget * button, GtkWidget * box)
{
	if (GTK_WIDGET_VISIBLE (box))
	{
		gtk_label_set_text (GTK_LABEL (GTK_BIN (button)->child), "<");
		gtk_widget_hide (box);
		add_tip (button, _("Open Toolbox"));
	} else
	{
		gtk_label_set_text (GTK_LABEL (GTK_BIN (button)->child), ">");
		gtk_widget_show (box);
		add_tip (button, _("Close Toolbox"));
	}
}

static void
maingui_code (GtkWidget * button, char *code)
{
	if (menu_sess)
		key_action_insert (menu_sess->gui->inputgad, 0, code, 0, menu_sess);
}

static GtkWidget *
toolbox_button (char *label, char *code, GtkWidget * box, char *tip)
{
	GtkWidget *wid;

	wid = gtk_button_new_with_label (label);
	gtk_box_pack_end (GTK_BOX (box), wid, 0, 0, 0);
	if (code)
		gtk_signal_connect (GTK_OBJECT (wid), "clicked",
								  GTK_SIGNAL_FUNC (maingui_code), code);
	gtk_widget_show (wid);
	if (tip)
		add_tip (wid, tip);

	return wid;
}

static void
maingui_cp (GtkWidget * button, session * sess)
{
	GTK_XTEXT (sess->gui->textgad)->color_paste =
		GTK_TOGGLE_BUTTON (button)->active;
}

static void
toolbox_color (GtkWidget * button, int color_no)
{
	char buf[8];

	sprintf (buf, "%%C%d", color_no);

	if (menu_sess)
		key_action_insert (menu_sess->gui->inputgad, 0, buf, 0, menu_sess);
}

/* create the < and ^ buttons to the right of the inputbox */

void
gui_create_toolbox (session *sess, GtkWidget *box)
{
	GtkStyle *style;
	GtkWidget *wid, *toolbox;
	int i;

	sess->gui->toolbox = toolbox = gtk_hbox_new (0, 0);
	gtk_box_pack_start (GTK_BOX (box), toolbox, 0, 0, 0);

	sess->gui->beepbutton = wid = gtk_toggle_button_new_with_label (_("Beep"));
	gtk_box_pack_end (GTK_BOX (toolbox), wid, 0, 0, 0);
	gtk_widget_show (wid);
	add_tip (wid, _("Beep on messages"));

	sess->gui->confbutton = wid = gtk_toggle_button_new_with_label (_("Conf"));
	gtk_box_pack_end (GTK_BOX (toolbox), wid, 0, 0, 0);
	gtk_widget_show (wid);
	add_tip (wid, _("Conference mode (no join/part msgs)"));

	wid = gtk_toggle_button_new_with_label (_("CP"));
	gtk_signal_connect (GTK_OBJECT (wid), "toggled",
							  GTK_SIGNAL_FUNC (maingui_cp), sess);
	gtk_box_pack_end (GTK_BOX (toolbox), wid, 0, 0, 0);
	gtk_widget_show (wid);
	add_tip (wid, _("Color Paste"));

	wid = toolbox_button (_("Ascii"), 0, toolbox, _("Open ASCII Chart"));
	gtk_signal_connect (GTK_OBJECT (wid), "clicked",
							  GTK_SIGNAL_FUNC (ascii_open), 0);

	for (i = 15; i; i--)
	{
		style = gtk_style_new ();
		style->bg[0] = colors[i];
		wid = toolbox_button ("  ", 0, toolbox, 0);
		gtk_widget_set_style (wid, style);
		gtk_signal_connect (GTK_OBJECT (wid), "clicked",
								  GTK_SIGNAL_FUNC (toolbox_color), (gpointer) i);
		gtk_style_unref (style);
	}

	wid = toolbox_button ("", "%U", toolbox, _("Underline"));
	gtk_label_parse_uline (GTK_LABEL (GTK_BIN (wid)->child), "_U");

	/*wid =*/ toolbox_button ("B", "%B", toolbox, _("Bold"));
	/*style = gtk_style_new ();
	gdk_font_unref (style->font);
   style->font = font_bold;
   gdk_font_ref (font_bold); 
	gtk_widget_set_style (GTK_BIN (wid)->child, style);
	gtk_style_unref (style);*/

	toolbox_button ("A", "%O", toolbox, _("Plain Text"));

	wid = gtk_button_new_with_label ("<");
	gtk_signal_connect (GTK_OBJECT (wid), "clicked",
							  GTK_SIGNAL_FUNC (maingui_toolbox), toolbox);
	gtk_box_pack_start (GTK_BOX (box), wid, 0, 0, 1);
	if (prefs.inputgad_superfocus)
		show_and_unfocus (wid);
	else
		gtk_widget_show (wid);
	add_tip (wid, _("Open Toolbox"));
}

/*static void
ul_keypress_cb (GtkWidget *widget, GdkEventKey *event, session *sess)
{
	struct User *user;
	GSList *list = sess->userlist;
	int row = 0;

	while (list)
	{
		user = list->data;
		if (user->nick[0] == event->keyval)
		{
			gtk_clist_moveto (GTK_CLIST (sess->gui->namelistgad), row, 0, 0.5, 0);
			break;
		}
		list = list->next;
		row++;
	}
}*/

static GtkWidget *
create_infoframe (GdkPixmap *pix, GdkPixmap *mask, GtkWidget *box)
{
	GtkWidget *frame, *label, *hbox, *p;

	frame = gtk_frame_new (0);
	gtk_frame_set_shadow_type ((GtkFrame*)frame, GTK_SHADOW_OUT);
	gtk_container_add (GTK_CONTAINER (box), frame);
	gtk_widget_show (frame);

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

	if (pix)
	{
		p = gtk_pixmap_new (pix, mask);
		gtk_container_add (GTK_CONTAINER (hbox), p);
		gtk_widget_show (p);
	}

	label = gtk_label_new (" ");
	gtk_container_add (GTK_CONTAINER (hbox), label);
	gtk_widget_show (label);

	return label;
}

static void
maingui_make_changad (session *sess)
{
	if (sess->type == SESS_CHANNEL || sess->type == SESS_SERVER)
	{
		if (sess->channel[0])
			sess->gui->changad = gtk_label_new (sess->channel);
		else
			sess->gui->changad = gtk_label_new (_("<none>"));
		gtk_box_pack_start (GTK_BOX (sess->gui->tbox), sess->gui->changad,
								  FALSE, FALSE, 5);
		gtk_box_reorder_child (GTK_BOX (sess->gui->tbox), sess->gui->changad, 1);
		gtk_widget_show (sess->gui->changad);
	} else
	{
		sess->gui->changad = NULL;
	}
}

/* a session got delinked or relinked */

void
link_cb (GtkWidget *win, session *sess)