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