ARM: 7409/1: Do not call flush_cache_user_range with mmap_sem held
[linux/fpc-iii.git] / scripts / kconfig / gconf.c
bloba11d5f7b9eeb1f793514fb8548b646a7414ca321
1 /* Hey EMACS -*- linux-c -*- */
2 /*
4 * Copyright (C) 2002-2003 Romain Lievin <roms@tilp.info>
5 * Released under the terms of the GNU GPL v2.0.
7 */
9 #ifdef HAVE_CONFIG_H
10 # include <config.h>
11 #endif
13 #include "lkc.h"
14 #include "images.c"
16 #include <glade/glade.h>
17 #include <gtk/gtk.h>
18 #include <glib.h>
19 #include <gdk/gdkkeysyms.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <time.h>
25 #include <stdlib.h>
27 //#define DEBUG
29 enum {
30 SINGLE_VIEW, SPLIT_VIEW, FULL_VIEW
33 enum {
34 OPT_NORMAL, OPT_ALL, OPT_PROMPT
37 static gint view_mode = FULL_VIEW;
38 static gboolean show_name = TRUE;
39 static gboolean show_range = TRUE;
40 static gboolean show_value = TRUE;
41 static gboolean resizeable = FALSE;
42 static int opt_mode = OPT_NORMAL;
44 GtkWidget *main_wnd = NULL;
45 GtkWidget *tree1_w = NULL; // left frame
46 GtkWidget *tree2_w = NULL; // right frame
47 GtkWidget *text_w = NULL;
48 GtkWidget *hpaned = NULL;
49 GtkWidget *vpaned = NULL;
50 GtkWidget *back_btn = NULL;
51 GtkWidget *save_btn = NULL;
52 GtkWidget *save_menu_item = NULL;
54 GtkTextTag *tag1, *tag2;
55 GdkColor color;
57 GtkTreeStore *tree1, *tree2, *tree;
58 GtkTreeModel *model1, *model2;
59 static GtkTreeIter *parents[256];
60 static gint indent;
62 static struct menu *current; // current node for SINGLE view
63 static struct menu *browsed; // browsed node for SPLIT view
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
72 static void display_list(void);
73 static void display_tree(struct menu *menu);
74 static void display_tree_part(void);
75 static void update_tree(struct menu *src, GtkTreeIter * dst);
76 static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row);
77 static gchar **fill_row(struct menu *menu);
78 static void conf_changed(void);
80 /* Helping/Debugging Functions */
82 const char *dbg_sym_flags(int val)
84 static char buf[256];
86 bzero(buf, 256);
88 if (val & SYMBOL_CONST)
89 strcat(buf, "const/");
90 if (val & SYMBOL_CHECK)
91 strcat(buf, "check/");
92 if (val & SYMBOL_CHOICE)
93 strcat(buf, "choice/");
94 if (val & SYMBOL_CHOICEVAL)
95 strcat(buf, "choiceval/");
96 if (val & SYMBOL_VALID)
97 strcat(buf, "valid/");
98 if (val & SYMBOL_OPTIONAL)
99 strcat(buf, "optional/");
100 if (val & SYMBOL_WRITE)
101 strcat(buf, "write/");
102 if (val & SYMBOL_CHANGED)
103 strcat(buf, "changed/");
104 if (val & SYMBOL_AUTO)
105 strcat(buf, "auto/");
107 buf[strlen(buf) - 1] = '\0';
109 return buf;
112 void replace_button_icon(GladeXML * xml, GdkDrawable * window,
113 GtkStyle * style, gchar * btn_name, gchar ** xpm)
115 GdkPixmap *pixmap;
116 GdkBitmap *mask;
117 GtkToolButton *button;
118 GtkWidget *image;
120 pixmap = gdk_pixmap_create_from_xpm_d(window, &mask,
121 &style->bg[GTK_STATE_NORMAL],
122 xpm);
124 button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, btn_name));
125 image = gtk_image_new_from_pixmap(pixmap, mask);
126 gtk_widget_show(image);
127 gtk_tool_button_set_icon_widget(button, image);
130 /* Main Window Initialization */
131 void init_main_window(const gchar * glade_file)
133 GladeXML *xml;
134 GtkWidget *widget;
135 GtkTextBuffer *txtbuf;
136 GtkStyle *style;
138 xml = glade_xml_new(glade_file, "window1", NULL);
139 if (!xml)
140 g_error(_("GUI loading failed !\n"));
141 glade_xml_signal_autoconnect(xml);
143 main_wnd = glade_xml_get_widget(xml, "window1");
144 hpaned = glade_xml_get_widget(xml, "hpaned1");
145 vpaned = glade_xml_get_widget(xml, "vpaned1");
146 tree1_w = glade_xml_get_widget(xml, "treeview1");
147 tree2_w = glade_xml_get_widget(xml, "treeview2");
148 text_w = glade_xml_get_widget(xml, "textview3");
150 back_btn = glade_xml_get_widget(xml, "button1");
151 gtk_widget_set_sensitive(back_btn, FALSE);
153 widget = glade_xml_get_widget(xml, "show_name1");
154 gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
155 show_name);
157 widget = glade_xml_get_widget(xml, "show_range1");
158 gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
159 show_range);
161 widget = glade_xml_get_widget(xml, "show_data1");
162 gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
163 show_value);
165 save_btn = glade_xml_get_widget(xml, "button3");
166 save_menu_item = glade_xml_get_widget(xml, "save1");
167 conf_set_changed_callback(conf_changed);
169 style = gtk_widget_get_style(main_wnd);
170 widget = glade_xml_get_widget(xml, "toolbar1");
172 #if 0 /* Use stock Gtk icons instead */
173 replace_button_icon(xml, main_wnd->window, style,
174 "button1", (gchar **) xpm_back);
175 replace_button_icon(xml, main_wnd->window, style,
176 "button2", (gchar **) xpm_load);
177 replace_button_icon(xml, main_wnd->window, style,
178 "button3", (gchar **) xpm_save);
179 #endif
180 replace_button_icon(xml, main_wnd->window, style,
181 "button4", (gchar **) xpm_single_view);
182 replace_button_icon(xml, main_wnd->window, style,
183 "button5", (gchar **) xpm_split_view);
184 replace_button_icon(xml, main_wnd->window, style,
185 "button6", (gchar **) xpm_tree_view);
187 #if 0
188 switch (view_mode) {
189 case SINGLE_VIEW:
190 widget = glade_xml_get_widget(xml, "button4");
191 g_signal_emit_by_name(widget, "clicked");
192 break;
193 case SPLIT_VIEW:
194 widget = glade_xml_get_widget(xml, "button5");
195 g_signal_emit_by_name(widget, "clicked");
196 break;
197 case FULL_VIEW:
198 widget = glade_xml_get_widget(xml, "button6");
199 g_signal_emit_by_name(widget, "clicked");
200 break;
202 #endif
203 txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
204 tag1 = gtk_text_buffer_create_tag(txtbuf, "mytag1",
205 "foreground", "red",
206 "weight", PANGO_WEIGHT_BOLD,
207 NULL);
208 tag2 = gtk_text_buffer_create_tag(txtbuf, "mytag2",
209 /*"style", PANGO_STYLE_OBLIQUE, */
210 NULL);
212 gtk_window_set_title(GTK_WINDOW(main_wnd), rootmenu.prompt->text);
214 gtk_widget_show(main_wnd);
217 void init_tree_model(void)
219 gint i;
221 tree = tree2 = gtk_tree_store_new(COL_NUMBER,
222 G_TYPE_STRING, G_TYPE_STRING,
223 G_TYPE_STRING, G_TYPE_STRING,
224 G_TYPE_STRING, G_TYPE_STRING,
225 G_TYPE_POINTER, GDK_TYPE_COLOR,
226 G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF,
227 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
228 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
229 G_TYPE_BOOLEAN);
230 model2 = GTK_TREE_MODEL(tree2);
232 for (parents[0] = NULL, i = 1; i < 256; i++)
233 parents[i] = (GtkTreeIter *) g_malloc(sizeof(GtkTreeIter));
235 tree1 = gtk_tree_store_new(COL_NUMBER,
236 G_TYPE_STRING, G_TYPE_STRING,
237 G_TYPE_STRING, G_TYPE_STRING,
238 G_TYPE_STRING, G_TYPE_STRING,
239 G_TYPE_POINTER, GDK_TYPE_COLOR,
240 G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF,
241 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
242 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
243 G_TYPE_BOOLEAN);
244 model1 = GTK_TREE_MODEL(tree1);
247 void init_left_tree(void)
249 GtkTreeView *view = GTK_TREE_VIEW(tree1_w);
250 GtkCellRenderer *renderer;
251 GtkTreeSelection *sel;
252 GtkTreeViewColumn *column;
254 gtk_tree_view_set_model(view, model1);
255 gtk_tree_view_set_headers_visible(view, TRUE);
256 gtk_tree_view_set_rules_hint(view, TRUE);
258 column = gtk_tree_view_column_new();
259 gtk_tree_view_append_column(view, column);
260 gtk_tree_view_column_set_title(column, _("Options"));
262 renderer = gtk_cell_renderer_toggle_new();
263 gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
264 renderer, FALSE);
265 gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
266 renderer,
267 "active", COL_BTNACT,
268 "inconsistent", COL_BTNINC,
269 "visible", COL_BTNVIS,
270 "radio", COL_BTNRAD, NULL);
271 renderer = gtk_cell_renderer_text_new();
272 gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
273 renderer, FALSE);
274 gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
275 renderer,
276 "text", COL_OPTION,
277 "foreground-gdk",
278 COL_COLOR, NULL);
280 sel = gtk_tree_view_get_selection(view);
281 gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
282 gtk_widget_realize(tree1_w);
285 static void renderer_edited(GtkCellRendererText * cell,
286 const gchar * path_string,
287 const gchar * new_text, gpointer user_data);
288 static void renderer_toggled(GtkCellRendererToggle * cellrenderertoggle,
289 gchar * arg1, gpointer user_data);
291 void init_right_tree(void)
293 GtkTreeView *view = GTK_TREE_VIEW(tree2_w);
294 GtkCellRenderer *renderer;
295 GtkTreeSelection *sel;
296 GtkTreeViewColumn *column;
297 gint i;
299 gtk_tree_view_set_model(view, model2);
300 gtk_tree_view_set_headers_visible(view, TRUE);
301 gtk_tree_view_set_rules_hint(view, TRUE);
303 column = gtk_tree_view_column_new();
304 gtk_tree_view_append_column(view, column);
305 gtk_tree_view_column_set_title(column, _("Options"));
307 renderer = gtk_cell_renderer_pixbuf_new();
308 gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
309 renderer, FALSE);
310 gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
311 renderer,
312 "pixbuf", COL_PIXBUF,
313 "visible", COL_PIXVIS, NULL);
314 renderer = gtk_cell_renderer_toggle_new();
315 gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
316 renderer, FALSE);
317 gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
318 renderer,
319 "active", COL_BTNACT,
320 "inconsistent", COL_BTNINC,
321 "visible", COL_BTNVIS,
322 "radio", COL_BTNRAD, NULL);
323 /*g_signal_connect(G_OBJECT(renderer), "toggled",
324 G_CALLBACK(renderer_toggled), NULL); */
325 renderer = gtk_cell_renderer_text_new();
326 gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
327 renderer, FALSE);
328 gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
329 renderer,
330 "text", COL_OPTION,
331 "foreground-gdk",
332 COL_COLOR, NULL);
334 renderer = gtk_cell_renderer_text_new();
335 gtk_tree_view_insert_column_with_attributes(view, -1,
336 _("Name"), renderer,
337 "text", COL_NAME,
338 "foreground-gdk",
339 COL_COLOR, NULL);
340 renderer = gtk_cell_renderer_text_new();
341 gtk_tree_view_insert_column_with_attributes(view, -1,
342 "N", renderer,
343 "text", COL_NO,
344 "foreground-gdk",
345 COL_COLOR, NULL);
346 renderer = gtk_cell_renderer_text_new();
347 gtk_tree_view_insert_column_with_attributes(view, -1,
348 "M", renderer,
349 "text", COL_MOD,
350 "foreground-gdk",
351 COL_COLOR, NULL);
352 renderer = gtk_cell_renderer_text_new();
353 gtk_tree_view_insert_column_with_attributes(view, -1,
354 "Y", renderer,
355 "text", COL_YES,
356 "foreground-gdk",
357 COL_COLOR, NULL);
358 renderer = gtk_cell_renderer_text_new();
359 gtk_tree_view_insert_column_with_attributes(view, -1,
360 _("Value"), renderer,
361 "text", COL_VALUE,
362 "editable",
363 COL_EDIT,
364 "foreground-gdk",
365 COL_COLOR, NULL);
366 g_signal_connect(G_OBJECT(renderer), "edited",
367 G_CALLBACK(renderer_edited), NULL);
369 column = gtk_tree_view_get_column(view, COL_NAME);
370 gtk_tree_view_column_set_visible(column, show_name);
371 column = gtk_tree_view_get_column(view, COL_NO);
372 gtk_tree_view_column_set_visible(column, show_range);
373 column = gtk_tree_view_get_column(view, COL_MOD);
374 gtk_tree_view_column_set_visible(column, show_range);
375 column = gtk_tree_view_get_column(view, COL_YES);
376 gtk_tree_view_column_set_visible(column, show_range);
377 column = gtk_tree_view_get_column(view, COL_VALUE);
378 gtk_tree_view_column_set_visible(column, show_value);
380 if (resizeable) {
381 for (i = 0; i < COL_VALUE; i++) {
382 column = gtk_tree_view_get_column(view, i);
383 gtk_tree_view_column_set_resizable(column, TRUE);
387 sel = gtk_tree_view_get_selection(view);
388 gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
392 /* Utility Functions */
395 static void text_insert_help(struct menu *menu)
397 GtkTextBuffer *buffer;
398 GtkTextIter start, end;
399 const char *prompt = _(menu_get_prompt(menu));
400 struct gstr help = str_new();
402 menu_get_ext_help(menu, &help);
404 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
405 gtk_text_buffer_get_bounds(buffer, &start, &end);
406 gtk_text_buffer_delete(buffer, &start, &end);
407 gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
409 gtk_text_buffer_get_end_iter(buffer, &end);
410 gtk_text_buffer_insert_with_tags(buffer, &end, prompt, -1, tag1,
411 NULL);
412 gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
413 gtk_text_buffer_get_end_iter(buffer, &end);
414 gtk_text_buffer_insert_with_tags(buffer, &end, str_get(&help), -1, tag2,
415 NULL);
416 str_free(&help);
420 static void text_insert_msg(const char *title, const char *message)
422 GtkTextBuffer *buffer;
423 GtkTextIter start, end;
424 const char *msg = message;
426 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
427 gtk_text_buffer_get_bounds(buffer, &start, &end);
428 gtk_text_buffer_delete(buffer, &start, &end);
429 gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
431 gtk_text_buffer_get_end_iter(buffer, &end);
432 gtk_text_buffer_insert_with_tags(buffer, &end, title, -1, tag1,
433 NULL);
434 gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
435 gtk_text_buffer_get_end_iter(buffer, &end);
436 gtk_text_buffer_insert_with_tags(buffer, &end, msg, -1, tag2,
437 NULL);
441 /* Main Windows Callbacks */
443 void on_save_activate(GtkMenuItem * menuitem, gpointer user_data);
444 gboolean on_window1_delete_event(GtkWidget * widget, GdkEvent * event,
445 gpointer user_data)
447 GtkWidget *dialog, *label;
448 gint result;
450 if (!conf_get_changed())
451 return FALSE;
453 dialog = gtk_dialog_new_with_buttons(_("Warning !"),
454 GTK_WINDOW(main_wnd),
455 (GtkDialogFlags)
456 (GTK_DIALOG_MODAL |
457 GTK_DIALOG_DESTROY_WITH_PARENT),
458 GTK_STOCK_OK,
459 GTK_RESPONSE_YES,
460 GTK_STOCK_NO,
461 GTK_RESPONSE_NO,
462 GTK_STOCK_CANCEL,
463 GTK_RESPONSE_CANCEL, NULL);
464 gtk_dialog_set_default_response(GTK_DIALOG(dialog),
465 GTK_RESPONSE_CANCEL);
467 label = gtk_label_new(_("\nSave configuration ?\n"));
468 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
469 gtk_widget_show(label);
471 result = gtk_dialog_run(GTK_DIALOG(dialog));
472 switch (result) {
473 case GTK_RESPONSE_YES:
474 on_save_activate(NULL, NULL);
475 return FALSE;
476 case GTK_RESPONSE_NO:
477 return FALSE;
478 case GTK_RESPONSE_CANCEL:
479 case GTK_RESPONSE_DELETE_EVENT:
480 default:
481 gtk_widget_destroy(dialog);
482 return TRUE;
485 return FALSE;
489 void on_window1_destroy(GtkObject * object, gpointer user_data)
491 gtk_main_quit();
495 void
496 on_window1_size_request(GtkWidget * widget,
497 GtkRequisition * requisition, gpointer user_data)
499 static gint old_h;
500 gint w, h;
502 if (widget->window == NULL)
503 gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h);
504 else
505 gdk_window_get_size(widget->window, &w, &h);
507 if (h == old_h)
508 return;
509 old_h = h;
511 gtk_paned_set_position(GTK_PANED(vpaned), 2 * h / 3);
515 /* Menu & Toolbar Callbacks */
518 static void
519 load_filename(GtkFileSelection * file_selector, gpointer user_data)
521 const gchar *fn;
523 fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
524 (user_data));
526 if (conf_read(fn))
527 text_insert_msg(_("Error"), _("Unable to load configuration !"));
528 else
529 display_tree(&rootmenu);
532 void on_load1_activate(GtkMenuItem * menuitem, gpointer user_data)
534 GtkWidget *fs;
536 fs = gtk_file_selection_new(_("Load file..."));
537 g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
538 "clicked",
539 G_CALLBACK(load_filename), (gpointer) fs);
540 g_signal_connect_swapped(GTK_OBJECT
541 (GTK_FILE_SELECTION(fs)->ok_button),
542 "clicked", G_CALLBACK(gtk_widget_destroy),
543 (gpointer) fs);
544 g_signal_connect_swapped(GTK_OBJECT
545 (GTK_FILE_SELECTION(fs)->cancel_button),
546 "clicked", G_CALLBACK(gtk_widget_destroy),
547 (gpointer) fs);
548 gtk_widget_show(fs);
552 void on_save_activate(GtkMenuItem * menuitem, gpointer user_data)
554 if (conf_write(NULL))
555 text_insert_msg(_("Error"), _("Unable to save configuration !"));
559 static void
560 store_filename(GtkFileSelection * file_selector, gpointer user_data)
562 const gchar *fn;
564 fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
565 (user_data));
567 if (conf_write(fn))
568 text_insert_msg(_("Error"), _("Unable to save configuration !"));
570 gtk_widget_destroy(GTK_WIDGET(user_data));
573 void on_save_as1_activate(GtkMenuItem * menuitem, gpointer user_data)
575 GtkWidget *fs;
577 fs = gtk_file_selection_new(_("Save file as..."));
578 g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
579 "clicked",
580 G_CALLBACK(store_filename), (gpointer) fs);
581 g_signal_connect_swapped(GTK_OBJECT
582 (GTK_FILE_SELECTION(fs)->ok_button),
583 "clicked", G_CALLBACK(gtk_widget_destroy),
584 (gpointer) fs);
585 g_signal_connect_swapped(GTK_OBJECT
586 (GTK_FILE_SELECTION(fs)->cancel_button),
587 "clicked", G_CALLBACK(gtk_widget_destroy),
588 (gpointer) fs);
589 gtk_widget_show(fs);
593 void on_quit1_activate(GtkMenuItem * menuitem, gpointer user_data)
595 if (!on_window1_delete_event(NULL, NULL, NULL))
596 gtk_widget_destroy(GTK_WIDGET(main_wnd));
600 void on_show_name1_activate(GtkMenuItem * menuitem, gpointer user_data)
602 GtkTreeViewColumn *col;
604 show_name = GTK_CHECK_MENU_ITEM(menuitem)->active;
605 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NAME);
606 if (col)
607 gtk_tree_view_column_set_visible(col, show_name);
611 void on_show_range1_activate(GtkMenuItem * menuitem, gpointer user_data)
613 GtkTreeViewColumn *col;
615 show_range = GTK_CHECK_MENU_ITEM(menuitem)->active;
616 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NO);
617 if (col)
618 gtk_tree_view_column_set_visible(col, show_range);
619 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_MOD);
620 if (col)
621 gtk_tree_view_column_set_visible(col, show_range);
622 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_YES);
623 if (col)
624 gtk_tree_view_column_set_visible(col, show_range);
629 void on_show_data1_activate(GtkMenuItem * menuitem, gpointer user_data)
631 GtkTreeViewColumn *col;
633 show_value = GTK_CHECK_MENU_ITEM(menuitem)->active;
634 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_VALUE);
635 if (col)
636 gtk_tree_view_column_set_visible(col, show_value);
640 void
641 on_set_option_mode1_activate(GtkMenuItem *menuitem, gpointer user_data)
643 opt_mode = OPT_NORMAL;
644 gtk_tree_store_clear(tree2);
645 display_tree(&rootmenu); /* instead of update_tree to speed-up */
649 void
650 on_set_option_mode2_activate(GtkMenuItem *menuitem, gpointer user_data)
652 opt_mode = OPT_ALL;
653 gtk_tree_store_clear(tree2);
654 display_tree(&rootmenu); /* instead of update_tree to speed-up */
658 void
659 on_set_option_mode3_activate(GtkMenuItem *menuitem, gpointer user_data)
661 opt_mode = OPT_PROMPT;
662 gtk_tree_store_clear(tree2);
663 display_tree(&rootmenu); /* instead of update_tree to speed-up */
667 void on_introduction1_activate(GtkMenuItem * menuitem, gpointer user_data)
669 GtkWidget *dialog;
670 const gchar *intro_text = _(
671 "Welcome to gkc, the GTK+ graphical configuration tool\n"
672 "For each option, a blank box indicates the feature is disabled, a\n"
673 "check indicates it is enabled, and a dot indicates that it is to\n"
674 "be compiled as a module. Clicking on the box will cycle through the three states.\n"
675 "\n"
676 "If you do not see an option (e.g., a device driver) that you\n"
677 "believe should be present, try turning on Show All Options\n"
678 "under the Options menu.\n"
679 "Although there is no cross reference yet to help you figure out\n"
680 "what other options must be enabled to support the option you\n"
681 "are interested in, you can still view the help of a grayed-out\n"
682 "option.\n"
683 "\n"
684 "Toggling Show Debug Info under the Options menu will show \n"
685 "the dependencies, which you can then match by examining other options.");
687 dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
688 GTK_DIALOG_DESTROY_WITH_PARENT,
689 GTK_MESSAGE_INFO,
690 GTK_BUTTONS_CLOSE, intro_text);
691 g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
692 G_CALLBACK(gtk_widget_destroy),
693 GTK_OBJECT(dialog));
694 gtk_widget_show_all(dialog);
698 void on_about1_activate(GtkMenuItem * menuitem, gpointer user_data)
700 GtkWidget *dialog;
701 const gchar *about_text =
702 _("gkc is copyright (c) 2002 Romain Lievin <roms@lpg.ticalc.org>.\n"
703 "Based on the source code from Roman Zippel.\n");
705 dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
706 GTK_DIALOG_DESTROY_WITH_PARENT,
707 GTK_MESSAGE_INFO,
708 GTK_BUTTONS_CLOSE, about_text);
709 g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
710 G_CALLBACK(gtk_widget_destroy),
711 GTK_OBJECT(dialog));
712 gtk_widget_show_all(dialog);
716 void on_license1_activate(GtkMenuItem * menuitem, gpointer user_data)
718 GtkWidget *dialog;
719 const gchar *license_text =
720 _("gkc is released under the terms of the GNU GPL v2.\n"
721 "For more information, please see the source code or\n"
722 "visit http://www.fsf.org/licenses/licenses.html\n");
724 dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
725 GTK_DIALOG_DESTROY_WITH_PARENT,
726 GTK_MESSAGE_INFO,
727 GTK_BUTTONS_CLOSE, license_text);
728 g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
729 G_CALLBACK(gtk_widget_destroy),
730 GTK_OBJECT(dialog));
731 gtk_widget_show_all(dialog);
735 void on_back_clicked(GtkButton * button, gpointer user_data)
737 enum prop_type ptype;
739 current = current->parent;
740 ptype = current->prompt ? current->prompt->type : P_UNKNOWN;
741 if (ptype != P_MENU)
742 current = current->parent;
743 display_tree_part();
745 if (current == &rootmenu)
746 gtk_widget_set_sensitive(back_btn, FALSE);
750 void on_load_clicked(GtkButton * button, gpointer user_data)
752 on_load1_activate(NULL, user_data);
756 void on_single_clicked(GtkButton * button, gpointer user_data)
758 view_mode = SINGLE_VIEW;
759 gtk_widget_hide(tree1_w);
760 current = &rootmenu;
761 display_tree_part();
765 void on_split_clicked(GtkButton * button, gpointer user_data)
767 gint w, h;
768 view_mode = SPLIT_VIEW;
769 gtk_widget_show(tree1_w);
770 gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h);
771 gtk_paned_set_position(GTK_PANED(hpaned), w / 2);
772 if (tree2)
773 gtk_tree_store_clear(tree2);
774 display_list();
776 /* Disable back btn, like in full mode. */
777 gtk_widget_set_sensitive(back_btn, FALSE);
781 void on_full_clicked(GtkButton * button, gpointer user_data)
783 view_mode = FULL_VIEW;
784 gtk_widget_hide(tree1_w);
785 if (tree2)
786 gtk_tree_store_clear(tree2);
787 display_tree(&rootmenu);
788 gtk_widget_set_sensitive(back_btn, FALSE);
792 void on_collapse_clicked(GtkButton * button, gpointer user_data)
794 gtk_tree_view_collapse_all(GTK_TREE_VIEW(tree2_w));
798 void on_expand_clicked(GtkButton * button, gpointer user_data)
800 gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
804 /* CTree Callbacks */
806 /* Change hex/int/string value in the cell */
807 static void renderer_edited(GtkCellRendererText * cell,
808 const gchar * path_string,
809 const gchar * new_text, gpointer user_data)
811 GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
812 GtkTreeIter iter;
813 const char *old_def, *new_def;
814 struct menu *menu;
815 struct symbol *sym;
817 if (!gtk_tree_model_get_iter(model2, &iter, path))
818 return;
820 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
821 sym = menu->sym;
823 gtk_tree_model_get(model2, &iter, COL_VALUE, &old_def, -1);
824 new_def = new_text;
826 sym_set_string_value(sym, new_def);
828 update_tree(&rootmenu, NULL);
830 gtk_tree_path_free(path);
833 /* Change the value of a symbol and update the tree */
834 static void change_sym_value(struct menu *menu, gint col)
836 struct symbol *sym = menu->sym;
837 tristate oldval, newval;
839 if (!sym)
840 return;
842 if (col == COL_NO)
843 newval = no;
844 else if (col == COL_MOD)
845 newval = mod;
846 else if (col == COL_YES)
847 newval = yes;
848 else
849 return;
851 switch (sym_get_type(sym)) {
852 case S_BOOLEAN:
853 case S_TRISTATE:
854 oldval = sym_get_tristate_value(sym);
855 if (!sym_tristate_within_range(sym, newval))
856 newval = yes;
857 sym_set_tristate_value(sym, newval);
858 if (view_mode == FULL_VIEW)
859 update_tree(&rootmenu, NULL);
860 else if (view_mode == SPLIT_VIEW) {
861 update_tree(browsed, NULL);
862 display_list();
864 else if (view_mode == SINGLE_VIEW)
865 display_tree_part(); //fixme: keep exp/coll
866 break;
867 case S_INT:
868 case S_HEX:
869 case S_STRING:
870 default:
871 break;
875 static void toggle_sym_value(struct menu *menu)
877 if (!menu->sym)
878 return;
880 sym_toggle_tristate_value(menu->sym);
881 if (view_mode == FULL_VIEW)
882 update_tree(&rootmenu, NULL);
883 else if (view_mode == SPLIT_VIEW) {
884 update_tree(browsed, NULL);
885 display_list();
887 else if (view_mode == SINGLE_VIEW)
888 display_tree_part(); //fixme: keep exp/coll
891 static void renderer_toggled(GtkCellRendererToggle * cell,
892 gchar * path_string, gpointer user_data)
894 GtkTreePath *path, *sel_path = NULL;
895 GtkTreeIter iter, sel_iter;
896 GtkTreeSelection *sel;
897 struct menu *menu;
899 path = gtk_tree_path_new_from_string(path_string);
900 if (!gtk_tree_model_get_iter(model2, &iter, path))
901 return;
903 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree2_w));
904 if (gtk_tree_selection_get_selected(sel, NULL, &sel_iter))
905 sel_path = gtk_tree_model_get_path(model2, &sel_iter);
906 if (!sel_path)
907 goto out1;
908 if (gtk_tree_path_compare(path, sel_path))
909 goto out2;
911 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
912 toggle_sym_value(menu);
914 out2:
915 gtk_tree_path_free(sel_path);
916 out1:
917 gtk_tree_path_free(path);
920 static gint column2index(GtkTreeViewColumn * column)
922 gint i;
924 for (i = 0; i < COL_NUMBER; i++) {
925 GtkTreeViewColumn *col;
927 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), i);
928 if (col == column)
929 return i;
932 return -1;
936 /* User click: update choice (full) or goes down (single) */
937 gboolean
938 on_treeview2_button_press_event(GtkWidget * widget,
939 GdkEventButton * event, gpointer user_data)
941 GtkTreeView *view = GTK_TREE_VIEW(widget);
942 GtkTreePath *path;
943 GtkTreeViewColumn *column;
944 GtkTreeIter iter;
945 struct menu *menu;
946 gint col;
948 #if GTK_CHECK_VERSION(2,1,4) // bug in ctree with earlier version of GTK
949 gint tx = (gint) event->x;
950 gint ty = (gint) event->y;
951 gint cx, cy;
953 gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
954 &cy);
955 #else
956 gtk_tree_view_get_cursor(view, &path, &column);
957 #endif
958 if (path == NULL)
959 return FALSE;
961 if (!gtk_tree_model_get_iter(model2, &iter, path))
962 return FALSE;
963 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
965 col = column2index(column);
966 if (event->type == GDK_2BUTTON_PRESS) {
967 enum prop_type ptype;
968 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
970 if (ptype == P_MENU && view_mode != FULL_VIEW && col == COL_OPTION) {
971 // goes down into menu
972 current = menu;
973 display_tree_part();
974 gtk_widget_set_sensitive(back_btn, TRUE);
975 } else if ((col == COL_OPTION)) {
976 toggle_sym_value(menu);
977 gtk_tree_view_expand_row(view, path, TRUE);
979 } else {
980 if (col == COL_VALUE) {
981 toggle_sym_value(menu);
982 gtk_tree_view_expand_row(view, path, TRUE);
983 } else if (col == COL_NO || col == COL_MOD
984 || col == COL_YES) {
985 change_sym_value(menu, col);
986 gtk_tree_view_expand_row(view, path, TRUE);
990 return FALSE;
993 /* Key pressed: update choice */
994 gboolean
995 on_treeview2_key_press_event(GtkWidget * widget,
996 GdkEventKey * event, gpointer user_data)
998 GtkTreeView *view = GTK_TREE_VIEW(widget);
999 GtkTreePath *path;
1000 GtkTreeViewColumn *column;
1001 GtkTreeIter iter;
1002 struct menu *menu;
1003 gint col;
1005 gtk_tree_view_get_cursor(view, &path, &column);
1006 if (path == NULL)
1007 return FALSE;
1009 if (event->keyval == GDK_space) {
1010 if (gtk_tree_view_row_expanded(view, path))
1011 gtk_tree_view_collapse_row(view, path);
1012 else
1013 gtk_tree_view_expand_row(view, path, FALSE);
1014 return TRUE;
1016 if (event->keyval == GDK_KP_Enter) {
1018 if (widget == tree1_w)
1019 return FALSE;
1021 gtk_tree_model_get_iter(model2, &iter, path);
1022 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1024 if (!strcasecmp(event->string, "n"))
1025 col = COL_NO;
1026 else if (!strcasecmp(event->string, "m"))
1027 col = COL_MOD;
1028 else if (!strcasecmp(event->string, "y"))
1029 col = COL_YES;
1030 else
1031 col = -1;
1032 change_sym_value(menu, col);
1034 return FALSE;
1038 /* Row selection changed: update help */
1039 void
1040 on_treeview2_cursor_changed(GtkTreeView * treeview, gpointer user_data)
1042 GtkTreeSelection *selection;
1043 GtkTreeIter iter;
1044 struct menu *menu;
1046 selection = gtk_tree_view_get_selection(treeview);
1047 if (gtk_tree_selection_get_selected(selection, &model2, &iter)) {
1048 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1049 text_insert_help(menu);
1054 /* User click: display sub-tree in the right frame. */
1055 gboolean
1056 on_treeview1_button_press_event(GtkWidget * widget,
1057 GdkEventButton * event, gpointer user_data)
1059 GtkTreeView *view = GTK_TREE_VIEW(widget);
1060 GtkTreePath *path;
1061 GtkTreeViewColumn *column;
1062 GtkTreeIter iter;
1063 struct menu *menu;
1065 gint tx = (gint) event->x;
1066 gint ty = (gint) event->y;
1067 gint cx, cy;
1069 gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
1070 &cy);
1071 if (path == NULL)
1072 return FALSE;
1074 gtk_tree_model_get_iter(model1, &iter, path);
1075 gtk_tree_model_get(model1, &iter, COL_MENU, &menu, -1);
1077 if (event->type == GDK_2BUTTON_PRESS) {
1078 toggle_sym_value(menu);
1079 current = menu;
1080 display_tree_part();
1081 } else {
1082 browsed = menu;
1083 display_tree_part();
1086 gtk_widget_realize(tree2_w);
1087 gtk_tree_view_set_cursor(view, path, NULL, FALSE);
1088 gtk_widget_grab_focus(tree2_w);
1090 return FALSE;
1094 /* Fill a row of strings */
1095 static gchar **fill_row(struct menu *menu)
1097 static gchar *row[COL_NUMBER];
1098 struct symbol *sym = menu->sym;
1099 const char *def;
1100 int stype;
1101 tristate val;
1102 enum prop_type ptype;
1103 int i;
1105 for (i = COL_OPTION; i <= COL_COLOR; i++)
1106 g_free(row[i]);
1107 bzero(row, sizeof(row));
1109 row[COL_OPTION] =
1110 g_strdup_printf("%s %s", _(menu_get_prompt(menu)),
1111 sym && !sym_has_value(sym) ? "(NEW)" : "");
1113 if (opt_mode == OPT_ALL && !menu_is_visible(menu))
1114 row[COL_COLOR] = g_strdup("DarkGray");
1115 else if (opt_mode == OPT_PROMPT &&
1116 menu_has_prompt(menu) && !menu_is_visible(menu))
1117 row[COL_COLOR] = g_strdup("DarkGray");
1118 else
1119 row[COL_COLOR] = g_strdup("Black");
1121 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
1122 switch (ptype) {
1123 case P_MENU:
1124 row[COL_PIXBUF] = (gchar *) xpm_menu;
1125 if (view_mode == SINGLE_VIEW)
1126 row[COL_PIXVIS] = GINT_TO_POINTER(TRUE);
1127 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1128 break;
1129 case P_COMMENT:
1130 row[COL_PIXBUF] = (gchar *) xpm_void;
1131 row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
1132 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1133 break;
1134 default:
1135 row[COL_PIXBUF] = (gchar *) xpm_void;
1136 row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
1137 row[COL_BTNVIS] = GINT_TO_POINTER(TRUE);
1138 break;
1141 if (!sym)
1142 return row;
1143 row[COL_NAME] = g_strdup(sym->name);
1145 sym_calc_value(sym);
1146 sym->flags &= ~SYMBOL_CHANGED;
1148 if (sym_is_choice(sym)) { // parse childs for getting final value
1149 struct menu *child;
1150 struct symbol *def_sym = sym_get_choice_value(sym);
1151 struct menu *def_menu = NULL;
1153 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1155 for (child = menu->list; child; child = child->next) {
1156 if (menu_is_visible(child)
1157 && child->sym == def_sym)
1158 def_menu = child;
1161 if (def_menu)
1162 row[COL_VALUE] =
1163 g_strdup(_(menu_get_prompt(def_menu)));
1165 if (sym->flags & SYMBOL_CHOICEVAL)
1166 row[COL_BTNRAD] = GINT_TO_POINTER(TRUE);
1168 stype = sym_get_type(sym);
1169 switch (stype) {
1170 case S_BOOLEAN:
1171 if (GPOINTER_TO_INT(row[COL_PIXVIS]) == FALSE)
1172 row[COL_BTNVIS] = GINT_TO_POINTER(TRUE);
1173 if (sym_is_choice(sym))
1174 break;
1175 case S_TRISTATE:
1176 val = sym_get_tristate_value(sym);
1177 switch (val) {
1178 case no:
1179 row[COL_NO] = g_strdup("N");
1180 row[COL_VALUE] = g_strdup("N");
1181 row[COL_BTNACT] = GINT_TO_POINTER(FALSE);
1182 row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
1183 break;
1184 case mod:
1185 row[COL_MOD] = g_strdup("M");
1186 row[COL_VALUE] = g_strdup("M");
1187 row[COL_BTNINC] = GINT_TO_POINTER(TRUE);
1188 break;
1189 case yes:
1190 row[COL_YES] = g_strdup("Y");
1191 row[COL_VALUE] = g_strdup("Y");
1192 row[COL_BTNACT] = GINT_TO_POINTER(TRUE);
1193 row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
1194 break;
1197 if (val != no && sym_tristate_within_range(sym, no))
1198 row[COL_NO] = g_strdup("_");
1199 if (val != mod && sym_tristate_within_range(sym, mod))
1200 row[COL_MOD] = g_strdup("_");
1201 if (val != yes && sym_tristate_within_range(sym, yes))
1202 row[COL_YES] = g_strdup("_");
1203 break;
1204 case S_INT:
1205 case S_HEX:
1206 case S_STRING:
1207 def = sym_get_string_value(sym);
1208 row[COL_VALUE] = g_strdup(def);
1209 row[COL_EDIT] = GINT_TO_POINTER(TRUE);
1210 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1211 break;
1214 return row;
1218 /* Set the node content with a row of strings */
1219 static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row)
1221 GdkColor color;
1222 gboolean success;
1223 GdkPixbuf *pix;
1225 pix = gdk_pixbuf_new_from_xpm_data((const char **)
1226 row[COL_PIXBUF]);
1228 gdk_color_parse(row[COL_COLOR], &color);
1229 gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1,
1230 FALSE, FALSE, &success);
1232 gtk_tree_store_set(tree, node,
1233 COL_OPTION, row[COL_OPTION],
1234 COL_NAME, row[COL_NAME],
1235 COL_NO, row[COL_NO],
1236 COL_MOD, row[COL_MOD],
1237 COL_YES, row[COL_YES],
1238 COL_VALUE, row[COL_VALUE],
1239 COL_MENU, (gpointer) menu,
1240 COL_COLOR, &color,
1241 COL_EDIT, GPOINTER_TO_INT(row[COL_EDIT]),
1242 COL_PIXBUF, pix,
1243 COL_PIXVIS, GPOINTER_TO_INT(row[COL_PIXVIS]),
1244 COL_BTNVIS, GPOINTER_TO_INT(row[COL_BTNVIS]),
1245 COL_BTNACT, GPOINTER_TO_INT(row[COL_BTNACT]),
1246 COL_BTNINC, GPOINTER_TO_INT(row[COL_BTNINC]),
1247 COL_BTNRAD, GPOINTER_TO_INT(row[COL_BTNRAD]),
1248 -1);
1250 g_object_unref(pix);
1254 /* Add a node to the tree */
1255 static void place_node(struct menu *menu, char **row)
1257 GtkTreeIter *parent = parents[indent - 1];
1258 GtkTreeIter *node = parents[indent];
1260 gtk_tree_store_append(tree, node, parent);
1261 set_node(node, menu, row);
1265 /* Find a node in the GTK+ tree */
1266 static GtkTreeIter found;
1269 * Find a menu in the GtkTree starting at parent.
1271 GtkTreeIter *gtktree_iter_find_node(GtkTreeIter * parent,
1272 struct menu *tofind)
1274 GtkTreeIter iter;
1275 GtkTreeIter *child = &iter;
1276 gboolean valid;
1277 GtkTreeIter *ret;
1279 valid = gtk_tree_model_iter_children(model2, child, parent);
1280 while (valid) {
1281 struct menu *menu;
1283 gtk_tree_model_get(model2, child, 6, &menu, -1);
1285 if (menu == tofind) {
1286 memcpy(&found, child, sizeof(GtkTreeIter));
1287 return &found;
1290 ret = gtktree_iter_find_node(child, tofind);
1291 if (ret)
1292 return ret;
1294 valid = gtk_tree_model_iter_next(model2, child);
1297 return NULL;
1302 * Update the tree by adding/removing entries
1303 * Does not change other nodes
1305 static void update_tree(struct menu *src, GtkTreeIter * dst)
1307 struct menu *child1;
1308 GtkTreeIter iter, tmp;
1309 GtkTreeIter *child2 = &iter;
1310 gboolean valid;
1311 GtkTreeIter *sibling;
1312 struct symbol *sym;
1313 struct property *prop;
1314 struct menu *menu1, *menu2;
1316 if (src == &rootmenu)
1317 indent = 1;
1319 valid = gtk_tree_model_iter_children(model2, child2, dst);
1320 for (child1 = src->list; child1; child1 = child1->next) {
1322 prop = child1->prompt;
1323 sym = child1->sym;
1325 reparse:
1326 menu1 = child1;
1327 if (valid)
1328 gtk_tree_model_get(model2, child2, COL_MENU,
1329 &menu2, -1);
1330 else
1331 menu2 = NULL; // force adding of a first child
1333 #ifdef DEBUG
1334 printf("%*c%s | %s\n", indent, ' ',
1335 menu1 ? menu_get_prompt(menu1) : "nil",
1336 menu2 ? menu_get_prompt(menu2) : "nil");
1337 #endif
1339 if ((opt_mode == OPT_NORMAL && !menu_is_visible(child1)) ||
1340 (opt_mode == OPT_PROMPT && !menu_has_prompt(child1)) ||
1341 (opt_mode == OPT_ALL && !menu_get_prompt(child1))) {
1343 /* remove node */
1344 if (gtktree_iter_find_node(dst, menu1) != NULL) {
1345 memcpy(&tmp, child2, sizeof(GtkTreeIter));
1346 valid = gtk_tree_model_iter_next(model2,
1347 child2);
1348 gtk_tree_store_remove(tree2, &tmp);
1349 if (!valid)
1350 return; /* next parent */
1351 else
1352 goto reparse; /* next child */
1353 } else
1354 continue;
1357 if (menu1 != menu2) {
1358 if (gtktree_iter_find_node(dst, menu1) == NULL) { // add node
1359 if (!valid && !menu2)
1360 sibling = NULL;
1361 else
1362 sibling = child2;
1363 gtk_tree_store_insert_before(tree2,
1364 child2,
1365 dst, sibling);
1366 set_node(child2, menu1, fill_row(menu1));
1367 if (menu2 == NULL)
1368 valid = TRUE;
1369 } else { // remove node
1370 memcpy(&tmp, child2, sizeof(GtkTreeIter));
1371 valid = gtk_tree_model_iter_next(model2,
1372 child2);
1373 gtk_tree_store_remove(tree2, &tmp);
1374 if (!valid)
1375 return; // next parent
1376 else
1377 goto reparse; // next child
1379 } else if (sym && (sym->flags & SYMBOL_CHANGED)) {
1380 set_node(child2, menu1, fill_row(menu1));
1383 indent++;
1384 update_tree(child1, child2);
1385 indent--;
1387 valid = gtk_tree_model_iter_next(model2, child2);
1392 /* Display the whole tree (single/split/full view) */
1393 static void display_tree(struct menu *menu)
1395 struct symbol *sym;
1396 struct property *prop;
1397 struct menu *child;
1398 enum prop_type ptype;
1400 if (menu == &rootmenu) {
1401 indent = 1;
1402 current = &rootmenu;
1405 for (child = menu->list; child; child = child->next) {
1406 prop = child->prompt;
1407 sym = child->sym;
1408 ptype = prop ? prop->type : P_UNKNOWN;
1410 if (sym)
1411 sym->flags &= ~SYMBOL_CHANGED;
1413 if ((view_mode == SPLIT_VIEW)
1414 && !(child->flags & MENU_ROOT) && (tree == tree1))
1415 continue;
1417 if ((view_mode == SPLIT_VIEW) && (child->flags & MENU_ROOT)
1418 && (tree == tree2))
1419 continue;
1421 if ((opt_mode == OPT_NORMAL && menu_is_visible(child)) ||
1422 (opt_mode == OPT_PROMPT && menu_has_prompt(child)) ||
1423 (opt_mode == OPT_ALL && menu_get_prompt(child)))
1424 place_node(child, fill_row(child));
1425 #ifdef DEBUG
1426 printf("%*c%s: ", indent, ' ', menu_get_prompt(child));
1427 printf("%s", child->flags & MENU_ROOT ? "rootmenu | " : "");
1428 printf("%s", prop_get_type_name(ptype));
1429 printf(" | ");
1430 if (sym) {
1431 printf("%s", sym_type_name(sym->type));
1432 printf(" | ");
1433 printf("%s", dbg_sym_flags(sym->flags));
1434 printf("\n");
1435 } else
1436 printf("\n");
1437 #endif
1438 if ((view_mode != FULL_VIEW) && (ptype == P_MENU)
1439 && (tree == tree2))
1440 continue;
1442 if (((menu != &rootmenu) && !(menu->flags & MENU_ROOT))
1443 || (view_mode == FULL_VIEW)
1444 || (view_mode == SPLIT_VIEW))*/
1446 /* Change paned position if the view is not in 'split mode' */
1447 if (view_mode == SINGLE_VIEW || view_mode == FULL_VIEW) {
1448 gtk_paned_set_position(GTK_PANED(hpaned), 0);
1451 if (((view_mode == SINGLE_VIEW) && (menu->flags & MENU_ROOT))
1452 || (view_mode == FULL_VIEW)
1453 || (view_mode == SPLIT_VIEW)) {
1454 indent++;
1455 display_tree(child);
1456 indent--;
1461 /* Display a part of the tree starting at current node (single/split view) */
1462 static void display_tree_part(void)
1464 if (tree2)
1465 gtk_tree_store_clear(tree2);
1466 if (view_mode == SINGLE_VIEW)
1467 display_tree(current);
1468 else if (view_mode == SPLIT_VIEW)
1469 display_tree(browsed);
1470 gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
1473 /* Display the list in the left frame (split view) */
1474 static void display_list(void)
1476 if (tree1)
1477 gtk_tree_store_clear(tree1);
1479 tree = tree1;
1480 display_tree(&rootmenu);
1481 gtk_tree_view_expand_all(GTK_TREE_VIEW(tree1_w));
1482 tree = tree2;
1485 void fixup_rootmenu(struct menu *menu)
1487 struct menu *child;
1488 static int menu_cnt = 0;
1490 menu->flags |= MENU_ROOT;
1491 for (child = menu->list; child; child = child->next) {
1492 if (child->prompt && child->prompt->type == P_MENU) {
1493 menu_cnt++;
1494 fixup_rootmenu(child);
1495 menu_cnt--;
1496 } else if (!menu_cnt)
1497 fixup_rootmenu(child);
1502 /* Main */
1503 int main(int ac, char *av[])
1505 const char *name;
1506 char *env;
1507 gchar *glade_file;
1509 #ifndef LKC_DIRECT_LINK
1510 kconfig_load();
1511 #endif
1513 bindtextdomain(PACKAGE, LOCALEDIR);
1514 bind_textdomain_codeset(PACKAGE, "UTF-8");
1515 textdomain(PACKAGE);
1517 /* GTK stuffs */
1518 gtk_set_locale();
1519 gtk_init(&ac, &av);
1520 glade_init();
1522 //add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
1523 //add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
1525 /* Determine GUI path */
1526 env = getenv(SRCTREE);
1527 if (env)
1528 glade_file = g_strconcat(env, "/scripts/kconfig/gconf.glade", NULL);
1529 else if (av[0][0] == '/')
1530 glade_file = g_strconcat(av[0], ".glade", NULL);
1531 else
1532 glade_file = g_strconcat(g_get_current_dir(), "/", av[0], ".glade", NULL);
1534 /* Conf stuffs */
1535 if (ac > 1 && av[1][0] == '-') {
1536 switch (av[1][1]) {
1537 case 'a':
1538 //showAll = 1;
1539 break;
1540 case 'h':
1541 case '?':
1542 printf("%s <config>\n", av[0]);
1543 exit(0);
1545 name = av[2];
1546 } else
1547 name = av[1];
1549 conf_parse(name);
1550 fixup_rootmenu(&rootmenu);
1551 conf_read(NULL);
1553 /* Load the interface and connect signals */
1554 init_main_window(glade_file);
1555 init_tree_model();
1556 init_left_tree();
1557 init_right_tree();
1559 switch (view_mode) {
1560 case SINGLE_VIEW:
1561 display_tree_part();
1562 break;
1563 case SPLIT_VIEW:
1564 display_list();
1565 break;
1566 case FULL_VIEW:
1567 display_tree(&rootmenu);
1568 break;
1571 gtk_main();
1573 return 0;
1576 static void conf_changed(void)
1578 bool changed = conf_get_changed();
1579 gtk_widget_set_sensitive(save_btn, changed);
1580 gtk_widget_set_sensitive(save_menu_item, changed);