Kernel

Kernel Git Source Tree

Root/scripts/kconfig/gconf.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/scripts/kconfig/gconf.c

interactive