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