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