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, FALSE); 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, FALSE); 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_paned_set_position(GTK_PANED(hpaned), 0); 760 gtk_widget_hide(tree1_w); 761 current = &rootmenu; 762 display_tree_part(); 763 } 764 765 766 void on_split_clicked(GtkButton * button, gpointer user_data) 767 { 768 gint w, h; 769 view_mode = SPLIT_VIEW; 770 gtk_widget_show(tree1_w); 771 gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h); 772 gtk_paned_set_position(GTK_PANED(hpaned), w / 2); 773 if (tree2) 774 gtk_tree_store_clear(tree2); 775 display_list(); 776 777 /* Disable back btn, like in full mode. */ 778 gtk_widget_set_sensitive(back_btn, FALSE); 779 } 780 781 782 void on_full_clicked(GtkButton * button, gpointer user_data) 783 { 784 view_mode = FULL_VIEW; 785 gtk_paned_set_position(GTK_PANED(hpaned), 0); 786 gtk_widget_hide(tree1_w); 787 if (tree2) 788 gtk_tree_store_clear(tree2); 789 display_tree(&rootmenu); 790 gtk_widget_set_sensitive(back_btn, FALSE); 791 } 792 793 794 void on_collapse_clicked(GtkButton * button, gpointer user_data) 795 { 796 gtk_tree_view_collapse_all(GTK_TREE_VIEW(tree2_w)); 797 } 798 799 800 void on_expand_clicked(GtkButton * button, gpointer user_data) 801 { 802 gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w)); 803 } 804 805 806 /* CTree Callbacks */ 807 808 /* Change hex/int/string value in the cell */ 809 static void renderer_edited(GtkCellRendererText * cell, 810 const gchar * path_string, 811 const gchar * new_text, gpointer user_data) 812 { 813 GtkTreePath *path = gtk_tree_path_new_from_string(path_string); 814 GtkTreeIter iter; 815 const char *old_def, *new_def; 816 struct menu *menu; 817 struct symbol *sym; 818 819 if (!gtk_tree_model_get_iter(model2, &iter, path)) 820 return; 821 822 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1); 823 sym = menu->sym; 824 825 gtk_tree_model_get(model2, &iter, COL_VALUE, &old_def, -1); 826 new_def = new_text; 827 828 sym_set_string_value(sym, new_def); 829 830 update_tree(&rootmenu, NULL); 831 832 gtk_tree_path_free(path); 833 } 834 835 /* Change the value of a symbol and update the tree */ 836 static void change_sym_value(struct menu *menu, gint col) 837 { 838 struct symbol *sym = menu->sym; 839 tristate oldval, newval; 840 841 if (!sym) 842 return; 843 844 if (col == COL_NO) 845 newval = no; 846 else if (col == COL_MOD) 847 newval = mod; 848 else if (col == COL_YES) 849 newval = yes; 850 else 851 return; 852 853 switch (sym_get_type(sym)) { 854 case S_BOOLEAN: 855 case S_TRISTATE: 856 oldval = sym_get_tristate_value(sym); 857 if (!sym_tristate_within_range(sym, newval)) 858 newval = yes; 859 sym_set_tristate_value(sym, newval); 860 if (view_mode == FULL_VIEW) 861 update_tree(&rootmenu, NULL); 862 else if (view_mode == SPLIT_VIEW) { 863 update_tree(browsed, NULL); 864 display_list(); 865 } 866 else if (view_mode == SINGLE_VIEW) 867 display_tree_part(); //fixme: keep exp/coll 868 break; 869 case S_INT: 870 case S_HEX: 871 case S_STRING: 872 default: 873 break; 874 } 875 } 876 877 static void toggle_sym_value(struct menu *menu) 878 { 879 if (!menu->sym) 880 return; 881 882 sym_toggle_tristate_value(menu->sym); 883 if (view_mode == FULL_VIEW) 884 update_tree(&rootmenu, NULL); 885 else if (view_mode == SPLIT_VIEW) { 886 update_tree(browsed, NULL); 887 display_list(); 888 } 889 else if (view_mode == SINGLE_VIEW) 890 display_tree_part(); //fixme: keep exp/coll 891 } 892 893 static void renderer_toggled(GtkCellRendererToggle * cell, 894 gchar * path_string, gpointer user_data) 895 { 896 GtkTreePath *path, *sel_path = NULL; 897 GtkTreeIter iter, sel_iter; 898 GtkTreeSelection *sel; 899 struct menu *menu; 900 901 path = gtk_tree_path_new_from_string(path_string); 902 if (!gtk_tree_model_get_iter(model2, &iter, path)) 903 return; 904 905 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree2_w)); 906 if (gtk_tree_selection_get_selected(sel, NULL, &sel_iter)) 907 sel_path = gtk_tree_model_get_path(model2, &sel_iter); 908 if (!sel_path) 909 goto out1; 910 if (gtk_tree_path_compare(path, sel_path)) 911 goto out2; 912 913 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1); 914 toggle_sym_value(menu); 915 916 out2: 917 gtk_tree_path_free(sel_path); 918 out1: 919 gtk_tree_path_free(path); 920 } 921 922 static gint column2index(GtkTreeViewColumn * column) 923 { 924 gint i; 925 926 for (i = 0; i < COL_NUMBER; i++) { 927 GtkTreeViewColumn *col; 928 929 col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), i); 930 if (col == column) 931 return i; 932 } 933 934 return -1; 935 } 936 937 938 /* User click: update choice (full) or goes down (single) */ 939 gboolean 940 on_treeview2_button_press_event(GtkWidget * widget, 941 GdkEventButton * event, gpointer user_data) 942 { 943 GtkTreeView *view = GTK_TREE_VIEW(widget); 944 GtkTreePath *path; 945 GtkTreeViewColumn *column; 946 GtkTreeIter iter; 947 struct menu *menu; 948 gint col; 949 950 #if GTK_CHECK_VERSION(2,1,4) // bug in ctree with earlier version of GTK 951 gint tx = (gint) event->x; 952 gint ty = (gint) event->y; 953 gint cx, cy; 954 955 gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx, 956 &cy); 957 #else 958 gtk_tree_view_get_cursor(view, &path, &column); 959 #endif 960 if (path == NULL) 961 return FALSE; 962 963 if (!gtk_tree_model_get_iter(model2, &iter, path)) 964 return FALSE; 965 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1); 966 967 col = column2index(column); 968 if (event->type == GDK_2BUTTON_PRESS) { 969 enum prop_type ptype; 970 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN; 971 972 if (ptype == P_MENU && view_mode != FULL_VIEW && col == COL_OPTION) { 973 // goes down into menu 974 current = menu; 975 display_tree_part(); 976 gtk_widget_set_sensitive(back_btn, TRUE); 977 } else if ((col == COL_OPTION)) { 978 toggle_sym_value(menu); 979 gtk_tree_view_expand_row(view, path, TRUE); 980 } 981 } else { 982 if (col == COL_VALUE) { 983 toggle_sym_value(menu); 984 gtk_tree_view_expand_row(view, path, TRUE); 985 } else if (col == COL_NO || col == COL_MOD 986 || col == COL_YES) { 987 change_sym_value(menu, col); 988 gtk_tree_view_expand_row(view, path, TRUE); 989 } 990 } 991 992 return FALSE; 993 } 994 995 /* Key pressed: update choice */ 996 gboolean 997 on_treeview2_key_press_event(GtkWidget * widget, 998 GdkEventKey * 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 gint col; 1006 1007 gtk_tree_view_get_cursor(view, &path, &column); 1008 if (path == NULL) 1009 return FALSE; 1010 1011 if (event->keyval == GDK_space) { 1012 if (gtk_tree_view_row_expanded(view, path)) 1013 gtk_tree_view_collapse_row(view, path); 1014 else 1015 gtk_tree_view_expand_row(view, path, FALSE); 1016 return TRUE; 1017 } 1018 if (event->keyval == GDK_KP_Enter) { 1019 } 1020 if (widget == tree1_w) 1021 return FALSE; 1022 1023 gtk_tree_model_get_iter(model2, &iter, path); 1024 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1); 1025 1026 if (!strcasecmp(event->string, "n")) 1027 col = COL_NO; 1028 else if (!strcasecmp(event->string, "m")) 1029 col = COL_MOD; 1030 else if (!strcasecmp(event->string, "y")) 1031 col = COL_YES; 1032 else 1033 col = -1; 1034 change_sym_value(menu, col); 1035 1036 return FALSE; 1037 } 1038 1039 1040 /* Row selection changed: update help */ 1041 void 1042 on_treeview2_cursor_changed(GtkTreeView * treeview, gpointer user_data) 1043 { 1044 GtkTreeSelection *selection; 1045 GtkTreeIter iter; 1046 struct menu *menu; 1047 1048 selection = gtk_tree_view_get_selection(treeview); 1049 if (gtk_tree_selection_get_selected(selection, &model2, &iter)) { 1050 gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1); 1051 text_insert_help(menu); 1052 } 1053 } 1054 1055 1056 /* User click: display sub-tree in the right frame. */ 1057 gboolean 1058 on_treeview1_button_press_event(GtkWidget * widget, 1059 GdkEventButton * event, gpointer user_data) 1060 { 1061 GtkTreeView *view = GTK_TREE_VIEW(widget); 1062 GtkTreePath *path; 1063 GtkTreeViewColumn *column; 1064 GtkTreeIter iter; 1065 struct menu *menu; 1066 1067 gint tx = (gint) event->x; 1068 gint ty = (gint) event->y; 1069 gint cx, cy; 1070 1071 gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx, 1072 &cy); 1073 if (path == NULL) 1074 return FALSE; 1075 1076 gtk_tree_model_get_iter(model1, &iter, path); 1077 gtk_tree_model_get(model1, &iter, COL_MENU, &menu, -1); 1078 1079 if (event->type == GDK_2BUTTON_PRESS) { 1080 toggle_sym_value(menu); 1081 current = menu; 1082 display_tree_part(); 1083 } else { 1084 browsed = menu; 1085 display_tree_part(); 1086 } 1087 1088 gtk_widget_realize(tree2_w); 1089 gtk_tree_view_set_cursor(view, path, NULL, FALSE); 1090 gtk_widget_grab_focus(tree2_w); 1091 1092 return FALSE; 1093 } 1094 1095 1096 /* Fill a row of strings */ 1097 static gchar **fill_row(struct menu *menu) 1098 { 1099 static gchar *row[COL_NUMBER]; 1100 struct symbol *sym = menu->sym; 1101 const char *def; 1102 int stype; 1103 tristate val; 1104 enum prop_type ptype; 1105 int i; 1106 1107 for (i = COL_OPTION; i <= COL_COLOR; i++) 1108 g_free(row[i]); 1109 bzero(row, sizeof(row)); 1110 1111 row[COL_OPTION] = 1112 g_strdup_printf("%s %s", _(menu_get_prompt(menu)), 1113 sym && !sym_has_value(sym) ? "(NEW)" : ""); 1114 1115 if (opt_mode == OPT_ALL && !menu_is_visible(menu)) 1116 row[COL_COLOR] = g_strdup("DarkGray"); 1117 else if (opt_mode == OPT_PROMPT && 1118 menu_has_prompt(menu) && !menu_is_visible(menu)) 1119 row[COL_COLOR] = g_strdup("DarkGray"); 1120 else 1121 row[COL_COLOR] = g_strdup("Black"); 1122 1123 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN; 1124 switch (ptype) { 1125 case P_MENU: 1126 row[COL_PIXBUF] = (gchar *) xpm_menu; 1127 if (view_mode == SINGLE_VIEW) 1128 row[COL_PIXVIS] = GINT_TO_POINTER(TRUE); 1129 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE); 1130 break; 1131 case P_COMMENT: 1132 row[COL_PIXBUF] = (gchar *) xpm_void; 1133 row[COL_PIXVIS] = GINT_TO_POINTER(FALSE); 1134 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE); 1135 break; 1136 default: 1137 row[COL_PIXBUF] = (gchar *) xpm_void; 1138 row[COL_PIXVIS] = GINT_TO_POINTER(FALSE); 1139 row[COL_BTNVIS] = GINT_TO_POINTER(TRUE); 1140 break; 1141 } 1142 1143 if (!sym) 1144 return row; 1145 row[COL_NAME] = g_strdup(sym->name); 1146 1147 sym_calc_value(sym); 1148 sym->flags &= ~SYMBOL_CHANGED; 1149 1150 if (sym_is_choice(sym)) { // parse childs for getting final value 1151 struct menu *child; 1152 struct symbol *def_sym = sym_get_choice_value(sym); 1153 struct menu *def_menu = NULL; 1154 1155 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE); 1156 1157 for (child = menu->list; child; child = child->next) { 1158 if (menu_is_visible(child) 1159 && child->sym == def_sym) 1160 def_menu = child; 1161 } 1162 1163 if (def_menu) 1164 row[COL_VALUE] = 1165 g_strdup(_(menu_get_prompt(def_menu))); 1166 } 1167 if (sym->flags & SYMBOL_CHOICEVAL) 1168 row[COL_BTNRAD] = GINT_TO_POINTER(TRUE); 1169 1170 stype = sym_get_type(sym); 1171 switch (stype) { 1172 case S_BOOLEAN: 1173 if (GPOINTER_TO_INT(row[COL_PIXVIS]) == FALSE) 1174 row[COL_BTNVIS] = GINT_TO_POINTER(TRUE); 1175 if (sym_is_choice(sym)) 1176 break; 1177 case S_TRISTATE: 1178 val = sym_get_tristate_value(sym); 1179 switch (val) { 1180 case no: 1181 row[COL_NO] = g_strdup("N"); 1182 row[COL_VALUE] = g_strdup("N"); 1183 row[COL_BTNACT] = GINT_TO_POINTER(FALSE); 1184 row[COL_BTNINC] = GINT_TO_POINTER(FALSE); 1185 break; 1186 case mod: 1187 row[COL_MOD] = g_strdup("M"); 1188 row[COL_VALUE] = g_strdup("M"); 1189 row[COL_BTNINC] = GINT_TO_POINTER(TRUE); 1190 break; 1191 case yes: 1192 row[COL_YES] = g_strdup("Y"); 1193 row[COL_VALUE] = g_strdup("Y"); 1194 row[COL_BTNACT] = GINT_TO_POINTER(TRUE); 1195 row[COL_BTNINC] = GINT_TO_POINTER(FALSE); 1196 break; 1197 } 1198 1199 if (val != no && sym_tristate_within_range(sym, no)) 1200 row[COL_NO] = g_strdup("_"); 1201 if (val != mod && sym_tristate_within_range(sym, mod)) 1202 row[COL_MOD] = g_strdup("_"); 1203 if (val != yes && sym_tristate_within_range(sym, yes)) 1204 row[COL_YES] = g_strdup("_"); 1205 break; 1206 case S_INT: 1207 case S_HEX: 1208 case S_STRING: 1209 def = sym_get_string_value(sym); 1210 row[COL_VALUE] = g_strdup(def); 1211 row[COL_EDIT] = GINT_TO_POINTER(TRUE); 1212 row[COL_BTNVIS] = GINT_TO_POINTER(FALSE); 1213 break; 1214 } 1215 1216 return row; 1217 } 1218 1219 1220 /* Set the node content with a row of strings */ 1221 static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row) 1222 { 1223 GdkColor color; 1224 gboolean success; 1225 GdkPixbuf *pix; 1226 1227 pix = gdk_pixbuf_new_from_xpm_data((const char **) 1228 row[COL_PIXBUF]); 1229 1230 gdk_color_parse(row[COL_COLOR], &color); 1231 gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1, 1232 FALSE, FALSE, &success); 1233 1234 gtk_tree_store_set(tree, node, 1235 COL_OPTION, row[COL_OPTION], 1236 COL_NAME, row[COL_NAME], 1237 COL_NO, row[COL_NO], 1238 COL_MOD, row[COL_MOD], 1239 COL_YES, row[COL_YES], 1240 COL_VALUE, row[COL_VALUE], 1241 COL_MENU, (gpointer) menu, 1242 COL_COLOR, &color, 1243 COL_EDIT, GPOINTER_TO_INT(row[COL_EDIT]), 1244 COL_PIXBUF, pix, 1245 COL_PIXVIS, GPOINTER_TO_INT(row[COL_PIXVIS]), 1246 COL_BTNVIS, GPOINTER_TO_INT(row[COL_BTNVIS]), 1247 COL_BTNACT, GPOINTER_TO_INT(row[COL_BTNACT]), 1248 COL_BTNINC, GPOINTER_TO_INT(row[COL_BTNINC]), 1249 COL_BTNRAD, GPOINTER_TO_INT(row[COL_BTNRAD]), 1250 -1); 1251 1252 g_object_unref(pix); 1253 } 1254 1255 1256 /* Add a node to the tree */ 1257 static void place_node(struct menu *menu, char **row) 1258 { 1259 GtkTreeIter *parent = parents[indent - 1]; 1260 GtkTreeIter *node = parents[indent]; 1261 1262 gtk_tree_store_append(tree, node, parent); 1263 set_node(node, menu, row); 1264 } 1265 1266 1267 /* Find a node in the GTK+ tree */ 1268 static GtkTreeIter found; 1269 1270 /* 1271 * Find a menu in the GtkTree starting at parent. 1272 */ 1273 GtkTreeIter *gtktree_iter_find_node(GtkTreeIter * parent, 1274 struct menu *tofind) 1275 { 1276 GtkTreeIter iter; 1277 GtkTreeIter *child = &iter; 1278 gboolean valid; 1279 GtkTreeIter *ret; 1280 1281 valid = gtk_tree_model_iter_children(model2, child, parent); 1282 while (valid) { 1283 struct menu *menu; 1284 1285 gtk_tree_model_get(model2, child, 6, &menu, -1); 1286 1287 if (menu == tofind) { 1288 memcpy(&found, child, sizeof(GtkTreeIter)); 1289 return &found; 1290 } 1291 1292 ret = gtktree_iter_find_node(child, tofind); 1293 if (ret) 1294 return ret; 1295 1296 valid = gtk_tree_model_iter_next(model2, child); 1297 } 1298 1299 return NULL; 1300 } 1301 1302 1303 /* 1304 * Update the tree by adding/removing entries 1305 * Does not change other nodes 1306 */ 1307 static void update_tree(struct menu *src, GtkTreeIter * dst) 1308 { 1309 struct menu *child1; 1310 GtkTreeIter iter, tmp; 1311 GtkTreeIter *child2 = &iter; 1312 gboolean valid; 1313 GtkTreeIter *sibling; 1314 struct symbol *sym; 1315 struct property *prop; 1316 struct menu *menu1, *menu2; 1317 1318 if (src == &rootmenu) 1319 indent = 1; 1320 1321 valid = gtk_tree_model_iter_children(model2, child2, dst); 1322 for (child1 = src->list; child1; child1 = child1->next) { 1323 1324 prop = child1->prompt; 1325 sym = child1->sym; 1326 1327 reparse: 1328 menu1 = child1; 1329 if (valid) 1330 gtk_tree_model_get(model2, child2, COL_MENU, 1331 &menu2, -1); 1332 else 1333 menu2 = NULL; // force adding of a first child 1334 1335 #ifdef DEBUG 1336 printf("%*c%s | %s\n", indent, ' ', 1337 menu1 ? menu_get_prompt(menu1) : "nil", 1338 menu2 ? menu_get_prompt(menu2) : "nil"); 1339 #endif 1340 1341 if ((opt_mode == OPT_NORMAL && !menu_is_visible(child1)) || 1342 (opt_mode == OPT_PROMPT && !menu_has_prompt(child1)) || 1343 (opt_mode == OPT_ALL && !menu_get_prompt(child1))) { 1344 1345 /* remove node */ 1346 if (gtktree_iter_find_node(dst, menu1) != NULL) { 1347 memcpy(&tmp, child2, sizeof(GtkTreeIter)); 1348 valid = gtk_tree_model_iter_next(model2, 1349 child2); 1350 gtk_tree_store_remove(tree2, &tmp); 1351 if (!valid) 1352 return; /* next parent */ 1353 else 1354 goto reparse; /* next child */ 1355 } else 1356 continue; 1357 } 1358 1359 if (menu1 != menu2) { 1360 if (gtktree_iter_find_node(dst, menu1) == NULL) { // add node 1361 if (!valid && !menu2) 1362 sibling = NULL; 1363 else 1364 sibling = child2; 1365 gtk_tree_store_insert_before(tree2, 1366 child2, 1367 dst, sibling); 1368 set_node(child2, menu1, fill_row(menu1)); 1369 if (menu2 == NULL) 1370 valid = TRUE; 1371 } else { // remove node 1372 memcpy(&tmp, child2, sizeof(GtkTreeIter)); 1373 valid = gtk_tree_model_iter_next(model2, 1374 child2); 1375 gtk_tree_store_remove(tree2, &tmp); 1376 if (!valid) 1377 return; // next parent 1378 else 1379 goto reparse; // next child 1380 } 1381 } else if (sym && (sym->flags & SYMBOL_CHANGED)) { 1382 set_node(child2, menu1, fill_row(menu1)); 1383 } 1384 1385 indent++; 1386 update_tree(child1, child2); 1387 indent--; 1388 1389 valid = gtk_tree_model_iter_next(model2, child2); 1390 } 1391 } 1392 1393 1394 /* Display the whole tree (single/split/full view) */ 1395 static void display_tree(struct menu *menu) 1396 { 1397 struct symbol *sym; 1398 struct property *prop; 1399 struct menu *child; 1400 enum prop_type ptype; 1401 1402 if (menu == &rootmenu) { 1403 indent = 1; 1404 current = &rootmenu; 1405 } 1406 1407 for (child = menu->list; child; child = child->next) { 1408 prop = child->prompt; 1409 sym = child->sym; 1410 ptype = prop ? prop->type : P_UNKNOWN; 1411 1412 if (sym) 1413 sym->flags &= ~SYMBOL_CHANGED; 1414 1415 if ((view_mode == SPLIT_VIEW) 1416 && !(child->flags & MENU_ROOT) && (tree == tree1)) 1417 continue; 1418 1419 if ((view_mode == SPLIT_VIEW) && (child->flags & MENU_ROOT) 1420 && (tree == tree2)) 1421 continue; 1422 1423 if ((opt_mode == OPT_NORMAL && menu_is_visible(child)) || 1424 (opt_mode == OPT_PROMPT && menu_has_prompt(child)) || 1425 (opt_mode == OPT_ALL && menu_get_prompt(child))) 1426 place_node(child, fill_row(child)); 1427 #ifdef DEBUG 1428 printf("%*c%s: ", indent, ' ', menu_get_prompt(child)); 1429 printf("%s", child->flags & MENU_ROOT ? "rootmenu | " : ""); 1430 printf("%s", prop_get_type_name(ptype)); 1431 printf(" | "); 1432 if (sym) { 1433 printf("%s", sym_type_name(sym->type)); 1434 printf(" | "); 1435 printf("%s", dbg_sym_flags(sym->flags)); 1436 printf("\n"); 1437 } else 1438 printf("\n"); 1439 #endif 1440 if ((view_mode != FULL_VIEW) && (ptype == P_MENU) 1441 && (tree == tree2)) 1442 continue; 1443 /* 1444 if (((menu != &rootmenu) && !(menu->flags & MENU_ROOT)) 1445 || (view_mode == FULL_VIEW) 1446 || (view_mode == SPLIT_VIEW))*/ 1447 if (((view_mode == SINGLE_VIEW) && (menu->flags & MENU_ROOT)) 1448 || (view_mode == FULL_VIEW) 1449 || (view_mode == SPLIT_VIEW)) { 1450 indent++; 1451 display_tree(child); 1452 indent--; 1453 } 1454 } 1455 } 1456 1457 /* Display a part of the tree starting at current node (single/split view) */ 1458 static void display_tree_part(void) 1459 { 1460 if (tree2) 1461 gtk_tree_store_clear(tree2); 1462 if (view_mode == SINGLE_VIEW) 1463 display_tree(current); 1464 else if (view_mode == SPLIT_VIEW) 1465 display_tree(browsed); 1466 gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w)); 1467 } 1468 1469 /* Display the list in the left frame (split view) */ 1470 static void display_list(void) 1471 { 1472 if (tree1) 1473 gtk_tree_store_clear(tree1); 1474 1475 tree = tree1; 1476 display_tree(&rootmenu); 1477 gtk_tree_view_expand_all(GTK_TREE_VIEW(tree1_w)); 1478 tree = tree2; 1479 } 1480 1481 void fixup_rootmenu(struct menu *menu) 1482 { 1483 struct menu *child; 1484 static int menu_cnt = 0; 1485 1486 menu->flags |= MENU_ROOT; 1487 for (child = menu->list; child; child = child->next) { 1488 if (child->prompt && child->prompt->type == P_MENU) { 1489 menu_cnt++; 1490 fixup_rootmenu(child); 1491 menu_cnt--; 1492 } else if (!menu_cnt) 1493 fixup_rootmenu(child); 1494 } 1495 } 1496 1497 1498 /* Main */ 1499 int main(int ac, char *av[]) 1500 { 1501 const char *name; 1502 char *env; 1503 gchar *glade_file; 1504 1505 #ifndef LKC_DIRECT_LINK 1506 kconfig_load(); 1507 #endif 1508 1509 bindtextdomain(PACKAGE, LOCALEDIR); 1510 bind_textdomain_codeset(PACKAGE, "UTF-8"); 1511 textdomain(PACKAGE); 1512 1513 /* GTK stuffs */ 1514 gtk_set_locale(); 1515 gtk_init(&ac, &av); 1516 glade_init(); 1517 1518 //add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps"); 1519 //add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps"); 1520 1521 /* Determine GUI path */ 1522 env = getenv(SRCTREE); 1523 if (env) 1524 glade_file = g_strconcat(env, "/scripts/kconfig/gconf.glade", NULL); 1525 else if (av[0][0] == '/') 1526 glade_file = g_strconcat(av[0], ".glade", NULL); 1527 else 1528 glade_file = g_strconcat(g_get_current_dir(), "/", av[0], ".glade", NULL); 1529 1530 /* Conf stuffs */ 1531 if (ac > 1 && av[1][0] == '-') { 1532 switch (av[1][1]) { 1533 case 'a': 1534 //showAll = 1; 1535 break; 1536 case 'h': 1537 case '?': 1538 printf("%s <config>\n", av[0]); 1539 exit(0); 1540 } 1541 name = av[2]; 1542 } else 1543 name = av[1]; 1544 1545 conf_parse(name); 1546 fixup_rootmenu(&rootmenu); 1547 conf_read(NULL); 1548 1549 /* Load the interface and connect signals */ 1550 init_main_window(glade_file); 1551 init_tree_model(); 1552 init_left_tree(); 1553 init_right_tree(); 1554 1555 switch (view_mode) { 1556 case SINGLE_VIEW: 1557 display_tree_part(); 1558 break; 1559 case SPLIT_VIEW: 1560 display_list(); 1561 break; 1562 case FULL_VIEW: 1563 display_tree(&rootmenu); 1564 break; 1565 } 1566 1567 gtk_main(); 1568 1569 return 0; 1570 } 1571 1572 static void conf_changed(void) 1573 { 1574 bool changed = conf_get_changed(); 1575 gtk_widget_set_sensitive(save_btn, changed); 1576 gtk_widget_set_sensitive(save_menu_item, changed); 1577 } 1578