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