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