Loading...
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}
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
21enum {
22 SINGLE_VIEW, SPLIT_VIEW, FULL_VIEW
23};
24
25enum {
26 OPT_NORMAL, OPT_ALL, OPT_PROMPT
27};
28
29static gint view_mode = FULL_VIEW;
30static gboolean show_name = TRUE;
31static gboolean show_range = TRUE;
32static gboolean show_value = TRUE;
33static gboolean resizeable = FALSE;
34static int opt_mode = OPT_NORMAL;
35
36GtkWidget *main_wnd = NULL;
37GtkWidget *tree1_w = NULL; // left frame
38GtkWidget *tree2_w = NULL; // right frame
39GtkWidget *text_w = NULL;
40GtkWidget *hpaned = NULL;
41GtkWidget *vpaned = NULL;
42GtkWidget *back_btn = NULL;
43GtkWidget *save_btn = NULL;
44GtkWidget *save_menu_item = NULL;
45
46GtkTextTag *tag1, *tag2;
47GdkColor color;
48
49GtkTreeStore *tree1, *tree2, *tree;
50GtkTreeModel *model1, *model2;
51static GtkTreeIter *parents[256];
52static gint indent;
53
54static struct menu *current; // current node for SINGLE view
55static struct menu *browsed; // browsed node for SPLIT view
56
57enum {
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
64static void display_list(void);
65static void display_tree(struct menu *menu);
66static void display_tree_part(void);
67static void update_tree(struct menu *src, GtkTreeIter * dst);
68
69static 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
87static 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 */
94static 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
156static 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
186static 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
224static void renderer_edited(GtkCellRendererText * cell,
225 const gchar * path_string,
226 const gchar * new_text, gpointer user_data);
227
228static 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
330static 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
355static 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
378void on_save_activate(GtkMenuItem * menuitem, gpointer user_data);
379gboolean 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
424void on_window1_destroy(GtkObject * object, gpointer user_data)
425{
426 gtk_main_quit();
427}
428
429
430void
431on_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
453static void
454load_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
467void 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
487void 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
495static void
496store_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
509void 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
529void 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
536void 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
547void 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
565void 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
576void
577on_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
585void
586on_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
594void
595on_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
603void 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
631void 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
649void 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
668void 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
683void on_load_clicked(GtkButton * button, gpointer user_data)
684{
685 on_load1_activate(NULL, user_data);
686}
687
688
689void 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
698void 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
714void 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
725void on_collapse_clicked(GtkButton * button, gpointer user_data)
726{
727 gtk_tree_view_collapse_all(GTK_TREE_VIEW(tree2_w));
728}
729
730
731void 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 */
740static 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 */
767static 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
807static 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
823static 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) */
840gboolean
841on_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 */
897gboolean
898on_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 */
942void
943on_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. */
958gboolean
959on_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 */
998static 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 */
1123static 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 */
1159static 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 */
1170static GtkTreeIter found;
1171
1172/*
1173 * Find a menu in the GtkTree starting at parent.
1174 */
1175static 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 */
1209static 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) */
1289static 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) */
1343static 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) */
1357static 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
1368static 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 */
1386int 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}