← Back to branch summary

~ubuntu-branches/ubuntu/precise/rhythmbox/precise-201203091205

« back to all changes in this revision

Viewing changes to widgets/rb-entry-view.c

Tags: upstream-0.9.5
Import upstream version 0.9.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
widgets/rb-entry-view.c
16
16
 *
17
17
 *  You should have received a copy of the GNU General Public License
18
18
 *  along with this program; if not, write to the Free Software
19
 
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
19
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.
20
20
 *
21
21
 */
22
22
 
51
51
struct RBEntryViewColumnSortData
52
52
{
53
53
        GCompareDataFunc func;
54
 
        RhythmDBPropType prop_id;
 
54
        gpointer data;
55
55
};
56
56
 
57
57
static void rb_entry_view_class_init (RBEntryViewClass *klass);
133
133
        RhythmDBQueryModel *playing_model;
134
134
        RhythmDBEntry *playing_entry;
135
135
        gboolean playing_entry_in_view;
 
136
        guint selection_changed_id;
136
137
 
137
138
        gboolean is_drag_source;
138
139
        gboolean is_drag_dest;
139
140
 
 
141
        GdkPixbuf *playing_col_pixbuf;
140
142
        GdkPixbuf *playing_pixbuf;
141
143
        GdkPixbuf *paused_pixbuf;
142
144
        GdkPixbuf *error_pixbuf;
147
149
        gint sorting_order;
148
150
        char *sorting_column_name;
149
151
 
150
 
        gboolean have_selection;
 
152
        gboolean have_selection, have_complete_selection;
151
153
 
152
154
        GHashTable *column_key_map;
153
155
 
187
189
 
188
190
static guint rb_entry_view_signals[LAST_SIGNAL] = { 0 };
189
191
 
 
192
static GQuark rb_entry_view_column_always_visible;
 
193
 
190
194
static gboolean
191
195
type_ahead_search_func (GtkTreeModel *model, gint column,
192
196
                        const gchar *key, GtkTreeIter *iter,
194
198
{
195
199
        RhythmDBEntry *entry;
196
200
        gchar *folded;
 
201
        const gchar *entry_folded;
197
202
        gboolean res;
198
203
 
199
204
        gtk_tree_model_get (model, iter, 0, &entry, -1);
200
205
        folded = rb_search_fold (key);
201
 
        res = (strstr (rb_refstring_get_folded (entry->title), folded) == NULL);
 
206
        entry_folded = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_FOLDED);
 
207
        res = (strstr (entry_folded, folded) == NULL);
202
208
        g_free (folded);
203
209
        return res;
204
210
}
323
329
                              G_SIGNAL_RUN_LAST,
324
330
                              G_STRUCT_OFFSET (RBEntryViewClass, show_popup),
325
331
                              NULL, NULL,
326
 
                              g_cclosure_marshal_VOID__VOID,
 
332
                              g_cclosure_marshal_VOID__BOOLEAN,
327
333
                              G_TYPE_NONE,
328
 
                              0);
 
334
                              1,
 
335
                              G_TYPE_BOOLEAN);
329
336
        rb_entry_view_signals[HAVE_SEL_CHANGED] =
330
337
                g_signal_new ("have_selection_changed",
331
338
                              G_OBJECT_CLASS_TYPE (object_class),
347
354
                              0);
348
355
 
349
356
        g_type_class_add_private (klass, sizeof (RBEntryViewPrivate));
 
357
 
 
358
        rb_entry_view_column_always_visible = g_quark_from_static_string ("rb_entry_view_column_always_visible");
350
359
}
351
360
 
352
361
static void
358
367
 
359
368
        icon_theme = gtk_icon_theme_get_default ();
360
369
 
 
370
        view->priv->playing_col_pixbuf = gtk_icon_theme_load_icon (icon_theme,
 
371
                                                               "stock_volume-max", 
 
372
                                                               16,
 
373
                                                               0, 
 
374
                                                               NULL);
 
375
 
361
376
        view->priv->playing_pixbuf = gtk_icon_theme_load_icon (icon_theme,
362
 
                                                               "stock_volume-max", 
 
377
                                                               "stock_media-play", 
363
378
                                                               16,
364
379
                                                               0, 
365
380
                                                               NULL);
366
381
        view->priv->paused_pixbuf = gtk_icon_theme_load_icon (icon_theme,
367
 
                                                              "stock_volume-0", 
 
382
                                                              "stock_media-pause", 
368
383
                                                              16,
369
384
                                                              0, 
370
385
                                                              NULL);
400
415
        g_hash_table_destroy (view->priv->column_sort_data_map);
401
416
        g_hash_table_destroy (view->priv->column_key_map);
402
417
 
403
 
        g_object_unref (G_OBJECT (view->priv->playing_pixbuf));
404
 
        g_object_unref (G_OBJECT (view->priv->paused_pixbuf));
405
 
        g_object_unref (G_OBJECT (view->priv->error_pixbuf));
 
418
        if (view->priv->playing_pixbuf)
 
419
                g_object_unref (G_OBJECT (view->priv->playing_pixbuf));
 
420
        if (view->priv->playing_col_pixbuf)
 
421
                g_object_unref (G_OBJECT (view->priv->playing_col_pixbuf));
 
422
        if (view->priv->paused_pixbuf)
 
423
                g_object_unref (G_OBJECT (view->priv->paused_pixbuf));
 
424
        if (view->priv->error_pixbuf)
 
425
                g_object_unref (G_OBJECT (view->priv->error_pixbuf));
406
426
 
407
427
        g_free (view->priv->sorting_key);
408
428
 
467
487
                                         view,
468
488
                                         0);
469
489
 
 
490
                gtk_tree_selection_unselect_all (view->priv->selection);
470
491
                view->priv->model = new_model;
471
492
                if (view->priv->sorting_column)
472
493
                        rb_entry_view_resort_model (view);
474
495
                gtk_tree_view_set_model (GTK_TREE_VIEW (view->priv->treeview),
475
496
                                         GTK_TREE_MODEL (new_model));
476
497
                view->priv->have_selection = FALSE;
 
498
                view->priv->have_complete_selection = FALSE;
477
499
 
478
500
                g_signal_emit (G_OBJECT (view), rb_entry_view_signals[ENTRIES_REPLACED], 0);
479
501
                break;
575
597
                                      RBEntryView *view)
576
598
{
577
599
        RhythmDBEntry *entry;
578
 
        GdkPixbuf *pixbuf;
 
600
        GdkPixbuf *pixbuf = NULL;
579
601
 
580
602
        entry = rhythmdb_query_model_iter_to_entry (view->priv->model, iter);
581
603
 
582
604
        if (entry == view->priv->playing_entry) {
583
605
                switch (view->priv->playing_state) {
584
 
                case RB_ENTRY_VIEW_PLAYING:     
 
606
                case RB_ENTRY_VIEW_PLAYING:
585
607
                        pixbuf = view->priv->playing_pixbuf;
586
608
                        break;
587
609
                case RB_ENTRY_VIEW_PAUSED:
591
613
                        pixbuf = NULL;
592
614
                        break;
593
615
                }
594
 
        } else if (entry->playback_error) {
 
616
        }
 
617
 
 
618
        if (pixbuf == NULL && rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_PLAYBACK_ERROR)) {
595
619
                pixbuf = view->priv->error_pixbuf;
596
 
        } else {
597
 
                pixbuf = NULL;
598
620
        }
599
621
 
600
622
        g_object_set (G_OBJECT (renderer), "pixbuf", pixbuf, NULL);
609
631
 
610
632
        entry = rhythmdb_query_model_iter_to_entry (view->priv->model, iter);
611
633
 
612
 
        g_object_set (G_OBJECT (renderer), "rating", entry->rating, NULL);
 
634
        g_object_set (G_OBJECT (renderer),
 
635
                      "rating", rhythmdb_entry_get_double (entry, RHYTHMDB_PROP_RATING),
 
636
                      NULL);
613
637
}
614
638
 
615
639
static void
697
721
        }
698
722
}
699
723
 
700
 
#if 0
701
724
static void
702
725
rb_entry_view_quality_cell_data_func (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
703
726
                                      GtkTreeModel *tree_model, GtkTreeIter *iter,
708
731
 
709
732
        entry = rhythmdb_query_model_iter_to_entry (data->view->priv->model, iter);
710
733
 
711
 
        bitrate = rhythmdb_entry_get_int (data->view->priv->db, entry,
712
 
                                          data->propid);
 
734
        bitrate = rhythmdb_entry_get_ulong (entry, data->propid);
713
735
 
714
 
        if (bitrate <= 0) {
 
736
        if (bitrate > 0) {
 
737
                char *s = g_strdup_printf (_("%u kbps"), (guint)bitrate);
 
738
                g_object_set (G_OBJECT (renderer), "text", s, NULL);
 
739
                g_free (s);
 
740
        } else {
715
741
                g_object_set (G_OBJECT (renderer), "text", _("Unknown"), NULL);
716
 
        } else if (bitrate <= 80) {
717
 
                g_object_set (G_OBJECT (renderer), "text", _("Very Low"), NULL);
718
 
        } else if (bitrate <= 112) {
719
 
                g_object_set (G_OBJECT (renderer), "text", _("Low"), NULL);
720
 
        } else if (bitrate <= 160) {
721
 
                g_object_set (G_OBJECT (renderer), "text", _("Regular"), NULL);
722
 
        } else if (bitrate <= 224) {
723
 
                g_object_set (G_OBJECT (renderer), "text", _("High"), NULL);
724
 
        } else if (bitrate <= 1410) {
725
 
                g_object_set (G_OBJECT (renderer), "text", _("Very High"), NULL);
726
 
        } else {
727
 
                g_object_set (G_OBJECT (renderer), "text", _("Perfect"), NULL);
728
742
        }
729
743
}
730
 
#endif
 
744
 
 
745
static void
 
746
rb_entry_view_location_cell_data_func (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
 
747
                                       GtkTreeModel *tree_model, GtkTreeIter *iter,
 
748
                                       struct RBEntryViewCellDataFuncData *data)
 
749
{
 
750
        RhythmDBEntry *entry;
 
751
        const char *location;
 
752
        char *str;
 
753
 
 
754
        entry = rhythmdb_query_model_iter_to_entry (data->view->priv->model, iter);
 
755
 
 
756
        location = rhythmdb_entry_get_string (entry, data->propid);
 
757
        str = gnome_vfs_unescape_string_for_display (location);
 
758
 
 
759
        g_object_set (G_OBJECT (renderer), "text", str, NULL);
 
760
        g_free (str);
 
761
}
731
762
 
732
763
static void
733
764
rb_entry_view_string_cell_data_func (GtkTreeViewColumn *column, GtkCellRenderer *renderer,
878
909
}
879
910
 
880
911
void
881
 
rb_entry_view_append_column (RBEntryView *view, RBEntryViewColumn coltype)
 
912
rb_entry_view_append_column (RBEntryView *view, RBEntryViewColumn coltype, gboolean always_visible)
882
913
{
883
914
        GtkTreeViewColumn *column;
884
915
        GtkCellRenderer *renderer = NULL;
975
1006
                strings[1] = "0000";
976
1007
                strings[2] = _("Unknown");
977
1008
                break;
978
 
#if 0
979
1009
        case RB_ENTRY_VIEW_COL_QUALITY:
980
1010
                propid = RHYTHMDB_PROP_BITRATE;
981
1011
                cell_data->propid = propid;
985
1015
                title = _("_Quality");
986
1016
                key = "Quality";
987
1017
                strings[0] = title;
988
 
                strings[1] = "000";
 
1018
                strings[1] = _("000 kbps");
 
1019
                strings[2] = _("Unknown");
989
1020
                break;
990
 
#endif
991
1021
        case RB_ENTRY_VIEW_COL_RATING:
992
1022
                propid = RHYTHMDB_PROP_RATING;
993
1023
                sort_func = (GCompareDataFunc) rhythmdb_query_model_double_ceiling_sort_func;
1046
1076
                strings[0] = title;
1047
1077
                strings[1] = rb_entry_view_get_time_date_column_sample ();
1048
1078
                break;
 
1079
        case RB_ENTRY_VIEW_COL_LAST_SEEN:
 
1080
                propid = RHYTHMDB_PROP_LAST_SEEN;
 
1081
                cell_data->propid = RHYTHMDB_PROP_LAST_SEEN_STR;
 
1082
                cell_data_func = (GtkTreeCellDataFunc) rb_entry_view_string_cell_data_func;
 
1083
                sort_propid = RHYTHMDB_PROP_LAST_SEEN;
 
1084
                sort_func = (GCompareDataFunc) rhythmdb_query_model_ulong_sort_func;
 
1085
                title = _("Last _Seen");
 
1086
                key = "LastSeen";
 
1087
                strings[0] = title;
 
1088
                strings[1] = rb_entry_view_get_time_date_column_sample ();
 
1089
                break;
 
1090
        case RB_ENTRY_VIEW_COL_LOCATION:
 
1091
                propid = RHYTHMDB_PROP_LOCATION;
 
1092
                cell_data->propid = RHYTHMDB_PROP_LOCATION;
 
1093
                cell_data_func = (GtkTreeCellDataFunc) rb_entry_view_location_cell_data_func;
 
1094
                sort_propid = RHYTHMDB_PROP_LOCATION;
 
1095
                sort_func = (GCompareDataFunc) rhythmdb_query_model_location_sort_func;
 
1096
                title = _("L_ocation");
 
1097
                key = "Location";
 
1098
                ellipsize = TRUE;
 
1099
                break;
 
1100
        case RB_ENTRY_VIEW_COL_ERROR:
 
1101
                propid = RHYTHMDB_PROP_PLAYBACK_ERROR;
 
1102
                cell_data->propid = RHYTHMDB_PROP_PLAYBACK_ERROR;
 
1103
                cell_data_func = (GtkTreeCellDataFunc) rb_entry_view_string_cell_data_func;
 
1104
                title = _("Error");
 
1105
                key = "Error";
 
1106
                ellipsize = TRUE;
 
1107
                break;
1049
1108
        default:
1050
1109
                g_assert_not_reached ();
1051
1110
                propid = -1;
1082
1141
        gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
1083
1142
        gtk_tree_view_column_set_clickable (column, TRUE);
1084
1143
 
 
1144
        if (always_visible)
 
1145
                g_object_set_qdata (G_OBJECT (column), 
 
1146
                                    rb_entry_view_column_always_visible, 
 
1147
                                    GINT_TO_POINTER (1));
 
1148
 
1085
1149
        g_hash_table_insert (view->priv->propid_column_map, GINT_TO_POINTER (propid), column);
1086
 
        rb_entry_view_append_column_custom (view, column, title, key, sort_func, sort_propid);
 
1150
 
 
1151
        rb_entry_view_append_column_custom (view, column, title, key, sort_func, GINT_TO_POINTER (sort_propid));
1087
1152
}
1088
1153
 
1089
1154
void
1092
1157
                                    const char *title,
1093
1158
                                    const char *key,
1094
1159
                                    GCompareDataFunc sort_func,
1095
 
                                    RhythmDBPropType sort_prop_id)
 
1160
                                    gpointer data)
1096
1161
{
1097
1162
        struct RBEntryViewColumnSortData *sortdata;
1098
1163
 
1113
1178
        if (sort_func != NULL) {
1114
1179
                sortdata = g_new (struct RBEntryViewColumnSortData, 1);
1115
1180
                sortdata->func = (GCompareDataFunc) sort_func;
1116
 
                sortdata->prop_id = sort_prop_id;
 
1181
                sortdata->data = data;
1117
1182
                g_hash_table_insert (view->priv->column_sort_data_map, column, sortdata);
1118
1183
        }
1119
1184
        g_hash_table_insert (view->priv->column_key_map, g_strdup (key), column);
1186
1251
                                                     GDK_BUTTON1_MASK,
1187
1252
                                                     rb_entry_view_drag_types,
1188
1253
                                                     G_N_ELEMENTS (rb_entry_view_drag_types),
1189
 
                                                     GDK_ACTION_COPY | GDK_ACTION_MOVE);
 
1254
                                                     GDK_ACTION_COPY);
1190
1255
        if (view->priv->is_drag_dest)
1191
1256
                rb_tree_dnd_add_drag_dest_support (GTK_TREE_VIEW (view->priv->treeview),
1192
1257
                                                   RB_TREE_DEST_CAN_DROP_BETWEEN | RB_TREE_DEST_EMPTY_VIEW_DROP,
1215
1280
                                                         view,
1216
1281
                                                         NULL);
1217
1282
 
1218
 
                image_widget = gtk_image_new_from_pixbuf (view->priv->playing_pixbuf);
 
1283
                image_widget = gtk_image_new_from_pixbuf (view->priv->playing_col_pixbuf);
1219
1284
                g_object_ref (G_OBJECT (image_widget));
1220
1285
                gtk_object_sink (GTK_OBJECT (image_widget));
1221
1286
                gtk_tree_view_column_set_widget (column, image_widget);
1291
1356
{
1292
1357
        GtkTreePath *path;
1293
1358
        RhythmDBEntry *entry;
 
1359
        const gchar *error;
1294
1360
 
1295
1361
        g_return_if_fail (path_string != NULL);
1296
1362
 
1299
1365
 
1300
1366
        gtk_tree_path_free (path);
1301
1367
 
1302
 
        if (entry->playback_error) {
1303
 
                rb_error_dialog (NULL, _("Playback Error"),
1304
 
                                 "%s", entry->playback_error);
 
1368
        error = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_PLAYBACK_ERROR);
 
1369
        if (error) {
 
1370
                rb_error_dialog (NULL, _("Playback Error"), "%s", error);
1305
1371
        }
1306
1372
}
1307
1373
 
1315
1381
  
1316
1382
        g_return_if_fail (RB_IS_ENTRY_VIEW (view));
1317
1383
  
1318
 
        if (view->priv->playing_state == RB_ENTRY_VIEW_NOT_PLAYING)
1319
 
                return;
1320
 
  
1321
 
        if (view->priv->playing_entry != NULL) {
1322
 
                rb_entry_view_emit_row_changed (view, view->priv->playing_entry);
1323
 
                g_object_unref (G_OBJECT (view->priv->playing_model));
1324
 
        }
 
1384
        if (view->priv->playing_entry != NULL) {
 
1385
                if (view->priv->playing_state != RB_ENTRY_VIEW_NOT_PLAYING)
 
1386
                        rb_entry_view_emit_row_changed (view, view->priv->playing_entry);
 
1387
                g_object_unref (G_OBJECT (view->priv->playing_model));
 
1388
        }
1325
1389
        
1326
1390
        view->priv->playing_entry = entry;
1327
1391
        g_object_ref (G_OBJECT (view->priv->model));
1328
1392
        view->priv->playing_model = view->priv->model;
1329
1393
 
1330
 
        if (view->priv->playing_entry != NULL) {
1331
 
                view->priv->playing_entry_in_view = 
1332
 
                        rb_entry_view_emit_row_changed (view, view->priv->playing_entry);
1333
 
        }
1334
 
 
1335
 
        if (view->priv->playing_entry
1336
 
            && view->priv->playing_entry_in_view) {
1337
 
            rb_entry_view_entry_is_visible (view, view->priv->playing_entry,
1338
 
                                            &realized, &visible, &iter);
1339
 
            if (realized && !visible)
1340
 
                    rb_entry_view_scroll_to_iter (view, &iter);
1341
 
        }
 
1394
        if (view->priv->playing_state != RB_ENTRY_VIEW_NOT_PLAYING) {
 
1395
                if (view->priv->playing_entry != NULL) {
 
1396
                        view->priv->playing_entry_in_view = 
 
1397
                                rb_entry_view_emit_row_changed (view, view->priv->playing_entry);
 
1398
                }
 
1399
         
 
1400
                if (view->priv->playing_entry
 
1401
                    && view->priv->playing_entry_in_view) {
 
1402
                    rb_entry_view_entry_is_visible (view, view->priv->playing_entry,
 
1403
                                                    &realized, &visible, &iter);
 
1404
                    if (realized && !visible)
 
1405
                            rb_entry_view_scroll_to_iter (view, &iter);
 
1406
                }
 
1407
        }
1342
1408
}
1343
1409
 
1344
1410
static gboolean
1366
1432
                                             (GtkTreeSelectionForeachFunc) harvest_entries,
1367
1433
                                             (gpointer) &list);
1368
1434
 
 
1435
        list = g_list_reverse (list);
1369
1436
        return list;
1370
1437
}
1371
1438
 
1390
1457
 
1391
1458
                        g_list_free (selected);
1392
1459
                        
1393
 
                        g_signal_emit (G_OBJECT (view), rb_entry_view_signals[SHOW_POPUP], 0);
1394
1460
                }
1395
 
                return view->priv->have_selection;
 
1461
                g_signal_emit (G_OBJECT (view), rb_entry_view_signals[SHOW_POPUP], 0, (path != NULL));
 
1462
                return TRUE;
1396
1463
        }
1397
1464
 
1398
1465
        return FALSE;
1409
1476
        return TRUE;
1410
1477
}
1411
1478
 
1412
 
static void
1413
 
rb_entry_view_selection_changed_cb (GtkTreeSelection *selection,
1414
 
                                   RBEntryView *view)
 
1479
static gboolean
 
1480
rb_entry_view_emit_selection_changed (RBEntryView *view)
1415
1481
{
1416
1482
        gboolean available;
1417
 
        GList *sel;
 
1483
        gint sel_count;
1418
1484
 
1419
 
        sel = rb_entry_view_get_selected_entries (view);
1420
 
        available = (sel != NULL);
1421
 
        g_list_free (sel);
 
1485
        sel_count = gtk_tree_selection_count_selected_rows (view->priv->selection);
 
1486
        available = (sel_count > 0);
1422
1487
 
1423
1488
        if (available != view->priv->have_selection) {
 
1489
                gint entry_count;
 
1490
 
 
1491
                entry_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (view->priv->model), NULL);
 
1492
                view->priv->have_complete_selection = (sel_count == entry_count);
 
1493
 
1424
1494
                view->priv->have_selection = available;
1425
1495
 
1426
1496
                g_signal_emit (G_OBJECT (view), rb_entry_view_signals[HAVE_SEL_CHANGED], 0, available);
1427
1497
        }
1428
1498
 
 
1499
        view->priv->selection_changed_id = 0;
1429
1500
        g_signal_emit (G_OBJECT (view), rb_entry_view_signals[SELECTION_CHANGED], 0);
 
1501
        return FALSE;
 
1502
}
1430
1503
 
 
1504
static void
 
1505
rb_entry_view_selection_changed_cb (GtkTreeSelection *selection,
 
1506
                                    RBEntryView *view)
 
1507
{
 
1508
        if (view->priv->selection_changed_id == 0)
 
1509
                view->priv->selection_changed_id = g_idle_add ((GSourceFunc)rb_entry_view_emit_selection_changed, view);
1431
1510
}
1432
1511
 
1433
1512
gboolean
1436
1515
        return view->priv->have_selection;
1437
1516
}
1438
1517
 
 
1518
gboolean
 
1519
rb_entry_view_have_complete_selection (RBEntryView *view)
 
1520
{
 
1521
        return view->priv->have_complete_selection;
 
1522
}
 
1523
 
1439
1524
static void
1440
1525
rb_entry_view_row_activated_cb (GtkTreeView *treeview,
1441
1526
                               GtkTreePath *path,
1485
1570
        GList *selected_rows;
1486
1571
        GList *i;
1487
1572
        gint model_size;
 
1573
        gboolean scrolled = FALSE;
 
1574
        
1488
1575
        rb_debug ("rows reordered");
1489
1576
 
1490
1577
        model_size = gtk_tree_model_iter_n_children (model, NULL);
1506
1593
                                if (order[newindex] == index) {
1507
1594
                                        newpath = gtk_tree_path_new_from_indices (newindex, -1);
1508
1595
                                        gtk_tree_selection_select_path (view->priv->selection, newpath);
 
1596
                                        if (!scrolled) {
 
1597
                                                GtkTreeViewColumn *col;
 
1598
                                                GtkTreeView *treeview = GTK_TREE_VIEW (view->priv->treeview);
 
1599
 
 
1600
                                                col = gtk_tree_view_get_column (treeview, 0);
 
1601
                                                gtk_tree_view_scroll_to_cell (treeview, newpath, col, TRUE, 0.5, 0.0);
 
1602
                                                scrolled = TRUE;
 
1603
                                        }
1509
1604
                                        gtk_tree_path_free (newpath);
1510
1605
                                        break;
1511
1606
                                }
1516
1611
 
1517
1612
        g_list_foreach (selected_rows, (GFunc) gtk_tree_path_free, NULL);
1518
1613
        g_list_free (selected_rows);
 
1614
 
 
1615
        gtk_widget_queue_draw (GTK_WIDGET (view));
1519
1616
}
1520
1617
 
1521
1618
void
1683
1780
static gint
1684
1781
propid_from_name (const char *name)
1685
1782
{
1686
 
        GEnumClass *prop_class = g_type_class_ref (RHYTHMDB_TYPE_PROP);
 
1783
        GEnumClass *prop_class = g_type_class_ref (RHYTHMDB_TYPE_PROP_TYPE);
1687
1784
        GEnumValue *ev;
1688
1785
        int ret;
1689
1786
 
1700
1797
{
1701
1798
        gboolean visible;
1702
1799
 
1703
 
        /* title is always visible */
1704
 
        if (propid == RHYTHMDB_PROP_TITLE)
1705
 
                return;
 
1800
        if (g_object_get_qdata (G_OBJECT (column), 
 
1801
                                rb_entry_view_column_always_visible) == GINT_TO_POINTER (1))
 
1802
                visible = TRUE;
 
1803
        else
 
1804
                visible = (g_list_find (visible_props, GINT_TO_POINTER (propid)) != NULL);
1706
1805
 
1707
 
        visible = (g_list_find (visible_props, GINT_TO_POINTER (propid)) != NULL);
1708
1806
        gtk_tree_view_column_set_visible (column, visible);
1709
1807
}
1710
1808
 
1841
1939
 
1842
1940
        rhythmdb_query_model_set_sort_order (view->priv->model,
1843
1941
                                             sort_data->func,
1844
 
                                             sort_data->prop_id,
 
1942
                                             sort_data->data,
 
1943
                                             NULL,
1845
1944
                                             (view->priv->sorting_order == GTK_SORT_DESCENDING));
1846
1945
}
 
1946
 
 
1947
/* This should really be standard. */
 
1948
#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
 
1949
 
 
1950
GType
 
1951
rb_entry_view_column_get_type (void)
 
1952
{
 
1953
        static GType etype = 0;
 
1954
 
 
1955
        if (etype == 0) {
 
1956
                static const GEnumValue values[] = {
 
1957
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_TRACK_NUMBER, "Track Number"),
 
1958
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_TITLE, "Title"),
 
1959
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_ARTIST, "Artist"),
 
1960
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_ALBUM, "Album"),
 
1961
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_GENRE, "Genre"),
 
1962
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_DURATION, "Duration"),
 
1963
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_QUALITY, "Quality"),
 
1964
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_RATING, "Rating"),
 
1965
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_PLAY_COUNT, "Play Count"),
 
1966
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_YEAR, "Year"),
 
1967
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_LAST_PLAYED, "Last Played"),
 
1968
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_FIRST_SEEN, "First Seen"),
 
1969
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_LAST_SEEN, "Last Seen"),
 
1970
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_LOCATION, "Location"),
 
1971
                        ENUM_ENTRY (RB_ENTRY_VIEW_COL_ERROR, "Error"),
 
1972
                        { 0, 0, 0 }
 
1973
                };
 
1974
 
 
1975
                etype = g_enum_register_static ("RBEntryViewColumn", values);
 
1976
        }
 
1977
 
 
1978
        return etype;
 
1979
}
 
1980
 
 
1981
GType
 
1982
rb_entry_view_state_get_type (void)
 
1983
{
 
1984
        static GType etype = 0;
 
1985
 
 
1986
        if (etype == 0) {
 
1987
                static const GEnumValue values[] = {
 
1988
                        ENUM_ENTRY (RB_ENTRY_VIEW_NOT_PLAYING, "Not Playing"),
 
1989
                        ENUM_ENTRY (RB_ENTRY_VIEW_PLAYING, "Playing"),
 
1990
                        ENUM_ENTRY (RB_ENTRY_VIEW_PAUSED, "Paused"),
 
1991
                        { 0, 0, 0 }
 
1992
                };
 
1993
 
 
1994
                etype = g_enum_register_static ("RBEntryViewState", values);
 
1995
        }
 
1996
 
 
1997
        return etype;
 
1998
}
 
1999