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