← Back to branch summary

~ubuntu-branches/debian/stretch/betaradio/stretch

« back to all changes in this revision

Viewing changes to src/betaradio.c

  • Committer: Bazaar Package Importer
  • Author(s): Shih-Yuan Lee (FourDollars)
  • Date: 2010-10-08 12:18:06 UTC
  • Revision ID: james.westby@ubuntu.com-20101008121806-k1sj8jn5elq86v71
Tags: upstream-1.2
Import upstream version 1.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/betaradio.c
 
1
/* betaradio.c generated by valac, the Vala compiler
 
2
 * generated from betaradio.vala, do not modify */
 
3
 
 
4
/* -*- coding: utf-8; indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*- */
 
5
/* vim:set fileencodings=utf-8 tabstop=4 expandtab shiftwidth=4 softtabstop=4: */
 
6
 
 
7
#include <glib.h>
 
8
#include <glib-object.h>
 
9
#include <gtk/gtk.h>
 
10
#include <glib/gi18n-lib.h>
 
11
#include <config.h>
 
12
#include <gst/gst.h>
 
13
#include <stdlib.h>
 
14
#include <string.h>
 
15
#include <glib/gstdio.h>
 
16
#include <gdk/gdk.h>
 
17
 
 
18
 
 
19
#define TYPE_BETA_RADIO (beta_radio_get_type ())
 
20
#define BETA_RADIO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BETA_RADIO, BetaRadio))
 
21
#define BETA_RADIO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BETA_RADIO, BetaRadioClass))
 
22
#define IS_BETA_RADIO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BETA_RADIO))
 
23
#define IS_BETA_RADIO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BETA_RADIO))
 
24
#define BETA_RADIO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BETA_RADIO, BetaRadioClass))
 
25
 
 
26
typedef struct _BetaRadio BetaRadio;
 
27
typedef struct _BetaRadioClass BetaRadioClass;
 
28
typedef struct _BetaRadioPrivate BetaRadioPrivate;
 
29
 
 
30
#define TYPE_GST_PLAYER (gst_player_get_type ())
 
31
#define GST_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_GST_PLAYER, GstPlayer))
 
32
#define GST_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_GST_PLAYER, GstPlayerClass))
 
33
#define IS_GST_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_GST_PLAYER))
 
34
#define IS_GST_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_GST_PLAYER))
 
35
#define GST_PLAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_GST_PLAYER, GstPlayerClass))
 
36
 
 
37
typedef struct _GstPlayer GstPlayer;
 
38
typedef struct _GstPlayerClass GstPlayerClass;
 
39
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
40
 
 
41
#define TYPE_JSON_SOUP (json_soup_get_type ())
 
42
#define JSON_SOUP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_JSON_SOUP, JsonSoup))
 
43
#define JSON_SOUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_JSON_SOUP, JsonSoupClass))
 
44
#define IS_JSON_SOUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_JSON_SOUP))
 
45
#define IS_JSON_SOUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_JSON_SOUP))
 
46
#define JSON_SOUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_JSON_SOUP, JsonSoupClass))
 
47
 
 
48
typedef struct _JsonSoup JsonSoup;
 
49
typedef struct _JsonSoupClass JsonSoupClass;
 
50
#define _g_free0(var) (var = (g_free (var), NULL))
 
51
typedef struct _Block1Data Block1Data;
 
52
typedef struct _Block2Data Block2Data;
 
53
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
 
54
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
55
 
 
56
struct _BetaRadio {
 
57
        GObject parent_instance;
 
58
        BetaRadioPrivate * priv;
 
59
};
 
60
 
 
61
struct _BetaRadioClass {
 
62
        GObjectClass parent_class;
 
63
};
 
64
 
 
65
struct _BetaRadioPrivate {
 
66
        GtkStatusIcon* icon;
 
67
        GtkMenu* menu;
 
68
        GstPlayer* player;
 
69
};
 
70
 
 
71
struct _Block1Data {
 
72
        int _ref_count_;
 
73
        BetaRadio * self;
 
74
        char* title;
 
75
        char* url;
 
76
};
 
77
 
 
78
struct _Block2Data {
 
79
        int _ref_count_;
 
80
        BetaRadio * self;
 
81
        char* title;
 
82
        char* url;
 
83
};
 
84
 
 
85
 
 
86
static gpointer beta_radio_parent_class = NULL;
 
87
 
 
88
GType beta_radio_get_type (void);
 
89
GType gst_player_get_type (void);
 
90
#define BETA_RADIO_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_BETA_RADIO, BetaRadioPrivate))
 
91
enum  {
 
92
        BETA_RADIO_DUMMY_PROPERTY
 
93
};
 
94
BetaRadio* beta_radio_new (void);
 
95
BetaRadio* beta_radio_construct (GType object_type);
 
96
void beta_radio_main (char** args, int args_length1);
 
97
void gst_player_stop (GstPlayer* self);
 
98
static void _lambda0_ (GtkMenuItem* e, BetaRadio* self);
 
99
static void __lambda0__gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self);
 
100
static GSList* beta_radio_getMenu (BetaRadio* self, GtkMenu* menu, GSList* group);
 
101
static void _lambda3_ (GtkMenuItem* e, BetaRadio* self);
 
102
static void __lambda3__gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self);
 
103
static gboolean _lambda4_ (GdkEventButton* e, BetaRadio* self);
 
104
static gboolean __lambda4__gtk_status_icon_button_release_event (GtkStatusIcon* _sender, GdkEventButton* event, gpointer self);
 
105
JsonSoup* json_soup_new_http (const char* url);
 
106
JsonSoup* json_soup_construct_http (GType object_type, const char* url);
 
107
GType json_soup_get_type (void);
 
108
gboolean json_soup_is_array (JsonSoup* self);
 
109
gint json_soup_length (JsonSoup* self);
 
110
JsonSoup* json_soup_array (JsonSoup* self, gint idx);
 
111
char* json_soup_get_string (JsonSoup* self);
 
112
JsonSoup* json_soup_object (JsonSoup* self, const char* name);
 
113
gboolean json_soup_is_string (JsonSoup* self);
 
114
JsonSoup* json_soup_sibling (JsonSoup* self, const char* name);
 
115
static GSList* beta_radio_getCategoryMenu (BetaRadio* self, GtkMenu* menu, GSList* group, JsonSoup* json);
 
116
static GSList* beta_radio_getChannelMenu (BetaRadio* self, GtkMenu* menu, GSList* group, JsonSoup* json);
 
117
JsonSoup* json_soup_parent (JsonSoup* self);
 
118
static char* beta_radio_filter_url (BetaRadio* self, const char* url, const char* type);
 
119
GstPlayer* gst_player_new (const char* name, const char* url);
 
120
GstPlayer* gst_player_construct (GType object_type, const char* name, const char* url);
 
121
void gst_player_play (GstPlayer* self);
 
122
static void _lambda1_ (GtkCheckMenuItem* e, Block1Data* _data1_);
 
123
static void __lambda1__gtk_check_menu_item_toggled (GtkCheckMenuItem* _sender, gpointer self);
 
124
JsonSoup* json_soup_grandparent (JsonSoup* self);
 
125
static Block1Data* block1_data_ref (Block1Data* _data1_);
 
126
static void block1_data_unref (Block1Data* _data1_);
 
127
static void _lambda2_ (GtkCheckMenuItem* e, Block2Data* _data2_);
 
128
static void __lambda2__gtk_check_menu_item_toggled (GtkCheckMenuItem* _sender, gpointer self);
 
129
static Block2Data* block2_data_ref (Block2Data* _data2_);
 
130
static void block2_data_unref (Block2Data* _data2_);
 
131
static void beta_radio_finalize (GObject* obj);
 
132
static int _vala_strcmp0 (const char * str1, const char * str2);
 
133
 
 
134
 
 
135
 
 
136
void beta_radio_main (char** args, int args_length1) {
 
137
        BetaRadio* app;
 
138
        bindtextdomain (PACKAGE_NAME, LOCALEDIR);
 
139
        bind_textdomain_codeset (PACKAGE_NAME, "UTF-8");
 
140
        textdomain (PACKAGE_NAME);
 
141
        gst_init (&args_length1, &args);
 
142
        gtk_init (&args_length1, &args);
 
143
        app = beta_radio_new ();
 
144
        gtk_main ();
 
145
        _g_object_unref0 (app);
 
146
}
 
147
 
 
148
 
 
149
int main (int argc, char ** argv) {
 
150
        g_type_init ();
 
151
        beta_radio_main (argv, argc);
 
152
        return 0;
 
153
}
 
154
 
 
155
 
 
156
static void _lambda0_ (GtkMenuItem* e, BetaRadio* self) {
 
157
        g_return_if_fail (e != NULL);
 
158
        if (self->priv->player != NULL) {
 
159
                GstPlayer* _tmp0_;
 
160
                gst_player_stop (self->priv->player);
 
161
                self->priv->player = (_tmp0_ = NULL, _g_object_unref0 (self->priv->player), _tmp0_);
 
162
                gtk_status_icon_set_tooltip_text (self->priv->icon, _ ("BetaRadio Tuner"));
 
163
        }
 
164
}
 
165
 
 
166
 
 
167
static void __lambda0__gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self) {
 
168
        _lambda0_ (_sender, self);
 
169
}
 
170
 
 
171
 
 
172
static void _lambda3_ (GtkMenuItem* e, BetaRadio* self) {
 
173
        g_return_if_fail (e != NULL);
 
174
        if (self->priv->player != NULL) {
 
175
                GstPlayer* _tmp0_;
 
176
                gst_player_stop (self->priv->player);
 
177
                self->priv->player = (_tmp0_ = NULL, _g_object_unref0 (self->priv->player), _tmp0_);
 
178
                gtk_status_icon_set_tooltip_text (self->priv->icon, _ ("BetaRadio Tuner"));
 
179
        }
 
180
        gtk_main_quit ();
 
181
}
 
182
 
 
183
 
 
184
static void __lambda3__gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self) {
 
185
        _lambda3_ (_sender, self);
 
186
}
 
187
 
 
188
 
 
189
static gboolean _lambda4_ (GdkEventButton* e, BetaRadio* self) {
 
190
        gboolean result = FALSE;
 
191
        gtk_menu_popup (self->priv->menu, NULL, NULL, NULL, NULL, (*e).button, (*e).time);
 
192
        result = TRUE;
 
193
        return result;
 
194
}
 
195
 
 
196
 
 
197
static gboolean __lambda4__gtk_status_icon_button_release_event (GtkStatusIcon* _sender, GdkEventButton* event, gpointer self) {
 
198
        return _lambda4_ (event, self);
 
199
}
 
200
 
 
201
 
 
202
BetaRadio* beta_radio_construct (GType object_type) {
 
203
        BetaRadio * self;
 
204
        GtkMenu* _tmp3_;
 
205
        GSList* group;
 
206
        GtkRadioMenuItem* stop;
 
207
        GtkSeparatorMenuItem* _tmp4_;
 
208
        GtkSeparatorMenuItem* _tmp5_;
 
209
        GtkRadioMenuItem* quit;
 
210
        self = (BetaRadio*) g_object_new (object_type, NULL);
 
211
        if (g_file_test (DATADIR "/pixmaps/betaradio/betaradio.png", G_FILE_TEST_IS_REGULAR) == TRUE) {
 
212
                GtkStatusIcon* _tmp0_;
 
213
                self->priv->icon = (_tmp0_ = gtk_status_icon_new_from_file (DATADIR "/pixmaps/betaradio/betaradio.png"), _g_object_unref0 (self->priv->icon), _tmp0_);
 
214
        } else {
 
215
                if (g_file_test ("data/betaradio.png", G_FILE_TEST_IS_REGULAR) == TRUE) {
 
216
                        GtkStatusIcon* _tmp1_;
 
217
                        self->priv->icon = (_tmp1_ = gtk_status_icon_new_from_file ("data/betaradio.png"), _g_object_unref0 (self->priv->icon), _tmp1_);
 
218
                } else {
 
219
                        GtkStatusIcon* _tmp2_;
 
220
                        self->priv->icon = (_tmp2_ = gtk_status_icon_new_from_stock (GTK_STOCK_MISSING_IMAGE), _g_object_unref0 (self->priv->icon), _tmp2_);
 
221
                }
 
222
        }
 
223
        gtk_status_icon_set_tooltip_text (self->priv->icon, _ ("BetaRadio Tuner"));
 
224
        self->priv->menu = (_tmp3_ = g_object_ref_sink ((GtkMenu*) gtk_menu_new ()), _g_object_unref0 (self->priv->menu), _tmp3_);
 
225
        group = NULL;
 
226
        stop = g_object_ref_sink ((GtkRadioMenuItem*) gtk_radio_menu_item_new_with_label (group, _ ("Stop")));
 
227
        group = gtk_radio_menu_item_get_group (stop);
 
228
        gtk_menu_shell_append ((GtkMenuShell*) self->priv->menu, (GtkWidget*) ((GtkMenuItem*) stop));
 
229
        g_signal_connect_object ((GtkMenuItem*) stop, "activate", (GCallback) __lambda0__gtk_menu_item_activate, self, 0);
 
230
        gtk_menu_shell_append ((GtkMenuShell*) self->priv->menu, (GtkWidget*) ((GtkMenuItem*) (_tmp4_ = g_object_ref_sink ((GtkSeparatorMenuItem*) gtk_separator_menu_item_new ()))));
 
231
        _g_object_unref0 (_tmp4_);
 
232
        group = beta_radio_getMenu (self, self->priv->menu, group);
 
233
        gtk_menu_shell_append ((GtkMenuShell*) self->priv->menu, (GtkWidget*) ((GtkMenuItem*) (_tmp5_ = g_object_ref_sink ((GtkSeparatorMenuItem*) gtk_separator_menu_item_new ()))));
 
234
        _g_object_unref0 (_tmp5_);
 
235
        quit = g_object_ref_sink ((GtkRadioMenuItem*) gtk_radio_menu_item_new_with_label (group, _ ("Quit")));
 
236
        group = gtk_radio_menu_item_get_group (stop);
 
237
        gtk_menu_shell_append ((GtkMenuShell*) self->priv->menu, (GtkWidget*) ((GtkMenuItem*) quit));
 
238
        g_signal_connect_object ((GtkMenuItem*) quit, "activate", (GCallback) __lambda3__gtk_menu_item_activate, self, 0);
 
239
        gtk_widget_show_all ((GtkWidget*) self->priv->menu);
 
240
        g_signal_connect_object (self->priv->icon, "button-release-event", (GCallback) __lambda4__gtk_status_icon_button_release_event, self, 0);
 
241
        _g_object_unref0 (stop);
 
242
        _g_object_unref0 (quit);
 
243
        return self;
 
244
}
 
245
 
 
246
 
 
247
BetaRadio* beta_radio_new (void) {
 
248
        return beta_radio_construct (TYPE_BETA_RADIO);
 
249
}
 
250
 
 
251
 
 
252
static GSList* beta_radio_getMenu (BetaRadio* self, GtkMenu* menu, GSList* group) {
 
253
        GSList* result = NULL;
 
254
        JsonSoup* list;
 
255
        gint length;
 
256
        g_return_val_if_fail (self != NULL, NULL);
 
257
        g_return_val_if_fail (menu != NULL, NULL);
 
258
        list = json_soup_new_http ("http://betaradio.googlecode.com/svn/trunk/utils/list.json");
 
259
        if (json_soup_is_array (list) == FALSE) {
 
260
                result = group;
 
261
                _g_object_unref0 (list);
 
262
                return result;
 
263
        }
 
264
        length = json_soup_length (list);
 
265
        {
 
266
                gint i;
 
267
                i = 0;
 
268
                {
 
269
                        gboolean _tmp0_;
 
270
                        _tmp0_ = TRUE;
 
271
                        while (TRUE) {
 
272
                                JsonSoup* _tmp1_;
 
273
                                char* _tmp2_;
 
274
                                char* feed;
 
275
                                JsonSoup* json;
 
276
                                JsonSoup* _tmp3_;
 
277
                                gboolean _tmp4_;
 
278
                                JsonSoup* _tmp5_;
 
279
                                char* _tmp6_;
 
280
                                char* title;
 
281
                                GtkMenuItem* item;
 
282
                                GtkMenu* submenu;
 
283
                                JsonSoup* _tmp7_;
 
284
                                char* _tmp8_;
 
285
                                char* property;
 
286
                                gboolean _tmp9_ = FALSE;
 
287
                                JsonSoup* _tmp13_;
 
288
                                if (!_tmp0_) {
 
289
                                        i++;
 
290
                                }
 
291
                                _tmp0_ = FALSE;
 
292
                                if (!(i < length)) {
 
293
                                        break;
 
294
                                }
 
295
                                feed = (_tmp2_ = json_soup_get_string (_tmp1_ = json_soup_array (list, i)), _g_object_unref0 (_tmp1_), _tmp2_);
 
296
                                json = json_soup_new_http (feed);
 
297
                                if ((_tmp4_ = json_soup_is_string (_tmp3_ = json_soup_object (json, "property")) == FALSE, _g_object_unref0 (_tmp3_), _tmp4_)) {
 
298
                                        _g_free0 (feed);
 
299
                                        _g_object_unref0 (json);
 
300
                                        continue;
 
301
                                }
 
302
                                title = (_tmp6_ = json_soup_get_string (_tmp5_ = json_soup_sibling (json, "title")), _g_object_unref0 (_tmp5_), _tmp6_);
 
303
                                item = g_object_ref_sink ((GtkMenuItem*) gtk_menu_item_new_with_label (title));
 
304
                                gtk_menu_shell_append ((GtkMenuShell*) menu, (GtkWidget*) item);
 
305
                                submenu = g_object_ref_sink ((GtkMenu*) gtk_menu_new ());
 
306
                                gtk_menu_item_set_submenu (item, (GtkWidget*) submenu);
 
307
                                property = (_tmp8_ = json_soup_get_string (_tmp7_ = json_soup_sibling (json, "property")), _g_object_unref0 (_tmp7_), _tmp8_);
 
308
                                if (_vala_strcmp0 (property, "category") == 0) {
 
309
                                        JsonSoup* _tmp10_;
 
310
                                        _tmp9_ = json_soup_is_array (_tmp10_ = json_soup_sibling (json, "category")) == TRUE;
 
311
                                        _g_object_unref0 (_tmp10_);
 
312
                                } else {
 
313
                                        _tmp9_ = FALSE;
 
314
                                }
 
315
                                if (_tmp9_) {
 
316
                                        group = beta_radio_getCategoryMenu (self, submenu, group, json);
 
317
                                } else {
 
318
                                        gboolean _tmp11_ = FALSE;
 
319
                                        if (_vala_strcmp0 (property, "channel") == 0) {
 
320
                                                JsonSoup* _tmp12_;
 
321
                                                _tmp11_ = json_soup_is_array (_tmp12_ = json_soup_sibling (json, "channel")) == TRUE;
 
322
                                                _g_object_unref0 (_tmp12_);
 
323
                                        } else {
 
324
                                                _tmp11_ = FALSE;
 
325
                                        }
 
326
                                        if (_tmp11_) {
 
327
                                                group = beta_radio_getChannelMenu (self, submenu, group, json);
 
328
                                        }
 
329
                                }
 
330
                                _tmp13_ = json_soup_parent (list);
 
331
                                _g_object_unref0 (_tmp13_);
 
332
                                _g_free0 (feed);
 
333
                                _g_object_unref0 (json);
 
334
                                _g_free0 (title);
 
335
                                _g_object_unref0 (item);
 
336
                                _g_object_unref0 (submenu);
 
337
                                _g_free0 (property);
 
338
                        }
 
339
                }
 
340
        }
 
341
        result = group;
 
342
        _g_object_unref0 (list);
 
343
        return result;
 
344
}
 
345
 
 
346
 
 
347
static void _lambda1_ (GtkCheckMenuItem* e, Block1Data* _data1_) {
 
348
        BetaRadio * self;
 
349
        GstPlayer* _tmp0_;
 
350
        self = _data1_->self;
 
351
        g_return_if_fail (e != NULL);
 
352
        if (self->priv->player != NULL) {
 
353
                gst_player_stop (self->priv->player);
 
354
        }
 
355
        self->priv->player = (_tmp0_ = gst_player_new ("BetaRadio", _data1_->url), _g_object_unref0 (self->priv->player), _tmp0_);
 
356
        gst_player_play (self->priv->player);
 
357
        gtk_status_icon_set_tooltip_text (self->priv->icon, _data1_->title);
 
358
}
 
359
 
 
360
 
 
361
static void __lambda1__gtk_check_menu_item_toggled (GtkCheckMenuItem* _sender, gpointer self) {
 
362
        _lambda1_ (_sender, self);
 
363
}
 
364
 
 
365
 
 
366
static Block1Data* block1_data_ref (Block1Data* _data1_) {
 
367
        ++_data1_->_ref_count_;
 
368
        return _data1_;
 
369
}
 
370
 
 
371
 
 
372
static void block1_data_unref (Block1Data* _data1_) {
 
373
        if ((--_data1_->_ref_count_) == 0) {
 
374
                _g_object_unref0 (_data1_->self);
 
375
                _g_free0 (_data1_->title);
 
376
                _g_free0 (_data1_->url);
 
377
                g_slice_free (Block1Data, _data1_);
 
378
        }
 
379
}
 
380
 
 
381
 
 
382
static GSList* beta_radio_getCategoryMenu (BetaRadio* self, GtkMenu* menu, GSList* group, JsonSoup* json) {
 
383
        GSList* result = NULL;
 
384
        gint length;
 
385
        g_return_val_if_fail (self != NULL, NULL);
 
386
        g_return_val_if_fail (menu != NULL, NULL);
 
387
        g_return_val_if_fail (json != NULL, NULL);
 
388
        length = json_soup_length (json);
 
389
        {
 
390
                gint i;
 
391
                i = 0;
 
392
                {
 
393
                        gboolean _tmp0_;
 
394
                        _tmp0_ = TRUE;
 
395
                        while (TRUE) {
 
396
                                JsonSoup* _tmp2_;
 
397
                                JsonSoup* _tmp1_;
 
398
                                char* _tmp3_;
 
399
                                char* category;
 
400
                                GtkMenuItem* item;
 
401
                                GtkMenu* submenu;
 
402
                                JsonSoup* _tmp4_;
 
403
                                gint _tmp5_;
 
404
                                gint size;
 
405
                                JsonSoup* _tmp16_;
 
406
                                if (!_tmp0_) {
 
407
                                        i++;
 
408
                                }
 
409
                                _tmp0_ = FALSE;
 
410
                                if (!(i < length)) {
 
411
                                        break;
 
412
                                }
 
413
                                category = (_tmp3_ = json_soup_get_string (_tmp2_ = json_soup_object (_tmp1_ = json_soup_array (json, i), "title")), _g_object_unref0 (_tmp2_), _g_object_unref0 (_tmp1_), _tmp3_);
 
414
                                item = g_object_ref_sink ((GtkMenuItem*) gtk_menu_item_new_with_label (category));
 
415
                                submenu = g_object_ref_sink ((GtkMenu*) gtk_menu_new ());
 
416
                                gtk_menu_shell_append ((GtkMenuShell*) menu, (GtkWidget*) item);
 
417
                                gtk_menu_item_set_submenu (item, (GtkWidget*) submenu);
 
418
                                size = (_tmp5_ = json_soup_length (_tmp4_ = json_soup_sibling (json, "channel")), _g_object_unref0 (_tmp4_), _tmp5_);
 
419
                                {
 
420
                                        gint j;
 
421
                                        j = 0;
 
422
                                        {
 
423
                                                gboolean _tmp6_;
 
424
                                                _tmp6_ = TRUE;
 
425
                                                while (TRUE) {
 
426
                                                        Block1Data* _data1_;
 
427
                                                        JsonSoup* _tmp8_;
 
428
                                                        JsonSoup* _tmp7_;
 
429
                                                        char* _tmp9_;
 
430
                                                        JsonSoup* _tmp10_;
 
431
                                                        char* _tmp11_;
 
432
                                                        char* type;
 
433
                                                        char* _tmp13_;
 
434
                                                        JsonSoup* _tmp12_;
 
435
                                                        char* _tmp14_;
 
436
                                                        GtkRadioMenuItem* radio;
 
437
                                                        JsonSoup* _tmp15_;
 
438
                                                        _data1_ = g_slice_new0 (Block1Data);
 
439
                                                        _data1_->_ref_count_ = 1;
 
440
                                                        _data1_->self = g_object_ref (self);
 
441
                                                        if (!_tmp6_) {
 
442
                                                                j++;
 
443
                                                        }
 
444
                                                        _tmp6_ = FALSE;
 
445
                                                        if (!(j < size)) {
 
446
                                                                block1_data_unref (_data1_);
 
447
                                                                break;
 
448
                                                        }
 
449
                                                        _data1_->title = (_tmp9_ = json_soup_get_string (_tmp8_ = json_soup_object (_tmp7_ = json_soup_array (json, j), "title")), _g_object_unref0 (_tmp8_), _g_object_unref0 (_tmp7_), _tmp9_);
 
450
                                                        type = (_tmp11_ = json_soup_get_string (_tmp10_ = json_soup_sibling (json, "type")), _g_object_unref0 (_tmp10_), _tmp11_);
 
451
                                                        _data1_->url = (_tmp14_ = beta_radio_filter_url (self, _tmp13_ = json_soup_get_string (_tmp12_ = json_soup_sibling (json, "url")), type), _g_free0 (_tmp13_), _g_object_unref0 (_tmp12_), _tmp14_);
 
452
                                                        radio = g_object_ref_sink ((GtkRadioMenuItem*) gtk_radio_menu_item_new_with_label (group, _data1_->title));
 
453
                                                        group = gtk_radio_menu_item_get_group (radio);
 
454
                                                        g_signal_connect_data ((GtkCheckMenuItem*) radio, "toggled", (GCallback) __lambda1__gtk_check_menu_item_toggled, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
 
455
                                                        gtk_menu_shell_append ((GtkMenuShell*) submenu, (GtkWidget*) ((GtkMenuItem*) radio));
 
456
                                                        _tmp15_ = json_soup_grandparent (json);
 
457
                                                        _g_object_unref0 (_tmp15_);
 
458
                                                        _g_free0 (type);
 
459
                                                        _g_object_unref0 (radio);
 
460
                                                        block1_data_unref (_data1_);
 
461
                                                }
 
462
                                        }
 
463
                                }
 
464
                                _tmp16_ = json_soup_grandparent (json);
 
465
                                _g_object_unref0 (_tmp16_);
 
466
                                _g_free0 (category);
 
467
                                _g_object_unref0 (item);
 
468
                                _g_object_unref0 (submenu);
 
469
                        }
 
470
                }
 
471
        }
 
472
        result = group;
 
473
        return result;
 
474
}
 
475
 
 
476
 
 
477
static void _lambda2_ (GtkCheckMenuItem* e, Block2Data* _data2_) {
 
478
        BetaRadio * self;
 
479
        GstPlayer* _tmp0_;
 
480
        self = _data2_->self;
 
481
        g_return_if_fail (e != NULL);
 
482
        if (self->priv->player != NULL) {
 
483
                gst_player_stop (self->priv->player);
 
484
        }
 
485
        self->priv->player = (_tmp0_ = gst_player_new ("BetaRadio", _data2_->url), _g_object_unref0 (self->priv->player), _tmp0_);
 
486
        gst_player_play (self->priv->player);
 
487
        gtk_status_icon_set_tooltip_text (self->priv->icon, _data2_->title);
 
488
}
 
489
 
 
490
 
 
491
static void __lambda2__gtk_check_menu_item_toggled (GtkCheckMenuItem* _sender, gpointer self) {
 
492
        _lambda2_ (_sender, self);
 
493
}
 
494
 
 
495
 
 
496
static Block2Data* block2_data_ref (Block2Data* _data2_) {
 
497
        ++_data2_->_ref_count_;
 
498
        return _data2_;
 
499
}
 
500
 
 
501
 
 
502
static void block2_data_unref (Block2Data* _data2_) {
 
503
        if ((--_data2_->_ref_count_) == 0) {
 
504
                _g_object_unref0 (_data2_->self);
 
505
                _g_free0 (_data2_->title);
 
506
                _g_free0 (_data2_->url);
 
507
                g_slice_free (Block2Data, _data2_);
 
508
        }
 
509
}
 
510
 
 
511
 
 
512
static GSList* beta_radio_getChannelMenu (BetaRadio* self, GtkMenu* menu, GSList* group, JsonSoup* json) {
 
513
        GSList* result = NULL;
 
514
        gint length;
 
515
        g_return_val_if_fail (self != NULL, NULL);
 
516
        g_return_val_if_fail (menu != NULL, NULL);
 
517
        g_return_val_if_fail (json != NULL, NULL);
 
518
        length = json_soup_length (json);
 
519
        {
 
520
                gint i;
 
521
                i = 0;
 
522
                {
 
523
                        gboolean _tmp0_;
 
524
                        _tmp0_ = TRUE;
 
525
                        while (TRUE) {
 
526
                                Block2Data* _data2_;
 
527
                                JsonSoup* _tmp2_;
 
528
                                JsonSoup* _tmp1_;
 
529
                                char* _tmp3_;
 
530
                                JsonSoup* _tmp4_;
 
531
                                char* _tmp5_;
 
532
                                char* type;
 
533
                                char* _tmp7_;
 
534
                                JsonSoup* _tmp6_;
 
535
                                char* _tmp8_;
 
536
                                GtkRadioMenuItem* radio;
 
537
                                JsonSoup* _tmp9_;
 
538
                                _data2_ = g_slice_new0 (Block2Data);
 
539
                                _data2_->_ref_count_ = 1;
 
540
                                _data2_->self = g_object_ref (self);
 
541
                                if (!_tmp0_) {
 
542
                                        i++;
 
543
                                }
 
544
                                _tmp0_ = FALSE;
 
545
                                if (!(i < length)) {
 
546
                                        block2_data_unref (_data2_);
 
547
                                        break;
 
548
                                }
 
549
                                _data2_->title = (_tmp3_ = json_soup_get_string (_tmp2_ = json_soup_object (_tmp1_ = json_soup_array (json, i), "title")), _g_object_unref0 (_tmp2_), _g_object_unref0 (_tmp1_), _tmp3_);
 
550
                                type = (_tmp5_ = json_soup_get_string (_tmp4_ = json_soup_sibling (json, "type")), _g_object_unref0 (_tmp4_), _tmp5_);
 
551
                                _data2_->url = (_tmp8_ = beta_radio_filter_url (self, _tmp7_ = json_soup_get_string (_tmp6_ = json_soup_sibling (json, "url")), type), _g_free0 (_tmp7_), _g_object_unref0 (_tmp6_), _tmp8_);
 
552
                                radio = g_object_ref_sink ((GtkRadioMenuItem*) gtk_radio_menu_item_new_with_label (group, _data2_->title));
 
553
                                group = gtk_radio_menu_item_get_group (radio);
 
554
                                g_signal_connect_data ((GtkCheckMenuItem*) radio, "toggled", (GCallback) __lambda2__gtk_check_menu_item_toggled, block2_data_ref (_data2_), (GClosureNotify) block2_data_unref, 0);
 
555
                                gtk_menu_shell_append ((GtkMenuShell*) menu, (GtkWidget*) ((GtkMenuItem*) radio));
 
556
                                _tmp9_ = json_soup_grandparent (json);
 
557
                                _g_object_unref0 (_tmp9_);
 
558
                                _g_free0 (type);
 
559
                                _g_object_unref0 (radio);
 
560
                                block2_data_unref (_data2_);
 
561
                        }
 
562
                }
 
563
        }
 
564
        result = group;
 
565
        return result;
 
566
}
 
567
 
 
568
 
 
569
static char* string_replace (const char* self, const char* old, const char* replacement) {
 
570
        char* result = NULL;
 
571
        GError * _inner_error_;
 
572
        g_return_val_if_fail (self != NULL, NULL);
 
573
        g_return_val_if_fail (old != NULL, NULL);
 
574
        g_return_val_if_fail (replacement != NULL, NULL);
 
575
        _inner_error_ = NULL;
 
576
        {
 
577
                char* _tmp0_;
 
578
                GRegex* _tmp1_;
 
579
                GRegex* regex;
 
580
                char* _tmp2_;
 
581
                regex = (_tmp1_ = g_regex_new (_tmp0_ = g_regex_escape_string (old, -1), 0, 0, &_inner_error_), _g_free0 (_tmp0_), _tmp1_);
 
582
                if (_inner_error_ != NULL) {
 
583
                        if (_inner_error_->domain == G_REGEX_ERROR) {
 
584
                                goto __catch0_g_regex_error;
 
585
                        }
 
586
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
587
                        g_clear_error (&_inner_error_);
 
588
                        return NULL;
 
589
                }
 
590
                _tmp2_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);
 
591
                if (_inner_error_ != NULL) {
 
592
                        _g_regex_unref0 (regex);
 
593
                        if (_inner_error_->domain == G_REGEX_ERROR) {
 
594
                                goto __catch0_g_regex_error;
 
595
                        }
 
596
                        _g_regex_unref0 (regex);
 
597
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
598
                        g_clear_error (&_inner_error_);
 
599
                        return NULL;
 
600
                }
 
601
                result = _tmp2_;
 
602
                _g_regex_unref0 (regex);
 
603
                return result;
 
604
        }
 
605
        goto __finally0;
 
606
        __catch0_g_regex_error:
 
607
        {
 
608
                GError * e;
 
609
                e = _inner_error_;
 
610
                _inner_error_ = NULL;
 
611
                {
 
612
                        g_assert_not_reached ();
 
613
                        _g_error_free0 (e);
 
614
                }
 
615
        }
 
616
        __finally0:
 
617
        if (_inner_error_ != NULL) {
 
618
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
619
                g_clear_error (&_inner_error_);
 
620
                return NULL;
 
621
        }
 
622
}
 
623
 
 
624
 
 
625
static char* beta_radio_filter_url (BetaRadio* self, const char* url, const char* type) {
 
626
        char* result = NULL;
 
627
        gboolean _tmp0_ = FALSE;
 
628
        g_return_val_if_fail (self != NULL, NULL);
 
629
        g_return_val_if_fail (url != NULL, NULL);
 
630
        g_return_val_if_fail (type != NULL, NULL);
 
631
        if (_vala_strcmp0 (type, "mms") == 0) {
 
632
                _tmp0_ = g_str_has_prefix (url, "http://") == TRUE;
 
633
        } else {
 
634
                _tmp0_ = FALSE;
 
635
        }
 
636
        if (_tmp0_) {
 
637
                char* _tmp1_;
 
638
                char* _tmp2_;
 
639
                result = (_tmp2_ = g_strconcat (_tmp1_ = string_replace (url, "http", "mmsh"), "\\?MSWMExt\\=.asf", NULL), _g_free0 (_tmp1_), _tmp2_);
 
640
                return result;
 
641
        }
 
642
        result = g_strdup (url);
 
643
        return result;
 
644
}
 
645
 
 
646
 
 
647
static void beta_radio_class_init (BetaRadioClass * klass) {
 
648
        beta_radio_parent_class = g_type_class_peek_parent (klass);
 
649
        g_type_class_add_private (klass, sizeof (BetaRadioPrivate));
 
650
        G_OBJECT_CLASS (klass)->finalize = beta_radio_finalize;
 
651
}
 
652
 
 
653
 
 
654
static void beta_radio_instance_init (BetaRadio * self) {
 
655
        self->priv = BETA_RADIO_GET_PRIVATE (self);
 
656
        self->priv->icon = NULL;
 
657
        self->priv->menu = NULL;
 
658
        self->priv->player = NULL;
 
659
}
 
660
 
 
661
 
 
662
static void beta_radio_finalize (GObject* obj) {
 
663
        BetaRadio * self;
 
664
        self = BETA_RADIO (obj);
 
665
        _g_object_unref0 (self->priv->icon);
 
666
        _g_object_unref0 (self->priv->menu);
 
667
        _g_object_unref0 (self->priv->player);
 
668
        G_OBJECT_CLASS (beta_radio_parent_class)->finalize (obj);
 
669
}
 
670
 
 
671
 
 
672
GType beta_radio_get_type (void) {
 
673
        static volatile gsize beta_radio_type_id__volatile = 0;
 
674
        if (g_once_init_enter (&beta_radio_type_id__volatile)) {
 
675
                static const GTypeInfo g_define_type_info = { sizeof (BetaRadioClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) beta_radio_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (BetaRadio), 0, (GInstanceInitFunc) beta_radio_instance_init, NULL };
 
676
                GType beta_radio_type_id;
 
677
                beta_radio_type_id = g_type_register_static (G_TYPE_OBJECT, "BetaRadio", &g_define_type_info, 0);
 
678
                g_once_init_leave (&beta_radio_type_id__volatile, beta_radio_type_id);
 
679
        }
 
680
        return beta_radio_type_id__volatile;
 
681
}
 
682
 
 
683
 
 
684
static int _vala_strcmp0 (const char * str1, const char * str2) {
 
685
        if (str1 == NULL) {
 
686
                return -(str1 != str2);
 
687
        }
 
688
        if (str2 == NULL) {
 
689
                return str1 != str2;
 
690
        }
 
691
        return strcmp (str1, str2);
 
692
}
 
693
 
 
694
 
 
695
 
 
696