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     N_("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 void replace_button_icon(GladeXML * xml, GdkDrawable * window,
 182                          GtkStyle * style, gchar * btn_name, gchar ** xpm)
 183 {
 184         GdkPixmap *pixmap;
 185         GdkBitmap *mask;
 186         GtkToolButton *button;
 187         GtkWidget *image;
 188
 189         pixmap = gdk_pixmap_create_from_xpm_d(window, &mask,
 190                                               &style->bg[GTK_STATE_NORMAL],
 191                                               xpm);
 192
 193         button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, btn_name));
 194         image = gtk_image_new_from_pixmap(pixmap, mask);
 195         gtk_widget_show(image);
 196         gtk_tool_button_set_icon_widget(button, image);
 197 }
 198
 199 /* Main Window Initialization */
 200 void init_main_window(const gchar * glade_file)
 201 {
 202         GladeXML *xml;
 203         GtkWidget *widget;
 204         GtkTextBuffer *txtbuf;
 205         char title[256];
 206         GtkStyle *style;
 207
 208         xml = glade_xml_new(glade_file, "window1", NULL);
 209         if (!xml)
 210                 g_error(_("GUI loading failed !\n"));
 211         glade_xml_signal_autoconnect(xml);
 212
 213         main_wnd = glade_xml_get_widget(xml, "window1");
 214         hpaned = glade_xml_get_widget(xml, "hpaned1");
 215         vpaned = glade_xml_get_widget(xml, "vpaned1");
 216         tree1_w = glade_xml_get_widget(xml, "treeview1");
 217         tree2_w = glade_xml_get_widget(xml, "treeview2");
 218         text_w = glade_xml_get_widget(xml, "textview3");
 219
 220         back_btn = glade_xml_get_widget(xml, "button1");
 221         gtk_widget_set_sensitive(back_btn, FALSE);
 222
 223         widget = glade_xml_get_widget(xml, "show_name1");
 224         gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
 225                                        show_name);
 226
 227         widget = glade_xml_get_widget(xml, "show_range1");
 228         gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
 229                                        show_range);
 230
 231         widget = glade_xml_get_widget(xml, "show_data1");
 232         gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
 233                                        show_value);
 234
 235         style = gtk_widget_get_style(main_wnd);
 236         widget = glade_xml_get_widget(xml, "toolbar1");
 237
 238 #if 0   /* Use stock Gtk icons instead */
 239         replace_button_icon(xml, main_wnd->window, style,
 240                             "button1", (gchar **) xpm_back);
 241         replace_button_icon(xml, main_wnd->window, style,
 242                             "button2", (gchar **) xpm_load);
 243         replace_button_icon(xml, main_wnd->window, style,
 244                             "button3", (gchar **) xpm_save);
 245 #endif
 246         replace_button_icon(xml, main_wnd->window, style,
 247                             "button4", (gchar **) xpm_single_view);
 248         replace_button_icon(xml, main_wnd->window, style,
 249                             "button5", (gchar **) xpm_split_view);
 250         replace_button_icon(xml, main_wnd->window, style,
 251                             "button6", (gchar **) xpm_tree_view);
 252
 253 #if 0
 254         switch (view_mode) {
 255         case SINGLE_VIEW:
 256                 widget = glade_xml_get_widget(xml, "button4");
 257                 g_signal_emit_by_name(widget, "clicked");
 258                 break;
 259         case SPLIT_VIEW:
 260                 widget = glade_xml_get_widget(xml, "button5");
 261                 g_signal_emit_by_name(widget, "clicked");
 262                 break;
 263         case FULL_VIEW:
 264                 widget = glade_xml_get_widget(xml, "button6");
 265                 g_signal_emit_by_name(widget, "clicked");
 266                 break;
 267         }
 268 #endif
 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, _("LWK Kernel v%s Configuration"),
 279                 getenv("KERNELVERSION"));
 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 LWK.\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_clicked(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_clicked(GtkButton * button, gpointer user_data)
 825 {
 826         on_load1_activate(NULL, user_data);
 827 }
 828
 829
 830 void on_save_clicked(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         /* Disable back btn, like in full mode. */
 858         gtk_widget_set_sensitive(back_btn, FALSE);
 859 }
 860
 861
 862 void on_full_clicked(GtkButton * button, gpointer user_data)
 863 {
 864         view_mode = FULL_VIEW;
 865         gtk_paned_set_position(GTK_PANED(hpaned), 0);
 866         gtk_widget_hide(tree1_w);
 867         if (tree2)
 868                 gtk_tree_store_clear(tree2);
 869         display_tree(&rootmenu);
 870         gtk_widget_set_sensitive(back_btn, FALSE);
 871 }
 872
 873
 874 void on_collapse_clicked(GtkButton * button, gpointer user_data)
 875 {
 876         gtk_tree_view_collapse_all(GTK_TREE_VIEW(tree2_w));
 877 }
 878
 879
 880 void on_expand_clicked(GtkButton * button, gpointer user_data)
 881 {
 882         gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
 883 }
 884
 885
 886 /* CTree Callbacks */
 887
 888 /* Change hex/int/string value in the cell */
 889 static void renderer_edited(GtkCellRendererText * cell,
 890                             const gchar * path_string,
 891                             const gchar * new_text, gpointer user_data)
 892 {
 893         GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
 894         GtkTreeIter iter;
 895         const char *old_def, *new_def;
 896         struct menu *menu;
 897         struct symbol *sym;
 898
 899         if (!gtk_tree_model_get_iter(model2, &iter, path))
 900                 return;
 901
 902         gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
 903         sym = menu->sym;
 904
 905         gtk_tree_model_get(model2, &iter, COL_VALUE, &old_def, -1);
 906         new_def = new_text;
 907
 908         sym_set_string_value(sym, new_def);
 909
 910         config_changed = TRUE;
 911         update_tree(&rootmenu, NULL);
 912
 913         gtk_tree_path_free(path);
 914 }
 915
 916 /* Change the value of a symbol and update the tree */
 917 static void change_sym_value(struct menu *menu, gint col)
 918 {
 919         struct symbol *sym = menu->sym;
 920         tristate oldval, newval;
 921
 922         if (!sym)
 923                 return;
 924
 925         if (col == COL_NO)
 926                 newval = no;
 927         else if (col == COL_MOD)
 928                 newval = mod;
 929         else if (col == COL_YES)
 930                 newval = yes;
 931         else
 932                 return;
 933
 934         switch (sym_get_type(sym)) {
 935         case S_BOOLEAN:
 936         case S_TRISTATE:
 937                 oldval = sym_get_tristate_value(sym);
 938                 if (!sym_tristate_within_range(sym, newval))
 939                         newval = yes;
 940                 sym_set_tristate_value(sym, newval);
 941                 config_changed = TRUE;
 942                 if (view_mode == FULL_VIEW)
 943                         update_tree(&rootmenu, NULL);
 944                 else if (view_mode == SPLIT_VIEW) {
 945                         update_tree(browsed, NULL);
 946                         display_list();
 947                 }
 948                 else if (view_mode == SINGLE_VIEW)
 949                         display_tree_part();    //fixme: keep exp/coll
 950                 break;
 951         case S_INT:
 952         case S_HEX:
 953         case S_STRING:
 954         default:
 955                 break;
 956         }
 957 }
 958
 959 static void toggle_sym_value(struct menu *menu)
 960 {
 961         if (!menu->sym)
 962                 return;
 963
 964         sym_toggle_tristate_value(menu->sym);
 965         if (view_mode == FULL_VIEW)
 966                 update_tree(&rootmenu, NULL);
 967         else if (view_mode == SPLIT_VIEW) {
 968                 update_tree(browsed, NULL);
 969                 display_list();
 970         }
 971         else if (view_mode == SINGLE_VIEW)
 972                 display_tree_part();    //fixme: keep exp/coll
 973 }
 974
 975 static void renderer_toggled(GtkCellRendererToggle * cell,
 976                              gchar * path_string, gpointer user_data)
 977 {
 978         GtkTreePath *path, *sel_path = NULL;
 979         GtkTreeIter iter, sel_iter;
 980         GtkTreeSelection *sel;
 981         struct menu *menu;
 982
 983         path = gtk_tree_path_new_from_string(path_string);
 984         if (!gtk_tree_model_get_iter(model2, &iter, path))
 985                 return;
 986
 987         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree2_w));
 988         if (gtk_tree_selection_get_selected(sel, NULL, &sel_iter))
 989                 sel_path = gtk_tree_model_get_path(model2, &sel_iter);
 990         if (!sel_path)
 991                 goto out1;
 992         if (gtk_tree_path_compare(path, sel_path))
 993                 goto out2;
 994
 995         gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
 996         toggle_sym_value(menu);
 997
 998       out2:
 999         gtk_tree_path_free(sel_path);
1000       out1:
1001         gtk_tree_path_free(path);
1002 }
1003
1004 static gint column2index(GtkTreeViewColumn * column)
1005 {
1006         gint i;
1007
1008         for (i = 0; i < COL_NUMBER; i++) {
1009                 GtkTreeViewColumn *col;
1010
1011                 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), i);
1012                 if (col == column)
1013                         return i;
1014         }
1015
1016         return -1;
1017 }
1018
1019
1020 /* User click: update choice (full) or goes down (single) */
1021 gboolean
1022 on_treeview2_button_press_event(GtkWidget * widget,
1023                                 GdkEventButton * event, gpointer user_data)
1024 {
1025         GtkTreeView *view = GTK_TREE_VIEW(widget);
1026         GtkTreePath *path;
1027         GtkTreeViewColumn *column;
1028         GtkTreeIter iter;
1029         struct menu *menu;
1030         gint col;
1031
1032 #if GTK_CHECK_VERSION(2,1,4) // bug in ctree with earlier version of GTK
1033         gint tx = (gint) event->x;
1034         gint ty = (gint) event->y;
1035         gint cx, cy;
1036
1037         gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
1038                                       &cy);
1039 #else
1040         gtk_tree_view_get_cursor(view, &path, &column);
1041 #endif
1042         if (path == NULL)
1043                 return FALSE;
1044
1045         if (!gtk_tree_model_get_iter(model2, &iter, path))
1046                 return FALSE;
1047         gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1048
1049         col = column2index(column);
1050         if (event->type == GDK_2BUTTON_PRESS) {
1051                 enum prop_type ptype;
1052                 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
1053
1054                 if (ptype == P_MENU && view_mode != FULL_VIEW && col == COL_OPTION) {
1055                         // goes down into menu
1056                         current = menu;
1057                         display_tree_part();
1058                         gtk_widget_set_sensitive(back_btn, TRUE);
1059                 } else if ((col == COL_OPTION)) {
1060                         toggle_sym_value(menu);
1061                         gtk_tree_view_expand_row(view, path, TRUE);
1062                 }
1063         } else {
1064                 if (col == COL_VALUE) {
1065                         toggle_sym_value(menu);
1066                         gtk_tree_view_expand_row(view, path, TRUE);
1067                 } else if (col == COL_NO || col == COL_MOD
1068                            || col == COL_YES) {
1069                         change_sym_value(menu, col);
1070                         gtk_tree_view_expand_row(view, path, TRUE);
1071                 }
1072         }
1073
1074         return FALSE;
1075 }
1076
1077 /* Key pressed: update choice */
1078 gboolean
1079 on_treeview2_key_press_event(GtkWidget * widget,
1080                              GdkEventKey * event, gpointer user_data)
1081 {
1082         GtkTreeView *view = GTK_TREE_VIEW(widget);
1083         GtkTreePath *path;
1084         GtkTreeViewColumn *column;
1085         GtkTreeIter iter;
1086         struct menu *menu;
1087         gint col;
1088
1089         gtk_tree_view_get_cursor(view, &path, &column);
1090         if (path == NULL)
1091                 return FALSE;
1092
1093         if (event->keyval == GDK_space) {
1094                 if (gtk_tree_view_row_expanded(view, path))
1095                         gtk_tree_view_collapse_row(view, path);
1096                 else
1097                         gtk_tree_view_expand_row(view, path, FALSE);
1098                 return TRUE;
1099         }
1100         if (event->keyval == GDK_KP_Enter) {
1101         }
1102         if (widget == tree1_w)
1103                 return FALSE;
1104
1105         gtk_tree_model_get_iter(model2, &iter, path);
1106         gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1107
1108         if (!strcasecmp(event->string, "n"))
1109                 col = COL_NO;
1110         else if (!strcasecmp(event->string, "m"))
1111                 col = COL_MOD;
1112         else if (!strcasecmp(event->string, "y"))
1113                 col = COL_YES;
1114         else
1115                 col = -1;
1116         change_sym_value(menu, col);
1117
1118         return FALSE;
1119 }
1120
1121
1122 /* Row selection changed: update help */
1123 void
1124 on_treeview2_cursor_changed(GtkTreeView * treeview, gpointer user_data)
1125 {
1126         GtkTreeSelection *selection;
1127         GtkTreeIter iter;
1128         struct menu *menu;
1129
1130         selection = gtk_tree_view_get_selection(treeview);
1131         if (gtk_tree_selection_get_selected(selection, &model2, &iter)) {
1132                 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
1133                 text_insert_help(menu);
1134         }
1135 }
1136
1137
1138 /* User click: display sub-tree in the right frame. */
1139 gboolean
1140 on_treeview1_button_press_event(GtkWidget * widget,
1141                                 GdkEventButton * event, gpointer user_data)
1142 {
1143         GtkTreeView *view = GTK_TREE_VIEW(widget);
1144         GtkTreePath *path;
1145         GtkTreeViewColumn *column;
1146         GtkTreeIter iter;
1147         struct menu *menu;
1148
1149         gint tx = (gint) event->x;
1150         gint ty = (gint) event->y;
1151         gint cx, cy;
1152
1153         gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
1154                                       &cy);
1155         if (path == NULL)
1156                 return FALSE;
1157
1158         gtk_tree_model_get_iter(model1, &iter, path);
1159         gtk_tree_model_get(model1, &iter, COL_MENU, &menu, -1);
1160
1161         if (event->type == GDK_2BUTTON_PRESS) {
1162                 toggle_sym_value(menu);
1163                 current = menu;
1164                 display_tree_part();
1165         } else {
1166                 browsed = menu;
1167                 display_tree_part();
1168         }
1169
1170         gtk_widget_realize(tree2_w);
1171         gtk_tree_view_set_cursor(view, path, NULL, FALSE);
1172         gtk_widget_grab_focus(tree2_w);
1173
1174         return FALSE;
1175 }
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)
1493                     && !(child->flags & MENU_ROOT) && (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)
1524                     || (view_mode == SPLIT_VIEW)) {
1525                         indent++;
1526                         display_tree(child);
1527                         indent--;
1528                 }
1529         }
1530 }
1531
1532 /* Display a part of the tree starting at current node (single/split view) */
1533 static void display_tree_part(void)
1534 {
1535         if (tree2)
1536                 gtk_tree_store_clear(tree2);
1537         if (view_mode == SINGLE_VIEW)
1538                 display_tree(current);
1539         else if (view_mode == SPLIT_VIEW)
1540                 display_tree(browsed);
1541         gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
1542 }
1543
1544 /* Display the list in the left frame (split view) */
1545 static void display_list(void)
1546 {
1547         if (tree1)
1548                 gtk_tree_store_clear(tree1);
1549
1550         tree = tree1;
1551         display_tree(&rootmenu);
1552         gtk_tree_view_expand_all(GTK_TREE_VIEW(tree1_w));
1553         tree = tree2;
1554 }
1555
1556 void fixup_rootmenu(struct menu *menu)
1557 {
1558         struct menu *child;
1559         static int menu_cnt = 0;
1560
1561         menu->flags |= MENU_ROOT;
1562         for (child = menu->list; child; child = child->next) {
1563                 if (child->prompt && child->prompt->type == P_MENU) {
1564                         menu_cnt++;
1565                         fixup_rootmenu(child);
1566                         menu_cnt--;
1567                 } else if (!menu_cnt)
1568                         fixup_rootmenu(child);
1569         }
1570 }
1571
1572
1573 /* Main */
1574 int main(int ac, char *av[])
1575 {
1576         const char *name;
1577         char *env;
1578         gchar *glade_file;
1579
1580 #ifndef LKC_DIRECT_LINK
1581         kconfig_load();
1582 #endif
1583
1584         bindtextdomain(PACKAGE, LOCALEDIR);
1585         bind_textdomain_codeset(PACKAGE, "UTF-8");
1586         textdomain(PACKAGE);
1587
1588         /* GTK stuffs */
1589         gtk_set_locale();
1590         gtk_init(&ac, &av);
1591         glade_init();
1592
1593         //add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
1594         //add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
1595
1596         /* Determine GUI path */
1597         env = getenv(SRCTREE);
1598         if (env)
1599                 glade_file = g_strconcat(env, "/scripts/kconfig/gconf.glade", NULL);
1600         else if (av[0][0] == '/')
1601                 glade_file = g_strconcat(av[0], ".glade", NULL);
1602         else
1603                 glade_file = g_strconcat(g_get_current_dir(), "/", av[0], ".glade", NULL);
1604
1605         /* Load the interface and connect signals */
1606         init_main_window(glade_file);
1607         init_tree_model();
1608         init_left_tree();
1609         init_right_tree();
1610
1611         /* Conf stuffs */
1612         if (ac > 1 && av[1][0] == '-') {
1613                 switch (av[1][1]) {
1614                 case 'a':
1615                         //showAll = 1;
1616                         break;
1617                 case 'h':
1618                 case '?':
1619                         printf("%s <config>\n", av[0]);
1620                         exit(0);
1621                 }
1622                 name = av[2];
1623         } else
1624                 name = av[1];
1625
1626         conf_parse(name);
1627         fixup_rootmenu(&rootmenu);
1628         conf_read(NULL);
1629
1630         switch (view_mode) {
1631         case SINGLE_VIEW:
1632                 display_tree_part();
1633                 break;
1634         case SPLIT_VIEW:
1635                 display_list();
1636                 break;
1637         case FULL_VIEW:
1638                 display_tree(&rootmenu);
1639                 break;
1640         }
1641
1642         gtk_main();
1643
1644         return 0;
1645 }