← Back to branch summary

~and471/+junk/symphony-legacy

« back to all changes in this revision

Viewing changes to src/frontend/widgets/stores/tracks.c

  • Committer: rugby471 at gmail
  • Date: 2011-02-18 21:11:12 UTC
  • Revision ID: rugby471@gmail.com-20110218211112-w3dhag8ttp1quckk
lots more :)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/frontend/widgets/stores/tracks.c
28
28
typedef struct _TrackStoreClass TrackStoreClass;
29
29
typedef struct _TrackStorePrivate TrackStorePrivate;
30
30
 
 
31
#define TYPE_PLAYER (player_get_type ())
 
32
#define PLAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PLAYER, Player))
 
33
#define PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PLAYER, PlayerClass))
 
34
#define IS_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PLAYER))
 
35
#define IS_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PLAYER))
 
36
#define PLAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PLAYER, PlayerClass))
 
37
 
 
38
typedef struct _Player Player;
 
39
typedef struct _PlayerClass PlayerClass;
 
40
#define _g_free0(var) ((var == NULL) ? NULL : (var = (g_free (var), NULL)))
 
41
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
42
 
31
43
#define TYPE_TRACK (track_get_type ())
32
44
#define TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRACK, Track))
33
45
#define TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRACK, TrackClass))
48
60
 
49
61
typedef struct _Album Album;
50
62
typedef struct _AlbumClass AlbumClass;
51
 
#define _g_free0(var) (var = (g_free (var), NULL))
52
63
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
53
64
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
54
65
 
55
66
#define TYPE_TRACK_STORE_COL (track_store_col_get_type ())
56
67
 
 
68
#define TYPE_LOGGER (logger_get_type ())
 
69
#define LOGGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LOGGER, Logger))
 
70
#define LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LOGGER, LoggerClass))
 
71
#define IS_LOGGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LOGGER))
 
72
#define IS_LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LOGGER))
 
73
#define LOGGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LOGGER, LoggerClass))
 
74
 
 
75
typedef struct _Logger Logger;
 
76
typedef struct _LoggerClass LoggerClass;
 
77
 
57
78
struct _TrackStore {
58
79
        GtkListStore parent_instance;
59
80
        TrackStorePrivate * priv;
63
84
        GtkListStoreClass parent_class;
64
85
};
65
86
 
 
87
struct _TrackStorePrivate {
 
88
        GtkTreeIter* highlighted_iter;
 
89
        Player* player;
 
90
};
 
91
 
66
92
struct _Track {
67
93
        GObject parent_instance;
68
94
        TrackPrivate * priv;
 
95
        guint id;
69
96
        gchar* title;
70
97
        gchar* artist;
71
98
        gchar* album;
93
120
 
94
121
 
95
122
static gpointer track_store_parent_class = NULL;
 
123
extern Logger* Log;
96
124
 
97
125
GType track_store_get_type (void) G_GNUC_CONST;
 
126
GType player_get_type (void) G_GNUC_CONST;
 
127
#define TRACK_STORE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TRACK_STORE, TrackStorePrivate))
98
128
enum  {
99
129
        TRACK_STORE_DUMMY_PROPERTY
100
130
};
101
 
TrackStore* track_store_new (void);
102
 
TrackStore* track_store_construct (GType object_type);
 
131
TrackStore* track_store_new (Player* player);
 
132
TrackStore* track_store_construct (GType object_type, Player* player);
103
133
GType track_get_type (void) G_GNUC_CONST;
104
134
void track_store_add_track (TrackStore* self, Track* track);
105
135
GType album_get_type (void) G_GNUC_CONST;
106
136
GType track_store_col_get_type (void) G_GNUC_CONST;
107
 
 
108
 
 
109
 
TrackStore* track_store_construct (GType object_type) {
 
137
Track* player_get_current_track (Player* self);
 
138
void track_store_unhighlight_row (TrackStore* self, GtkTreeIter* iter);
 
139
void track_store_highlight_row (TrackStore* self, GtkTreeIter* iter);
 
140
static GtkTreeIter* _gtk_tree_iter_dup (GtkTreeIter* self);
 
141
GType logger_get_type (void) G_GNUC_CONST;
 
142
void logger_debug (Logger* self, const gchar* text);
 
143
static gboolean _gtk_tree_iter_equal (const GtkTreeIter* s1, const GtkTreeIter* s2);
 
144
static void track_store_finalize (GObject* obj);
 
145
 
 
146
 
 
147
static gpointer _g_object_ref0 (gpointer self) {
 
148
        return self ? g_object_ref (self) : NULL;
 
149
}
 
150
 
 
151
 
 
152
TrackStore* track_store_construct (GType object_type, Player* player) {
110
153
        TrackStore * self = NULL;
 
154
        Player* _tmp0_;
 
155
        Player* _tmp1_;
111
156
        GType* column_types = NULL;
112
157
        gint column_types_length1 = 0;
113
158
        gint _column_types_size_ = 0;
114
 
        GType* _tmp0_ = NULL;
115
 
        GType* _tmp1_;
 
159
        GType* _tmp2_ = NULL;
 
160
        GType* _tmp3_;
 
161
        g_return_val_if_fail (player != NULL, NULL);
116
162
        self = (TrackStore*) g_object_new (object_type, NULL);
117
 
        _tmp0_ = g_new0 (GType, 3);
118
 
        _tmp0_[0] = TYPE_TRACK;
119
 
        _tmp0_[1] = G_TYPE_STRING;
120
 
        _tmp0_[2] = G_TYPE_STRING;
 
163
        _tmp0_ = _g_object_ref0 (player);
121
164
        _tmp1_ = _tmp0_;
 
165
        _g_object_unref0 (self->priv->player);
 
166
        self->priv->player = _tmp1_;
 
167
        _tmp2_ = g_new0 (GType, 3);
 
168
        _tmp2_[0] = TYPE_TRACK;
 
169
        _tmp2_[1] = G_TYPE_STRING;
 
170
        _tmp2_[2] = G_TYPE_STRING;
 
171
        _tmp3_ = _tmp2_;
122
172
        column_types = (g_free (column_types), NULL);
123
173
        column_types_length1 = 3;
124
174
        _column_types_size_ = column_types_length1;
125
 
        column_types = _tmp1_;
 
175
        column_types = _tmp3_;
126
176
        gtk_list_store_set_column_types ((GtkListStore*) self, column_types_length1, column_types);
127
177
        column_types = (g_free (column_types), NULL);
128
178
        return self;
129
179
}
130
180
 
131
181
 
132
 
TrackStore* track_store_new (void) {
133
 
        return track_store_construct (TYPE_TRACK_STORE);
 
182
TrackStore* track_store_new (Player* player) {
 
183
        return track_store_construct (TYPE_TRACK_STORE, player);
134
184
}
135
185
 
136
186
 
193
243
}
194
244
 
195
245
 
 
246
static GtkTreeIter* _gtk_tree_iter_dup (GtkTreeIter* self) {
 
247
        GtkTreeIter* dup;
 
248
        dup = g_new0 (GtkTreeIter, 1);
 
249
        memcpy (dup, self, sizeof (GtkTreeIter));
 
250
        return dup;
 
251
}
 
252
 
 
253
 
 
254
static gpointer __gtk_tree_iter_dup0 (gpointer self) {
 
255
        return self ? _gtk_tree_iter_dup (self) : NULL;
 
256
}
 
257
 
 
258
 
196
259
void track_store_add_track (TrackStore* self, Track* track) {
197
260
        gchar* _tmp0_ = NULL;
198
261
        gchar* title;
200
263
        gchar* number;
201
264
        GtkTreeIter iter = {0};
202
265
        GtkTreeIter _tmp2_ = {0};
 
266
        Track* _tmp3_ = NULL;
203
267
        g_return_if_fail (self != NULL);
204
268
        g_return_if_fail (track != NULL);
205
269
        _tmp0_ = string_replace (track->title, "&", "&");
209
273
        gtk_list_store_append ((GtkListStore*) self, &_tmp2_);
210
274
        iter = _tmp2_;
211
275
        gtk_list_store_set ((GtkListStore*) self, &iter, TRACK_STORE_COL_TRACK_OBJ, track, TRACK_STORE_COL_NUMBER, number, TRACK_STORE_COL_TITLE, title, -1);
 
276
        _tmp3_ = player_get_current_track (self->priv->player);
 
277
        if (_tmp3_ != NULL) {
 
278
                Track* _tmp4_ = NULL;
 
279
                _tmp4_ = player_get_current_track (self->priv->player);
 
280
                if (_tmp4_->id == track->id) {
 
281
                        GtkTreeIter* _tmp5_;
 
282
                        GtkTreeIter* _tmp6_;
 
283
                        track_store_unhighlight_row (self, &iter);
 
284
                        track_store_highlight_row (self, &iter);
 
285
                        _tmp5_ = __gtk_tree_iter_dup0 (&iter);
 
286
                        _tmp6_ = _tmp5_;
 
287
                        _g_free0 (self->priv->highlighted_iter);
 
288
                        self->priv->highlighted_iter = _tmp6_;
 
289
                }
 
290
        }
212
291
        _g_free0 (number);
213
292
        _g_free0 (title);
214
293
}
215
294
 
216
295
 
 
296
void track_store_highlight_row (TrackStore* self, GtkTreeIter* iter) {
 
297
        Track* track = NULL;
 
298
        GValue value_track = {0};
 
299
        GValue _tmp0_ = {0};
 
300
        Track* _tmp1_;
 
301
        Track* _tmp2_;
 
302
        gchar* _tmp3_ = NULL;
 
303
        gchar* _tmp4_;
 
304
        gchar* _tmp5_ = NULL;
 
305
        GValue _tmp6_ = {0};
 
306
        gchar* _tmp7_ = NULL;
 
307
        gchar* _tmp8_;
 
308
        gchar* _tmp9_ = NULL;
 
309
        GValue _tmp10_ = {0};
 
310
        GtkTreeIter* _tmp11_;
 
311
        GtkTreeIter* _tmp12_;
 
312
        g_return_if_fail (self != NULL);
 
313
        gtk_tree_model_get_value ((GtkTreeModel*) self, iter, (gint) TRACK_STORE_COL_TRACK_OBJ, &_tmp0_);
 
314
        G_IS_VALUE (&value_track) ? (g_value_unset (&value_track), NULL) : NULL;
 
315
        value_track = _tmp0_;
 
316
        _tmp1_ = _g_object_ref0 (g_value_get_object (&value_track));
 
317
        _tmp2_ = _tmp1_;
 
318
        _g_object_unref0 (track);
 
319
        track = _tmp2_;
 
320
        _tmp3_ = g_strdup_printf ("%u", track->number);
 
321
        _tmp4_ = _tmp3_;
 
322
        _tmp5_ = g_strdup_printf ("<span weight='bold'>%s</span>", _tmp4_);
 
323
        g_value_init (&_tmp6_, G_TYPE_STRING);
 
324
        g_value_take_string (&_tmp6_, _tmp5_);
 
325
        gtk_list_store_set_value ((GtkListStore*) self, iter, (gint) TRACK_STORE_COL_NUMBER, &_tmp6_);
 
326
        G_IS_VALUE (&_tmp6_) ? (g_value_unset (&_tmp6_), NULL) : NULL;
 
327
        _g_free0 (_tmp4_);
 
328
        _tmp7_ = string_replace (track->title, "&", "&amp;");
 
329
        _tmp8_ = _tmp7_;
 
330
        _tmp9_ = g_strdup_printf ("<span weight='bold'>%s</span>", _tmp8_);
 
331
        g_value_init (&_tmp10_, G_TYPE_STRING);
 
332
        g_value_take_string (&_tmp10_, _tmp9_);
 
333
        gtk_list_store_set_value ((GtkListStore*) self, iter, (gint) TRACK_STORE_COL_TITLE, &_tmp10_);
 
334
        G_IS_VALUE (&_tmp10_) ? (g_value_unset (&_tmp10_), NULL) : NULL;
 
335
        _g_free0 (_tmp8_);
 
336
        _tmp11_ = __gtk_tree_iter_dup0 (iter);
 
337
        _tmp12_ = _tmp11_;
 
338
        _g_free0 (self->priv->highlighted_iter);
 
339
        self->priv->highlighted_iter = _tmp12_;
 
340
        G_IS_VALUE (&value_track) ? (g_value_unset (&value_track), NULL) : NULL;
 
341
        _g_object_unref0 (track);
 
342
}
 
343
 
 
344
 
 
345
static gboolean _gtk_tree_iter_equal (const GtkTreeIter* s1, const GtkTreeIter* s2) {
 
346
        if (s1 == s2) {
 
347
                return TRUE;
 
348
        }
 
349
        if (s1 == NULL) {
 
350
                return FALSE;
 
351
        }
 
352
        if (s2 == NULL) {
 
353
                return FALSE;
 
354
        }
 
355
        if (s1->stamp != s2->stamp) {
 
356
                return FALSE;
 
357
        }
 
358
        if (s1->user_data != s2->user_data) {
 
359
                return FALSE;
 
360
        }
 
361
        if (s1->user_data2 != s2->user_data2) {
 
362
                return FALSE;
 
363
        }
 
364
        if (s1->user_data3 != s2->user_data3) {
 
365
                return FALSE;
 
366
        }
 
367
        return TRUE;
 
368
}
 
369
 
 
370
 
 
371
void track_store_unhighlight_row (TrackStore* self, GtkTreeIter* iter) {
 
372
        gboolean _tmp0_ = FALSE;
 
373
        gboolean _tmp1_ = FALSE;
 
374
        g_return_if_fail (self != NULL);
 
375
        logger_debug (Log, "unhighlight");
 
376
        if (self->priv->highlighted_iter != NULL) {
 
377
                _tmp1_ = _gtk_tree_iter_equal (self->priv->highlighted_iter, iter) != TRUE;
 
378
        } else {
 
379
                _tmp1_ = FALSE;
 
380
        }
 
381
        if (_tmp1_) {
 
382
                gboolean _tmp2_;
 
383
                _tmp2_ = gtk_list_store_iter_is_valid ((GtkListStore*) self, self->priv->highlighted_iter);
 
384
                _tmp0_ = _tmp2_;
 
385
        } else {
 
386
                _tmp0_ = FALSE;
 
387
        }
 
388
        if (_tmp0_) {
 
389
                Track* track = NULL;
 
390
                GValue value_track = {0};
 
391
                GValue _tmp3_ = {0};
 
392
                Track* _tmp4_;
 
393
                Track* _tmp5_;
 
394
                gchar* _tmp6_ = NULL;
 
395
                gchar* _tmp7_;
 
396
                gchar* _tmp8_ = NULL;
 
397
                GValue _tmp9_ = {0};
 
398
                gchar* _tmp10_ = NULL;
 
399
                gchar* _tmp11_;
 
400
                gchar* _tmp12_ = NULL;
 
401
                GValue _tmp13_ = {0};
 
402
                logger_debug (Log, "do highlight");
 
403
                gtk_tree_model_get_value ((GtkTreeModel*) self, self->priv->highlighted_iter, (gint) TRACK_STORE_COL_TRACK_OBJ, &_tmp3_);
 
404
                G_IS_VALUE (&value_track) ? (g_value_unset (&value_track), NULL) : NULL;
 
405
                value_track = _tmp3_;
 
406
                _tmp4_ = _g_object_ref0 (g_value_get_object (&value_track));
 
407
                _tmp5_ = _tmp4_;
 
408
                _g_object_unref0 (track);
 
409
                track = _tmp5_;
 
410
                _tmp6_ = g_strdup_printf ("%u", track->number);
 
411
                _tmp7_ = _tmp6_;
 
412
                _tmp8_ = g_strdup_printf ("%s", _tmp7_);
 
413
                g_value_init (&_tmp9_, G_TYPE_STRING);
 
414
                g_value_take_string (&_tmp9_, _tmp8_);
 
415
                gtk_list_store_set_value ((GtkListStore*) self, self->priv->highlighted_iter, (gint) TRACK_STORE_COL_NUMBER, &_tmp9_);
 
416
                G_IS_VALUE (&_tmp9_) ? (g_value_unset (&_tmp9_), NULL) : NULL;
 
417
                _g_free0 (_tmp7_);
 
418
                _tmp10_ = string_replace (track->title, "&", "&amp;");
 
419
                _tmp11_ = _tmp10_;
 
420
                _tmp12_ = g_strdup_printf ("%s", _tmp11_);
 
421
                g_value_init (&_tmp13_, G_TYPE_STRING);
 
422
                g_value_take_string (&_tmp13_, _tmp12_);
 
423
                gtk_list_store_set_value ((GtkListStore*) self, self->priv->highlighted_iter, (gint) TRACK_STORE_COL_TITLE, &_tmp13_);
 
424
                G_IS_VALUE (&_tmp13_) ? (g_value_unset (&_tmp13_), NULL) : NULL;
 
425
                _g_free0 (_tmp11_);
 
426
                G_IS_VALUE (&value_track) ? (g_value_unset (&value_track), NULL) : NULL;
 
427
                _g_object_unref0 (track);
 
428
        }
 
429
}
 
430
 
 
431
 
217
432
static void track_store_class_init (TrackStoreClass * klass) {
218
433
        track_store_parent_class = g_type_class_peek_parent (klass);
 
434
        g_type_class_add_private (klass, sizeof (TrackStorePrivate));
 
435
        G_OBJECT_CLASS (klass)->finalize = track_store_finalize;
219
436
}
220
437
 
221
438
 
222
439
static void track_store_instance_init (TrackStore * self) {
 
440
        self->priv = TRACK_STORE_GET_PRIVATE (self);
 
441
        self->priv->highlighted_iter = NULL;
 
442
}
 
443
 
 
444
 
 
445
static void track_store_finalize (GObject* obj) {
 
446
        TrackStore * self;
 
447
        self = TRACK_STORE (obj);
 
448
        _g_free0 (self->priv->highlighted_iter);
 
449
        _g_object_unref0 (self->priv->player);
 
450
        G_OBJECT_CLASS (track_store_parent_class)->finalize (obj);
223
451
}
224
452
 
225
453