← Back to branch summary

~ubuntu-branches/ubuntu/utopic/rhythmbox/utopic-proposed

« back to all changes in this revision

Viewing changes to rhythmdb/rhythmdb.h

Tags: upstream-0.9.2
Import upstream version 0.9.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
rhythmdb/rhythmdb.h
31
31
#include <libxml/tree.h>
32
32
 
33
33
#include "config.h"
 
34
#include "rb-refstring.h"
34
35
 
35
36
G_BEGIN_DECLS
36
37
 
46
47
 
47
48
#define RHYTHMDB_ENTRY_TYPE_SONG (rhythmdb_entry_song_get_type ())
48
49
#define RHYTHMDB_ENTRY_TYPE_IRADIO_STATION (rhythmdb_entry_iradio_get_type ())
 
50
#define RHYTHMDB_ENTRY_TYPE_PODCAST_POST (rhythmdb_entry_podcast_post_get_type ())
 
51
#define RHYTHMDB_ENTRY_TYPE_PODCAST_FEED (rhythmdb_entry_podcast_feed_get_type ())
49
52
 
50
53
typedef enum
51
54
{
57
60
        RHYTHMDB_QUERY_PROP_NOT_LIKE,
58
61
        RHYTHMDB_QUERY_PROP_GREATER,
59
62
        RHYTHMDB_QUERY_PROP_LESS,
 
63
        RHYTHMDB_QUERY_PROP_CURRENT_TIME_WITHIN,
 
64
        RHYTHMDB_QUERY_PROP_CURRENT_TIME_NOT_WITHIN,
60
65
} RhythmDBQueryType;
61
66
 
62
67
/* If you modify this enum, don't forget to modify rhythmdb_prop_get_type */
72
77
        RHYTHMDB_PROP_DURATION,
73
78
        RHYTHMDB_PROP_FILE_SIZE,
74
79
        RHYTHMDB_PROP_LOCATION,
 
80
        RHYTHMDB_PROP_MOUNTPOINT,
75
81
        RHYTHMDB_PROP_MTIME,
 
82
        RHYTHMDB_PROP_FIRST_SEEN,
 
83
        RHYTHMDB_PROP_LAST_SEEN,
76
84
        RHYTHMDB_PROP_RATING,
77
 
        RHYTHMDB_PROP_AUTO_RATE,
78
85
        RHYTHMDB_PROP_PLAY_COUNT,
79
86
        RHYTHMDB_PROP_LAST_PLAYED,
80
87
        RHYTHMDB_PROP_BITRATE,
 
88
        RHYTHMDB_PROP_DATE,
81
89
        RHYTHMDB_PROP_TRACK_GAIN,
82
90
        RHYTHMDB_PROP_TRACK_PEAK,
83
91
        RHYTHMDB_PROP_ALBUM_GAIN,
84
92
        RHYTHMDB_PROP_ALBUM_PEAK,
85
93
        RHYTHMDB_PROP_MIMETYPE,
86
 
        /* This should always be the last element of this enum */
87
 
        RHYTHMDB_NUM_SAVED_PROPERTIES
88
 
} RhythmDBPropType;
89
 
 
90
 
 
91
 
/* If you modify this enum, don't forget to modify 
92
 
 * rhythmdb_unsaved_prop_get_type 
93
 
 */
94
 
typedef enum
95
 
{
96
 
        RHYTHMDB_PROP_TITLE_SORT_KEY = RHYTHMDB_NUM_SAVED_PROPERTIES,
 
94
        RHYTHMDB_PROP_TITLE_SORT_KEY,
97
95
        RHYTHMDB_PROP_GENRE_SORT_KEY,
98
96
        RHYTHMDB_PROP_ARTIST_SORT_KEY,
99
97
        RHYTHMDB_PROP_ALBUM_SORT_KEY,
102
100
        RHYTHMDB_PROP_ARTIST_FOLDED,
103
101
        RHYTHMDB_PROP_ALBUM_FOLDED,
104
102
        RHYTHMDB_PROP_LAST_PLAYED_STR,
105
 
        /* This should always be the last element of this enum */
 
103
        RHYTHMDB_PROP_HIDDEN,
 
104
        RHYTHMDB_PROP_PLAYBACK_ERROR,
 
105
        RHYTHMDB_PROP_FIRST_SEEN_STR,
 
106
        RHYTHMDB_PROP_SEARCH_MATCH,
 
107
 
 
108
//podcast propriets
 
109
        RHYTHMDB_PROP_STATUS,
 
110
        RHYTHMDB_PROP_DESCRIPTION,
 
111
        RHYTHMDB_PROP_SUBTITLE,
 
112
        RHYTHMDB_PROP_SUMMARY,
 
113
        RHYTHMDB_PROP_LANG,
 
114
        RHYTHMDB_PROP_COPYRIGHT,
 
115
        RHYTHMDB_PROP_IMAGE,
 
116
        RHYTHMDB_PROP_POST_TIME,
 
117
        
106
118
        RHYTHMDB_NUM_PROPERTIES
107
 
} RhythmDBUnsavedPropType;
 
119
} RhythmDBPropType;
 
120
 
 
121
enum {
 
122
        RHYTHMDB_PODCAST_STATUS_COMPLETE = 100,
 
123
        RHYTHMDB_PODCAST_STATUS_ERROR = 101,
 
124
        RHYTHMDB_PODCAST_STATUS_WAITING = 102,
 
125
        RHYTHMDB_PODCAST_STATUS_PAUSED = 103,
 
126
};
108
127
 
109
128
GType rhythmdb_query_get_type (void);
110
129
GType rhythmdb_prop_get_type (void);
111
 
GType rhythmdb_unsaved_prop_get_type (void);
112
130
 
113
131
#define RHYTHMDB_TYPE_QUERY (rhythmdb_query_get_type ())
114
132
#define RHYTHMDB_TYPE_PROP (rhythmdb_prop_get_type ())
115
 
#define RHYTHMDB_TYPE_UNSAVED_PROP (rhythmdb_unsaved_prop_get_type ())
116
133
 
117
134
typedef struct {
118
135
        guint type;
121
138
        GPtrArray *subquery;
122
139
} RhythmDBQueryData;
123
140
 
124
 
typedef void RhythmDBEntry;
 
141
typedef struct {
 
142
        /* podcast */
 
143
        RBRefString *description;
 
144
        RBRefString *subtitle;
 
145
        RBRefString *summary;
 
146
        RBRefString *lang;
 
147
        RBRefString *copyright;
 
148
        RBRefString *image;
 
149
        gulong status;   //0-99: downloading; 100: Conplete; 101: Error; 102: wait; 103: pause;
 
150
        gulong post_time;
 
151
} RhythmDBPodcastFields;
 
152
 
 
153
 
 
154
typedef struct {
 
155
        /* internal bits */
 
156
#ifndef G_DISABLE_ASSERT
 
157
        guint magic;
 
158
#endif  
 
159
        gboolean inserted;
 
160
        gint refcount;
 
161
        void *data;
 
162
        gulong type;
 
163
        
 
164
        /* metadata */
 
165
        RBRefString *title;
 
166
        RBRefString *artist;
 
167
        RBRefString *album;
 
168
        RBRefString *genre;
 
169
        gulong tracknum;
 
170
        gulong discnum;
 
171
        gulong duration;
 
172
        gulong bitrate;
 
173
        double track_gain;
 
174
        double track_peak;
 
175
        double album_gain;
 
176
        double album_peak;
 
177
        GDate *date;
 
178
 
 
179
        /* filesystem */
 
180
        char *location;
 
181
        RBRefString *mountpoint;
 
182
        guint64 file_size;
 
183
        RBRefString *mimetype;
 
184
#if 0
 
185
        dev_t device;
 
186
        GnomeVFSInodeNumber inode;
 
187
#endif
 
188
        gulong mtime;
 
189
        gulong first_seen;
 
190
        gulong last_seen;
 
191
 
 
192
        /* user data */
 
193
        gdouble rating;
 
194
        glong play_count;
 
195
        gulong last_played;
 
196
 
 
197
        /* cached data */
 
198
        RBRefString *last_played_str;
 
199
        RBRefString *first_seen_str;
 
200
 
 
201
        /* playback error string */
 
202
        char *playback_error;
 
203
 
 
204
        /* visibility (to hide entries on unmounted volumes) */
 
205
        gboolean hidden;
 
206
 
 
207
        /*Podcast*/
 
208
        RhythmDBPodcastFields *podcast;
 
209
} RhythmDBEntry;
 
210
 
 
211
typedef struct {
 
212
        RhythmDBPropType prop;
 
213
        GValue old;
 
214
        GValue new;
 
215
} RhythmDBEntryChange;
 
216
 
 
217
void rhythmdb_entry_get (RhythmDBEntry *entry, RhythmDBPropType propid, GValue *val);
 
218
G_INLINE_FUNC const char *rhythmdb_entry_get_string     (RhythmDBEntry *entry, RhythmDBPropType propid);
 
219
G_INLINE_FUNC gboolean rhythmdb_entry_get_boolean       (RhythmDBEntry *entry, RhythmDBPropType propid);
 
220
G_INLINE_FUNC guint64 rhythmdb_entry_get_uint64         (RhythmDBEntry *entry, RhythmDBPropType propid);
 
221
G_INLINE_FUNC gulong rhythmdb_entry_get_ulong           (RhythmDBEntry *entry, RhythmDBPropType propid);
 
222
G_INLINE_FUNC double rhythmdb_entry_get_double          (RhythmDBEntry *entry, RhythmDBPropType propid);
 
223
 
 
224
#if defined (G_CAN_INLINE) || defined (__RHYTHMDB_C__)
 
225
 
 
226
G_INLINE_FUNC const char *
 
227
rhythmdb_entry_get_string (RhythmDBEntry *entry, RhythmDBPropType propid)
 
228
{
 
229
        switch (propid)
 
230
        {
 
231
        case RHYTHMDB_PROP_TITLE:
 
232
                return rb_refstring_get (entry->title);
 
233
        case RHYTHMDB_PROP_ALBUM:
 
234
                return rb_refstring_get (entry->album);
 
235
        case RHYTHMDB_PROP_ARTIST:
 
236
                return rb_refstring_get (entry->artist);
 
237
        case RHYTHMDB_PROP_GENRE:
 
238
                return rb_refstring_get (entry->genre);
 
239
        case RHYTHMDB_PROP_MIMETYPE:
 
240
                return rb_refstring_get (entry->mimetype);
 
241
        case RHYTHMDB_PROP_TITLE_SORT_KEY:
 
242
                return rb_refstring_get_sort_key (entry->title);
 
243
        case RHYTHMDB_PROP_ALBUM_SORT_KEY:
 
244
                return rb_refstring_get_sort_key (entry->album);
 
245
        case RHYTHMDB_PROP_ARTIST_SORT_KEY:
 
246
                return rb_refstring_get_sort_key (entry->artist);
 
247
        case RHYTHMDB_PROP_GENRE_SORT_KEY:
 
248
                return rb_refstring_get_sort_key (entry->genre);
 
249
        case RHYTHMDB_PROP_TITLE_FOLDED:
 
250
                return rb_refstring_get_folded (entry->title);
 
251
        case RHYTHMDB_PROP_ALBUM_FOLDED:
 
252
                return rb_refstring_get_folded (entry->album);
 
253
        case RHYTHMDB_PROP_ARTIST_FOLDED:
 
254
                return rb_refstring_get_folded (entry->artist);
 
255
        case RHYTHMDB_PROP_GENRE_FOLDED:
 
256
                return rb_refstring_get_folded (entry->genre);
 
257
        case RHYTHMDB_PROP_LOCATION:
 
258
                return entry->location;
 
259
        case RHYTHMDB_PROP_MOUNTPOINT:
 
260
                return rb_refstring_get (entry->mountpoint);
 
261
        case RHYTHMDB_PROP_LAST_PLAYED_STR:
 
262
                return rb_refstring_get (entry->last_played_str);
 
263
        case RHYTHMDB_PROP_PLAYBACK_ERROR:
 
264
                return entry->playback_error;
 
265
        case RHYTHMDB_PROP_FIRST_SEEN_STR:
 
266
                return rb_refstring_get (entry->first_seen_str);
 
267
//podcast propriets
 
268
        case RHYTHMDB_PROP_DESCRIPTION:
 
269
                if (entry->podcast)
 
270
                        return rb_refstring_get (entry->podcast->description);
 
271
                else
 
272
                        return NULL;
 
273
        case RHYTHMDB_PROP_SUBTITLE:
 
274
                if (entry->podcast)
 
275
                        return rb_refstring_get (entry->podcast->subtitle);
 
276
                else
 
277
                        return NULL;
 
278
        case RHYTHMDB_PROP_SUMMARY: 
 
279
                if (entry->podcast)
 
280
                        return rb_refstring_get (entry->podcast->summary);
 
281
                else
 
282
                        return NULL;
 
283
        case RHYTHMDB_PROP_LANG:
 
284
                if (entry->podcast)
 
285
                        return rb_refstring_get (entry->podcast->lang);
 
286
                else
 
287
                        return NULL;
 
288
        case RHYTHMDB_PROP_COPYRIGHT:
 
289
                if (entry->podcast)
 
290
                        return rb_refstring_get (entry->podcast->copyright);
 
291
                else
 
292
                        return NULL;
 
293
        case RHYTHMDB_PROP_IMAGE:
 
294
                if (entry->podcast)
 
295
                        return rb_refstring_get (entry->podcast->image);
 
296
                else
 
297
                        return NULL;
 
298
 
 
299
        default:
 
300
                g_assert_not_reached ();
 
301
                return NULL;
 
302
        }
 
303
}
 
304
 
 
305
G_INLINE_FUNC gboolean
 
306
rhythmdb_entry_get_boolean (RhythmDBEntry *entry, RhythmDBPropType propid)
 
307
{
 
308
        switch (propid) {
 
309
        case RHYTHMDB_PROP_HIDDEN:
 
310
                return entry->hidden;
 
311
        default:
 
312
                g_assert_not_reached ();
 
313
                return FALSE;
 
314
        }
 
315
}
 
316
 
 
317
G_INLINE_FUNC guint64
 
318
rhythmdb_entry_get_uint64 (RhythmDBEntry *entry, RhythmDBPropType propid)
 
319
{
 
320
        switch (propid) {
 
321
        case RHYTHMDB_PROP_FILE_SIZE:
 
322
                return entry->file_size;
 
323
        default:
 
324
                g_assert_not_reached ();
 
325
                return 0;
 
326
        }
 
327
}
 
328
 
 
329
G_INLINE_FUNC gulong
 
330
rhythmdb_entry_get_ulong (RhythmDBEntry *entry, RhythmDBPropType propid)
 
331
{
 
332
        switch (propid) {
 
333
        case RHYTHMDB_PROP_TYPE:
 
334
                return entry->type;
 
335
        case RHYTHMDB_PROP_TRACK_NUMBER:
 
336
                return entry->tracknum;
 
337
        case RHYTHMDB_PROP_DISC_NUMBER:
 
338
                return entry->discnum;
 
339
        case RHYTHMDB_PROP_DURATION:
 
340
                return entry->duration;
 
341
        case RHYTHMDB_PROP_MTIME:
 
342
                return entry->mtime;
 
343
        case RHYTHMDB_PROP_FIRST_SEEN:
 
344
                return entry->first_seen;
 
345
        case RHYTHMDB_PROP_LAST_SEEN:
 
346
                return entry->last_seen;
 
347
        case RHYTHMDB_PROP_LAST_PLAYED:
 
348
                return entry->last_played;
 
349
        case RHYTHMDB_PROP_PLAY_COUNT:
 
350
                return entry->play_count;
 
351
        case RHYTHMDB_PROP_BITRATE:
 
352
                return entry->bitrate;          
 
353
        case RHYTHMDB_PROP_DATE:
 
354
                if (entry->date)
 
355
                        return g_date_get_julian (entry->date);
 
356
                else
 
357
                        return 0;
 
358
        case RHYTHMDB_PROP_POST_TIME:
 
359
                if (entry->podcast)
 
360
                        return entry->podcast->post_time;
 
361
                else
 
362
                        return 0;
 
363
        case RHYTHMDB_PROP_STATUS:
 
364
                if (entry->podcast)
 
365
                        return entry->podcast->status;          
 
366
                else
 
367
                        return 0;
 
368
        default:
 
369
                g_assert_not_reached ();
 
370
                return 0;
 
371
        }
 
372
}
 
373
 
 
374
G_INLINE_FUNC double
 
375
rhythmdb_entry_get_double (RhythmDBEntry *entry, RhythmDBPropType propid)
 
376
{
 
377
        switch (propid) {
 
378
        case RHYTHMDB_PROP_TRACK_GAIN:
 
379
                return entry->track_gain;
 
380
        case RHYTHMDB_PROP_TRACK_PEAK:
 
381
                return entry->track_peak;
 
382
        case RHYTHMDB_PROP_ALBUM_GAIN:
 
383
                return entry->album_gain;
 
384
        case RHYTHMDB_PROP_ALBUM_PEAK:
 
385
                return entry->album_peak;
 
386
        case RHYTHMDB_PROP_RATING:
 
387
                return entry->rating;
 
388
        default:
 
389
                g_assert_not_reached ();
 
390
                return 0.0;
 
391
        }
 
392
}
 
393
#endif
125
394
 
126
395
typedef enum
127
396
{
148
417
        /* signals */
149
418
        void    (*entry_added)          (RhythmDBEntry *entry);
150
419
        void    (*entry_restored)       (RhythmDBEntry *entry);
151
 
        void    (*entry_changed)        (RhythmDBEntry *entry, RhythmDBPropType prop,
152
 
                                         const GValue *old, const GValue *new);
 
420
        void    (*entry_changed)        (RhythmDBEntry *entry, GSList *changes); /* list of RhythmDBEntryChanges */
153
421
        void    (*entry_deleted)        (RhythmDBEntry *entry);
154
 
        void    (*load_complete)        (RhythmDBEntry *entry);
155
 
        void    (*save_complete)        (RhythmDBEntry *entry);
 
422
        void    (*load_complete)        (void);
 
423
        void    (*save_complete)        (void);
156
424
        void    (*error)                (const char *uri, const char *msg);
 
425
        void    (*read_only)            (gboolean readonly);
157
426
 
158
427
        /* virtual methods */
159
428
 
160
429
        void            (*impl_load)            (RhythmDB *db, gboolean *dead);
161
430
        void            (*impl_save)            (RhythmDB *db);
162
431
        
163
 
        RhythmDBEntry * (*impl_entry_new)       (RhythmDB *db, RhythmDBEntryType type,
164
 
                                                 const char *uri);
 
432
        void            (*impl_entry_new)       (RhythmDB *db, RhythmDBEntry *entry);
165
433
 
166
 
        void            (*impl_entry_set)       (RhythmDB *db, RhythmDBEntry *entry,
167
 
                                                 guint propid, const GValue *value);
 
434
        gboolean        (*impl_entry_set)       (RhythmDB *db, RhythmDBEntry *entry,
 
435
                                         guint propid, const GValue *value);
168
436
 
169
437
        void            (*impl_entry_get)       (RhythmDB *db, RhythmDBEntry *entry,
170
438
                                                 guint propid, GValue *value);
174
442
        void            (*impl_entry_delete_by_type) (RhythmDB *db, RhythmDBEntryType type);
175
443
 
176
444
        RhythmDBEntry * (*impl_lookup_by_location)(RhythmDB *db, const char *uri);
177
 
 
 
445
        
178
446
        gboolean        (*impl_evaluate_query)  (RhythmDB *db, GPtrArray *query, RhythmDBEntry *entry);
179
447
 
 
448
        void            (*impl_entry_foreach)   (RhythmDB *db, GFunc func, gpointer data);
 
449
 
180
450
        void            (*impl_do_full_query)   (RhythmDB *db, GPtrArray *query,
181
451
                                                 GtkTreeModel *main_model,
182
452
                                                 gboolean *cancel);
188
458
 
189
459
void            rhythmdb_shutdown       (RhythmDB *db);
190
460
 
191
 
/**
192
 
 * This function must be called WITHOUT the RhythmDB lock held!
193
 
 */
194
461
void            rhythmdb_load           (RhythmDB *db);
195
462
 
196
463
void            rhythmdb_save           (RhythmDB *db);
197
 
void            rhythmdb_save_blocking  (RhythmDB *db);
198
 
 
199
 
 
200
 
/* Used to mark DB as dirty after first start so that we
201
 
 *  always save a rhythmdb.xml.
202
 
 */
203
 
void            rhythmdb_set_dirty      (RhythmDB *db);
204
 
 
205
 
void            rhythmdb_read_lock      (RhythmDB *db);
206
 
void            rhythmdb_write_lock     (RhythmDB *db);
207
 
void            rhythmdb_read_unlock    (RhythmDB *db);
208
 
void            rhythmdb_write_unlock   (RhythmDB *db);
 
464
void            rhythmdb_save_async     (RhythmDB *db);
 
465
 
 
466
void            rhythmdb_commit         (RhythmDB *db);
209
467
 
210
468
gboolean        rhythmdb_entry_is_editable (RhythmDB *db, RhythmDBEntry *entry);
211
469
 
212
470
RhythmDBEntry * rhythmdb_entry_new      (RhythmDB *db, RhythmDBEntryType type, const char *uri);
213
471
 
214
 
void            rhythmdb_add_uri_async  (RhythmDB *db, const char *uri);
215
 
RhythmDBEntry * rhythmdb_add_song       (RhythmDB *db, const char *uri, GError **error);
 
472
void            rhythmdb_add_uri        (RhythmDB *db, const char *uri);
216
473
 
217
474
void            rhythmdb_entry_set      (RhythmDB *db, RhythmDBEntry *entry,
218
 
                                         guint propid, GValue *value);
219
 
 
220
 
void            rhythmdb_entry_queue_set(RhythmDB *db, RhythmDBEntry *entry,
221
 
                                         guint propid, GValue *value);
222
 
 
223
 
void            rhythmdb_entry_get      (RhythmDB *db, RhythmDBEntry *entry,
224
 
                                         guint propid, GValue *value);
225
 
 
226
 
#ifndef WITH_RHYTHMDB_TREE
227
 
#define rhythmdb_entry_ref(DB, ENTRY) 
228
 
#define rhythmdb_entry_ref_unlocked(DB, ENTRY) 
229
 
#define rhythmdb_entry_unref(DB, ENTRY) 
230
 
#define rhythmdb_entry_unref_unlocked(DB, ENTRY) 
231
 
#else
232
 
#include "rhythmdb-tree.h"
233
 
#endif
 
475
                                         guint propid, const GValue *value);
 
476
void            rhythmdb_entry_set_nonotify     (RhythmDB *db, RhythmDBEntry *entry,
 
477
                                                 guint propid, const GValue *value);
 
478
void            rhythmdb_entry_set_uninserted   (RhythmDB *db, RhythmDBEntry *entry,
 
479
                                                 guint propid, const GValue *value);
234
480
 
235
481
void            rhythmdb_entry_delete   (RhythmDB *db, RhythmDBEntry *entry);
236
482
void            rhythmdb_entry_delete_by_type (RhythmDB *db, 
237
483
                                               RhythmDBEntryType type);
238
484
 
239
485
 
240
 
const char *    rhythmdb_entry_get_string       (RhythmDB *db,
241
 
                                                 RhythmDBEntry *entry,
242
 
                                                 guint property_id);
243
 
gboolean        rhythmdb_entry_get_boolean      (RhythmDB *db,
244
 
                                                 RhythmDBEntry *entry,
245
 
                                                 guint property_id);
246
 
long            rhythmdb_entry_get_long         (RhythmDB *db,
247
 
                                                 RhythmDBEntry *entry,
248
 
                                                 guint property_id);
249
 
guint64         rhythmdb_entry_get_uint64       (RhythmDB *db,
250
 
                                                 RhythmDBEntry *entry,
251
 
                                                 guint property_id);
252
 
int             rhythmdb_entry_get_int          (RhythmDB *db,
253
 
                                                 RhythmDBEntry *entry,
254
 
                                                 guint property_id);
255
 
double          rhythmdb_entry_get_double       (RhythmDB *db,
256
 
                                                 RhythmDBEntry *entry,
257
 
                                                 guint property_id);
258
 
float           rhythmdb_entry_get_float        (RhythmDB *db,
259
 
                                                 RhythmDBEntry *entry,
260
 
                                                 guint property_id);
261
 
gpointer        rhythmdb_entry_get_pointer      (RhythmDB *db,
262
 
                                                 RhythmDBEntry *entry,
263
 
                                                 guint property_id);
264
 
 
265
486
RhythmDBEntry * rhythmdb_entry_lookup_by_location (RhythmDB *db, const char *uri);
266
487
 
267
488
gboolean        rhythmdb_evaluate_query         (RhythmDB *db, GPtrArray *query,
268
489
                                                 RhythmDBEntry *entry);
269
490
 
 
491
void            rhythmdb_entry_foreach          (RhythmDB *db,
 
492
                                                 GFunc func,
 
493
                                                 gpointer data);
 
494
 
270
495
/**
271
496
 * Returns a freshly allocated GtkTreeModel which represents the query.
272
497
 * The extended arguments alternate between RhythmDBQueryType args
273
 
 * and their values.  Here's an example:
274
 
 *
275
 
 * rhythmdb_do_full_query (db, RHYTHMDB_QUERY_PROP_EQUALS, "genre", "Classical",
276
 
 *                          RHYTHMDB_QUERY_PROP_GREATER, "rating", 5,
277
 
 *                          RHYTHMDB_QUERY_END);
278
 
 *
 
498
 * and their values. Items are prioritized like algebraic expressions, and
 
499
 * implicitly ANDed. Here's an example:
 
500
 *
 
501
rhythmdb_do_full_query (db,
 
502
                        RHYTHMDB_QUERY_PROP_EQUALS,
 
503
                                RHYTHMDB_PROP_ARTIST, "Pink Floyd",
 
504
                RHYTHMDB_QUERY_DISJUNCTION,
 
505
                        RHYTHMDB_QUERY_PROP_EQUALS,
 
506
                                RHYTHMDB_PROP_GENRE, "Classical",
 
507
                        RHYTHMDB_QUERY_PROP_GREATER,
 
508
                                RHYTHMDB_PROP_RATING, 5,
 
509
        RHYTHMDB_QUERY_END);
 
510
 * Which means: artist = Pink Floyd OR (genre = Classical AND rating >= 5)
279
511
 */
280
512
void            rhythmdb_do_full_query                  (RhythmDB *db,
281
513
                                                         GtkTreeModel *main_model,
291
523
 
292
524
void            rhythmdb_query_cancel                   (RhythmDB *db, GtkTreeModel *query_model);
293
525
 
294
 
GType           rhythmdb_get_property_type              (RhythmDB *db, guint property_id);
295
 
 
296
 
void            rhythmdb_entry_sync_mirrored            (RhythmDB *db, RhythmDBEntry *entry,
297
 
                                                         guint propid, GValue *value);
 
526
void            rhythmdb_entry_sync_mirrored            (RhythmDB *db, RhythmDBEntry *entry, guint propid);
298
527
 
299
528
GPtrArray *     rhythmdb_query_parse                    (RhythmDB *db, ...);
300
529
void            rhythmdb_query_append                   (RhythmDB *db, GPtrArray *query, ...);
301
530
void            rhythmdb_query_free                     (GPtrArray *query);
302
531
GPtrArray *     rhythmdb_query_copy                     (GPtrArray *array);
 
532
void            rhythmdb_query_preprocess               (GPtrArray *query);
303
533
 
304
534
void            rhythmdb_query_serialize                (RhythmDB *db, GPtrArray *query,
305
535
                                                         xmlNodePtr node);
306
536
 
307
537
GPtrArray *     rhythmdb_query_deserialize              (RhythmDB *db, xmlNodePtr node);
308
538
 
309
 
inline const char *     rhythmdb_nice_elt_name_from_propid      (RhythmDB *db, gint propid);
310
 
inline int              rhythmdb_propid_from_nice_elt_name      (RhythmDB *db, const char *name);
 
539
inline const xmlChar *  rhythmdb_nice_elt_name_from_propid      (RhythmDB *db, RhythmDBPropType propid);
 
540
inline int              rhythmdb_propid_from_nice_elt_name      (RhythmDB *db, const xmlChar *name);
311
541
 
312
542
void            rhythmdb_emit_entry_added               (RhythmDB *db, RhythmDBEntry *entry);
313
 
void            rhythmdb_emit_entry_restored            (RhythmDB *db, RhythmDBEntry *entry);
314
543
void            rhythmdb_emit_entry_deleted             (RhythmDB *db, RhythmDBEntry *entry);
315
544
 
316
 
char *          rhythmdb_get_status                     (RhythmDB *db);
 
545
gboolean        rhythmdb_is_busy                        (RhythmDB *db);
317
546
char *          rhythmdb_compute_status_normal          (gint n_songs, glong duration,
318
547
                                                         GnomeVFSFileSize size);
319
548
RhythmDBEntryType rhythmdb_entry_register_type          (void);
320
549
 
321
550
RhythmDBEntryType rhythmdb_entry_song_get_type          (void);
322
551
RhythmDBEntryType rhythmdb_entry_iradio_get_type        (void);
 
552
RhythmDBEntryType rhythmdb_entry_podcast_post_get_type  (void);
 
553
RhythmDBEntryType rhythmdb_entry_podcast_feed_get_type  (void);
323
554
RhythmDBEntryType rhythmdb_entry_icecast_get_type        (void);
324
555
 
 
556
extern GType rhythmdb_property_type_map[RHYTHMDB_NUM_PROPERTIES];
 
557
G_INLINE_FUNC GType rhythmdb_get_property_type          (RhythmDB *db, guint property_id);
 
558
 
 
559
#if defined (G_CAN_INLINE) || defined (__RHYTHMDB_C__)
 
560
 
 
561
G_INLINE_FUNC GType
 
562
rhythmdb_get_property_type (RhythmDB *db, guint property_id)
 
563
{
 
564
        g_assert (property_id >= 0 && property_id < RHYTHMDB_NUM_PROPERTIES);
 
565
        return rhythmdb_property_type_map[property_id];
 
566
}
 
567
 
 
568
#endif
 
569
 
 
570
void rhythmdb_entry_ref (RhythmDB *db, RhythmDBEntry *entry);
 
571
 
 
572
void rhythmdb_entry_unref (RhythmDB *db, RhythmDBEntry *entry);
325
573
 
326
574
G_END_DECLS
327
575