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