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