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