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