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