?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux v2.6.13
[linux-2.6/next.git] / scripts / kconfig / gconf.c
blob9f5aabd58fa96cdb86220a4fe322855d8194f6e1
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_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 bzero(buf, 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, _("Linux Kernel v%s Configuration"),
279 getenv("KERNELRELEASE"));
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 kernel 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 bzero(row, 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 }
linux-next