~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/kconfig/gconf.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp