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