![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / tools / kconfig|
Return to gconf.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / tools / kconfig |
1.1 root 1: /* Hey EMACS -*- linux-c -*- */
2: /*
3: *
4: * Copyright (C) 2002-2003 Romain Lievin <[email protected]>
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: enum {
34: OPT_NORMAL, OPT_ALL, OPT_PROMPT
35: };
36:
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;
43:
44: GtkWidget *main_wnd = NULL;
45: GtkWidget *tree1_w = NULL; // left frame
46: GtkWidget *tree2_w = NULL; // right frame
47: GtkWidget *text_w = NULL;
48: GtkWidget *hpaned = NULL;
49: GtkWidget *vpaned = NULL;
50: GtkWidget *back_btn = NULL;
51: GtkWidget *save_btn = NULL;
52: GtkWidget *save_menu_item = NULL;
53:
54: GtkTextTag *tag1, *tag2;
55: GdkColor color;
56:
57: GtkTreeStore *tree1, *tree2, *tree;
58: GtkTreeModel *model1, *model2;
59: static GtkTreeIter *parents[256];
60: static gint indent;
61:
62: static struct menu *current; // current node for SINGLE view
63: static struct menu *browsed; // browsed node for SPLIT view
64:
65: enum {
66: COL_OPTION, COL_NAME, COL_NO, COL_MOD, COL_YES, COL_VALUE,
67: COL_MENU, COL_COLOR, COL_EDIT, COL_PIXBUF,
68: COL_PIXVIS, COL_BTNVIS, COL_BTNACT, COL_BTNINC, COL_BTNRAD,
69: COL_NUMBER
70: };
71:
72: static void display_list(void);
73: static void display_tree(struct menu *menu);
74: static void display_tree_part(void);
75: static void update_tree(struct menu *src, GtkTreeIter * dst);
76: static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row);
77: static gchar **fill_row(struct menu *menu);
78: static void conf_changed(void);
79:
80: /* Helping/Debugging Functions */
81:
82: const char *dbg_sym_flags(int val)
83: {
84: static char buf[256];
85:
86: bzero(buf, 256);
87:
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/");
106:
107: buf[strlen(buf) - 1] = '\0';
108:
109: return buf;
110: }
111:
112: void replace_button_icon(GladeXML * xml, GdkDrawable * window,
113: GtkStyle * style, gchar * btn_name, gchar ** xpm)
114: {
115: GdkPixmap *pixmap;
116: GdkBitmap *mask;
117: GtkToolButton *button;
118: GtkWidget *image;
119:
120: pixmap = gdk_pixmap_create_from_xpm_d(window, &mask,
121: &style->bg[GTK_STATE_NORMAL],
122: xpm);
123:
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);
128: }
129:
130: /* Main Window Initialization */
131: void init_main_window(const gchar * glade_file)
132: {
133: GladeXML *xml;
134: GtkWidget *widget;
135: GtkTextBuffer *txtbuf;
136: GtkStyle *style;
137:
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);
142:
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");
149:
150: back_btn = glade_xml_get_widget(xml, "button1");
151: gtk_widget_set_sensitive(back_btn, FALSE);
152:
153: widget = glade_xml_get_widget(xml, "show_name1");
154: gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
155: show_name);
156:
157: widget = glade_xml_get_widget(xml, "show_range1");
158: gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
159: show_range);
160:
161: widget = glade_xml_get_widget(xml, "show_data1");
162: gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
163: show_value);
164:
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);
168:
169: style = gtk_widget_get_style(main_wnd);
170: widget = glade_xml_get_widget(xml, "toolbar1");
171:
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);
186:
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;
201: }
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);
211:
212: gtk_window_set_title(GTK_WINDOW(main_wnd), rootmenu.prompt->text);
213:
214: gtk_widget_show(main_wnd);
215: }
216:
217: void init_tree_model(void)
218: {
219: gint i;
220:
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);
231:
232: for (parents[0] = NULL, i = 1; i < 256; i++)
233: parents[i] = (GtkTreeIter *) g_malloc(sizeof(GtkTreeIter));
234:
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);
245: }
246:
247: void init_left_tree(void)
248: {
249: GtkTreeView *view = GTK_TREE_VIEW(tree1_w);
250: GtkCellRenderer *renderer;
251: GtkTreeSelection *sel;
252: GtkTreeViewColumn *column;
253:
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, FALSE);
257:
258: column = gtk_tree_view_column_new();
259: gtk_tree_view_append_column(view, column);
260: gtk_tree_view_column_set_title(column, _("Options"));
261:
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);
279:
280: sel = gtk_tree_view_get_selection(view);
281: gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
282: gtk_widget_realize(tree1_w);
283: }
284:
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);
290:
291: void init_right_tree(void)
292: {
293: GtkTreeView *view = GTK_TREE_VIEW(tree2_w);
294: GtkCellRenderer *renderer;
295: GtkTreeSelection *sel;
296: GtkTreeViewColumn *column;
297: gint i;
298:
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, FALSE);
302:
303: column = gtk_tree_view_column_new();
304: gtk_tree_view_append_column(view, column);
305: gtk_tree_view_column_set_title(column, _("Options"));
306:
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);
333:
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);
368:
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);
379:
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);
384: }
385: }
386:
387: sel = gtk_tree_view_get_selection(view);
388: gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
389: }
390:
391:
392: /* Utility Functions */
393:
394:
395: static void text_insert_help(struct menu *menu)
396: {
397: GtkTextBuffer *buffer;
398: GtkTextIter start, end;
399: const char *prompt = _(menu_get_prompt(menu));
400: struct gstr help = str_new();
401:
402: menu_get_ext_help(menu, &help);
403:
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);
408:
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);
417: }
418:
419:
420: static void text_insert_msg(const char *title, const char *message)
421: {
422: GtkTextBuffer *buffer;
423: GtkTextIter start, end;
424: const char *msg = message;
425:
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);
430:
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);
438: }
439:
440:
441: /* Main Windows Callbacks */
442:
443: void on_save_activate(GtkMenuItem * menuitem, gpointer user_data);
444: gboolean on_window1_delete_event(GtkWidget * widget, GdkEvent * event,
445: gpointer user_data)
446: {
447: GtkWidget *dialog, *label;
448: gint result;
449:
450: if (!conf_get_changed())
451: return FALSE;
452:
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);
466:
467: label = gtk_label_new(_("\nSave configuration ?\n"));
468: gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
469: gtk_widget_show(label);
470:
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;
483: }
484:
485: return FALSE;
486: }
487:
488:
489: void on_window1_destroy(GtkObject * object, gpointer user_data)
490: {
491: gtk_main_quit();
492: }
493:
494:
495: void
496: on_window1_size_request(GtkWidget * widget,
497: GtkRequisition * requisition, gpointer user_data)
498: {
499: static gint old_h;
500: gint w, h;
501:
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);
506:
507: if (h == old_h)
508: return;
509: old_h = h;
510:
511: gtk_paned_set_position(GTK_PANED(vpaned), 2 * h / 3);
512: }
513:
514:
515: /* Menu & Toolbar Callbacks */
516:
517:
518: static void
519: load_filename(GtkFileSelection * file_selector, gpointer user_data)
520: {
521: const gchar *fn;
522:
523: fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
524: (user_data));
525:
526: if (conf_read(fn))
527: text_insert_msg(_("Error"), _("Unable to load configuration !"));
528: else
529: display_tree(&rootmenu);
530: }
531:
532: void on_load1_activate(GtkMenuItem * menuitem, gpointer user_data)
533: {
534: GtkWidget *fs;
535:
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);
549: }
550:
551:
552: void on_save_activate(GtkMenuItem * menuitem, gpointer user_data)
553: {
554: if (conf_write(NULL))
555: text_insert_msg(_("Error"), _("Unable to save configuration !"));
556: }
557:
558:
559: static void
560: store_filename(GtkFileSelection * file_selector, gpointer user_data)
561: {
562: const gchar *fn;
563:
564: fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
565: (user_data));
566:
567: if (conf_write(fn))
568: text_insert_msg(_("Error"), _("Unable to save configuration !"));
569:
570: gtk_widget_destroy(GTK_WIDGET(user_data));
571: }
572:
573: void on_save_as1_activate(GtkMenuItem * menuitem, gpointer user_data)
574: {
575: GtkWidget *fs;
576:
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);
590: }
591:
592:
593: void on_quit1_activate(GtkMenuItem * menuitem, gpointer user_data)
594: {
595: if (!on_window1_delete_event(NULL, NULL, NULL))
596: gtk_widget_destroy(GTK_WIDGET(main_wnd));
597: }
598:
599:
600: void on_show_name1_activate(GtkMenuItem * menuitem, gpointer user_data)
601: {
602: GtkTreeViewColumn *col;
603:
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);
608: }
609:
610:
611: void on_show_range1_activate(GtkMenuItem * menuitem, gpointer user_data)
612: {
613: GtkTreeViewColumn *col;
614:
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);
625:
626: }
627:
628:
629: void on_show_data1_activate(GtkMenuItem * menuitem, gpointer user_data)
630: {
631: GtkTreeViewColumn *col;
632:
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);
637: }
638:
639:
640: void
641: on_set_option_mode1_activate(GtkMenuItem *menuitem, gpointer user_data)
642: {
643: opt_mode = OPT_NORMAL;
644: gtk_tree_store_clear(tree2);
645: display_tree(&rootmenu); /* instead of update_tree to speed-up */
646: }
647:
648:
649: void
650: on_set_option_mode2_activate(GtkMenuItem *menuitem, gpointer user_data)
651: {
652: opt_mode = OPT_ALL;
653: gtk_tree_store_clear(tree2);
654: display_tree(&rootmenu); /* instead of update_tree to speed-up */
655: }
656:
657:
658: void
659: on_set_option_mode3_activate(GtkMenuItem *menuitem, gpointer user_data)
660: {
661: opt_mode = OPT_PROMPT;
662: gtk_tree_store_clear(tree2);
663: display_tree(&rootmenu); /* instead of update_tree to speed-up */
664: }
665:
666:
667: void on_introduction1_activate(GtkMenuItem * menuitem, gpointer user_data)
668: {
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.");
686:
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);
695: }
696:
697:
698: void on_about1_activate(GtkMenuItem * menuitem, gpointer user_data)
699: {
700: GtkWidget *dialog;
701: const gchar *about_text =
702: _("gkc is copyright (c) 2002 Romain Lievin <[email protected]>.\n"
703: "Based on the source code from Roman Zippel.\n");
704:
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);
713: }
714:
715:
716: void on_license1_activate(GtkMenuItem * menuitem, gpointer user_data)
717: {
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");
723:
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);
732: }
733:
734:
735: void on_back_clicked(GtkButton * button, gpointer user_data)
736: {
737: enum prop_type ptype;
738:
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();
744:
745: if (current == &rootmenu)
746: gtk_widget_set_sensitive(back_btn, FALSE);
747: }
748:
749:
750: void on_load_clicked(GtkButton * button, gpointer user_data)
751: {
752: on_load1_activate(NULL, user_data);
753: }
754:
755:
756: void on_single_clicked(GtkButton * button, gpointer user_data)
757: {
758: view_mode = SINGLE_VIEW;
759: gtk_paned_set_position(GTK_PANED(hpaned), 0);
760: gtk_widget_hide(tree1_w);
761: current = &rootmenu;
762: display_tree_part();
763: }
764:
765:
766: void on_split_clicked(GtkButton * button, gpointer user_data)
767: {
768: gint w, h;
769: view_mode = SPLIT_VIEW;
770: gtk_widget_show(tree1_w);
771: gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h);
772: gtk_paned_set_position(GTK_PANED(hpaned), w / 2);
773: if (tree2)
774: gtk_tree_store_clear(tree2);
775: display_list();
776:
777: /* Disable back btn, like in full mode. */
778: gtk_widget_set_sensitive(back_btn, FALSE);
779: }
780:
781:
782: void on_full_clicked(GtkButton * button, gpointer user_data)
783: {
784: view_mode = FULL_VIEW;
785: gtk_paned_set_position(GTK_PANED(hpaned), 0);
786: gtk_widget_hide(tree1_w);
787: if (tree2)
788: gtk_tree_store_clear(tree2);
789: display_tree(&rootmenu);
790: gtk_widget_set_sensitive(back_btn, FALSE);
791: }
792:
793:
794: void on_collapse_clicked(GtkButton * button, gpointer user_data)
795: {
796: gtk_tree_view_collapse_all(GTK_TREE_VIEW(tree2_w));
797: }
798:
799:
800: void on_expand_clicked(GtkButton * button, gpointer user_data)
801: {
802: gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
803: }
804:
805:
806: /* CTree Callbacks */
807:
808: /* Change hex/int/string value in the cell */
809: static void renderer_edited(GtkCellRendererText * cell,
810: const gchar * path_string,
811: const gchar * new_text, gpointer user_data)
812: {
813: GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
814: GtkTreeIter iter;
815: const char *old_def, *new_def;
816: struct menu *menu;
817: struct symbol *sym;
818:
819: if (!gtk_tree_model_get_iter(model2, &iter, path))
820: return;
821:
822: gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
823: sym = menu->sym;
824:
825: gtk_tree_model_get(model2, &iter, COL_VALUE, &old_def, -1);
826: new_def = new_text;
827:
828: sym_set_string_value(sym, new_def);
829:
830: update_tree(&rootmenu, NULL);
831:
832: gtk_tree_path_free(path);
833: }
834:
835: /* Change the value of a symbol and update the tree */
836: static void change_sym_value(struct menu *menu, gint col)
837: {
838: struct symbol *sym = menu->sym;
839: tristate oldval, newval;
840:
841: if (!sym)
842: return;
843:
844: if (col == COL_NO)
845: newval = no;
846: else if (col == COL_MOD)
847: newval = mod;
848: else if (col == COL_YES)
849: newval = yes;
850: else
851: return;
852:
853: switch (sym_get_type(sym)) {
854: case S_BOOLEAN:
855: case S_TRISTATE:
856: oldval = sym_get_tristate_value(sym);
857: if (!sym_tristate_within_range(sym, newval))
858: newval = yes;
859: sym_set_tristate_value(sym, newval);
860: if (view_mode == FULL_VIEW)
861: update_tree(&rootmenu, NULL);
862: else if (view_mode == SPLIT_VIEW) {
863: update_tree(browsed, NULL);
864: display_list();
865: }
866: else if (view_mode == SINGLE_VIEW)
867: display_tree_part(); //fixme: keep exp/coll
868: break;
869: case S_INT:
870: case S_HEX:
871: case S_STRING:
872: default:
873: break;
874: }
875: }
876:
877: static void toggle_sym_value(struct menu *menu)
878: {
879: if (!menu->sym)
880: return;
881:
882: sym_toggle_tristate_value(menu->sym);
883: if (view_mode == FULL_VIEW)
884: update_tree(&rootmenu, NULL);
885: else if (view_mode == SPLIT_VIEW) {
886: update_tree(browsed, NULL);
887: display_list();
888: }
889: else if (view_mode == SINGLE_VIEW)
890: display_tree_part(); //fixme: keep exp/coll
891: }
892:
893: static void renderer_toggled(GtkCellRendererToggle * cell,
894: gchar * path_string, gpointer user_data)
895: {
896: GtkTreePath *path, *sel_path = NULL;
897: GtkTreeIter iter, sel_iter;
898: GtkTreeSelection *sel;
899: struct menu *menu;
900:
901: path = gtk_tree_path_new_from_string(path_string);
902: if (!gtk_tree_model_get_iter(model2, &iter, path))
903: return;
904:
905: sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree2_w));
906: if (gtk_tree_selection_get_selected(sel, NULL, &sel_iter))
907: sel_path = gtk_tree_model_get_path(model2, &sel_iter);
908: if (!sel_path)
909: goto out1;
910: if (gtk_tree_path_compare(path, sel_path))
911: goto out2;
912:
913: gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
914: toggle_sym_value(menu);
915:
916: out2:
917: gtk_tree_path_free(sel_path);
918: out1:
919: gtk_tree_path_free(path);
920: }
921:
922: static gint column2index(GtkTreeViewColumn * column)
923: {
924: gint i;
925:
926: for (i = 0; i < COL_NUMBER; i++) {
927: GtkTreeViewColumn *col;
928:
929: col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), i);
930: if (col == column)
931: return i;
932: }
933:
934: return -1;
935: }
936:
937:
938: /* User click: update choice (full) or goes down (single) */
939: gboolean
940: on_treeview2_button_press_event(GtkWidget * widget,
941: GdkEventButton * event, gpointer user_data)
942: {
943: GtkTreeView *view = GTK_TREE_VIEW(widget);
944: GtkTreePath *path;
945: GtkTreeViewColumn *column;
946: GtkTreeIter iter;
947: struct menu *menu;
948: gint col;
949:
950: #if GTK_CHECK_VERSION(2,1,4) // bug in ctree with earlier version of GTK
951: gint tx = (gint) event->x;
952: gint ty = (gint) event->y;
953: gint cx, cy;
954:
955: gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
956: &cy);
957: #else
958: gtk_tree_view_get_cursor(view, &path, &column);
959: #endif
960: if (path == NULL)
961: return FALSE;
962:
963: if (!gtk_tree_model_get_iter(model2, &iter, path))
964: return FALSE;
965: gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
966:
967: col = column2index(column);
968: if (event->type == GDK_2BUTTON_PRESS) {
969: enum prop_type ptype;
970: ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
971:
972: if (ptype == P_MENU && view_mode != FULL_VIEW && col == COL_OPTION) {
973: // goes down into menu
974: current = menu;
975: display_tree_part();
976: gtk_widget_set_sensitive(back_btn, TRUE);
977: } else if ((col == COL_OPTION)) {
978: toggle_sym_value(menu);
979: gtk_tree_view_expand_row(view, path, TRUE);
980: }
981: } else {
982: if (col == COL_VALUE) {
983: toggle_sym_value(menu);
984: gtk_tree_view_expand_row(view, path, TRUE);
985: } else if (col == COL_NO || col == COL_MOD
986: || col == COL_YES) {
987: change_sym_value(menu, col);
988: gtk_tree_view_expand_row(view, path, TRUE);
989: }
990: }
991:
992: return FALSE;
993: }
994:
995: /* Key pressed: update choice */
996: gboolean
997: on_treeview2_key_press_event(GtkWidget * widget,
998: GdkEventKey * event, gpointer user_data)
999: {
1000: GtkTreeView *view = GTK_TREE_VIEW(widget);
1001: GtkTreePath *path;
1002: GtkTreeViewColumn *column;
1003: GtkTreeIter iter;
1004: struct menu *menu;
1005: gint col;
1006:
1007: gtk_tree_view_get_cursor(view, &path, &column);
1008: if (path == NULL)
1009: return FALSE;
1010:
1011: if (event->keyval == GDK_space) {
1012: if (gtk_tree_view_row_expanded(view, path))
1013: gtk_tree_view_collapse_row(view, path);
1014: else
1015: gtk_tree_view_expand_row(view, path, FALSE);
1016: return TRUE;
1017: }
1018: if (event->keyval == GDK_KP_Enter) {
1019: }
1020: if (widget == tree1_w)
1021: return FALSE;
1022:
1023: gtk_tree_model_get_iter(model2, &iter, path);
1024: gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1025:
1026: if (!strcasecmp(event->string, "n"))
1027: col = COL_NO;
1028: else if (!strcasecmp(event->string, "m"))
1029: col = COL_MOD;
1030: else if (!strcasecmp(event->string, "y"))
1031: col = COL_YES;
1032: else
1033: col = -1;
1034: change_sym_value(menu, col);
1035:
1036: return FALSE;
1037: }
1038:
1039:
1040: /* Row selection changed: update help */
1041: void
1042: on_treeview2_cursor_changed(GtkTreeView * treeview, gpointer user_data)
1043: {
1044: GtkTreeSelection *selection;
1045: GtkTreeIter iter;
1046: struct menu *menu;
1047:
1048: selection = gtk_tree_view_get_selection(treeview);
1049: if (gtk_tree_selection_get_selected(selection, &model2, &iter)) {
1050: gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1051: text_insert_help(menu);
1052: }
1053: }
1054:
1055:
1056: /* User click: display sub-tree in the right frame. */
1057: gboolean
1058: on_treeview1_button_press_event(GtkWidget * widget,
1059: GdkEventButton * event, gpointer user_data)
1060: {
1061: GtkTreeView *view = GTK_TREE_VIEW(widget);
1062: GtkTreePath *path;
1063: GtkTreeViewColumn *column;
1064: GtkTreeIter iter;
1065: struct menu *menu;
1066:
1067: gint tx = (gint) event->x;
1068: gint ty = (gint) event->y;
1069: gint cx, cy;
1070:
1071: gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
1072: &cy);
1073: if (path == NULL)
1074: return FALSE;
1075:
1076: gtk_tree_model_get_iter(model1, &iter, path);
1077: gtk_tree_model_get(model1, &iter, COL_MENU, &menu, -1);
1078:
1079: if (event->type == GDK_2BUTTON_PRESS) {
1080: toggle_sym_value(menu);
1081: current = menu;
1082: display_tree_part();
1083: } else {
1084: browsed = menu;
1085: display_tree_part();
1086: }
1087:
1088: gtk_widget_realize(tree2_w);
1089: gtk_tree_view_set_cursor(view, path, NULL, FALSE);
1090: gtk_widget_grab_focus(tree2_w);
1091:
1092: return FALSE;
1093: }
1094:
1095:
1096: /* Fill a row of strings */
1097: static gchar **fill_row(struct menu *menu)
1098: {
1099: static gchar *row[COL_NUMBER];
1100: struct symbol *sym = menu->sym;
1101: const char *def;
1102: int stype;
1103: tristate val;
1104: enum prop_type ptype;
1105: int i;
1106:
1107: for (i = COL_OPTION; i <= COL_COLOR; i++)
1108: g_free(row[i]);
1109: bzero(row, sizeof(row));
1110:
1111: row[COL_OPTION] =
1112: g_strdup_printf("%s %s", _(menu_get_prompt(menu)),
1113: sym && !sym_has_value(sym) ? "(NEW)" : "");
1114:
1115: if (opt_mode == OPT_ALL && !menu_is_visible(menu))
1116: row[COL_COLOR] = g_strdup("DarkGray");
1117: else if (opt_mode == OPT_PROMPT &&
1118: menu_has_prompt(menu) && !menu_is_visible(menu))
1119: row[COL_COLOR] = g_strdup("DarkGray");
1120: else
1121: row[COL_COLOR] = g_strdup("Black");
1122:
1123: ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
1124: switch (ptype) {
1125: case P_MENU:
1126: row[COL_PIXBUF] = (gchar *) xpm_menu;
1127: if (view_mode == SINGLE_VIEW)
1128: row[COL_PIXVIS] = GINT_TO_POINTER(TRUE);
1129: row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1130: break;
1131: case P_COMMENT:
1132: row[COL_PIXBUF] = (gchar *) xpm_void;
1133: row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
1134: row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1135: break;
1136: default:
1137: row[COL_PIXBUF] = (gchar *) xpm_void;
1138: row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
1139: row[COL_BTNVIS] = GINT_TO_POINTER(TRUE);
1140: break;
1141: }
1142:
1143: if (!sym)
1144: return row;
1145: row[COL_NAME] = g_strdup(sym->name);
1146:
1147: sym_calc_value(sym);
1148: sym->flags &= ~SYMBOL_CHANGED;
1149:
1150: if (sym_is_choice(sym)) { // parse childs for getting final value
1151: struct menu *child;
1152: struct symbol *def_sym = sym_get_choice_value(sym);
1153: struct menu *def_menu = NULL;
1154:
1155: row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1156:
1157: for (child = menu->list; child; child = child->next) {
1158: if (menu_is_visible(child)
1159: && child->sym == def_sym)
1160: def_menu = child;
1161: }
1162:
1163: if (def_menu)
1164: row[COL_VALUE] =
1165: g_strdup(_(menu_get_prompt(def_menu)));
1166: }
1167: if (sym->flags & SYMBOL_CHOICEVAL)
1168: row[COL_BTNRAD] = GINT_TO_POINTER(TRUE);
1169:
1170: stype = sym_get_type(sym);
1171: switch (stype) {
1172: case S_BOOLEAN:
1173: if (GPOINTER_TO_INT(row[COL_PIXVIS]) == FALSE)
1174: row[COL_BTNVIS] = GINT_TO_POINTER(TRUE);
1175: if (sym_is_choice(sym))
1176: break;
1177: case S_TRISTATE:
1178: val = sym_get_tristate_value(sym);
1179: switch (val) {
1180: case no:
1181: row[COL_NO] = g_strdup("N");
1182: row[COL_VALUE] = g_strdup("N");
1183: row[COL_BTNACT] = GINT_TO_POINTER(FALSE);
1184: row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
1185: break;
1186: case mod:
1187: row[COL_MOD] = g_strdup("M");
1188: row[COL_VALUE] = g_strdup("M");
1189: row[COL_BTNINC] = GINT_TO_POINTER(TRUE);
1190: break;
1191: case yes:
1192: row[COL_YES] = g_strdup("Y");
1193: row[COL_VALUE] = g_strdup("Y");
1194: row[COL_BTNACT] = GINT_TO_POINTER(TRUE);
1195: row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
1196: break;
1197: }
1198:
1199: if (val != no && sym_tristate_within_range(sym, no))
1200: row[COL_NO] = g_strdup("_");
1201: if (val != mod && sym_tristate_within_range(sym, mod))
1202: row[COL_MOD] = g_strdup("_");
1203: if (val != yes && sym_tristate_within_range(sym, yes))
1204: row[COL_YES] = g_strdup("_");
1205: break;
1206: case S_INT:
1207: case S_HEX:
1208: case S_STRING:
1209: def = sym_get_string_value(sym);
1210: row[COL_VALUE] = g_strdup(def);
1211: row[COL_EDIT] = GINT_TO_POINTER(TRUE);
1212: row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
1213: break;
1214: }
1215:
1216: return row;
1217: }
1218:
1219:
1220: /* Set the node content with a row of strings */
1221: static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row)
1222: {
1223: GdkColor color;
1224: gboolean success;
1225: GdkPixbuf *pix;
1226:
1227: pix = gdk_pixbuf_new_from_xpm_data((const char **)
1228: row[COL_PIXBUF]);
1229:
1230: gdk_color_parse(row[COL_COLOR], &color);
1231: gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1,
1232: FALSE, FALSE, &success);
1233:
1234: gtk_tree_store_set(tree, node,
1235: COL_OPTION, row[COL_OPTION],
1236: COL_NAME, row[COL_NAME],
1237: COL_NO, row[COL_NO],
1238: COL_MOD, row[COL_MOD],
1239: COL_YES, row[COL_YES],
1240: COL_VALUE, row[COL_VALUE],
1241: COL_MENU, (gpointer) menu,
1242: COL_COLOR, &color,
1243: COL_EDIT, GPOINTER_TO_INT(row[COL_EDIT]),
1244: COL_PIXBUF, pix,
1245: COL_PIXVIS, GPOINTER_TO_INT(row[COL_PIXVIS]),
1246: COL_BTNVIS, GPOINTER_TO_INT(row[COL_BTNVIS]),
1247: COL_BTNACT, GPOINTER_TO_INT(row[COL_BTNACT]),
1248: COL_BTNINC, GPOINTER_TO_INT(row[COL_BTNINC]),
1249: COL_BTNRAD, GPOINTER_TO_INT(row[COL_BTNRAD]),
1250: -1);
1251:
1252: g_object_unref(pix);
1253: }
1254:
1255:
1256: /* Add a node to the tree */
1257: static void place_node(struct menu *menu, char **row)
1258: {
1259: GtkTreeIter *parent = parents[indent - 1];
1260: GtkTreeIter *node = parents[indent];
1261:
1262: gtk_tree_store_append(tree, node, parent);
1263: set_node(node, menu, row);
1264: }
1265:
1266:
1267: /* Find a node in the GTK+ tree */
1268: static GtkTreeIter found;
1269:
1270: /*
1271: * Find a menu in the GtkTree starting at parent.
1272: */
1273: GtkTreeIter *gtktree_iter_find_node(GtkTreeIter * parent,
1274: struct menu *tofind)
1275: {
1276: GtkTreeIter iter;
1277: GtkTreeIter *child = &iter;
1278: gboolean valid;
1279: GtkTreeIter *ret;
1280:
1281: valid = gtk_tree_model_iter_children(model2, child, parent);
1282: while (valid) {
1283: struct menu *menu;
1284:
1285: gtk_tree_model_get(model2, child, 6, &menu, -1);
1286:
1287: if (menu == tofind) {
1288: memcpy(&found, child, sizeof(GtkTreeIter));
1289: return &found;
1290: }
1291:
1292: ret = gtktree_iter_find_node(child, tofind);
1293: if (ret)
1294: return ret;
1295:
1296: valid = gtk_tree_model_iter_next(model2, child);
1297: }
1298:
1299: return NULL;
1300: }
1301:
1302:
1303: /*
1304: * Update the tree by adding/removing entries
1305: * Does not change other nodes
1306: */
1307: static void update_tree(struct menu *src, GtkTreeIter * dst)
1308: {
1309: struct menu *child1;
1310: GtkTreeIter iter, tmp;
1311: GtkTreeIter *child2 = &iter;
1312: gboolean valid;
1313: GtkTreeIter *sibling;
1314: struct symbol *sym;
1315: struct property *prop;
1316: struct menu *menu1, *menu2;
1317:
1318: if (src == &rootmenu)
1319: indent = 1;
1320:
1321: valid = gtk_tree_model_iter_children(model2, child2, dst);
1322: for (child1 = src->list; child1; child1 = child1->next) {
1323:
1324: prop = child1->prompt;
1325: sym = child1->sym;
1326:
1327: reparse:
1328: menu1 = child1;
1329: if (valid)
1330: gtk_tree_model_get(model2, child2, COL_MENU,
1331: &menu2, -1);
1332: else
1333: menu2 = NULL; // force adding of a first child
1334:
1335: #ifdef DEBUG
1336: printf("%*c%s | %s\n", indent, ' ',
1337: menu1 ? menu_get_prompt(menu1) : "nil",
1338: menu2 ? menu_get_prompt(menu2) : "nil");
1339: #endif
1340:
1341: if ((opt_mode == OPT_NORMAL && !menu_is_visible(child1)) ||
1342: (opt_mode == OPT_PROMPT && !menu_has_prompt(child1)) ||
1343: (opt_mode == OPT_ALL && !menu_get_prompt(child1))) {
1344:
1345: /* remove node */
1346: if (gtktree_iter_find_node(dst, menu1) != NULL) {
1347: memcpy(&tmp, child2, sizeof(GtkTreeIter));
1348: valid = gtk_tree_model_iter_next(model2,
1349: child2);
1350: gtk_tree_store_remove(tree2, &tmp);
1351: if (!valid)
1352: return; /* next parent */
1353: else
1354: goto reparse; /* next child */
1355: } else
1356: continue;
1357: }
1358:
1359: if (menu1 != menu2) {
1360: if (gtktree_iter_find_node(dst, menu1) == NULL) { // add node
1361: if (!valid && !menu2)
1362: sibling = NULL;
1363: else
1364: sibling = child2;
1365: gtk_tree_store_insert_before(tree2,
1366: child2,
1367: dst, sibling);
1368: set_node(child2, menu1, fill_row(menu1));
1369: if (menu2 == NULL)
1370: valid = TRUE;
1371: } else { // remove node
1372: memcpy(&tmp, child2, sizeof(GtkTreeIter));
1373: valid = gtk_tree_model_iter_next(model2,
1374: child2);
1375: gtk_tree_store_remove(tree2, &tmp);
1376: if (!valid)
1377: return; // next parent
1378: else
1379: goto reparse; // next child
1380: }
1381: } else if (sym && (sym->flags & SYMBOL_CHANGED)) {
1382: set_node(child2, menu1, fill_row(menu1));
1383: }
1384:
1385: indent++;
1386: update_tree(child1, child2);
1387: indent--;
1388:
1389: valid = gtk_tree_model_iter_next(model2, child2);
1390: }
1391: }
1392:
1393:
1394: /* Display the whole tree (single/split/full view) */
1395: static void display_tree(struct menu *menu)
1396: {
1397: struct symbol *sym;
1398: struct property *prop;
1399: struct menu *child;
1400: enum prop_type ptype;
1401:
1402: if (menu == &rootmenu) {
1403: indent = 1;
1404: current = &rootmenu;
1405: }
1406:
1407: for (child = menu->list; child; child = child->next) {
1408: prop = child->prompt;
1409: sym = child->sym;
1410: ptype = prop ? prop->type : P_UNKNOWN;
1411:
1412: if (sym)
1413: sym->flags &= ~SYMBOL_CHANGED;
1414:
1415: if ((view_mode == SPLIT_VIEW)
1416: && !(child->flags & MENU_ROOT) && (tree == tree1))
1417: continue;
1418:
1419: if ((view_mode == SPLIT_VIEW) && (child->flags & MENU_ROOT)
1420: && (tree == tree2))
1421: continue;
1422:
1423: if ((opt_mode == OPT_NORMAL && menu_is_visible(child)) ||
1424: (opt_mode == OPT_PROMPT && menu_has_prompt(child)) ||
1425: (opt_mode == OPT_ALL && menu_get_prompt(child)))
1426: place_node(child, fill_row(child));
1427: #ifdef DEBUG
1428: printf("%*c%s: ", indent, ' ', menu_get_prompt(child));
1429: printf("%s", child->flags & MENU_ROOT ? "rootmenu | " : "");
1430: printf("%s", prop_get_type_name(ptype));
1431: printf(" | ");
1432: if (sym) {
1433: printf("%s", sym_type_name(sym->type));
1434: printf(" | ");
1435: printf("%s", dbg_sym_flags(sym->flags));
1436: printf("\n");
1437: } else
1438: printf("\n");
1439: #endif
1440: if ((view_mode != FULL_VIEW) && (ptype == P_MENU)
1441: && (tree == tree2))
1442: continue;
1443: /*
1444: if (((menu != &rootmenu) && !(menu->flags & MENU_ROOT))
1445: || (view_mode == FULL_VIEW)
1446: || (view_mode == SPLIT_VIEW))*/
1447: if (((view_mode == SINGLE_VIEW) && (menu->flags & MENU_ROOT))
1448: || (view_mode == FULL_VIEW)
1449: || (view_mode == SPLIT_VIEW)) {
1450: indent++;
1451: display_tree(child);
1452: indent--;
1453: }
1454: }
1455: }
1456:
1457: /* Display a part of the tree starting at current node (single/split view) */
1458: static void display_tree_part(void)
1459: {
1460: if (tree2)
1461: gtk_tree_store_clear(tree2);
1462: if (view_mode == SINGLE_VIEW)
1463: display_tree(current);
1464: else if (view_mode == SPLIT_VIEW)
1465: display_tree(browsed);
1466: gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
1467: }
1468:
1469: /* Display the list in the left frame (split view) */
1470: static void display_list(void)
1471: {
1472: if (tree1)
1473: gtk_tree_store_clear(tree1);
1474:
1475: tree = tree1;
1476: display_tree(&rootmenu);
1477: gtk_tree_view_expand_all(GTK_TREE_VIEW(tree1_w));
1478: tree = tree2;
1479: }
1480:
1481: void fixup_rootmenu(struct menu *menu)
1482: {
1483: struct menu *child;
1484: static int menu_cnt = 0;
1485:
1486: menu->flags |= MENU_ROOT;
1487: for (child = menu->list; child; child = child->next) {
1488: if (child->prompt && child->prompt->type == P_MENU) {
1489: menu_cnt++;
1490: fixup_rootmenu(child);
1491: menu_cnt--;
1492: } else if (!menu_cnt)
1493: fixup_rootmenu(child);
1494: }
1495: }
1496:
1497:
1498: /* Main */
1499: int main(int ac, char *av[])
1500: {
1501: const char *name;
1502: char *env;
1503: gchar *glade_file;
1504:
1505: #ifndef LKC_DIRECT_LINK
1506: kconfig_load();
1507: #endif
1508:
1509: bindtextdomain(PACKAGE, LOCALEDIR);
1510: bind_textdomain_codeset(PACKAGE, "UTF-8");
1511: textdomain(PACKAGE);
1512:
1513: /* GTK stuffs */
1514: gtk_set_locale();
1515: gtk_init(&ac, &av);
1516: glade_init();
1517:
1518: //add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
1519: //add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
1520:
1521: /* Determine GUI path */
1522: env = getenv(SRCTREE);
1523: if (env)
1524: glade_file = g_strconcat(env, "/tools/kconfig/gconf.glade", NULL);
1525: else if (av[0][0] == '/')
1526: glade_file = g_strconcat(av[0], ".glade", NULL);
1527: else
1528: glade_file = g_strconcat(g_get_current_dir(), "/", av[0], ".glade", NULL);
1529:
1530: /* Conf stuffs */
1531: if (ac > 1 && av[1][0] == '-') {
1532: switch (av[1][1]) {
1533: case 'a':
1534: //showAll = 1;
1535: break;
1536: case 'h':
1537: case '?':
1538: printf("%s <config>\n", av[0]);
1539: exit(0);
1540: }
1541: name = av[2];
1542: } else
1543: name = av[1];
1544:
1545: conf_parse(name);
1546: fixup_rootmenu(&rootmenu);
1547: conf_read(NULL);
1548:
1549: /* Load the interface and connect signals */
1550: init_main_window(glade_file);
1551: init_tree_model();
1552: init_left_tree();
1553: init_right_tree();
1554:
1555: switch (view_mode) {
1556: case SINGLE_VIEW:
1557: display_tree_part();
1558: break;
1559: case SPLIT_VIEW:
1560: display_list();
1561: break;
1562: case FULL_VIEW:
1563: display_tree(&rootmenu);
1564: break;
1565: }
1566:
1567: gtk_main();
1568:
1569: return 0;
1570: }
1571:
1572: static void conf_changed(void)
1573: {
1574: bool changed = conf_get_changed();
1575: gtk_widget_set_sensitive(save_btn, changed);
1576: gtk_widget_set_sensitive(save_menu_item, changed);
1577: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.