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