← Back to branch summary

~ubuntu-branches/ubuntu/precise/hardinfo/precise

« back to all changes in this revision

Viewing changes to shell.c

  • Committer: Bazaar Package Importer
  • Author(s): Agney Lopes Roth Ferraz
  • Date: 2009-03-28 22:55:02 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090328225502-p4bnvi8q6hr95cij
Tags: 0.5c-1
http://bugs.debian.org/517591
http://bugs.debian.org/511237
http://bugs.debian.org/457703
http://bugs.debian.org/519256
http://bugs.debian.org/449250
http://bugs.debian.org/457820
http://bugs.debian.org/497758
New upstream version. 
(Closes: #517591, #511237, #457703, #519256, #449250, #457820, #497758) 

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell.c
1
1
/*
2
2
 *    HardInfo - Displays System Information
3
 
 *    Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@linuxmag.com.br>
 
3
 *    Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org>
4
4
 *
5
5
 *    This program is free software; you can redistribute it and/or modify
6
6
 *    it under the terms of the GNU General Public License as published by
197
197
void shell_status_pulse(void)
198
198
{
199
199
    if (params.gui_running) {
200
 
        if (shell->_pulses++ == 20) {
 
200
        if (shell->_pulses++ == 5) {
201
201
            /* we're pulsing for some time, disable the interface and change the cursor
202
202
               to a hourglass */
203
203
            shell_view_set_enabled(FALSE);
252
252
    shell_action_set_enabled("RefreshAction", setting);
253
253
    shell_action_set_enabled("CopyAction", setting);
254
254
    shell_action_set_enabled("ReportAction", setting);
255
 
    shell_action_set_enabled("SyncManagerAction", setting);
 
255
    shell_action_set_enabled("SyncManagerAction", setting && sync_manager_count_entries() > 0);
256
256
    shell_action_set_enabled("SaveGraphAction",
257
257
                             setting ? shell->view_type ==
258
258
                             SHELL_VIEW_PROGRESS : FALSE);
355
355
    gtk_window_set_icon(GTK_WINDOW(shell->window),
356
356
                        icon_cache_get_pixbuf("logo.png"));
357
357
    gtk_window_set_title(GTK_WINDOW(shell->window), "System Information");
358
 
    gtk_widget_set_size_request(shell->window, 600, 400);
 
358
    gtk_window_set_default_size(GTK_WINDOW(shell->window), 800, 600);
359
359
    g_signal_connect(G_OBJECT(shell->window), "destroy", destroy_me, NULL);
360
360
 
361
361
    vbox = gtk_vbox_new(FALSE, 0);
485
485
    ShellModule *module = (ShellModule *) data;
486
486
    GtkTreeStore *store = GTK_TREE_STORE(shelltree->model);
487
487
    GtkTreeIter parent;
 
488
    
 
489
    if (!module) {
 
490
        return;
 
491
    }
488
492
 
489
493
    gtk_tree_store_append(store, &parent, NULL);
490
494
    gtk_tree_store_set(store, &parent, TREE_COL_NAME, module->name,
604
608
    fu = (ShellFieldUpdate *) data;
605
609
    g_return_val_if_fail(fu != NULL, FALSE);
606
610
    
 
611
    DEBUG("update_field [%s]", fu->field_name);
 
612
    
607
613
    iter = g_hash_table_lookup(update_tbl, fu->field_name);
608
614
    g_return_val_if_fail(iter != NULL, FALSE);
609
 
 
 
615
    
610
616
    /* if the entry is still selected, update it */
611
617
    if (iter && fu->entry->selected && fu->entry->fieldfunc) {
612
618
        GtkTreeStore *store = GTK_TREE_STORE(shell->info->model);
639
645
        update_sfusrc = NULL;
640
646
    }
641
647
 
642
 
    DEBUG("destroying ShellFieldUpdate for field %s", fu->field_name);
643
 
 
644
648
    /* otherwise, cleanup and destroy the timeout */
645
649
    g_free(fu->field_name);
646
650
    g_free(fu);
648
652
    return FALSE;
649
653
}
650
654
 
 
655
#define RANGE_SET_VALUE(tree,scrollbar,value) \
 
656
          gtk_range_set_value(GTK_RANGE \
 
657
                            (GTK_SCROLLED_WINDOW(shell->tree->scroll)-> \
 
658
                             scrollbar), value);
 
659
 
651
660
static gboolean reload_section(gpointer data)
652
661
{
653
662
    ShellModuleEntry *entry = (ShellModuleEntry *) data;
657
666
        GtkTreePath *path = NULL;
658
667
        GtkTreeIter iter;
659
668
 
 
669
        /* avoid drawing the window while we reload */
 
670
        gdk_window_freeze_updates(shell->window->window);
 
671
        
660
672
        /* gets the current selected path */
661
673
        if (gtk_tree_selection_get_selected
662
 
            (shell->info->selection, &shell->info->model, &iter))
 
674
            (shell->info->selection, &shell->info->model, &iter)) {
663
675
            path = gtk_tree_model_get_path(shell->info->model, &iter);
 
676
        }
664
677
 
665
678
        /* update the information, clear the treeview and populate it again */
666
679
        module_entry_reload(entry);
670
683
        /* if there was a selection, reselect it */
671
684
        if (path) {
672
685
            gtk_tree_selection_select_path(shell->info->selection, path);
 
686
            gtk_tree_view_set_cursor(GTK_TREE_VIEW(shell->info->view), path, NULL,
 
687
                                     FALSE);
673
688
            gtk_tree_path_free(path);
674
689
        }
 
690
        
 
691
        /* make the window drawable again */
 
692
        gdk_window_thaw_updates(shell->window->window);
675
693
    }
676
694
 
677
695
    /* destroy the timeout: it'll be set up again */
714
732
    return ret;
715
733
}
716
734
 
717
 
static void set_view_type(ShellViewType viewtype)
 
735
static void set_view_type(ShellViewType viewtype, gboolean reload)
718
736
{
 
737
    if (viewtype < SHELL_VIEW_NORMAL || viewtype >= SHELL_VIEW_N_VIEWS)
 
738
        viewtype = SHELL_VIEW_NORMAL;
 
739
 
 
740
    shell->normalize_percentage = TRUE;
 
741
    shell->view_type = viewtype;
 
742
 
719
743
    /* reset to the default model */
720
744
    gtk_tree_view_set_model(GTK_TREE_VIEW(shell->info->view),
721
745
                            shell->info->model);
722
746
 
723
747
    /* reset to the default view columns */
724
 
    gtk_tree_view_column_set_visible(shell->info->col_progress, FALSE);
725
 
    gtk_tree_view_column_set_visible(shell->info->col_value, TRUE);
726
 
 
 
748
    if (!reload) {
 
749
      gtk_tree_view_column_set_visible(shell->info->col_extra1, FALSE);
 
750
      gtk_tree_view_column_set_visible(shell->info->col_extra2, FALSE);
 
751
      gtk_tree_view_column_set_visible(shell->info->col_progress, FALSE);
 
752
      gtk_tree_view_column_set_visible(shell->info->col_value, TRUE);
 
753
    }
 
754
    
727
755
    /* turn off the rules hint */
728
756
    gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(shell->info->view), FALSE);
729
757
 
730
758
    /* turn off the save graphic action */
731
759
    shell_action_set_enabled("SaveGraphAction", FALSE);
732
760
 
733
 
    if (viewtype == shell->view_type)
734
 
        return;
735
 
 
736
 
    if (viewtype < SHELL_VIEW_NORMAL || viewtype >= SHELL_VIEW_N_VIEWS)
737
 
        viewtype = SHELL_VIEW_NORMAL;
738
 
 
739
 
    shell->view_type = viewtype;
740
 
 
741
761
    switch (viewtype) {
742
762
    default:
743
763
    case SHELL_VIEW_NORMAL:
744
764
        gtk_widget_hide(shell->notebook);
 
765
        
 
766
        if (!reload) {
 
767
          gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(shell->info->view), FALSE);
 
768
        }
745
769
        break;
746
770
    case SHELL_VIEW_DUAL:
747
771
        gtk_notebook_set_page(GTK_NOTEBOOK(shell->notebook), 0);
756
780
                               shell->hpaned->allocation.height -
757
781
                               shell->loadgraph->height - 16);
758
782
        break;
 
783
    case SHELL_VIEW_PROGRESS_DUAL:
 
784
        gtk_notebook_set_page(GTK_NOTEBOOK(shell->notebook), 0);
 
785
        gtk_widget_show(shell->notebook);
 
786
        /* fallthrough */
759
787
    case SHELL_VIEW_PROGRESS:
760
788
        shell_action_set_enabled("SaveGraphAction", TRUE);
761
 
        gtk_tree_view_column_set_visible(shell->info->col_progress, TRUE);
762
 
        gtk_tree_view_column_set_visible(shell->info->col_value, FALSE);
763
 
        gtk_widget_hide(shell->notebook);
 
789
        
 
790
        if (!reload) {
 
791
          gtk_tree_view_column_set_visible(shell->info->col_progress, TRUE);
 
792
          gtk_tree_view_column_set_visible(shell->info->col_value, FALSE);
 
793
        }
 
794
        
 
795
        if (viewtype == SHELL_VIEW_PROGRESS)
 
796
                gtk_widget_hide(shell->notebook);
764
797
        break;
765
798
    }
766
799
}
767
800
 
768
801
static void
769
802
group_handle_special(GKeyFile * key_file, ShellModuleEntry * entry,
770
 
                     gchar * group, gchar ** keys)
 
803
                     gchar * group, gchar ** keys, gboolean reload)
771
804
{
772
805
    if (g_str_equal(group, "$ShellParam$")) {
 
806
        gboolean headers_visible = FALSE;
773
807
        gint i;
774
808
 
775
809
        for (i = 0; keys[i]; i++) {
790
824
                sfutbl->sfu = fu;
791
825
 
792
826
                update_sfusrc = g_slist_prepend(update_sfusrc, sfutbl);
 
827
            } else if (g_str_equal(key, "NormalizePercentage")) {
 
828
                shell->normalize_percentage = g_key_file_get_boolean(key_file, group, key, NULL);
793
829
            } else if (g_str_equal(key, "LoadGraphSuffix")) {
794
830
                gchar *suffix =
795
831
                    g_key_file_get_value(key_file, group, key, NULL);
807
843
                ms = g_key_file_get_integer(key_file, group, key, NULL);
808
844
 
809
845
                g_timeout_add(ms, rescan_section, entry);
 
846
            } else if (g_str_equal(key, "ShowColumnHeaders")) {
 
847
                headers_visible = g_key_file_get_boolean(key_file, group, key, NULL);
 
848
            } else if (g_str_has_prefix(key, "ColumnTitle")) {
 
849
                GtkTreeViewColumn *column;
 
850
                gchar *value, *title = strchr(key, '$') + 1;
 
851
 
 
852
                value = g_key_file_get_value(key_file, group, key, NULL);
 
853
 
 
854
                if (g_str_equal(title, "Extra1")) {
 
855
                        column = shell->info->col_extra1;
 
856
                } else if (g_str_equal(title, "Extra2")) {
 
857
                        column = shell->info->col_extra2;
 
858
                } else if (g_str_equal(title, "Value")) {
 
859
                        column = shell->info->col_value;
 
860
                } else if (g_str_equal(title, "TextValue")) {
 
861
                        column = shell->info->col_textvalue;
 
862
                } else if (g_str_equal(title, "Progress")) {
 
863
                        column = shell->info->col_progress;
 
864
                }
 
865
 
 
866
                gtk_tree_view_column_set_title(column, value);
 
867
                gtk_tree_view_column_set_visible(column, TRUE);
 
868
 
 
869
                g_free(value);
810
870
            } else if (g_str_equal(key, "OrderType")) {
811
871
                shell->_order_type = g_key_file_get_integer(key_file,
812
872
                                                            group,
813
873
                                                            key, NULL);
814
874
            } else if (g_str_equal(key, "ViewType")) {
815
875
                set_view_type(g_key_file_get_integer(key_file, group,
816
 
                                                     key, NULL));
 
876
                                                     key, NULL), reload);
817
877
            } else if (g_str_has_prefix(key, "Icon")) {
818
878
                GtkTreeIter *iter = g_hash_table_lookup(update_tbl,
819
879
                                                        strchr(key,
837
897
                                             (key_file, group, key, NULL));
838
898
            }
839
899
        }
 
900
 
 
901
        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(shell->info->view), headers_visible);
840
902
    } else {
841
903
        g_warning("Unknown parameter group: ``%s''", group);
842
904
    }
870
932
            value = entry->fieldfunc(key);
871
933
        }
872
934
 
873
 
        if ((key && value) &&
874
 
            g_utf8_validate(key, -1, NULL)
875
 
            && g_utf8_validate(value, -1, NULL)) {
 
935
        if ((key && value) && g_utf8_validate(key, -1, NULL) && g_utf8_validate(value, -1, NULL)) {
876
936
            if (ngroups == 1) {
877
937
                gtk_tree_store_append(store, &child, NULL);
878
938
            } else {
879
939
                gtk_tree_store_append(store, &child, &parent);
880
940
            }
881
 
            gtk_tree_store_set(store, &child, INFO_TREE_COL_VALUE, value,
882
 
                               -1);
 
941
            
 
942
            /* FIXME: use g_key_file_get_string_list? */
 
943
            if (strchr(value, '|')) {
 
944
                gchar **columns = g_strsplit(value, "|", 0);
 
945
 
 
946
                gtk_tree_store_set(store, &child, INFO_TREE_COL_VALUE, columns[0], -1);
 
947
                if (columns[1]) {
 
948
                        gtk_tree_store_set(store, &child, INFO_TREE_COL_EXTRA1, columns[1], -1);
 
949
                        if (columns[2]) {
 
950
                                gtk_tree_store_set(store, &child, INFO_TREE_COL_EXTRA2, columns[2], -1);
 
951
                        }
 
952
                }
 
953
 
 
954
                g_strfreev(columns);
 
955
            } else {
 
956
                gtk_tree_store_set(store, &child, INFO_TREE_COL_VALUE, value, -1);
 
957
            }
883
958
 
884
959
            strend(key, '#');
885
960
 
942
1017
    GtkTreeStore *store = GTK_TREE_STORE(model);
943
1018
    GtkTreeIter iter, fiter;
944
1019
    gchar *tmp;
945
 
    gdouble maxv = 0, maxp = 0, cur;
 
1020
    gdouble maxv = 0, maxp = 0, cur, floatval;
946
1021
 
947
1022
    gtk_tree_model_get_iter_first(model, &fiter);
948
1023
 
949
1024
    /* finds the maximum value */
950
 
    iter = fiter;
951
 
    do {
952
 
        gtk_tree_model_get(model, &iter, INFO_TREE_COL_VALUE, &tmp, -1);
953
 
 
954
 
        cur = atof(tmp);
955
 
        maxv = MAX(maxv, cur);
956
 
 
957
 
        g_free(tmp);
958
 
    } while (gtk_tree_model_iter_next(model, &iter));
 
1025
    if (shell->normalize_percentage) {
 
1026
        iter = fiter;
 
1027
        do {
 
1028
                gtk_tree_model_get(model, &iter, INFO_TREE_COL_VALUE, &tmp, -1);
 
1029
        
 
1030
                cur = atof(tmp);
 
1031
                maxv = MAX(maxv, cur);
 
1032
        
 
1033
                g_free(tmp);
 
1034
        } while (gtk_tree_model_iter_next(model, &iter));
 
1035
    } else {
 
1036
        maxv = 100.0f;
 
1037
    }
959
1038
 
960
1039
    /* calculates the relative percentage and finds the maximum percentage */
961
1040
    if (shell->_order_type == SHELL_ORDER_ASCENDING) {
962
1041
        iter = fiter;
963
1042
        do {
964
 
            gtk_tree_model_get(model, &iter, INFO_TREE_COL_VALUE, &tmp,
965
 
                               -1);
 
1043
            gtk_tree_model_get(model, &iter, INFO_TREE_COL_VALUE, &tmp, -1);
966
1044
 
967
1045
            cur = 100 - 100 * atof(tmp) / maxv;
968
1046
            maxp = MAX(cur, maxp);
976
1054
    /* fix the maximum relative percentage */
977
1055
    iter = fiter;
978
1056
    do {
 
1057
        char *strval;
 
1058
        
979
1059
        gtk_tree_model_get(model, &iter, INFO_TREE_COL_VALUE, &tmp, -1);
 
1060
        floatval = atof(tmp);
 
1061
        strval = g_strdup(tmp);
 
1062
        g_free(tmp);
 
1063
        
 
1064
        cur = 100 * floatval / maxv;
980
1065
 
981
 
        cur = 100 * atof(tmp) / maxv;
982
1066
        if (shell->_order_type == SHELL_ORDER_ASCENDING)
983
1067
            cur = 100 - cur + maxp;
 
1068
            
 
1069
        if (strchr(strval, ' ')) {
 
1070
            tmp = g_strdup_printf("%.2f%s", floatval, strchr(strval, ' '));
 
1071
        } else {
 
1072
            tmp = g_strdup_printf("%.2f", floatval);
 
1073
        }
984
1074
 
985
 
        gtk_tree_store_set(store, &iter, INFO_TREE_COL_PROGRESS, cur, -1);
986
 
        g_free(tmp);
 
1075
        tmp = strreplace(tmp, ",", '.');
 
1076
        gtk_tree_store_set(store, &iter, INFO_TREE_COL_PROGRESS, cur,
 
1077
                                         INFO_TREE_COL_VALUE, tmp, -1);
 
1078
        g_free(tmp);
 
1079
        g_free(strval);
987
1080
    } while (gtk_tree_model_iter_next(model, &iter));
988
1081
 
989
1082
    /* now sort everything up. that wasn't as hard as i thought :) */
1020
1113
    GKeyFile *key_file = g_key_file_new();
1021
1114
    GtkTreeStore *store;
1022
1115
    gchar *key_data, **groups;
 
1116
    gboolean has_shell_param = FALSE;
1023
1117
    gint i;
1024
1118
    gsize ngroups;
1025
1119
 
1026
1120
    module_entry_scan(entry);
1027
1121
    key_data = module_entry_function(entry);
1028
1122
 
 
1123
    /* */
 
1124
    gdk_window_freeze_updates(shell->info->view->window);
 
1125
 
 
1126
    g_object_ref(shell->info->model);
 
1127
    gtk_tree_view_set_model(GTK_TREE_VIEW(shell->info->view), NULL);
 
1128
 
1029
1129
    /* reset the view type to normal */
1030
 
    set_view_type(SHELL_VIEW_NORMAL);
 
1130
    set_view_type(SHELL_VIEW_NORMAL, reload);
1031
1131
 
1032
 
    /* recreate the iter hash table */
1033
1132
    if (!reload) {
 
1133
        /* recreate the iter hash table */
1034
1134
        h_hash_table_remove_all(update_tbl);
1035
1135
    }
1036
1136
    
1052
1152
    }
1053
1153
 
1054
1154
    store = GTK_TREE_STORE(shell->info->model);
 
1155
 
1055
1156
    gtk_tree_store_clear(store);
1056
1157
 
1057
1158
    g_key_file_load_from_data(key_file, key_data, strlen(key_data), 0,
1067
1168
        gchar **keys = g_key_file_get_keys(key_file, group, NULL, NULL);
1068
1169
 
1069
1170
        if (*group == '$') {
1070
 
            group_handle_special(key_file, entry, group, keys);
 
1171
            group_handle_special(key_file, entry, group, keys, reload);
 
1172
            has_shell_param = TRUE;
1071
1173
        } else {
1072
1174
            group_handle_normal(key_file, entry, group, keys, ngroups);
1073
1175
        }
1074
1176
 
1075
1177
        g_strfreev(keys);
1076
1178
    }
1077
 
 
 
1179
    
 
1180
    /* */
 
1181
    if (!has_shell_param) {
 
1182
        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(shell->info->view), FALSE);
 
1183
    }
 
1184
    
 
1185
    /* */
 
1186
    g_object_unref(shell->info->model);
 
1187
    gtk_tree_view_set_model(GTK_TREE_VIEW(shell->info->view), shell->info->model);
1078
1188
    gtk_tree_view_expand_all(GTK_TREE_VIEW(shell->info->view));
1079
1189
 
1080
 
    if (shell->view_type == SHELL_VIEW_PROGRESS) {
 
1190
    gdk_window_thaw_updates(shell->info->view->window);
 
1191
    shell_set_note_from_entry(entry);
 
1192
 
 
1193
    if (shell->view_type == SHELL_VIEW_PROGRESS || shell->view_type == SHELL_VIEW_PROGRESS_DUAL) {
1081
1194
        update_progress();
1082
1195
    }
1083
1196
 
1084
 
    shell_set_note_from_entry(entry);
 
1197
#if GTK_CHECK_VERSION(2,12,0)
 
1198
    if (ngroups == 1) {
 
1199
        gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(shell->info->view),
 
1200
                                         FALSE);
 
1201
    } else {
 
1202
        gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(shell->info->view),
 
1203
                                         TRUE);
 
1204
    }
 
1205
#endif
1085
1206
 
1086
1207
    g_strfreev(groups);
1087
1208
    g_key_file_free(key_file);
1169
1290
        gtk_tree_view_columns_autosize(GTK_TREE_VIEW(shell->info->view));
1170
1291
 
1171
1292
        /* urgh. why don't GTK do this when the model is cleared? */
1172
 
#define RANGE_SET_VALUE(tree,scrollbar,value) \
1173
 
          gtk_range_set_value(GTK_RANGE \
1174
 
                            (GTK_SCROLLED_WINDOW(shell->tree->scroll)-> \
1175
 
                             scrollbar), value);
1176
 
 
1177
1293
        RANGE_SET_VALUE(info, vscrollbar, 0.0);
1178
1294
        RANGE_SET_VALUE(info, hscrollbar, 0.0);
1179
1295
        RANGE_SET_VALUE(moreinfo, vscrollbar, 0.0);
1180
1296
        RANGE_SET_VALUE(moreinfo, hscrollbar, 0.0);
1181
1297
 
1182
 
#undef RANGE_SET_VALUE
1183
 
 
1184
1298
        shell_status_update("Done.");
1185
1299
        shell_status_set_enabled(FALSE);
1186
1300
 
1197
1311
        shell_action_set_enabled("CopyAction", FALSE);
1198
1312
 
1199
1313
        gtk_tree_store_clear(GTK_TREE_STORE(shell->info->model));
1200
 
        set_view_type(SHELL_VIEW_NORMAL);
 
1314
        set_view_type(SHELL_VIEW_NORMAL, FALSE);
1201
1315
    }
1202
1316
 
1203
1317
    current = entry;
1236
1350
                                        (scroll), GTK_SHADOW_IN);
1237
1351
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
1238
1352
                                   GTK_POLICY_AUTOMATIC,
1239
 
                                   GTK_POLICY_AUTOMATIC);
 
1353
                                   GTK_POLICY_ALWAYS);
1240
1354
 
1241
1355
    store =
1242
1356
        gtk_tree_store_new(INFO_TREE_NCOL, G_TYPE_STRING, G_TYPE_STRING,
1243
 
                           G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_FLOAT);
 
1357
                           G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_FLOAT,
 
1358
                           G_TYPE_STRING, G_TYPE_STRING);
1244
1359
    model = GTK_TREE_MODEL(store);
1245
1360
    treeview = gtk_tree_view_new_with_model(model);
1246
1361
    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
1247
 
 
1248
 
    column = gtk_tree_view_column_new();
1249
 
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
1250
 
 
1251
 
    cr_pbuf = gtk_cell_renderer_pixbuf_new();
1252
 
    gtk_tree_view_column_pack_start(column, cr_pbuf, FALSE);
1253
 
    gtk_tree_view_column_add_attribute(column, cr_pbuf, "pixbuf",
1254
 
                                       INFO_TREE_COL_PBUF);
1255
 
 
1256
 
    cr_text = gtk_cell_renderer_text_new();
1257
 
    gtk_tree_view_column_pack_start(column, cr_text, FALSE);
1258
 
    gtk_tree_view_column_add_attribute(column, cr_text, "markup",
1259
 
                                       INFO_TREE_COL_NAME);
1260
 
 
1261
 
    info->col_value = column = gtk_tree_view_column_new();
1262
 
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
1263
 
 
1264
 
    cr_text = gtk_cell_renderer_text_new();
1265
 
    gtk_tree_view_column_pack_start(column, cr_text, FALSE);
1266
 
    gtk_tree_view_column_add_attribute(column, cr_text, "markup",
1267
 
                                       INFO_TREE_COL_VALUE);
 
1362
    gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(treeview), TRUE);
1268
1363
 
1269
1364
    info->col_progress = column = gtk_tree_view_column_new();
 
1365
    gtk_tree_view_column_set_visible(column, FALSE);
 
1366
    gtk_tree_view_column_set_min_width(column, 240);
 
1367
    gtk_tree_view_column_set_clickable(column, TRUE);
1270
1368
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
1271
1369
 
1272
1370
    cr_progress = gtk_cell_renderer_progress_new();
1277
1375
                                       INFO_TREE_COL_VALUE);
1278
1376
    gtk_tree_view_column_set_visible(column, FALSE);
1279
1377
 
 
1378
    info->col_textvalue = column = gtk_tree_view_column_new();
 
1379
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 
1380
    gtk_tree_view_column_set_clickable(column, TRUE);
 
1381
 
 
1382
    cr_pbuf = gtk_cell_renderer_pixbuf_new();
 
1383
    gtk_tree_view_column_pack_start(column, cr_pbuf, FALSE);
 
1384
    gtk_tree_view_column_add_attribute(column, cr_pbuf, "pixbuf",
 
1385
                                       INFO_TREE_COL_PBUF);
 
1386
 
 
1387
    cr_text = gtk_cell_renderer_text_new();
 
1388
    gtk_tree_view_column_pack_start(column, cr_text, TRUE);
 
1389
    gtk_tree_view_column_add_attribute(column, cr_text, "markup",
 
1390
                                       INFO_TREE_COL_NAME);
 
1391
 
 
1392
    info->col_extra1 = column = gtk_tree_view_column_new();
 
1393
    gtk_tree_view_column_set_visible(column, FALSE);
 
1394
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 
1395
    gtk_tree_view_column_set_clickable(column, TRUE);
 
1396
 
 
1397
    cr_text = gtk_cell_renderer_text_new();
 
1398
    gtk_tree_view_column_pack_start(column, cr_text, FALSE);
 
1399
    gtk_tree_view_column_add_attribute(column, cr_text, "markup",
 
1400
                                       INFO_TREE_COL_EXTRA1);
 
1401
 
 
1402
    info->col_extra2 = column = gtk_tree_view_column_new();
 
1403
    gtk_tree_view_column_set_visible(column, FALSE);
 
1404
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 
1405
    gtk_tree_view_column_set_clickable(column, TRUE);
 
1406
 
 
1407
    cr_text = gtk_cell_renderer_text_new();
 
1408
    gtk_tree_view_column_pack_start(column, cr_text, FALSE);
 
1409
    gtk_tree_view_column_add_attribute(column, cr_text, "markup",
 
1410
                                       INFO_TREE_COL_EXTRA2);
 
1411
 
 
1412
    info->col_value = column = gtk_tree_view_column_new();
 
1413
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
 
1414
    gtk_tree_view_column_set_clickable(column, TRUE);
 
1415
 
 
1416
    cr_text = gtk_cell_renderer_text_new();
 
1417
    gtk_tree_view_column_pack_start(column, cr_text, FALSE);
 
1418
    gtk_tree_view_column_add_attribute(column, cr_text, "markup",
 
1419
                                       INFO_TREE_COL_VALUE);
 
1420
 
1280
1421
    sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
1281
1422
 
1282
1423
    if (!extra)
1311
1452
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW
1312
1453
                                        (scroll), GTK_SHADOW_IN);
1313
1454
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
1314
 
                                   GTK_POLICY_AUTOMATIC,
 
1455
                                   GTK_POLICY_NEVER,
1315
1456
                                   GTK_POLICY_AUTOMATIC);
1316
1457
 
1317
1458
    store = gtk_tree_store_new(TREE_NCOL, GDK_TYPE_PIXBUF, G_TYPE_STRING,