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