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