scripts/kconfig/gconf.c

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