scripts/kconfig/gconf.c

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