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