Context Navigation

gconf.c

Last change on this file was 1765, checked in by Bruno Cornec, 13 years ago
Update to busybox 1.7.2
Property svn:eol-style set to `native`
File size: 40.6 KB

Line
1	/* Hey EMACS -- linux-c -- */
2	/*
3	*
4	* Copyright (C) 2002-2003 Romain Lievin <roms@tilp.info>
5	* Released under the terms of the GNU GPL v2.0.
6	*
7	*/
8
9	#ifdef HAVE_CONFIG_H
10	# include <config.h>
11	#endif
12
13	#include "lkc.h"
14	#include "images.c"
15
16	#include <glade/glade.h>
17	#include <gtk/gtk.h>
18	#include <glib.h>
19	#include <gdk/gdkkeysyms.h>
20
21	#include <stdio.h>
22	#include <string.h>
23	#include <unistd.h>
24	#include <time.h>
25	#include <stdlib.h>
26
27	//#define DEBUG
28
29	enum {
30	SINGLE_VIEW, SPLIT_VIEW, FULL_VIEW
31	};
32
33	static gint view_mode = FULL_VIEW;
34	static gboolean show_name = TRUE;
35	static gboolean show_range = TRUE;
36	static gboolean show_value = TRUE;
37	static gboolean show_all = FALSE;
38	static gboolean show_debug = FALSE;
39	static gboolean resizeable = FALSE;
40
41	static gboolean config_changed = FALSE;
42
43	static char nohelp_text[] =
44	N_("Sorry, no help available for this option yet.\n");
45
46	GtkWidget *main_wnd = NULL;
47	GtkWidget *tree1_w = NULL; // left frame
48	GtkWidget *tree2_w = NULL; // right frame
49	GtkWidget *text_w = NULL;
50	GtkWidget *hpaned = NULL;
51	GtkWidget *vpaned = NULL;
52	GtkWidget *back_btn = NULL;
53
54	GtkTextTag tag1, tag2;
55	GdkColor color;
56
57	GtkTreeStore tree1, tree2, *tree;
58	GtkTreeModel model1, model2;
59	static GtkTreeIter *parents[256];
60	static gint indent;
61
62	static struct menu *current; // current node for SINGLE view
63	static struct menu *browsed; // browsed node for SPLIT view
64
65	enum {
66	COL_OPTION, COL_NAME, COL_NO, COL_MOD, COL_YES, COL_VALUE,
67	COL_MENU, COL_COLOR, COL_EDIT, COL_PIXBUF,
68	COL_PIXVIS, COL_BTNVIS, COL_BTNACT, COL_BTNINC, COL_BTNRAD,
69	COL_NUMBER
70	};
71
72	static void display_list(void);
73	static void display_tree(struct menu *menu);
74	static void display_tree_part(void);
75	static void update_tree(struct menu src, GtkTreeIter dst);
76	static void set_node(GtkTreeIter * node, struct menu menu, gchar * row);
77	static gchar *fill_row(struct menu menu);
78
79
80	/* Helping/Debugging Functions */
81
82
83	const char *dbg_print_stype(int val)
84	{
85	static char buf[256];
86
87	memset(buf, 0, 256);
88
89	if (val == S_UNKNOWN)
90	strcpy(buf, "unknown");
91	if (val == S_BOOLEAN)
92	strcpy(buf, "boolean");
93	if (val == S_TRISTATE)
94	strcpy(buf, "tristate");
95	if (val == S_INT)
96	strcpy(buf, "int");
97	if (val == S_HEX)
98	strcpy(buf, "hex");
99	if (val == S_STRING)
100	strcpy(buf, "string");
101	if (val == S_OTHER)
102	strcpy(buf, "other");
103
104	#ifdef DEBUG
105	printf("%s", buf);
106	#endif
107
108	return buf;
109	}
110
111	const char *dbg_print_flags(int val)
112	{
113	static char buf[256];
114
115	memset(buf, 0, 256);
116
117	if (val & SYMBOL_YES)
118	strcat(buf, "yes/");
119	if (val & SYMBOL_MOD)
120	strcat(buf, "mod/");
121	if (val & SYMBOL_NO)
122	strcat(buf, "no/");
123	if (val & SYMBOL_CONST)
124	strcat(buf, "const/");
125	if (val & SYMBOL_CHECK)
126	strcat(buf, "check/");
127	if (val & SYMBOL_CHOICE)
128	strcat(buf, "choice/");
129	if (val & SYMBOL_CHOICEVAL)
130	strcat(buf, "choiceval/");
131	if (val & SYMBOL_PRINTED)
132	strcat(buf, "printed/");
133	if (val & SYMBOL_VALID)
134	strcat(buf, "valid/");
135	if (val & SYMBOL_OPTIONAL)
136	strcat(buf, "optional/");
137	if (val & SYMBOL_WRITE)
138	strcat(buf, "write/");
139	if (val & SYMBOL_CHANGED)
140	strcat(buf, "changed/");
141	if (val & SYMBOL_NEW)
142	strcat(buf, "new/");
143	if (val & SYMBOL_AUTO)
144	strcat(buf, "auto/");
145
146	buf[strlen(buf) - 1] = '\0';
147	#ifdef DEBUG
148	printf("%s", buf);
149	#endif
150
151	return buf;
152	}
153
154	const char *dbg_print_ptype(int val)
155	{
156	static char buf[256];
157
158	memset(buf, 0, 256);
159
160	if (val == P_UNKNOWN)
161	strcpy(buf, "unknown");
162	if (val == P_PROMPT)
163	strcpy(buf, "prompt");
164	if (val == P_COMMENT)
165	strcpy(buf, "comment");
166	if (val == P_MENU)
167	strcpy(buf, "menu");
168	if (val == P_DEFAULT)
169	strcpy(buf, "default");
170	if (val == P_CHOICE)
171	strcpy(buf, "choice");
172
173	#ifdef DEBUG
174	printf("%s", buf);
175	#endif
176
177	return buf;
178	}
179
180
181	void replace_button_icon(GladeXML * xml, GdkDrawable * window,
182	GtkStyle * style, gchar * btn_name, gchar ** xpm)
183	{
184	GdkPixmap *pixmap;
185	GdkBitmap *mask;
186	GtkToolButton *button;
187	GtkWidget *image;
188
189	pixmap = gdk_pixmap_create_from_xpm_d(window, &mask,
190	&style->bg[GTK_STATE_NORMAL],
191	xpm);
192
193	button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, btn_name));
194	image = gtk_image_new_from_pixmap(pixmap, mask);
195	gtk_widget_show(image);
196	gtk_tool_button_set_icon_widget(button, image);
197	}
198
199	/* Main Window Initialization */
200	void init_main_window(const gchar * glade_file)
201	{
202	GladeXML *xml;
203	GtkWidget *widget;
204	GtkTextBuffer *txtbuf;
205	char title[256];
206	GtkStyle *style;
207
208	xml = glade_xml_new(glade_file, "window1", NULL);
209	if (!xml)
210	g_error(_("GUI loading failed !\n"));
211	glade_xml_signal_autoconnect(xml);
212
213	main_wnd = glade_xml_get_widget(xml, "window1");
214	hpaned = glade_xml_get_widget(xml, "hpaned1");
215	vpaned = glade_xml_get_widget(xml, "vpaned1");
216	tree1_w = glade_xml_get_widget(xml, "treeview1");
217	tree2_w = glade_xml_get_widget(xml, "treeview2");
218	text_w = glade_xml_get_widget(xml, "textview3");
219
220	back_btn = glade_xml_get_widget(xml, "button1");
221	gtk_widget_set_sensitive(back_btn, FALSE);
222
223	widget = glade_xml_get_widget(xml, "show_name1");
224	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
225	show_name);
226
227	widget = glade_xml_get_widget(xml, "show_range1");
228	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
229	show_range);
230
231	widget = glade_xml_get_widget(xml, "show_data1");
232	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
233	show_value);
234
235	style = gtk_widget_get_style(main_wnd);
236	widget = glade_xml_get_widget(xml, "toolbar1");
237
238	#if 0 /* Use stock Gtk icons instead */
239	replace_button_icon(xml, main_wnd->window, style,
240	"button1", (gchar **) xpm_back);
241	replace_button_icon(xml, main_wnd->window, style,
242	"button2", (gchar **) xpm_load);
243	replace_button_icon(xml, main_wnd->window, style,
244	"button3", (gchar **) xpm_save);
245	#endif
246	replace_button_icon(xml, main_wnd->window, style,
247	"button4", (gchar **) xpm_single_view);
248	replace_button_icon(xml, main_wnd->window, style,
249	"button5", (gchar **) xpm_split_view);
250	replace_button_icon(xml, main_wnd->window, style,
251	"button6", (gchar **) xpm_tree_view);
252
253	#if 0
254	switch (view_mode) {
255	case SINGLE_VIEW:
256	widget = glade_xml_get_widget(xml, "button4");
257	g_signal_emit_by_name(widget, "clicked");
258	break;
259	case SPLIT_VIEW:
260	widget = glade_xml_get_widget(xml, "button5");
261	g_signal_emit_by_name(widget, "clicked");
262	break;
263	case FULL_VIEW:
264	widget = glade_xml_get_widget(xml, "button6");
265	g_signal_emit_by_name(widget, "clicked");
266	break;
267	}
268	#endif
269	txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
270	tag1 = gtk_text_buffer_create_tag(txtbuf, "mytag1",
271	"foreground", "red",
272	"weight", PANGO_WEIGHT_BOLD,
273	NULL);
274	tag2 = gtk_text_buffer_create_tag(txtbuf, "mytag2",
275	/"style", PANGO_STYLE_OBLIQUE, /
276	NULL);
277
278	sprintf(title, _("BusyBox %s Configuration"),
279	getenv("KERNELVERSION"));
280	gtk_window_set_title(GTK_WINDOW(main_wnd), title);
281
282	gtk_widget_show(main_wnd);
283	}
284
285	void init_tree_model(void)
286	{
287	gint i;
288
289	tree = tree2 = gtk_tree_store_new(COL_NUMBER,
290	G_TYPE_STRING, G_TYPE_STRING,
291	G_TYPE_STRING, G_TYPE_STRING,
292	G_TYPE_STRING, G_TYPE_STRING,
293	G_TYPE_POINTER, GDK_TYPE_COLOR,
294	G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF,
295	G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
296	G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
297	G_TYPE_BOOLEAN);
298	model2 = GTK_TREE_MODEL(tree2);
299
300	for (parents[0] = NULL, i = 1; i < 256; i++)
301	parents[i] = (GtkTreeIter *) g_malloc(sizeof(GtkTreeIter));
302
303	tree1 = gtk_tree_store_new(COL_NUMBER,
304	G_TYPE_STRING, G_TYPE_STRING,
305	G_TYPE_STRING, G_TYPE_STRING,
306	G_TYPE_STRING, G_TYPE_STRING,
307	G_TYPE_POINTER, GDK_TYPE_COLOR,
308	G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF,
309	G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
310	G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
311	G_TYPE_BOOLEAN);
312	model1 = GTK_TREE_MODEL(tree1);
313	}
314
315	void init_left_tree(void)
316	{
317	GtkTreeView *view = GTK_TREE_VIEW(tree1_w);
318	GtkCellRenderer *renderer;
319	GtkTreeSelection *sel;
320	GtkTreeViewColumn *column;
321
322	gtk_tree_view_set_model(view, model1);
323	gtk_tree_view_set_headers_visible(view, TRUE);
324	gtk_tree_view_set_rules_hint(view, FALSE);
325
326	column = gtk_tree_view_column_new();
327	gtk_tree_view_append_column(view, column);
328	gtk_tree_view_column_set_title(column, _("Options"));
329
330	renderer = gtk_cell_renderer_toggle_new();
331	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
332	renderer, FALSE);
333	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
334	renderer,
335	"active", COL_BTNACT,
336	"inconsistent", COL_BTNINC,
337	"visible", COL_BTNVIS,
338	"radio", COL_BTNRAD, NULL);
339	renderer = gtk_cell_renderer_text_new();
340	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
341	renderer, FALSE);
342	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
343	renderer,
344	"text", COL_OPTION,
345	"foreground-gdk",
346	COL_COLOR, NULL);
347
348	sel = gtk_tree_view_get_selection(view);
349	gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
350	gtk_widget_realize(tree1_w);
351	}
352
353	static void renderer_edited(GtkCellRendererText * cell,
354	const gchar * path_string,
355	const gchar * new_text, gpointer user_data);
356	static void renderer_toggled(GtkCellRendererToggle * cellrenderertoggle,
357	gchar * arg1, gpointer user_data);
358
359	void init_right_tree(void)
360	{
361	GtkTreeView *view = GTK_TREE_VIEW(tree2_w);
362	GtkCellRenderer *renderer;
363	GtkTreeSelection *sel;
364	GtkTreeViewColumn *column;
365	gint i;
366
367	gtk_tree_view_set_model(view, model2);
368	gtk_tree_view_set_headers_visible(view, TRUE);
369	gtk_tree_view_set_rules_hint(view, FALSE);
370
371	column = gtk_tree_view_column_new();
372	gtk_tree_view_append_column(view, column);
373	gtk_tree_view_column_set_title(column, _("Options"));
374
375	renderer = gtk_cell_renderer_pixbuf_new();
376	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
377	renderer, FALSE);
378	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
379	renderer,
380	"pixbuf", COL_PIXBUF,
381	"visible", COL_PIXVIS, NULL);
382	renderer = gtk_cell_renderer_toggle_new();
383	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
384	renderer, FALSE);
385	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
386	renderer,
387	"active", COL_BTNACT,
388	"inconsistent", COL_BTNINC,
389	"visible", COL_BTNVIS,
390	"radio", COL_BTNRAD, NULL);
391	/*g_signal_connect(G_OBJECT(renderer), "toggled",
392	G_CALLBACK(renderer_toggled), NULL); */
393	renderer = gtk_cell_renderer_text_new();
394	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
395	renderer, FALSE);
396	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
397	renderer,
398	"text", COL_OPTION,
399	"foreground-gdk",
400	COL_COLOR, NULL);
401
402	renderer = gtk_cell_renderer_text_new();
403	gtk_tree_view_insert_column_with_attributes(view, -1,
404	_("Name"), renderer,
405	"text", COL_NAME,
406	"foreground-gdk",
407	COL_COLOR, NULL);
408	renderer = gtk_cell_renderer_text_new();
409	gtk_tree_view_insert_column_with_attributes(view, -1,
410	"N", renderer,
411	"text", COL_NO,
412	"foreground-gdk",
413	COL_COLOR, NULL);
414	renderer = gtk_cell_renderer_text_new();
415	gtk_tree_view_insert_column_with_attributes(view, -1,
416	"M", renderer,
417	"text", COL_MOD,
418	"foreground-gdk",
419	COL_COLOR, NULL);
420	renderer = gtk_cell_renderer_text_new();
421	gtk_tree_view_insert_column_with_attributes(view, -1,
422	"Y", renderer,
423	"text", COL_YES,
424	"foreground-gdk",
425	COL_COLOR, NULL);
426	renderer = gtk_cell_renderer_text_new();
427	gtk_tree_view_insert_column_with_attributes(view, -1,
428	_("Value"), renderer,
429	"text", COL_VALUE,
430	"editable",
431	COL_EDIT,
432	"foreground-gdk",
433	COL_COLOR, NULL);
434	g_signal_connect(G_OBJECT(renderer), "edited",
435	G_CALLBACK(renderer_edited), NULL);
436
437	column = gtk_tree_view_get_column(view, COL_NAME);
438	gtk_tree_view_column_set_visible(column, show_name);
439	column = gtk_tree_view_get_column(view, COL_NO);
440	gtk_tree_view_column_set_visible(column, show_range);
441	column = gtk_tree_view_get_column(view, COL_MOD);
442	gtk_tree_view_column_set_visible(column, show_range);
443	column = gtk_tree_view_get_column(view, COL_YES);
444	gtk_tree_view_column_set_visible(column, show_range);
445	column = gtk_tree_view_get_column(view, COL_VALUE);
446	gtk_tree_view_column_set_visible(column, show_value);
447
448	if (resizeable) {
449	for (i = 0; i < COL_VALUE; i++) {
450	column = gtk_tree_view_get_column(view, i);
451	gtk_tree_view_column_set_resizable(column, TRUE);
452	}
453	}
454
455	sel = gtk_tree_view_get_selection(view);
456	gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
457	}
458
459
460	/* Utility Functions */
461
462
463	static void text_insert_help(struct menu *menu)
464	{
465	GtkTextBuffer *buffer;
466	GtkTextIter start, end;
467	const char *prompt = menu_get_prompt(menu);
468	gchar *name;
469	const char *help = _(nohelp_text);
470
471	if (!menu->sym)
472	help = "";
473	else if (menu->sym->help)
474	help = _(menu->sym->help);
475
476	if (menu->sym && menu->sym->name)
477	name = g_strdup_printf(_(menu->sym->name));
478	else
479	name = g_strdup("");
480
481	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
482	gtk_text_buffer_get_bounds(buffer, &start, &end);
483	gtk_text_buffer_delete(buffer, &start, &end);
484	gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
485
486	gtk_text_buffer_get_end_iter(buffer, &end);
487	gtk_text_buffer_insert_with_tags(buffer, &end, prompt, -1, tag1,
488	NULL);
489	gtk_text_buffer_insert_at_cursor(buffer, " ", 1);
490	gtk_text_buffer_get_end_iter(buffer, &end);
491	gtk_text_buffer_insert_with_tags(buffer, &end, name, -1, tag1,
492	NULL);
493	gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
494	gtk_text_buffer_get_end_iter(buffer, &end);
495	gtk_text_buffer_insert_with_tags(buffer, &end, help, -1, tag2,
496	NULL);
497	}
498
499
500	static void text_insert_msg(const char title, const char message)
501	{
502	GtkTextBuffer *buffer;
503	GtkTextIter start, end;
504	const char *msg = message;
505
506	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
507	gtk_text_buffer_get_bounds(buffer, &start, &end);
508	gtk_text_buffer_delete(buffer, &start, &end);
509	gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
510
511	gtk_text_buffer_get_end_iter(buffer, &end);
512	gtk_text_buffer_insert_with_tags(buffer, &end, title, -1, tag1,
513	NULL);
514	gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
515	gtk_text_buffer_get_end_iter(buffer, &end);
516	gtk_text_buffer_insert_with_tags(buffer, &end, msg, -1, tag2,
517	NULL);
518	}
519
520
521	/* Main Windows Callbacks */
522
523	void on_save1_activate(GtkMenuItem * menuitem, gpointer user_data);
524	gboolean on_window1_delete_event(GtkWidget * widget, GdkEvent * event,
525	gpointer user_data)
526	{
527	GtkWidget dialog, label;
528	gint result;
529
530	if (config_changed == FALSE)
531	return FALSE;
532
533	dialog = gtk_dialog_new_with_buttons(_("Warning !"),
534	GTK_WINDOW(main_wnd),
535	(GtkDialogFlags)
536	(GTK_DIALOG_MODAL \|
537	GTK_DIALOG_DESTROY_WITH_PARENT),
538	GTK_STOCK_OK,
539	GTK_RESPONSE_YES,
540	GTK_STOCK_NO,
541	GTK_RESPONSE_NO,
542	GTK_STOCK_CANCEL,
543	GTK_RESPONSE_CANCEL, NULL);
544	gtk_dialog_set_default_response(GTK_DIALOG(dialog),
545	GTK_RESPONSE_CANCEL);
546
547	label = gtk_label_new(_("\nSave configuration ?\n"));
548	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
549	gtk_widget_show(label);
550
551	result = gtk_dialog_run(GTK_DIALOG(dialog));
552	switch (result) {
553	case GTK_RESPONSE_YES:
554	on_save1_activate(NULL, NULL);
555	return FALSE;
556	case GTK_RESPONSE_NO:
557	return FALSE;
558	case GTK_RESPONSE_CANCEL:
559	case GTK_RESPONSE_DELETE_EVENT:
560	default:
561	gtk_widget_destroy(dialog);
562	return TRUE;
563	}
564
565	return FALSE;
566	}
567
568
569	void on_window1_destroy(GtkObject * object, gpointer user_data)
570	{
571	gtk_main_quit();
572	}
573
574
575	void
576	on_window1_size_request(GtkWidget * widget,
577	GtkRequisition * requisition, gpointer user_data)
578	{
579	static gint old_h;
580	gint w, h;
581
582	if (widget->window == NULL)
583	gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h);
584	else
585	gdk_window_get_size(widget->window, &w, &h);
586
587	if (h == old_h)
588	return;
589	old_h = h;
590
591	gtk_paned_set_position(GTK_PANED(vpaned), 2 * h / 3);
592	}
593
594
595	/* Menu & Toolbar Callbacks */
596
597
598	static void
599	load_filename(GtkFileSelection * file_selector, gpointer user_data)
600	{
601	const gchar *fn;
602
603	fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
604	(user_data));
605
606	if (conf_read(fn))
607	text_insert_msg(_("Error"), _("Unable to load configuration !"));
608	else
609	display_tree(&rootmenu);
610	}
611
612	void on_load1_activate(GtkMenuItem * menuitem, gpointer user_data)
613	{
614	GtkWidget *fs;
615
616	fs = gtk_file_selection_new(_("Load file..."));
617	g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
618	"clicked",
619	G_CALLBACK(load_filename), (gpointer) fs);
620	g_signal_connect_swapped(GTK_OBJECT
621	(GTK_FILE_SELECTION(fs)->ok_button),
622	"clicked", G_CALLBACK(gtk_widget_destroy),
623	(gpointer) fs);
624	g_signal_connect_swapped(GTK_OBJECT
625	(GTK_FILE_SELECTION(fs)->cancel_button),
626	"clicked", G_CALLBACK(gtk_widget_destroy),
627	(gpointer) fs);
628	gtk_widget_show(fs);
629	}
630
631
632	void on_save1_activate(GtkMenuItem * menuitem, gpointer user_data)
633	{
634	if (conf_write(NULL))
635	text_insert_msg(_("Error"), _("Unable to save configuration !"));
636
637	config_changed = FALSE;
638	}
639
640
641	static void
642	store_filename(GtkFileSelection * file_selector, gpointer user_data)
643	{
644	const gchar *fn;
645
646	fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
647	(user_data));
648
649	if (conf_write(fn))
650	text_insert_msg(_("Error"), _("Unable to save configuration !"));
651
652	gtk_widget_destroy(GTK_WIDGET(user_data));
653	}
654
655	void on_save_as1_activate(GtkMenuItem * menuitem, gpointer user_data)
656	{
657	GtkWidget *fs;
658
659	fs = gtk_file_selection_new(_("Save file as..."));
660	g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
661	"clicked",
662	G_CALLBACK(store_filename), (gpointer) fs);
663	g_signal_connect_swapped(GTK_OBJECT
664	(GTK_FILE_SELECTION(fs)->ok_button),
665	"clicked", G_CALLBACK(gtk_widget_destroy),
666	(gpointer) fs);
667	g_signal_connect_swapped(GTK_OBJECT
668	(GTK_FILE_SELECTION(fs)->cancel_button),
669	"clicked", G_CALLBACK(gtk_widget_destroy),
670	(gpointer) fs);
671	gtk_widget_show(fs);
672	}
673
674
675	void on_quit1_activate(GtkMenuItem * menuitem, gpointer user_data)
676	{
677	if (!on_window1_delete_event(NULL, NULL, NULL))
678	gtk_widget_destroy(GTK_WIDGET(main_wnd));
679	}
680
681
682	void on_show_name1_activate(GtkMenuItem * menuitem, gpointer user_data)
683	{
684	GtkTreeViewColumn *col;
685
686	show_name = GTK_CHECK_MENU_ITEM(menuitem)->active;
687	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NAME);
688	if (col)
689	gtk_tree_view_column_set_visible(col, show_name);
690	}
691
692
693	void on_show_range1_activate(GtkMenuItem * menuitem, gpointer user_data)
694	{
695	GtkTreeViewColumn *col;
696
697	show_range = GTK_CHECK_MENU_ITEM(menuitem)->active;
698	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NO);
699	if (col)
700	gtk_tree_view_column_set_visible(col, show_range);
701	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_MOD);
702	if (col)
703	gtk_tree_view_column_set_visible(col, show_range);
704	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_YES);
705	if (col)
706	gtk_tree_view_column_set_visible(col, show_range);
707
708	}
709
710
711	void on_show_data1_activate(GtkMenuItem * menuitem, gpointer user_data)
712	{
713	GtkTreeViewColumn *col;
714
715	show_value = GTK_CHECK_MENU_ITEM(menuitem)->active;
716	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_VALUE);
717	if (col)
718	gtk_tree_view_column_set_visible(col, show_value);
719	}
720
721
722	void
723	on_show_all_options1_activate(GtkMenuItem * menuitem, gpointer user_data)
724	{
725	show_all = GTK_CHECK_MENU_ITEM(menuitem)->active;
726
727	gtk_tree_store_clear(tree2);
728	display_tree(&rootmenu); // instead of update_tree to speed-up
729	}
730
731
732	void
733	on_show_debug_info1_activate(GtkMenuItem * menuitem, gpointer user_data)
734	{
735	show_debug = GTK_CHECK_MENU_ITEM(menuitem)->active;
736	update_tree(&rootmenu, NULL);
737	}
738
739
740	void on_introduction1_activate(GtkMenuItem * menuitem, gpointer user_data)
741	{
742	GtkWidget *dialog;
743	const gchar *intro_text = _(
744	"Welcome to gkc, the GTK+ graphical busybox configuration tool\n"
745	"for Linux.\n"
746	"For each option, a blank box indicates the feature is disabled, a\n"
747	"check indicates it is enabled, and a dot indicates that it is to\n"
748	"be compiled as a module. Clicking on the box will cycle through the three states.\n"
749	"\n"
750	"If you do not see an option (e.g., a device driver) that you\n"
751	"believe should be present, try turning on Show All Options\n"
752	"under the Options menu.\n"
753	"Although there is no cross reference yet to help you figure out\n"
754	"what other options must be enabled to support the option you\n"
755	"are interested in, you can still view the help of a grayed-out\n"
756	"option.\n"
757	"\n"
758	"Toggling Show Debug Info under the Options menu will show\n"
759	"the dependencies, which you can then match by examining other options.");
760
761	dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
762	GTK_DIALOG_DESTROY_WITH_PARENT,
763	GTK_MESSAGE_INFO,
764	GTK_BUTTONS_CLOSE, intro_text);
765	g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
766	G_CALLBACK(gtk_widget_destroy),
767	GTK_OBJECT(dialog));
768	gtk_widget_show_all(dialog);
769	}
770
771
772	void on_about1_activate(GtkMenuItem * menuitem, gpointer user_data)
773	{
774	GtkWidget *dialog;
775	const gchar *about_text =
776	_("gkc is copyright (c) 2002 Romain Lievin <roms@lpg.ticalc.org>.\n"
777	"Based on the source code from Roman Zippel.\n");
778
779	dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
780	GTK_DIALOG_DESTROY_WITH_PARENT,
781	GTK_MESSAGE_INFO,
782	GTK_BUTTONS_CLOSE, about_text);
783	g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
784	G_CALLBACK(gtk_widget_destroy),
785	GTK_OBJECT(dialog));
786	gtk_widget_show_all(dialog);
787	}
788
789
790	void on_license1_activate(GtkMenuItem * menuitem, gpointer user_data)
791	{
792	GtkWidget *dialog;
793	const gchar *license_text =
794	_("gkc is released under the terms of the GNU GPL v2.\n"
795	"For more information, please see the source code or\n"
796	"visit http://www.fsf.org/licenses/licenses.html\n");
797
798	dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
799	GTK_DIALOG_DESTROY_WITH_PARENT,
800	GTK_MESSAGE_INFO,
801	GTK_BUTTONS_CLOSE, license_text);
802	g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
803	G_CALLBACK(gtk_widget_destroy),
804	GTK_OBJECT(dialog));
805	gtk_widget_show_all(dialog);
806	}
807
808
809	void on_back_clicked(GtkButton * button, gpointer user_data)
810	{
811	enum prop_type ptype;
812
813	current = current->parent;
814	ptype = current->prompt ? current->prompt->type : P_UNKNOWN;
815	if (ptype != P_MENU)
816	current = current->parent;
817	display_tree_part();
818
819	if (current == &rootmenu)
820	gtk_widget_set_sensitive(back_btn, FALSE);
821	}
822
823
824	void on_load_clicked(GtkButton * button, gpointer user_data)
825	{
826	on_load1_activate(NULL, user_data);
827	}
828
829
830	void on_save_clicked(GtkButton * button, gpointer user_data)
831	{
832	on_save1_activate(NULL, user_data);
833	}
834
835
836	void on_single_clicked(GtkButton * button, gpointer user_data)
837	{
838	view_mode = SINGLE_VIEW;
839	gtk_paned_set_position(GTK_PANED(hpaned), 0);
840	gtk_widget_hide(tree1_w);
841	current = &rootmenu;
842	display_tree_part();
843	}
844
845
846	void on_split_clicked(GtkButton * button, gpointer user_data)
847	{
848	gint w, h;
849	view_mode = SPLIT_VIEW;
850	gtk_widget_show(tree1_w);
851	gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h);
852	gtk_paned_set_position(GTK_PANED(hpaned), w / 2);
853	if (tree2)
854	gtk_tree_store_clear(tree2);
855	display_list();
856
857	/* Disable back btn, like in full mode. */
858	gtk_widget_set_sensitive(back_btn, FALSE);
859	}
860
861
862	void on_full_clicked(GtkButton * button, gpointer user_data)
863	{
864	view_mode = FULL_VIEW;
865	gtk_paned_set_position(GTK_PANED(hpaned), 0);
866	gtk_widget_hide(tree1_w);
867	if (tree2)
868	gtk_tree_store_clear(tree2);
869	display_tree(&rootmenu);
870	gtk_widget_set_sensitive(back_btn, FALSE);
871	}
872
873
874	void on_collapse_clicked(GtkButton * button, gpointer user_data)
875	{
876	gtk_tree_view_collapse_all(GTK_TREE_VIEW(tree2_w));
877	}
878
879
880	void on_expand_clicked(GtkButton * button, gpointer user_data)
881	{
882	gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
883	}
884
885
886	/* CTree Callbacks */
887
888	/* Change hex/int/string value in the cell */
889	static void renderer_edited(GtkCellRendererText * cell,
890	const gchar * path_string,
891	const gchar * new_text, gpointer user_data)
892	{
893	GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
894	GtkTreeIter iter;
895	const char old_def, new_def;
896	struct menu *menu;
897	struct symbol *sym;
898
899	if (!gtk_tree_model_get_iter(model2, &iter, path))
900	return;
901
902	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
903	sym = menu->sym;
904
905	gtk_tree_model_get(model2, &iter, COL_VALUE, &old_def, -1);
906	new_def = new_text;
907
908	sym_set_string_value(sym, new_def);
909
910	config_changed = TRUE;
911	update_tree(&rootmenu, NULL);
912
913	gtk_tree_path_free(path);
914	}
915
916	/* Change the value of a symbol and update the tree */
917	static void change_sym_value(struct menu *menu, gint col)
918	{
919	struct symbol *sym = menu->sym;
920	tristate oldval, newval;
921
922	if (!sym)
923	return;
924
925	if (col == COL_NO)
926	newval = no;
927	else if (col == COL_MOD)
928	newval = mod;
929	else if (col == COL_YES)
930	newval = yes;
931	else
932	return;
933
934	switch (sym_get_type(sym)) {
935	case S_BOOLEAN:
936	case S_TRISTATE:
937	oldval = sym_get_tristate_value(sym);
938	if (!sym_tristate_within_range(sym, newval))
939	newval = yes;
940	sym_set_tristate_value(sym, newval);
941	config_changed = TRUE;
942	if (view_mode == FULL_VIEW)
943	update_tree(&rootmenu, NULL);
944	else if (view_mode == SPLIT_VIEW) {
945	update_tree(browsed, NULL);
946	display_list();
947	}
948	else if (view_mode == SINGLE_VIEW)
949	display_tree_part(); //fixme: keep exp/coll
950	break;
951	case S_INT:
952	case S_HEX:
953	case S_STRING:
954	default:
955	break;
956	}
957	}
958
959	static void toggle_sym_value(struct menu *menu)
960	{
961	if (!menu->sym)
962	return;
963
964	sym_toggle_tristate_value(menu->sym);
965	if (view_mode == FULL_VIEW)
966	update_tree(&rootmenu, NULL);
967	else if (view_mode == SPLIT_VIEW) {
968	update_tree(browsed, NULL);
969	display_list();
970	}
971	else if (view_mode == SINGLE_VIEW)
972	display_tree_part(); //fixme: keep exp/coll
973	}
974
975	static void renderer_toggled(GtkCellRendererToggle * cell,
976	gchar * path_string, gpointer user_data)
977	{
978	GtkTreePath path, sel_path = NULL;
979	GtkTreeIter iter, sel_iter;
980	GtkTreeSelection *sel;
981	struct menu *menu;
982
983	path = gtk_tree_path_new_from_string(path_string);
984	if (!gtk_tree_model_get_iter(model2, &iter, path))
985	return;
986
987	sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree2_w));
988	if (gtk_tree_selection_get_selected(sel, NULL, &sel_iter))
989	sel_path = gtk_tree_model_get_path(model2, &sel_iter);
990	if (!sel_path)
991	goto out1;
992	if (gtk_tree_path_compare(path, sel_path))
993	goto out2;
994
995	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
996	toggle_sym_value(menu);
997
998	out2:
999	gtk_tree_path_free(sel_path);
1000	out1:
1001	gtk_tree_path_free(path);
1002	}
1003
1004	static gint column2index(GtkTreeViewColumn * column)
1005	{
1006	gint i;
1007
1008	for (i = 0; i < COL_NUMBER; i++) {
1009	GtkTreeViewColumn *col;
1010
1011	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), i);
1012	if (col == column)
1013	return i;
1014	}
1015
1016	return -1;
1017	}
1018
1019
1020	/* User click: update choice (full) or goes down (single) */
1021	gboolean
1022	on_treeview2_button_press_event(GtkWidget * widget,
1023	GdkEventButton * event, gpointer user_data)
1024	{
1025	GtkTreeView *view = GTK_TREE_VIEW(widget);
1026	GtkTreePath *path;
1027	GtkTreeViewColumn *column;
1028	GtkTreeIter iter;
1029	struct menu *menu;
1030	gint col;
1031
1032	#if GTK_CHECK_VERSION(2,1,4) // bug in ctree with earlier version of GTK
1033	gint tx = (gint) event->x;
1034	gint ty = (gint) event->y;
1035	gint cx, cy;
1036
1037	gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
1038	&cy);
1039	#else
1040	gtk_tree_view_get_cursor(view, &path, &column);
1041	#endif
1042	if (path == NULL)
1043	return FALSE;
1044
1045	if (!gtk_tree_model_get_iter(model2, &iter, path))
1046	return FALSE;
1047	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1048
1049	col = column2index(column);
1050	if (event->type == GDK_2BUTTON_PRESS) {
1051	enum prop_type ptype;
1052	ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
1053
1054	if (ptype == P_MENU && view_mode != FULL_VIEW && col == COL_OPTION) {
1055	// goes down into menu
1056	current = menu;
1057	display_tree_part();
1058	gtk_widget_set_sensitive(back_btn, TRUE);
1059	} else if ((col == COL_OPTION)) {
1060	toggle_sym_value(menu);
1061	gtk_tree_view_expand_row(view, path, TRUE);
1062	}
1063	} else {
1064	if (col == COL_VALUE) {
1065	toggle_sym_value(menu);
1066	gtk_tree_view_expand_row(view, path, TRUE);
1067	} else if (col == COL_NO \|\| col == COL_MOD
1068	\|\| col == COL_YES) {
1069	change_sym_value(menu, col);
1070	gtk_tree_view_expand_row(view, path, TRUE);
1071	}
1072	}
1073
1074	return FALSE;
1075	}
1076
1077	/* Key pressed: update choice */
1078	gboolean
1079	on_treeview2_key_press_event(GtkWidget * widget,
1080	GdkEventKey * event, gpointer user_data)
1081	{
1082	GtkTreeView *view = GTK_TREE_VIEW(widget);
1083	GtkTreePath *path;
1084	GtkTreeViewColumn *column;
1085	GtkTreeIter iter;
1086	struct menu *menu;
1087	gint col;
1088
1089	gtk_tree_view_get_cursor(view, &path, &column);
1090	if (path == NULL)
1091	return FALSE;
1092
1093	if (event->keyval == GDK_space) {
1094	if (gtk_tree_view_row_expanded(view, path))
1095	gtk_tree_view_collapse_row(view, path);
1096	else
1097	gtk_tree_view_expand_row(view, path, FALSE);
1098	return TRUE;
1099	}
1100	if (event->keyval == GDK_KP_Enter) {
1101	}
1102	if (widget == tree1_w)
1103	return FALSE;
1104
1105	gtk_tree_model_get_iter(model2, &iter, path);
1106	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1107
1108	if (!strcasecmp(event->string, "n"))
1109	col = COL_NO;
1110	else if (!strcasecmp(event->string, "m"))
1111	col = COL_MOD;
1112	else if (!strcasecmp(event->string, "y"))
1113	col = COL_YES;
1114	else
1115	col = -1;
1116	change_sym_value(menu, col);
1117
1118	return FALSE;
1119	}
1120
1121
1122	/* Row selection changed: update help */
1123	void
1124	on_treeview2_cursor_changed(GtkTreeView * treeview, gpointer user_data)
1125	{
1126	GtkTreeSelection *selection;
1127	GtkTreeIter iter;
1128	struct menu *menu;
1129
1130	selection = gtk_tree_view_get_selection(treeview);
1131	if (gtk_tree_selection_get_selected(selection, &model2, &iter)) {
1132	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1133	text_insert_help(menu);
1134	}
1135	}
1136
1137
1138	/* User click: display sub-tree in the right frame. */
1139	gboolean
1140	on_treeview1_button_press_event(GtkWidget * widget,
1141	GdkEventButton * event, gpointer user_data)
1142	{
1143	GtkTreeView *view = GTK_TREE_VIEW(widget);
1144	GtkTreePath *path;
1145	GtkTreeViewColumn *column;
1146	GtkTreeIter iter;
1147	struct menu *menu;
1148
1149	gint tx = (gint) event->x;
1150	gint ty = (gint) event->y;
1151	gint cx, cy;
1152
1153	gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
1154	&cy);
1155	if (path == NULL)
1156	return FALSE;
1157
1158	gtk_tree_model_get_iter(model1, &iter, path);
1159	gtk_tree_model_get(model1, &iter, COL_MENU, &menu, -1);
1160
1161	if (event->type == GDK_2BUTTON_PRESS) {
1162	toggle_sym_value(menu);
1163	current = menu;
1164	display_tree_part();
1165	} else {
1166	browsed = menu;
1167	display_tree_part();
1168	}
1169
1170	gtk_widget_realize(tree2_w);
1171	gtk_tree_view_set_cursor(view, path, NULL, FALSE);
1172	gtk_widget_grab_focus(tree2_w);
1173
1174	return FALSE;
1175	}
1176
1177
1178	/* Fill a row of strings */
1179	static gchar *fill_row(struct menu menu)
1180	{
1181	static gchar *row[COL_NUMBER];
1182	struct symbol *sym = menu->sym;
1183	const char *def;
1184	int stype;
1185	tristate val;
1186	enum prop_type ptype;
1187	int i;
1188
1189	for (i = COL_OPTION; i <= COL_COLOR; i++)
1190	g_free(row[i]);
1191	memset(row, 0, sizeof(row));
1192
1193	row[COL_OPTION] =
1194	g_strdup_printf("%s %s", menu_get_prompt(menu),
1195	sym ? (sym->
1196	flags & SYMBOL_NEW ? "(NEW)" : "") :
1197	"");
1198
1199	if (show_all && !menu_is_visible(menu))
1200	row[COL_COLOR] = g_strdup("DarkGray");
1201	else
1202	row[COL_COLOR] = g_strdup("Black");
1203
1204	ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
1205	switch (ptype) {
1206	case P_MENU:
1207	row[COL_PIXBUF] = (gchar *) xpm_menu;
1208	if (view_mode == SINGLE_VIEW)
1209	row[COL_PIXVIS] = GINT_TO_POINTER(TRUE);
1210	row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1211	break;
1212	case P_COMMENT:
1213	row[COL_PIXBUF] = (gchar *) xpm_void;
1214	row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
1215	row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1216	break;
1217	default:
1218	row[COL_PIXBUF] = (gchar *) xpm_void;
1219	row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
1220	row[COL_BTNVIS] = GINT_TO_POINTER(TRUE);
1221	break;
1222	}
1223
1224	if (!sym)
1225	return row;
1226	row[COL_NAME] = g_strdup(sym->name);
1227
1228	sym_calc_value(sym);
1229	sym->flags &= ~SYMBOL_CHANGED;
1230
1231	if (sym_is_choice(sym)) { // parse childs for getting final value
1232	struct menu *child;
1233	struct symbol *def_sym = sym_get_choice_value(sym);
1234	struct menu *def_menu = NULL;
1235
1236	row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1237
1238	for (child = menu->list; child; child = child->next) {
1239	if (menu_is_visible(child)
1240	&& child->sym == def_sym)
1241	def_menu = child;
1242	}
1243
1244	if (def_menu)
1245	row[COL_VALUE] =
1246	g_strdup(menu_get_prompt(def_menu));
1247	}
1248	if (sym->flags & SYMBOL_CHOICEVAL)
1249	row[COL_BTNRAD] = GINT_TO_POINTER(TRUE);
1250
1251	stype = sym_get_type(sym);
1252	switch (stype) {
1253	case S_BOOLEAN:
1254	if (GPOINTER_TO_INT(row[COL_PIXVIS]) == FALSE)
1255	row[COL_BTNVIS] = GINT_TO_POINTER(TRUE);
1256	if (sym_is_choice(sym))
1257	break;
1258	case S_TRISTATE:
1259	val = sym_get_tristate_value(sym);
1260	switch (val) {
1261	case no:
1262	row[COL_NO] = g_strdup("N");
1263	row[COL_VALUE] = g_strdup("N");
1264	row[COL_BTNACT] = GINT_TO_POINTER(FALSE);
1265	row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
1266	break;
1267	case mod:
1268	row[COL_MOD] = g_strdup("M");
1269	row[COL_VALUE] = g_strdup("M");
1270	row[COL_BTNINC] = GINT_TO_POINTER(TRUE);
1271	break;
1272	case yes:
1273	row[COL_YES] = g_strdup("Y");
1274	row[COL_VALUE] = g_strdup("Y");
1275	row[COL_BTNACT] = GINT_TO_POINTER(TRUE);
1276	row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
1277	break;
1278	}
1279
1280	if (val != no && sym_tristate_within_range(sym, no))
1281	row[COL_NO] = g_strdup("_");
1282	if (val != mod && sym_tristate_within_range(sym, mod))
1283	row[COL_MOD] = g_strdup("_");
1284	if (val != yes && sym_tristate_within_range(sym, yes))
1285	row[COL_YES] = g_strdup("_");
1286	break;
1287	case S_INT:
1288	case S_HEX:
1289	case S_STRING:
1290	def = sym_get_string_value(sym);
1291	row[COL_VALUE] = g_strdup(def);
1292	row[COL_EDIT] = GINT_TO_POINTER(TRUE);
1293	row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1294	break;
1295	}
1296
1297	return row;
1298	}
1299
1300
1301	/* Set the node content with a row of strings */
1302	static void set_node(GtkTreeIter * node, struct menu menu, gchar * row)
1303	{
1304	GdkColor color;
1305	gboolean success;
1306	GdkPixbuf *pix;
1307
1308	pix = gdk_pixbuf_new_from_xpm_data((const char **)
1309	row[COL_PIXBUF]);
1310
1311	gdk_color_parse(row[COL_COLOR], &color);
1312	gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1,
1313	FALSE, FALSE, &success);
1314
1315	gtk_tree_store_set(tree, node,
1316	COL_OPTION, row[COL_OPTION],
1317	COL_NAME, row[COL_NAME],
1318	COL_NO, row[COL_NO],
1319	COL_MOD, row[COL_MOD],
1320	COL_YES, row[COL_YES],
1321	COL_VALUE, row[COL_VALUE],
1322	COL_MENU, (gpointer) menu,
1323	COL_COLOR, &color,
1324	COL_EDIT, GPOINTER_TO_INT(row[COL_EDIT]),
1325	COL_PIXBUF, pix,
1326	COL_PIXVIS, GPOINTER_TO_INT(row[COL_PIXVIS]),
1327	COL_BTNVIS, GPOINTER_TO_INT(row[COL_BTNVIS]),
1328	COL_BTNACT, GPOINTER_TO_INT(row[COL_BTNACT]),
1329	COL_BTNINC, GPOINTER_TO_INT(row[COL_BTNINC]),
1330	COL_BTNRAD, GPOINTER_TO_INT(row[COL_BTNRAD]),
1331	-1);
1332
1333	g_object_unref(pix);
1334	}
1335
1336
1337	/* Add a node to the tree */
1338	static void place_node(struct menu menu, char *row)
1339	{
1340	GtkTreeIter *parent = parents[indent - 1];
1341	GtkTreeIter *node = parents[indent];
1342
1343	gtk_tree_store_append(tree, node, parent);
1344	set_node(node, menu, row);
1345	}
1346
1347
1348	/* Find a node in the GTK+ tree */
1349	static GtkTreeIter found;
1350
1351	/*
1352	* Find a menu in the GtkTree starting at parent.
1353	*/
1354	GtkTreeIter gtktree_iter_find_node(GtkTreeIter parent,
1355	struct menu *tofind)
1356	{
1357	GtkTreeIter iter;
1358	GtkTreeIter *child = &iter;
1359	gboolean valid;
1360	GtkTreeIter *ret;
1361
1362	valid = gtk_tree_model_iter_children(model2, child, parent);
1363	while (valid) {
1364	struct menu *menu;
1365
1366	gtk_tree_model_get(model2, child, 6, &menu, -1);
1367
1368	if (menu == tofind) {
1369	memcpy(&found, child, sizeof(GtkTreeIter));
1370	return &found;
1371	}
1372
1373	ret = gtktree_iter_find_node(child, tofind);
1374	if (ret)
1375	return ret;
1376
1377	valid = gtk_tree_model_iter_next(model2, child);
1378	}
1379
1380	return NULL;
1381	}
1382
1383
1384	/*
1385	* Update the tree by adding/removing entries
1386	* Does not change other nodes
1387	*/
1388	static void update_tree(struct menu src, GtkTreeIter dst)
1389	{
1390	struct menu *child1;
1391	GtkTreeIter iter, tmp;
1392	GtkTreeIter *child2 = &iter;
1393	gboolean valid;
1394	GtkTreeIter *sibling;
1395	struct symbol *sym;
1396	struct property *prop;
1397	struct menu menu1, menu2;
1398
1399	if (src == &rootmenu)
1400	indent = 1;
1401
1402	valid = gtk_tree_model_iter_children(model2, child2, dst);
1403	for (child1 = src->list; child1; child1 = child1->next) {
1404
1405	prop = child1->prompt;
1406	sym = child1->sym;
1407
1408	reparse:
1409	menu1 = child1;
1410	if (valid)
1411	gtk_tree_model_get(model2, child2, COL_MENU,
1412	&menu2, -1);
1413	else
1414	menu2 = NULL; // force adding of a first child
1415
1416	#ifdef DEBUG
1417	printf("%*c%s \| %s\n", indent, ' ',
1418	menu1 ? menu_get_prompt(menu1) : "nil",
1419	menu2 ? menu_get_prompt(menu2) : "nil");
1420	#endif
1421
1422	if (!menu_is_visible(child1) && !show_all) { // remove node
1423	if (gtktree_iter_find_node(dst, menu1) != NULL) {
1424	memcpy(&tmp, child2, sizeof(GtkTreeIter));
1425	valid = gtk_tree_model_iter_next(model2,
1426	child2);
1427	gtk_tree_store_remove(tree2, &tmp);
1428	if (!valid)
1429	return; // next parent
1430	else
1431	goto reparse; // next child
1432	} else
1433	continue;
1434	}
1435
1436	if (menu1 != menu2) {
1437	if (gtktree_iter_find_node(dst, menu1) == NULL) { // add node
1438	if (!valid && !menu2)
1439	sibling = NULL;
1440	else
1441	sibling = child2;
1442	gtk_tree_store_insert_before(tree2,
1443	child2,
1444	dst, sibling);
1445	set_node(child2, menu1, fill_row(menu1));
1446	if (menu2 == NULL)
1447	valid = TRUE;
1448	} else { // remove node
1449	memcpy(&tmp, child2, sizeof(GtkTreeIter));
1450	valid = gtk_tree_model_iter_next(model2,
1451	child2);
1452	gtk_tree_store_remove(tree2, &tmp);
1453	if (!valid)
1454	return; // next parent
1455	else
1456	goto reparse; // next child
1457	}
1458	} else if (sym && (sym->flags & SYMBOL_CHANGED)) {
1459	set_node(child2, menu1, fill_row(menu1));
1460	}
1461
1462	indent++;
1463	update_tree(child1, child2);
1464	indent--;
1465
1466	valid = gtk_tree_model_iter_next(model2, child2);
1467	}
1468	}
1469
1470
1471	/* Display the whole tree (single/split/full view) */
1472	static void display_tree(struct menu *menu)
1473	{
1474	struct symbol *sym;
1475	struct property *prop;
1476	struct menu *child;
1477	enum prop_type ptype;
1478
1479	if (menu == &rootmenu) {
1480	indent = 1;
1481	current = &rootmenu;
1482	}
1483
1484	for (child = menu->list; child; child = child->next) {
1485	prop = child->prompt;
1486	sym = child->sym;
1487	ptype = prop ? prop->type : P_UNKNOWN;
1488
1489	if (sym)
1490	sym->flags &= ~SYMBOL_CHANGED;
1491
1492	if ((view_mode == SPLIT_VIEW)
1493	&& !(child->flags & MENU_ROOT) && (tree == tree1))
1494	continue;
1495
1496	if ((view_mode == SPLIT_VIEW) && (child->flags & MENU_ROOT)
1497	&& (tree == tree2))
1498	continue;
1499
1500	if (menu_is_visible(child) \|\| show_all)
1501	place_node(child, fill_row(child));
1502	#ifdef DEBUG
1503	printf("%*c%s: ", indent, ' ', menu_get_prompt(child));
1504	printf("%s", child->flags & MENU_ROOT ? "rootmenu \| " : "");
1505	dbg_print_ptype(ptype);
1506	printf(" \| ");
1507	if (sym) {
1508	dbg_print_stype(sym->type);
1509	printf(" \| ");
1510	dbg_print_flags(sym->flags);
1511	printf("\n");
1512	} else
1513	printf("\n");
1514	#endif
1515	if ((view_mode != FULL_VIEW) && (ptype == P_MENU)
1516	&& (tree == tree2))
1517	continue;
1518	/*
1519	if (((menu != &rootmenu) && !(menu->flags & MENU_ROOT))
1520	\|\| (view_mode == FULL_VIEW)
1521	\|\| (view_mode == SPLIT_VIEW))*/
1522	if (((view_mode == SINGLE_VIEW) && (menu->flags & MENU_ROOT))
1523	\|\| (view_mode == FULL_VIEW)
1524	\|\| (view_mode == SPLIT_VIEW)) {
1525	indent++;
1526	display_tree(child);
1527	indent--;
1528	}
1529	}
1530	}
1531
1532	/* Display a part of the tree starting at current node (single/split view) */
1533	static void display_tree_part(void)
1534	{
1535	if (tree2)
1536	gtk_tree_store_clear(tree2);
1537	if (view_mode == SINGLE_VIEW)
1538	display_tree(current);
1539	else if (view_mode == SPLIT_VIEW)
1540	display_tree(browsed);
1541	gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
1542	}
1543
1544	/* Display the list in the left frame (split view) */
1545	static void display_list(void)
1546	{
1547	if (tree1)
1548	gtk_tree_store_clear(tree1);
1549
1550	tree = tree1;
1551	display_tree(&rootmenu);
1552	gtk_tree_view_expand_all(GTK_TREE_VIEW(tree1_w));
1553	tree = tree2;
1554	}
1555
1556	void fixup_rootmenu(struct menu *menu)
1557	{
1558	struct menu *child;
1559	static int menu_cnt = 0;
1560
1561	menu->flags \|= MENU_ROOT;
1562	for (child = menu->list; child; child = child->next) {
1563	if (child->prompt && child->prompt->type == P_MENU) {
1564	menu_cnt++;
1565	fixup_rootmenu(child);
1566	menu_cnt--;
1567	} else if (!menu_cnt)
1568	fixup_rootmenu(child);
1569	}
1570	}
1571
1572
1573	/* Main */
1574	int main(int ac, char *av[])
1575	{
1576	const char *name;
1577	char *env;
1578	gchar *glade_file;
1579
1580	#ifndef LKC_DIRECT_LINK
1581	kconfig_load();
1582	#endif
1583
1584	bindtextdomain(PACKAGE, LOCALEDIR);
1585	bind_textdomain_codeset(PACKAGE, "UTF-8");
1586	textdomain(PACKAGE);
1587
1588	/* GTK stuffs */
1589	gtk_set_locale();
1590	gtk_init(&ac, &av);
1591	glade_init();
1592
1593	//add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
1594	//add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
1595
1596	/* Determine GUI path */
1597	env = getenv(SRCTREE);
1598	if (env)
1599	glade_file = g_strconcat(env, "/scripts/kconfig/gconf.glade", NULL);
1600	else if (av[0][0] == '/')
1601	glade_file = g_strconcat(av[0], ".glade", NULL);
1602	else
1603	glade_file = g_strconcat(g_get_current_dir(), "/", av[0], ".glade", NULL);
1604
1605	/* Load the interface and connect signals */
1606	init_main_window(glade_file);
1607	init_tree_model();
1608	init_left_tree();
1609	init_right_tree();
1610
1611	/* Conf stuffs */
1612	if (ac > 1 && av[1][0] == '-') {
1613	switch (av[1][1]) {
1614	case 'a':
1615	//showAll = 1;
1616	break;
1617	case 'h':
1618	case '?':
1619	printf("%s <config>\n", av[0]);
1620	exit(0);
1621	}
1622	name = av[2];
1623	} else
1624	name = av[1];
1625
1626	conf_parse(name);
1627	fixup_rootmenu(&rootmenu);
1628	conf_read(NULL);
1629
1630	switch (view_mode) {
1631	case SINGLE_VIEW:
1632	display_tree_part();
1633	break;
1634	case SPLIT_VIEW:
1635	display_list();
1636	break;
1637	case FULL_VIEW:
1638	display_tree(&rootmenu);
1639	break;
1640	}
1641
1642	gtk_main();
1643
1644	return 0;
1645	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: MondoRescue/branches/2.2.5/mindi-busybox/scripts/kconfig/gconf.c

Download in other formats: