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