~ubuntu-branches/ubuntu/oneiric/gwibber/oneiric

« back to all changes in this revision

Viewing changes to libgwibber-gtk/stream-view-tile.c

  • Committer: Bazaar Package Importer
  • Author(s): Ken VanDine
  • Date: 2011-08-25 15:36:16 UTC
  • mfrom: (1.1.59 upstream)
  • Revision ID: james.westby@ubuntu.com-20110825153616-sd8yqbkdytwh0gi5
Tags: 3.1.6-0ubuntu1
* New upstream release
  - async loading of all images
  - display thumbnails for images and videos
  - display facebook comments inline
  - round the corners of avatars and thumbnails
  - significant performance improvements for rendering the stream views
* debian/libgwibber-gtk2.symbols
  - added symbols

Show diffs side-by-side

added added

removed removed

Lines of Context:
24
24
#include <glib-object.h>
25
25
#include "gwibber-gtk.h"
26
26
#include <gtk/gtk.h>
 
27
#include <cairo.h>
 
28
#include <float.h>
 
29
#include <math.h>
27
30
#include <gwibber.h>
28
31
#include <stdlib.h>
29
32
#include <string.h>
30
 
#include <cairo.h>
31
 
#include <float.h>
32
 
#include <math.h>
 
33
#include <gio/gio.h>
 
34
#include <json-glib/json-glib.h>
 
35
#include <pango/pango.h>
33
36
#include <gdk/gdk.h>
34
37
#include <glib/gi18n-lib.h>
35
 
#include <gio/gio.h>
36
 
#include <pango/pango.h>
 
38
#include <gdk-pixbuf/gdk-pixdata.h>
37
39
#include <libsoup/soup.h>
38
40
#include <gee.h>
39
41
#include <libnotify/notify.h>
40
42
 
41
43
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
44
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
42
45
#define _g_free0(var) (var = (g_free (var), NULL))
43
46
#define _cairo_pattern_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_pattern_destroy (var), NULL)))
44
 
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
 
47
typedef struct _Block2Data Block2Data;
 
48
typedef struct _Block3Data Block3Data;
 
49
typedef struct _Block4Data Block4Data;
 
50
#define _json_object_unref0(var) ((var == NULL) ? NULL : (var = (json_object_unref (var), NULL)))
 
51
#define _json_array_unref0(var) ((var == NULL) ? NULL : (var = (json_array_unref (var), NULL)))
 
52
typedef struct _Block5Data Block5Data;
 
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
typedef struct _GwibberGtkStreamViewTileLoadAvatarAsyncData GwibberGtkStreamViewTileLoadAvatarAsyncData;
 
56
typedef struct _GwibberGtkStreamViewTileLoadThumbnailAsyncData GwibberGtkStreamViewTileLoadThumbnailAsyncData;
45
57
#define __g_list_free__g_object_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__g_object_unref0_ (var), NULL)))
46
58
#define _soup_uri_free0(var) ((var == NULL) ? NULL : (var = (soup_uri_free (var), NULL)))
47
59
 
51
63
        GtkAlignment* lalignment;
52
64
        GtkAlignment* ralignment;
53
65
        GtkEventBox* icon_box;
54
 
        GtkImage* icon;
 
66
        GwibberGtkStreamViewAvatar* icon;
55
67
        GtkImage* private;
56
68
        GtkVBox* vbox;
 
69
        GtkVBox* comments_box;
57
70
        GtkHBox* likes_hbox;
58
71
        GtkLabel* likes_count;
59
72
        GtkLabel* name;
60
73
        GtkLabel* time;
61
74
        GtkLabel* message;
 
75
        GwibberGtkStreamViewAvatar* thumbnail;
 
76
        GtkEventBox* thumb_box;
62
77
        GtkLabel* reply_to;
63
78
        GtkLabel* retweeted_by;
64
79
        GwibberUtils* _utils;
 
80
        GwibberService* _service;
65
81
        gboolean _show_fullname;
66
82
        guint _update_time_area_id;
 
83
        guint _cache_avatar_id;
 
84
        GList* _to_disconnect;
67
85
        gchar* sender;
68
86
        gchar* url;
69
87
        gchar* time_string;
70
88
        GwibberGtkActionBox* action_box;
71
 
};
72
 
 
73
 
 
 
89
        GCancellable* cancellable;
 
90
        gchar* img_uri;
 
91
        gchar* img_src;
 
92
        guint img_id;
 
93
};
 
94
 
 
95
struct _Block2Data {
 
96
        int _ref_count_;
 
97
        GwibberGtkStreamViewTile * self;
 
98
        gchar* link_str;
 
99
        gchar* video_str;
 
100
        gchar* _stream;
 
101
        gchar* _html;
 
102
        gchar* _icon_uri;
 
103
        gchar* _img_url;
 
104
        gchar* _img_name;
 
105
};
 
106
 
 
107
struct _Block3Data {
 
108
        int _ref_count_;
 
109
        Block2Data * _data2_;
 
110
        GwibberGtkStreamViewAvatar* cicon;
 
111
};
 
112
 
 
113
struct _Block4Data {
 
114
        int _ref_count_;
 
115
        Block3Data * _data3_;
 
116
        gchar* cimage;
 
117
};
 
118
 
 
119
struct _Block5Data {
 
120
        int _ref_count_;
 
121
        Block2Data * _data2_;
 
122
        gchar* img_str;
 
123
};
 
124
 
 
125
struct _GwibberGtkStreamViewTileLoadAvatarAsyncData {
 
126
        int _state_;
 
127
        GObject* _source_object_;
 
128
        GAsyncResult* _res_;
 
129
        GSimpleAsyncResult* _async_result;
 
130
        GwibberGtkStreamViewTile* self;
 
131
        gchar* url;
 
132
        GtkImage* cicon;
 
133
        gchar* t;
 
134
        GFile* _tmp0_;
 
135
        GFile* file;
 
136
        GFileInputStream* _tmp1_;
 
137
        GFileInputStream* stream;
 
138
        GdkPixbuf* pixbuf;
 
139
        GdkPixbuf* _tmp2_;
 
140
        GdkPixbuf* _tmp3_;
 
141
        const gchar* _tmp4_;
 
142
        gchar* _tmp5_;
 
143
        gchar* _tmp6_;
 
144
        gchar* _tmp7_;
 
145
        gchar* _tmp8_;
 
146
        gchar* cimage;
 
147
        gchar* _tmp9_;
 
148
        gboolean _tmp10_;
 
149
        gboolean _tmp11_;
 
150
        gboolean _tmp12_;
 
151
        gboolean _tmp13_;
 
152
        gboolean _tmp14_;
 
153
        gchar* _tmp15_;
 
154
        GError * e;
 
155
        GError * _inner_error_;
 
156
};
 
157
 
 
158
struct _GwibberGtkStreamViewTileLoadThumbnailAsyncData {
 
159
        int _state_;
 
160
        GObject* _source_object_;
 
161
        GAsyncResult* _res_;
 
162
        GSimpleAsyncResult* _async_result;
 
163
        GwibberGtkStreamViewTile* self;
 
164
        gchar* img_markup;
 
165
        GtkAllocation alloc;
 
166
        GtkAllocation _tmp0_;
 
167
        gchar* _tmp1_;
 
168
        gchar* _tmp2_;
 
169
        GFile* _tmp3_;
 
170
        GFile* _tmp4_;
 
171
        GFile* file;
 
172
        GFileInputStream* _tmp5_;
 
173
        GFileInputStream* stream;
 
174
        GdkPixbuf* pixbuf;
 
175
        GdkPixbuf* _tmp6_;
 
176
        GdkPixbuf* _tmp7_;
 
177
        GError * e;
 
178
        GError * _inner_error_;
 
179
};
 
180
 
 
181
 
 
182
static gpointer gwibber_gtk_stream_view_avatar_parent_class = NULL;
74
183
static gpointer gwibber_gtk_stream_view_tile_parent_class = NULL;
75
184
 
 
185
enum  {
 
186
        GWIBBER_GTK_STREAM_VIEW_AVATAR_DUMMY_PROPERTY
 
187
};
 
188
static gboolean gwibber_gtk_stream_view_avatar_on_draw (GwibberGtkStreamViewAvatar* self, cairo_t* cr);
 
189
static gboolean _gwibber_gtk_stream_view_avatar_on_draw_gtk_widget_draw (GtkWidget* _sender, cairo_t* cr, gpointer self);
76
190
#define GWIBBER_GTK_STREAM_VIEW_TILE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GWIBBER_GTK_TYPE_STREAM_VIEW_TILE, GwibberGtkStreamViewTilePrivate))
77
191
enum  {
78
192
        GWIBBER_GTK_STREAM_VIEW_TILE_DUMMY_PROPERTY,
79
193
        GWIBBER_GTK_STREAM_VIEW_TILE_UTILS,
 
194
        GWIBBER_GTK_STREAM_VIEW_TILE_SERVICE,
80
195
        GWIBBER_GTK_STREAM_VIEW_TILE_SHOW_FULLNAME
81
196
};
82
197
#define GWIBBER_GTK_STREAM_VIEW_TILE_our_padding 6
85
200
static gboolean _lambda15_ (GwibberGtkStreamViewTile* self);
86
201
static void gwibber_gtk_stream_view_tile_update_time_area (GwibberGtkStreamViewTile* self);
87
202
static gboolean __lambda15__gsource_func (gpointer self);
 
203
static Block2Data* block2_data_ref (Block2Data* _data2_);
 
204
static void block2_data_unref (Block2Data* _data2_);
 
205
static Block3Data* block3_data_ref (Block3Data* _data3_);
 
206
static void block3_data_unref (Block3Data* _data3_);
 
207
static Block4Data* block4_data_ref (Block4Data* _data4_);
 
208
static void block4_data_unref (Block4Data* _data4_);
 
209
static gboolean _lambda16_ (Block4Data* _data4_);
 
210
static void gwibber_gtk_stream_view_tile_load_avatar_async (GwibberGtkStreamViewTile* self, const gchar* url, GtkImage* cicon, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
211
static void gwibber_gtk_stream_view_tile_load_avatar_finish (GwibberGtkStreamViewTile* self, GAsyncResult* _res_);
 
212
static gboolean __lambda16__gsource_func (gpointer self);
88
213
static gboolean _vala_string_array_contains (gchar** stack, int stack_length, gchar* needle);
89
214
static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value);
90
 
static void _lambda16_ (const gchar* mid, const gchar* account, const gchar* sender, GwibberGtkStreamViewTile* self);
91
 
static void __lambda16__gwibber_gtk_action_box_item_reply (GwibberGtkActionBoxItem* _sender, const gchar* mid, const gchar* account, const gchar* sender, gpointer self);
 
215
static void _lambda17_ (const gchar* mid, const gchar* account, const gchar* sender, GwibberGtkStreamViewTile* self);
 
216
static void __lambda17__gwibber_gtk_action_box_item_reply (GwibberGtkActionBoxItem* _sender, const gchar* mid, const gchar* account, const gchar* sender, gpointer self);
 
217
static gboolean _lambda18_ (Block2Data* _data2_);
 
218
static gboolean __lambda18__gsource_func (gpointer self);
92
219
static gboolean gwibber_gtk_stream_view_tile_on_avatar_click (GwibberGtkStreamViewTile* self, GdkEventButton* button);
93
220
static gboolean _gwibber_gtk_stream_view_tile_on_avatar_click_gtk_widget_button_press_event (GtkWidget* _sender, GdkEventButton* event, gpointer self);
 
221
static Block5Data* block5_data_ref (Block5Data* _data5_);
 
222
static void block5_data_unref (Block5Data* _data5_);
 
223
static gboolean _lambda19_ (Block5Data* _data5_);
 
224
static void gwibber_gtk_stream_view_tile_load_thumbnail_async (GwibberGtkStreamViewTile* self, const gchar* img_markup, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
225
static void gwibber_gtk_stream_view_tile_load_thumbnail_finish (GwibberGtkStreamViewTile* self, GAsyncResult* _res_);
 
226
static gboolean __lambda19__gsource_func (gpointer self);
 
227
static void gwibber_gtk_stream_view_tile_load_avatar_async_data_free (gpointer _data);
 
228
static gboolean gwibber_gtk_stream_view_tile_load_avatar_async_co (GwibberGtkStreamViewTileLoadAvatarAsyncData* data);
 
229
static void gwibber_gtk_stream_view_tile_load_avatar_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
230
static void gwibber_gtk_stream_view_tile_load_thumbnail_async_data_free (gpointer _data);
 
231
static gboolean gwibber_gtk_stream_view_tile_load_thumbnail_async_co (GwibberGtkStreamViewTileLoadThumbnailAsyncData* data);
 
232
static gchar* gwibber_gtk_stream_view_tile_fix_image_uri (GwibberGtkStreamViewTile* self, const gchar* uri);
 
233
static void gwibber_gtk_stream_view_tile_load_thumbnail_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
94
234
static void gwibber_gtk_stream_view_tile_real_reply (GwibberGtkStreamViewTile* self, const gchar* mid, const gchar* account, const gchar* sender);
95
235
static void g_cclosure_user_marshal_VOID__STRING_STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
96
236
static GObject * gwibber_gtk_stream_view_tile_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties);
97
237
static gboolean _gwibber_gtk_stream_view_tile_on_draw_gtk_widget_draw (GtkWidget* _sender, cairo_t* cr, gpointer self);
98
 
static gboolean _lambda17_ (const gchar* uri, GwibberGtkStreamViewTile* self);
 
238
static gboolean _lambda20_ (const gchar* uri, GwibberGtkStreamViewTile* self);
99
239
static void _g_object_unref0_ (gpointer var);
100
240
static void _g_list_free__g_object_unref0_ (GList* self);
101
 
static gboolean __lambda17__gtk_label_activate_link (GtkLabel* _sender, const gchar* uri, gpointer self);
102
 
static gboolean _lambda18_ (GwibberGtkStreamViewTile* self);
103
 
static gboolean __lambda18__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
104
 
static gboolean _lambda19_ (GwibberGtkStreamViewTile* self);
105
 
static gboolean __lambda19__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
106
 
static gboolean _lambda20_ (GwibberGtkStreamViewTile* self);
107
 
static gboolean __lambda20__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
 
241
static gboolean __lambda20__gtk_label_activate_link (GtkLabel* _sender, const gchar* uri, gpointer self);
108
242
static gboolean _lambda21_ (GwibberGtkStreamViewTile* self);
109
 
static gboolean __lambda21__gtk_widget_leave_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
 
243
static gboolean __lambda21__gtk_widget_button_release_event (GtkWidget* _sender, GdkEventButton* event, gpointer self);
 
244
static gboolean _lambda22_ (GwibberGtkStreamViewTile* self);
 
245
static gboolean __lambda22__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
 
246
static gboolean _lambda23_ (GwibberGtkStreamViewTile* self);
 
247
static gboolean __lambda23__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
 
248
static gboolean _lambda24_ (GwibberGtkStreamViewTile* self);
 
249
static gboolean __lambda24__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
 
250
static gboolean _lambda25_ (GwibberGtkStreamViewTile* self);
 
251
static gboolean __lambda25__gtk_widget_leave_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self);
110
252
static void gwibber_gtk_stream_view_tile_finalize (GObject* obj);
111
253
static void _vala_gwibber_gtk_stream_view_tile_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
112
254
static void _vala_gwibber_gtk_stream_view_tile_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
115
257
static gint _vala_array_length (gpointer array);
116
258
 
117
259
 
118
 
GwibberGtkStreamViewTile* gwibber_gtk_stream_view_tile_construct (GType object_type, GwibberUtils* utils, gboolean show_fullname) {
 
260
static gboolean _gwibber_gtk_stream_view_avatar_on_draw_gtk_widget_draw (GtkWidget* _sender, cairo_t* cr, gpointer self) {
 
261
        gboolean result;
 
262
        result = gwibber_gtk_stream_view_avatar_on_draw (self, cr);
 
263
        return result;
 
264
}
 
265
 
 
266
 
 
267
GwibberGtkStreamViewAvatar* gwibber_gtk_stream_view_avatar_construct (GType object_type) {
 
268
        GwibberGtkStreamViewAvatar * self = NULL;
 
269
        self = (GwibberGtkStreamViewAvatar*) g_object_new (object_type, NULL);
 
270
        g_signal_connect_object ((GtkWidget*) self, "draw", (GCallback) _gwibber_gtk_stream_view_avatar_on_draw_gtk_widget_draw, self, 0);
 
271
        return self;
 
272
}
 
273
 
 
274
 
 
275
GwibberGtkStreamViewAvatar* gwibber_gtk_stream_view_avatar_new (void) {
 
276
        return gwibber_gtk_stream_view_avatar_construct (GWIBBER_GTK_TYPE_STREAM_VIEW_AVATAR);
 
277
}
 
278
 
 
279
 
 
280
static gboolean gwibber_gtk_stream_view_avatar_on_draw (GwibberGtkStreamViewAvatar* self, cairo_t* cr) {
 
281
        gboolean result = FALSE;
 
282
        GtkAllocation alloc = {0};
 
283
        GtkAllocation _tmp0_ = {0};
 
284
        gfloat radius;
 
285
        g_return_val_if_fail (self != NULL, FALSE);
 
286
        g_return_val_if_fail (cr != NULL, FALSE);
 
287
        gtk_widget_get_allocation ((GtkWidget*) self, &_tmp0_);
 
288
        alloc = _tmp0_;
 
289
        radius = 10.0f;
 
290
        cairo_move_to (cr, (gdouble) 0, (gdouble) radius);
 
291
        cairo_curve_to (cr, (gdouble) 0, (gdouble) 0, (gdouble) 0, (gdouble) 0, (gdouble) radius, (gdouble) 0);
 
292
        cairo_line_to (cr, (gdouble) (alloc.width - radius), (gdouble) 0);
 
293
        cairo_curve_to (cr, (gdouble) alloc.width, (gdouble) 0, (gdouble) alloc.width, (gdouble) 0, (gdouble) alloc.width, (gdouble) radius);
 
294
        cairo_line_to (cr, (gdouble) alloc.width, (gdouble) (alloc.height - radius));
 
295
        cairo_curve_to (cr, (gdouble) alloc.width, (gdouble) alloc.height, (gdouble) alloc.width, (gdouble) alloc.height, (gdouble) (alloc.width - radius), (gdouble) alloc.height);
 
296
        cairo_line_to (cr, (gdouble) radius, (gdouble) alloc.height);
 
297
        cairo_curve_to (cr, (gdouble) 0, (gdouble) alloc.height, (gdouble) 0, (gdouble) alloc.height, (gdouble) 0, (gdouble) (alloc.height - radius));
 
298
        cairo_close_path (cr);
 
299
        cairo_clip (cr);
 
300
        GTK_WIDGET_CLASS (gwibber_gtk_stream_view_avatar_parent_class)->draw ((GtkWidget*) GTK_IMAGE (self), cr);
 
301
        result = TRUE;
 
302
        return result;
 
303
}
 
304
 
 
305
 
 
306
static void gwibber_gtk_stream_view_avatar_class_init (GwibberGtkStreamViewAvatarClass * klass) {
 
307
        gwibber_gtk_stream_view_avatar_parent_class = g_type_class_peek_parent (klass);
 
308
}
 
309
 
 
310
 
 
311
static void gwibber_gtk_stream_view_avatar_instance_init (GwibberGtkStreamViewAvatar * self) {
 
312
}
 
313
 
 
314
 
 
315
GType gwibber_gtk_stream_view_avatar_get_type (void) {
 
316
        static volatile gsize gwibber_gtk_stream_view_avatar_type_id__volatile = 0;
 
317
        if (g_once_init_enter (&gwibber_gtk_stream_view_avatar_type_id__volatile)) {
 
318
                static const GTypeInfo g_define_type_info = { sizeof (GwibberGtkStreamViewAvatarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gwibber_gtk_stream_view_avatar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GwibberGtkStreamViewAvatar), 0, (GInstanceInitFunc) gwibber_gtk_stream_view_avatar_instance_init, NULL };
 
319
                GType gwibber_gtk_stream_view_avatar_type_id;
 
320
                gwibber_gtk_stream_view_avatar_type_id = g_type_register_static (GTK_TYPE_IMAGE, "GwibberGtkStreamViewAvatar", &g_define_type_info, 0);
 
321
                g_once_init_leave (&gwibber_gtk_stream_view_avatar_type_id__volatile, gwibber_gtk_stream_view_avatar_type_id);
 
322
        }
 
323
        return gwibber_gtk_stream_view_avatar_type_id__volatile;
 
324
}
 
325
 
 
326
 
 
327
GwibberGtkStreamViewTile* gwibber_gtk_stream_view_tile_construct (GType object_type, GwibberUtils* utils, GwibberService* service, gboolean show_fullname) {
119
328
        GwibberGtkStreamViewTile * self = NULL;
120
329
        g_return_val_if_fail (utils != NULL, NULL);
121
 
        self = (GwibberGtkStreamViewTile*) g_object_new (object_type, "above-child", FALSE, "visible-window", FALSE, "utils", utils, "show-fullname", show_fullname, NULL);
 
330
        g_return_val_if_fail (service != NULL, NULL);
 
331
        self = (GwibberGtkStreamViewTile*) g_object_new (object_type, "above-child", FALSE, "visible-window", FALSE, "utils", utils, "service", service, "show-fullname", show_fullname, NULL);
122
332
        return self;
123
333
}
124
334
 
125
335
 
126
 
GwibberGtkStreamViewTile* gwibber_gtk_stream_view_tile_new (GwibberUtils* utils, gboolean show_fullname) {
127
 
        return gwibber_gtk_stream_view_tile_construct (GWIBBER_GTK_TYPE_STREAM_VIEW_TILE, utils, show_fullname);
 
336
GwibberGtkStreamViewTile* gwibber_gtk_stream_view_tile_new (GwibberUtils* utils, GwibberService* service, gboolean show_fullname) {
 
337
        return gwibber_gtk_stream_view_tile_construct (GWIBBER_GTK_TYPE_STREAM_VIEW_TILE, utils, service, show_fullname);
128
338
}
129
339
 
130
340
 
225
435
        }
226
436
        if (_tmp3_) {
227
437
                gtk_widget_hide ((GtkWidget*) self->priv->time);
 
438
                gtk_widget_set_no_show_all ((GtkWidget*) self->priv->action_box, FALSE);
228
439
                gtk_widget_show_all ((GtkWidget*) self->priv->action_box);
229
440
        } else {
230
441
                gchar* _tmp6_;
248
459
}
249
460
 
250
461
 
 
462
static Block2Data* block2_data_ref (Block2Data* _data2_) {
 
463
        g_atomic_int_inc (&_data2_->_ref_count_);
 
464
        return _data2_;
 
465
}
 
466
 
 
467
 
 
468
static void block2_data_unref (Block2Data* _data2_) {
 
469
        if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
 
470
                _g_object_unref0 (_data2_->self);
 
471
                _g_free0 (_data2_->video_str);
 
472
                _g_free0 (_data2_->link_str);
 
473
                _g_free0 (_data2_->_stream);
 
474
                _g_free0 (_data2_->_html);
 
475
                _g_free0 (_data2_->_icon_uri);
 
476
                _g_free0 (_data2_->_img_url);
 
477
                _g_free0 (_data2_->_img_name);
 
478
                g_slice_free (Block2Data, _data2_);
 
479
        }
 
480
}
 
481
 
 
482
 
 
483
static gpointer _json_object_ref0 (gpointer self) {
 
484
        return self ? json_object_ref (self) : NULL;
 
485
}
 
486
 
 
487
 
 
488
static gpointer _json_array_ref0 (gpointer self) {
 
489
        return self ? json_array_ref (self) : NULL;
 
490
}
 
491
 
 
492
 
 
493
static Block3Data* block3_data_ref (Block3Data* _data3_) {
 
494
        g_atomic_int_inc (&_data3_->_ref_count_);
 
495
        return _data3_;
 
496
}
 
497
 
 
498
 
 
499
static void block3_data_unref (Block3Data* _data3_) {
 
500
        if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
 
501
                block2_data_unref (_data3_->_data2_);
 
502
                _data3_->_data2_ = NULL;
 
503
                _g_object_unref0 (_data3_->cicon);
 
504
                g_slice_free (Block3Data, _data3_);
 
505
        }
 
506
}
 
507
 
 
508
 
 
509
static Block4Data* block4_data_ref (Block4Data* _data4_) {
 
510
        g_atomic_int_inc (&_data4_->_ref_count_);
 
511
        return _data4_;
 
512
}
 
513
 
 
514
 
 
515
static void block4_data_unref (Block4Data* _data4_) {
 
516
        if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
 
517
                block3_data_unref (_data4_->_data3_);
 
518
                _data4_->_data3_ = NULL;
 
519
                _g_free0 (_data4_->cimage);
 
520
                g_slice_free (Block4Data, _data4_);
 
521
        }
 
522
}
 
523
 
 
524
 
 
525
static gboolean _lambda16_ (Block4Data* _data4_) {
 
526
        Block3Data* _data3_;
 
527
        Block2Data* _data2_;
 
528
        GwibberGtkStreamViewTile * self;
 
529
        gboolean result = FALSE;
 
530
        _data3_ = _data4_->_data3_;
 
531
        _data2_ = _data3_->_data2_;
 
532
        self = _data2_->self;
 
533
        gwibber_gtk_stream_view_tile_load_avatar_async (self, _data4_->cimage, (GtkImage*) _data3_->cicon, NULL, NULL);
 
534
        result = FALSE;
 
535
        return result;
 
536
}
 
537
 
 
538
 
 
539
static gboolean __lambda16__gsource_func (gpointer self) {
 
540
        gboolean result;
 
541
        result = _lambda16_ (self);
 
542
        return result;
 
543
}
 
544
 
 
545
 
251
546
static gpointer _g_object_ref0 (gpointer self) {
252
547
        return self ? g_object_ref (self) : NULL;
253
548
}
274
569
}
275
570
 
276
571
 
277
 
static void _lambda16_ (const gchar* mid, const gchar* account, const gchar* sender, GwibberGtkStreamViewTile* self) {
 
572
static void _lambda17_ (const gchar* mid, const gchar* account, const gchar* sender, GwibberGtkStreamViewTile* self) {
278
573
        g_return_if_fail (mid != NULL);
279
574
        g_return_if_fail (account != NULL);
280
575
        g_return_if_fail (sender != NULL);
282
577
}
283
578
 
284
579
 
285
 
static void __lambda16__gwibber_gtk_action_box_item_reply (GwibberGtkActionBoxItem* _sender, const gchar* mid, const gchar* account, const gchar* sender, gpointer self) {
286
 
        _lambda16_ (mid, account, sender, self);
 
580
static void __lambda17__gwibber_gtk_action_box_item_reply (GwibberGtkActionBoxItem* _sender, const gchar* mid, const gchar* account, const gchar* sender, gpointer self) {
 
581
        _lambda17_ (mid, account, sender, self);
 
582
}
 
583
 
 
584
 
 
585
static gboolean _lambda18_ (Block2Data* _data2_) {
 
586
        GwibberGtkStreamViewTile * self;
 
587
        gboolean result = FALSE;
 
588
        self = _data2_->self;
 
589
        gwibber_gtk_stream_view_tile_load_avatar_async (self, _data2_->_icon_uri, (GtkImage*) self->priv->icon, NULL, NULL);
 
590
        result = FALSE;
 
591
        return result;
 
592
}
 
593
 
 
594
 
 
595
static gboolean __lambda18__gsource_func (gpointer self) {
 
596
        gboolean result;
 
597
        result = _lambda18_ (self);
 
598
        return result;
287
599
}
288
600
 
289
601
 
314
626
}
315
627
 
316
628
 
317
 
void gwibber_gtk_stream_view_tile_set_details (GwibberGtkStreamViewTile* self, gchar** _accounts, int _accounts_length1, const gchar* _stream, const gchar* _sender, const gchar* _sender_nick, gboolean _from_me, const gchar* _timestamp, const gchar* _message, const gchar* _html, const gchar* _icon_uri, const gchar* _url, const gchar* _source, const gchar* _timestring, const gchar* _reply_nick, const gchar* _reply_name, const gchar* _reply_url, gdouble _likes, const gchar* _retweet_nick, const gchar* _retweet_name, const gchar* _retweet_id, const gchar* _link_picture, const gchar* _link_name, const gchar* _link_url, const gchar* _link_desc, const gchar* _link_caption, const gchar* _link_icon, const gchar* _img_url, const gchar* _img_src, const gchar* _img_thumb, const gchar* _img_name) {
 
629
static Block5Data* block5_data_ref (Block5Data* _data5_) {
 
630
        g_atomic_int_inc (&_data5_->_ref_count_);
 
631
        return _data5_;
 
632
}
 
633
 
 
634
 
 
635
static void block5_data_unref (Block5Data* _data5_) {
 
636
        if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {
 
637
                block2_data_unref (_data5_->_data2_);
 
638
                _data5_->_data2_ = NULL;
 
639
                _g_free0 (_data5_->img_str);
 
640
                g_slice_free (Block5Data, _data5_);
 
641
        }
 
642
}
 
643
 
 
644
 
 
645
static gboolean _lambda19_ (Block5Data* _data5_) {
 
646
        Block2Data* _data2_;
 
647
        GwibberGtkStreamViewTile * self;
 
648
        gboolean result = FALSE;
 
649
        gboolean _tmp0_ = FALSE;
 
650
        _data2_ = _data5_->_data2_;
 
651
        self = _data2_->self;
 
652
        if (g_strcmp0 (_data2_->_stream, "videos") == 0) {
 
653
                gint _tmp1_;
 
654
                _tmp1_ = strlen (_data2_->video_str);
 
655
                _tmp0_ = _tmp1_ > 0;
 
656
        } else {
 
657
                _tmp0_ = FALSE;
 
658
        }
 
659
        if (_tmp0_) {
 
660
                gchar* _tmp2_;
 
661
                _tmp2_ = g_strdup (_data2_->video_str);
 
662
                _g_free0 (_data5_->img_str);
 
663
                _data5_->img_str = _tmp2_;
 
664
        } else {
 
665
                gboolean _tmp3_ = FALSE;
 
666
                if (g_strcmp0 (_data2_->_stream, "links") == 0) {
 
667
                        gint _tmp4_;
 
668
                        _tmp4_ = strlen (_data2_->link_str);
 
669
                        _tmp3_ = _tmp4_ > 0;
 
670
                } else {
 
671
                        _tmp3_ = FALSE;
 
672
                }
 
673
                if (_tmp3_) {
 
674
                        gchar* _tmp5_;
 
675
                        _tmp5_ = g_strdup (_data2_->link_str);
 
676
                        _g_free0 (_data5_->img_str);
 
677
                        _data5_->img_str = _tmp5_;
 
678
                } else {
 
679
                        gint _tmp6_;
 
680
                        gchar* _tmp21_;
 
681
                        _tmp6_ = strlen (_data2_->_img_name);
 
682
                        if (_tmp6_ > 0) {
 
683
                                gchar* _tmp7_;
 
684
                                gchar* _tmp8_;
 
685
                                gchar* _tmp9_;
 
686
                                gchar* _tmp10_;
 
687
                                gchar* _tmp11_;
 
688
                                gchar* _tmp12_;
 
689
                                gchar* _tmp13_;
 
690
                                _tmp7_ = g_strconcat ("<a href='", _data2_->_img_url, NULL);
 
691
                                _tmp8_ = _tmp7_;
 
692
                                _tmp9_ = g_strconcat (_tmp8_, "'>", NULL);
 
693
                                _tmp10_ = _tmp9_;
 
694
                                _tmp11_ = g_strconcat (_tmp10_, _data2_->_img_name, NULL);
 
695
                                _tmp12_ = _tmp11_;
 
696
                                _tmp13_ = g_strconcat (_tmp12_, "</a>\n", NULL);
 
697
                                _g_free0 (_data5_->img_str);
 
698
                                _data5_->img_str = _tmp13_;
 
699
                                _g_free0 (_tmp12_);
 
700
                                _g_free0 (_tmp10_);
 
701
                                _g_free0 (_tmp8_);
 
702
                        } else {
 
703
                                gchar* _tmp14_;
 
704
                                gchar* _tmp15_;
 
705
                                gchar* _tmp16_;
 
706
                                gchar* _tmp17_;
 
707
                                gchar* _tmp18_;
 
708
                                gchar* _tmp19_;
 
709
                                gchar* _tmp20_;
 
710
                                _tmp14_ = g_strconcat ("<a href='", _data2_->_img_url, NULL);
 
711
                                _tmp15_ = _tmp14_;
 
712
                                _tmp16_ = g_strconcat (_tmp15_, "'>", NULL);
 
713
                                _tmp17_ = _tmp16_;
 
714
                                _tmp18_ = g_strconcat (_tmp17_, _data2_->_img_url, NULL);
 
715
                                _tmp19_ = _tmp18_;
 
716
                                _tmp20_ = g_strconcat (_tmp19_, "</a>\n", NULL);
 
717
                                _g_free0 (_data5_->img_str);
 
718
                                _data5_->img_str = _tmp20_;
 
719
                                _g_free0 (_tmp19_);
 
720
                                _g_free0 (_tmp17_);
 
721
                                _g_free0 (_tmp15_);
 
722
                        }
 
723
                        _tmp21_ = g_strconcat (_data5_->img_str, _data2_->_html, NULL);
 
724
                        _g_free0 (_data5_->img_str);
 
725
                        _data5_->img_str = _tmp21_;
 
726
                }
 
727
        }
 
728
        gwibber_gtk_stream_view_tile_load_thumbnail_async (self, _data5_->img_str, NULL, NULL);
 
729
        result = FALSE;
 
730
        return result;
 
731
}
 
732
 
 
733
 
 
734
static gboolean __lambda19__gsource_func (gpointer self) {
 
735
        gboolean result;
 
736
        result = _lambda19_ (self);
 
737
        return result;
 
738
}
 
739
 
 
740
 
 
741
void gwibber_gtk_stream_view_tile_set_details (GwibberGtkStreamViewTile* self, gchar** _accounts, int _accounts_length1, const gchar* _stream, const gchar* _sender, const gchar* _sender_nick, gboolean _from_me, const gchar* _timestamp, const gchar* _message, const gchar* _html, const gchar* _icon_uri, const gchar* _url, const gchar* _source, const gchar* _timestring, const gchar* _reply_nick, const gchar* _reply_name, const gchar* _reply_url, gdouble _likes, const gchar* _retweet_nick, const gchar* _retweet_name, const gchar* _retweet_id, const gchar* _link_picture, const gchar* _link_name, const gchar* _link_url, const gchar* _link_desc, const gchar* _link_caption, const gchar* _link_icon, const gchar* _img_url, const gchar* _img_src, const gchar* _img_thumb, const gchar* _img_name, const gchar* _video_picture, const gchar* _video_src, const gchar* _video_url, const gchar* _video_name, const gchar* _comments) {
 
742
        Block2Data* _data2_;
318
743
        gchar* _tmp0_;
 
744
        GList* _tmp9_ = NULL;
 
745
        gchar* _tmp51_;
319
746
        gchar* display_name;
320
 
        gboolean _tmp1_ = FALSE;
321
 
        gchar* _tmp6_;
322
 
        gchar* _tmp7_;
323
 
        gchar* _tmp8_;
324
 
        gchar* _tmp9_;
325
 
        gchar* _tmp10_ = NULL;
326
 
        gint _tmp11_;
327
 
        gchar* _tmp14_;
 
747
        gboolean _tmp52_ = FALSE;
 
748
        gchar* _tmp57_;
 
749
        gchar* _tmp58_;
 
750
        gchar* _tmp59_;
 
751
        gchar* _tmp60_;
 
752
        gchar* _tmp61_ = NULL;
 
753
        gint _tmp62_;
 
754
        gchar* _tmp65_;
328
755
        gchar** icon_displayed;
329
756
        gint icon_displayed_length1;
330
757
        gint _icon_displayed_size_;
331
 
        GList* _tmp15_ = NULL;
332
 
        gchar* _tmp37_ = NULL;
 
758
        GList* _tmp66_ = NULL;
 
759
        gchar* _tmp82_ = NULL;
333
760
        gchar* _avatar_cache_image;
334
 
        gchar* _tmp38_;
335
 
        guint _tmp39_;
336
 
        gint _tmp73_;
337
 
        glong _tmp95_;
338
 
        gchar* _tmp96_ = NULL;
339
 
        gchar* _tmp97_;
 
761
        gchar* _tmp84_;
 
762
        guint _tmp85_;
 
763
        gint _tmp124_;
 
764
        glong _tmp126_;
 
765
        gchar* _tmp127_ = NULL;
 
766
        gchar* _tmp128_;
340
767
        gchar* reply_to_string;
341
 
        gboolean _tmp98_ = FALSE;
342
 
        gchar* _tmp131_;
343
 
        gchar* _tmp132_;
 
768
        gboolean _tmp129_ = FALSE;
 
769
        gchar* _tmp162_;
 
770
        gchar* _tmp163_;
344
771
        gchar* retweeted_by_string;
345
 
        gboolean _tmp133_ = FALSE;
346
 
        gchar* _tmp154_;
 
772
        gboolean _tmp164_ = FALSE;
 
773
        gchar* _tmp185_;
 
774
        GError * _inner_error_ = NULL;
347
775
        g_return_if_fail (self != NULL);
348
776
        g_return_if_fail (_stream != NULL);
349
777
        g_return_if_fail (_sender != NULL);
371
799
        g_return_if_fail (_img_src != NULL);
372
800
        g_return_if_fail (_img_thumb != NULL);
373
801
        g_return_if_fail (_img_name != NULL);
374
 
        if (g_strcmp0 (_stream, "private") == 0) {
 
802
        g_return_if_fail (_video_picture != NULL);
 
803
        g_return_if_fail (_video_src != NULL);
 
804
        g_return_if_fail (_video_url != NULL);
 
805
        g_return_if_fail (_video_name != NULL);
 
806
        g_return_if_fail (_comments != NULL);
 
807
        _data2_ = g_slice_new0 (Block2Data);
 
808
        _data2_->_ref_count_ = 1;
 
809
        _data2_->self = g_object_ref (self);
 
810
        _data2_->_stream = g_strdup (_stream);
 
811
        _data2_->_html = g_strdup (_html);
 
812
        _data2_->_icon_uri = g_strdup (_icon_uri);
 
813
        _data2_->_img_url = g_strdup (_img_url);
 
814
        _data2_->_img_name = g_strdup (_img_name);
 
815
        gtk_widget_hide ((GtkWidget*) self->priv->icon);
 
816
        gtk_widget_hide ((GtkWidget*) self->priv->action_box);
 
817
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->action_box, TRUE);
 
818
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->comments_box, TRUE);
 
819
        gtk_widget_hide ((GtkWidget*) self->priv->comments_box);
 
820
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->thumb_box, TRUE);
 
821
        gtk_widget_hide ((GtkWidget*) self->priv->thumb_box);
 
822
        gtk_widget_hide ((GtkWidget*) self->priv->thumbnail);
 
823
        gtk_label_set_markup (self->priv->message, "");
 
824
        gtk_label_set_markup (self->priv->name, "");
 
825
        gtk_image_set_from_icon_name ((GtkImage*) self->priv->icon, "stock_person", GTK_ICON_SIZE_DIALOG);
 
826
        _g_free0 (self->priv->img_uri);
 
827
        self->priv->img_uri = NULL;
 
828
        _g_free0 (self->priv->img_src);
 
829
        self->priv->img_src = NULL;
 
830
        if (self->priv->img_id > 0) {
 
831
                g_source_remove (self->priv->img_id);
 
832
        }
 
833
        self->priv->img_id = (guint) 0;
 
834
        _tmp0_ = g_strdup (_img_src);
 
835
        _g_free0 (self->priv->img_uri);
 
836
        self->priv->img_uri = _tmp0_;
 
837
        if (g_strcmp0 (_data2_->_stream, "images") == 0) {
 
838
                gboolean _tmp1_ = FALSE;
 
839
                gchar* _tmp4_;
 
840
                if (_img_thumb != NULL) {
 
841
                        gint _tmp2_;
 
842
                        _tmp2_ = strlen (_img_thumb);
 
843
                        _tmp1_ = _tmp2_ > 0;
 
844
                } else {
 
845
                        _tmp1_ = FALSE;
 
846
                }
 
847
                if (_tmp1_) {
 
848
                        gchar* _tmp3_;
 
849
                        _tmp3_ = g_strdup (_img_thumb);
 
850
                        _g_free0 (self->priv->img_uri);
 
851
                        self->priv->img_uri = _tmp3_;
 
852
                }
 
853
                _tmp4_ = g_strdup (_data2_->_img_url);
 
854
                _g_free0 (self->priv->img_src);
 
855
                self->priv->img_src = _tmp4_;
 
856
        } else {
 
857
                if (g_strcmp0 (_data2_->_stream, "links") == 0) {
 
858
                        gchar* _tmp5_;
 
859
                        gchar* _tmp6_;
 
860
                        _tmp5_ = g_strdup (_link_picture);
 
861
                        _g_free0 (self->priv->img_uri);
 
862
                        self->priv->img_uri = _tmp5_;
 
863
                        _tmp6_ = g_strdup (_link_url);
 
864
                        _g_free0 (self->priv->img_src);
 
865
                        self->priv->img_src = _tmp6_;
 
866
                } else {
 
867
                        if (g_strcmp0 (_data2_->_stream, "videos") == 0) {
 
868
                                gchar* _tmp7_;
 
869
                                gchar* _tmp8_;
 
870
                                _tmp7_ = g_strdup (_video_picture);
 
871
                                _g_free0 (self->priv->img_uri);
 
872
                                self->priv->img_uri = _tmp7_;
 
873
                                _tmp8_ = g_strdup (_video_src);
 
874
                                _g_free0 (self->priv->img_src);
 
875
                                self->priv->img_src = _tmp8_;
 
876
                        }
 
877
                }
 
878
        }
 
879
        if (g_strcmp0 (_data2_->_stream, "private") == 0) {
375
880
                gtk_widget_show ((GtkWidget*) self->priv->private);
376
881
        } else {
377
882
                gtk_widget_hide ((GtkWidget*) self->priv->private);
378
883
        }
379
 
        gtk_label_set_markup (self->priv->message, "");
380
 
        _tmp0_ = g_strdup (_sender);
381
 
        display_name = _tmp0_;
 
884
        {
 
885
                GList* _to_disconnect_id_collection;
 
886
                GList* _to_disconnect_id_it;
 
887
                _to_disconnect_id_collection = self->priv->_to_disconnect;
 
888
                for (_to_disconnect_id_it = _to_disconnect_id_collection; _to_disconnect_id_it != NULL; _to_disconnect_id_it = _to_disconnect_id_it->next) {
 
889
                        guint _to_disconnect_id;
 
890
                        _to_disconnect_id = GPOINTER_TO_UINT (_to_disconnect_id_it->data);
 
891
                        {
 
892
                                g_source_remove (_to_disconnect_id);
 
893
                                self->priv->_to_disconnect = g_list_remove (self->priv->_to_disconnect, GUINT_TO_POINTER (_to_disconnect_id));
 
894
                        }
 
895
                }
 
896
        }
 
897
        _tmp9_ = gtk_container_get_children ((GtkContainer*) self->priv->comments_box);
 
898
        {
 
899
                GList* w_collection;
 
900
                GList* w_it;
 
901
                w_collection = _tmp9_;
 
902
                for (w_it = w_collection; w_it != NULL; w_it = w_it->next) {
 
903
                        GtkWidget* w;
 
904
                        w = (GtkWidget*) w_it->data;
 
905
                        {
 
906
                                if (GTK_IS_WIDGET (w)) {
 
907
                                        gtk_widget_destroy (w);
 
908
                                }
 
909
                        }
 
910
                }
 
911
                _g_list_free0 (w_collection);
 
912
        }
 
913
        if (_comments != NULL) {
 
914
                JsonParser* _tmp10_ = NULL;
 
915
                JsonParser* parser;
 
916
                JsonNode* comments_node;
 
917
                JsonNode* _tmp11_ = NULL;
 
918
                _tmp10_ = json_parser_new ();
 
919
                parser = _tmp10_;
 
920
                json_parser_load_from_data (parser, _comments, (gssize) (-1), &_inner_error_);
 
921
                if (_inner_error_ != NULL) {
 
922
                        _g_object_unref0 (parser);
 
923
                        block2_data_unref (_data2_);
 
924
                        _data2_ = NULL;
 
925
                        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);
 
926
                        g_clear_error (&_inner_error_);
 
927
                        return;
 
928
                }
 
929
                comments_node = NULL;
 
930
                _tmp11_ = json_parser_get_root (parser);
 
931
                comments_node = _tmp11_;
 
932
                if (comments_node != NULL) {
 
933
                        JsonObject* _tmp12_ = NULL;
 
934
                        JsonObject* _tmp13_;
 
935
                        JsonObject* comments_obj;
 
936
                        _tmp12_ = json_node_get_object (comments_node);
 
937
                        _tmp13_ = _json_object_ref0 (_tmp12_);
 
938
                        comments_obj = _tmp13_;
 
939
                        if (comments_obj != NULL) {
 
940
                                gboolean _tmp14_;
 
941
                                _tmp14_ = json_object_has_member (comments_obj, "comments");
 
942
                                if (_tmp14_) {
 
943
                                        JsonArray* _tmp15_ = NULL;
 
944
                                        JsonArray* _tmp16_;
 
945
                                        JsonArray* comments;
 
946
                                        _tmp15_ = json_object_get_array_member (comments_obj, "comments");
 
947
                                        _tmp16_ = _json_array_ref0 (_tmp15_);
 
948
                                        comments = _tmp16_;
 
949
                                        {
 
950
                                                gint i;
 
951
                                                i = 0;
 
952
                                                {
 
953
                                                        gboolean _tmp17_;
 
954
                                                        _tmp17_ = TRUE;
 
955
                                                        while (TRUE) {
 
956
                                                                guint _tmp18_;
 
957
                                                                JsonNode* _tmp19_ = NULL;
 
958
                                                                JsonObject* _tmp20_ = NULL;
 
959
                                                                JsonObject* _tmp21_;
 
960
                                                                JsonObject* obj;
 
961
                                                                if (!_tmp17_) {
 
962
                                                                        i++;
 
963
                                                                }
 
964
                                                                _tmp17_ = FALSE;
 
965
                                                                _tmp18_ = json_array_get_length (comments);
 
966
                                                                if (!(i < _tmp18_)) {
 
967
                                                                        break;
 
968
                                                                }
 
969
                                                                _tmp19_ = json_array_get_element (comments, (guint) i);
 
970
                                                                _tmp20_ = json_node_get_object (_tmp19_);
 
971
                                                                _tmp21_ = _json_object_ref0 (_tmp20_);
 
972
                                                                obj = _tmp21_;
 
973
                                                                if (obj != NULL) {
 
974
                                                                        Block3Data* _data3_;
 
975
                                                                        GtkVBox* _tmp22_ = NULL;
 
976
                                                                        GtkVBox* cvbox;
 
977
                                                                        GtkHBox* _tmp23_ = NULL;
 
978
                                                                        GtkHBox* chbox;
 
979
                                                                        GtkAlignment* _tmp24_ = NULL;
 
980
                                                                        GtkAlignment* clalignment;
 
981
                                                                        GwibberGtkStreamViewAvatar* _tmp25_ = NULL;
 
982
                                                                        gboolean _tmp26_;
 
983
                                                                        gboolean _tmp34_;
 
984
                                                                        _data3_ = g_slice_new0 (Block3Data);
 
985
                                                                        _data3_->_ref_count_ = 1;
 
986
                                                                        _data3_->_data2_ = block2_data_ref (_data2_);
 
987
                                                                        _tmp22_ = (GtkVBox*) gtk_vbox_new (FALSE, 2);
 
988
                                                                        cvbox = g_object_ref_sink (_tmp22_);
 
989
                                                                        _tmp23_ = (GtkHBox*) gtk_hbox_new (FALSE, 2);
 
990
                                                                        chbox = g_object_ref_sink (_tmp23_);
 
991
                                                                        _tmp24_ = (GtkAlignment*) gtk_alignment_new (0.5f, 0.0f, 0.0f, 0.0f);
 
992
                                                                        clalignment = g_object_ref_sink (_tmp24_);
 
993
                                                                        gtk_box_pack_start ((GtkBox*) chbox, (GtkWidget*) clalignment, FALSE, FALSE, (guint) 0);
 
994
                                                                        _tmp25_ = gwibber_gtk_stream_view_avatar_new ();
 
995
                                                                        _data3_->cicon = g_object_ref_sink (_tmp25_);
 
996
                                                                        gtk_container_add ((GtkContainer*) clalignment, (GtkWidget*) _data3_->cicon);
 
997
                                                                        gtk_box_pack_start ((GtkBox*) self->priv->comments_box, (GtkWidget*) chbox, FALSE, FALSE, (guint) 2);
 
998
                                                                        gtk_box_pack_start ((GtkBox*) chbox, (GtkWidget*) cvbox, FALSE, FALSE, (guint) 2);
 
999
                                                                        _tmp26_ = json_object_has_member (obj, "text");
 
1000
                                                                        if (_tmp26_) {
 
1001
                                                                                const gchar* _tmp27_ = NULL;
 
1002
                                                                                gchar* _tmp28_;
 
1003
                                                                                gchar* ctext;
 
1004
                                                                                GtkLabel* _tmp29_ = NULL;
 
1005
                                                                                GtkLabel* ctext_label;
 
1006
                                                                                gchar* _tmp30_;
 
1007
                                                                                gchar* _tmp31_;
 
1008
                                                                                gchar* _tmp32_;
 
1009
                                                                                gchar* _tmp33_;
 
1010
                                                                                _tmp27_ = json_object_get_string_member (obj, "text");
 
1011
                                                                                _tmp28_ = g_strdup (_tmp27_);
 
1012
                                                                                ctext = _tmp28_;
 
1013
                                                                                _tmp29_ = (GtkLabel*) gtk_label_new ("");
 
1014
                                                                                ctext_label = g_object_ref_sink (_tmp29_);
 
1015
                                                                                gtk_label_set_selectable (ctext_label, TRUE);
 
1016
                                                                                gtk_label_set_single_line_mode (ctext_label, FALSE);
 
1017
                                                                                gtk_label_set_line_wrap (ctext_label, TRUE);
 
1018
                                                                                gtk_label_set_line_wrap_mode (ctext_label, PANGO_WRAP_WORD_CHAR);
 
1019
                                                                                gtk_misc_set_alignment ((GtkMisc*) ctext_label, 0.0f, 0.0f);
 
1020
                                                                                _tmp30_ = g_strconcat ("<span font_size='small'>", ctext, NULL);
 
1021
                                                                                _tmp31_ = _tmp30_;
 
1022
                                                                                _tmp32_ = g_strconcat (_tmp31_, "</span>", NULL);
 
1023
                                                                                _tmp33_ = _tmp32_;
 
1024
                                                                                gtk_label_set_markup (ctext_label, _tmp33_);
 
1025
                                                                                _g_free0 (_tmp33_);
 
1026
                                                                                _g_free0 (_tmp31_);
 
1027
                                                                                gtk_box_pack_end ((GtkBox*) cvbox, (GtkWidget*) ctext_label, FALSE, FALSE, (guint) 2);
 
1028
                                                                                _g_object_unref0 (ctext_label);
 
1029
                                                                                _g_free0 (ctext);
 
1030
                                                                        }
 
1031
                                                                        _tmp34_ = json_object_has_member (obj, "sender");
 
1032
                                                                        if (_tmp34_) {
 
1033
                                                                                JsonObject* _tmp35_ = NULL;
 
1034
                                                                                JsonObject* _tmp36_;
 
1035
                                                                                JsonObject* _sender_obj;
 
1036
                                                                                _tmp35_ = json_object_get_object_member (obj, "sender");
 
1037
                                                                                _tmp36_ = _json_object_ref0 (_tmp35_);
 
1038
                                                                                _sender_obj = _tmp36_;
 
1039
                                                                                if (_sender_obj != NULL) {
 
1040
                                                                                        gboolean _tmp37_;
 
1041
                                                                                        gboolean _tmp46_;
 
1042
                                                                                        _tmp37_ = json_object_has_member (_sender_obj, "name");
 
1043
                                                                                        if (_tmp37_) {
 
1044
                                                                                                const gchar* _tmp38_ = NULL;
 
1045
                                                                                                gchar* _tmp39_;
 
1046
                                                                                                gchar* cname;
 
1047
                                                                                                GtkHBox* _tmp40_ = NULL;
 
1048
                                                                                                GtkHBox* cname_box;
 
1049
                                                                                                GtkLabel* _tmp41_ = NULL;
 
1050
                                                                                                GtkLabel* cname_label;
 
1051
                                                                                                gchar* _tmp42_;
 
1052
                                                                                                gchar* _tmp43_;
 
1053
                                                                                                gchar* _tmp44_;
 
1054
                                                                                                gchar* _tmp45_;
 
1055
                                                                                                _tmp38_ = json_object_get_string_member (_sender_obj, "name");
 
1056
                                                                                                _tmp39_ = g_strdup (_tmp38_);
 
1057
                                                                                                cname = _tmp39_;
 
1058
                                                                                                _tmp40_ = (GtkHBox*) gtk_hbox_new (FALSE, 2);
 
1059
                                                                                                cname_box = g_object_ref_sink (_tmp40_);
 
1060
                                                                                                _tmp41_ = (GtkLabel*) gtk_label_new ("");
 
1061
                                                                                                cname_label = g_object_ref_sink (_tmp41_);
 
1062
                                                                                                _tmp42_ = g_strconcat ("<b><span font_size='small'>", cname, NULL);
 
1063
                                                                                                _tmp43_ = _tmp42_;
 
1064
                                                                                                _tmp44_ = g_strconcat (_tmp43_, "</span></b>", NULL);
 
1065
                                                                                                _tmp45_ = _tmp44_;
 
1066
                                                                                                gtk_label_set_markup (cname_label, _tmp45_);
 
1067
                                                                                                _g_free0 (_tmp45_);
 
1068
                                                                                                _g_free0 (_tmp43_);
 
1069
                                                                                                gtk_box_pack_start ((GtkBox*) cname_box, (GtkWidget*) cname_label, FALSE, FALSE, (guint) 2);
 
1070
                                                                                                gtk_box_pack_end ((GtkBox*) cvbox, (GtkWidget*) cname_box, FALSE, FALSE, (guint) 2);
 
1071
                                                                                                _g_object_unref0 (cname_label);
 
1072
                                                                                                _g_object_unref0 (cname_box);
 
1073
                                                                                                _g_free0 (cname);
 
1074
                                                                                        }
 
1075
                                                                                        _tmp46_ = json_object_has_member (_sender_obj, "image");
 
1076
                                                                                        if (_tmp46_) {
 
1077
                                                                                                Block4Data* _data4_;
 
1078
                                                                                                const gchar* _tmp47_ = NULL;
 
1079
                                                                                                gchar* _tmp48_;
 
1080
                                                                                                gchar* _tmp49_ = NULL;
 
1081
                                                                                                gchar* cached_cicon;
 
1082
                                                                                                _data4_ = g_slice_new0 (Block4Data);
 
1083
                                                                                                _data4_->_ref_count_ = 1;
 
1084
                                                                                                _data4_->_data3_ = block3_data_ref (_data3_);
 
1085
                                                                                                _tmp47_ = json_object_get_string_member (_sender_obj, "image");
 
1086
                                                                                                _tmp48_ = g_strdup (_tmp47_);
 
1087
                                                                                                _data4_->cimage = _tmp48_;
 
1088
                                                                                                _tmp49_ = gwibber_utils_avatar_path (self->priv->_utils, _data4_->cimage);
 
1089
                                                                                                cached_cicon = _tmp49_;
 
1090
                                                                                                if (cached_cicon != NULL) {
 
1091
                                                                                                        gtk_image_set_from_file ((GtkImage*) _data3_->cicon, cached_cicon);
 
1092
                                                                                                } else {
 
1093
                                                                                                        guint _tmp50_;
 
1094
                                                                                                        guint cid;
 
1095
                                                                                                        gtk_image_set_from_icon_name ((GtkImage*) _data3_->cicon, "stock_person", GTK_ICON_SIZE_DIALOG);
 
1096
                                                                                                        gtk_widget_show ((GtkWidget*) _data3_->cicon);
 
1097
                                                                                                        _tmp50_ = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, __lambda16__gsource_func, block4_data_ref (_data4_), block4_data_unref);
 
1098
                                                                                                        cid = _tmp50_;
 
1099
                                                                                                        self->priv->_to_disconnect = g_list_append (self->priv->_to_disconnect, GUINT_TO_POINTER (cid));
 
1100
                                                                                                }
 
1101
                                                                                                _g_free0 (cached_cicon);
 
1102
                                                                                                block4_data_unref (_data4_);
 
1103
                                                                                                _data4_ = NULL;
 
1104
                                                                                        }
 
1105
                                                                                }
 
1106
                                                                                _json_object_unref0 (_sender_obj);
 
1107
                                                                        }
 
1108
                                                                        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->comments_box, FALSE);
 
1109
                                                                        gtk_widget_show_all ((GtkWidget*) self->priv->comments_box);
 
1110
                                                                        _g_object_unref0 (clalignment);
 
1111
                                                                        _g_object_unref0 (chbox);
 
1112
                                                                        _g_object_unref0 (cvbox);
 
1113
                                                                        block3_data_unref (_data3_);
 
1114
                                                                        _data3_ = NULL;
 
1115
                                                                }
 
1116
                                                                _json_object_unref0 (obj);
 
1117
                                                        }
 
1118
                                                }
 
1119
                                        }
 
1120
                                        _json_array_unref0 (comments);
 
1121
                                }
 
1122
                        }
 
1123
                        _json_object_unref0 (comments_obj);
 
1124
                }
 
1125
                _g_object_unref0 (parser);
 
1126
        }
 
1127
        _tmp51_ = g_strdup (_sender);
 
1128
        display_name = _tmp51_;
382
1129
        if (self->priv->_show_fullname) {
383
 
                gint _tmp2_;
384
 
                _tmp2_ = strlen (_sender);
385
 
                _tmp1_ = _tmp2_ > 0;
 
1130
                gint _tmp53_;
 
1131
                _tmp53_ = strlen (_sender);
 
1132
                _tmp52_ = _tmp53_ > 0;
386
1133
        } else {
387
 
                _tmp1_ = FALSE;
 
1134
                _tmp52_ = FALSE;
388
1135
        }
389
 
        if (_tmp1_) {
390
 
                gchar* _tmp3_;
391
 
                _tmp3_ = g_strdup (_sender);
 
1136
        if (_tmp52_) {
 
1137
                gchar* _tmp54_;
 
1138
                _tmp54_ = g_strdup (_sender);
392
1139
                _g_free0 (display_name);
393
 
                display_name = _tmp3_;
 
1140
                display_name = _tmp54_;
394
1141
        } else {
395
 
                gint _tmp4_;
396
 
                _tmp4_ = strlen (_sender_nick);
397
 
                if (_tmp4_ > 0) {
398
 
                        gchar* _tmp5_;
399
 
                        _tmp5_ = g_strdup (_sender_nick);
 
1142
                gint _tmp55_;
 
1143
                _tmp55_ = strlen (_sender_nick);
 
1144
                if (_tmp55_ > 0) {
 
1145
                        gchar* _tmp56_;
 
1146
                        _tmp56_ = g_strdup (_sender_nick);
400
1147
                        _g_free0 (display_name);
401
 
                        display_name = _tmp5_;
 
1148
                        display_name = _tmp56_;
402
1149
                }
403
1150
        }
404
 
        _tmp6_ = g_strconcat ("<b>", display_name, NULL);
405
 
        _tmp7_ = _tmp6_;
406
 
        _tmp8_ = g_strconcat (_tmp7_, "</b>", NULL);
407
 
        _tmp9_ = _tmp8_;
408
 
        gtk_label_set_markup (self->priv->name, _tmp9_);
409
 
        _g_free0 (_tmp9_);
410
 
        _g_free0 (_tmp7_);
411
 
        _tmp11_ = strlen (_sender_nick);
412
 
        if (_tmp11_ > 0) {
413
 
                gchar* _tmp12_;
414
 
                _tmp12_ = g_strconcat ("@", _sender_nick, NULL);
415
 
                _g_free0 (_tmp10_);
416
 
                _tmp10_ = _tmp12_;
 
1151
        _tmp57_ = g_strconcat ("<b>", display_name, NULL);
 
1152
        _tmp58_ = _tmp57_;
 
1153
        _tmp59_ = g_strconcat (_tmp58_, "</b>", NULL);
 
1154
        _tmp60_ = _tmp59_;
 
1155
        gtk_label_set_markup (self->priv->name, _tmp60_);
 
1156
        _g_free0 (_tmp60_);
 
1157
        _g_free0 (_tmp58_);
 
1158
        _tmp62_ = strlen (_sender_nick);
 
1159
        if (_tmp62_ > 0) {
 
1160
                gchar* _tmp63_;
 
1161
                _tmp63_ = g_strconcat ("@", _sender_nick, NULL);
 
1162
                _g_free0 (_tmp61_);
 
1163
                _tmp61_ = _tmp63_;
417
1164
        } else {
418
 
                gchar* _tmp13_;
419
 
                _tmp13_ = g_strdup ("");
420
 
                _g_free0 (_tmp10_);
421
 
                _tmp10_ = _tmp13_;
 
1165
                gchar* _tmp64_;
 
1166
                _tmp64_ = g_strdup ("");
 
1167
                _g_free0 (_tmp61_);
 
1168
                _tmp61_ = _tmp64_;
422
1169
        }
423
 
        _tmp14_ = g_strdup (_tmp10_);
 
1170
        _tmp65_ = g_strdup (_tmp61_);
424
1171
        _g_free0 (self->priv->sender);
425
 
        self->priv->sender = _tmp14_;
 
1172
        self->priv->sender = _tmp65_;
426
1173
        icon_displayed = NULL;
427
1174
        icon_displayed_length1 = 0;
428
1175
        _icon_displayed_size_ = 0;
429
 
        _tmp15_ = gtk_container_get_children ((GtkContainer*) self->priv->action_box);
 
1176
        _tmp66_ = gtk_container_get_children ((GtkContainer*) self->priv->action_box);
430
1177
        {
431
1178
                GList* _p_collection;
432
1179
                GList* _p_it;
433
 
                _p_collection = _tmp15_;
 
1180
                _p_collection = _tmp66_;
434
1181
                for (_p_it = _p_collection; _p_it != NULL; _p_it = _p_it->next) {
435
1182
                        GtkWidget* _p;
436
1183
                        _p = (GtkWidget*) _p_it->data;
437
1184
                        {
438
 
                                GtkWidget* _tmp16_;
439
 
                                GwibberGtkActionBoxItem* _tmp17_;
 
1185
                                GtkWidget* _tmp67_;
 
1186
                                GwibberGtkActionBoxItem* _tmp68_;
440
1187
                                GwibberGtkActionBoxItem* _i;
441
 
                                GList* _tmp18_ = NULL;
442
 
                                _tmp16_ = _p;
443
 
                                _tmp17_ = _g_object_ref0 (GWIBBER_GTK_IS_ACTION_BOX_ITEM (_tmp16_) ? ((GwibberGtkActionBoxItem*) _tmp16_) : NULL);
444
 
                                _i = _tmp17_;
445
 
                                _tmp18_ = gtk_container_get_children ((GtkContainer*) _i);
 
1188
                                GList* _tmp69_ = NULL;
 
1189
                                _tmp67_ = _p;
 
1190
                                _tmp68_ = _g_object_ref0 (GWIBBER_GTK_IS_ACTION_BOX_ITEM (_tmp67_) ? ((GwibberGtkActionBoxItem*) _tmp67_) : NULL);
 
1191
                                _i = _tmp68_;
 
1192
                                _tmp69_ = gtk_container_get_children ((GtkContainer*) _i);
446
1193
                                {
447
1194
                                        GList* _w_collection;
448
1195
                                        GList* _w_it;
449
 
                                        _w_collection = _tmp18_;
 
1196
                                        _w_collection = _tmp69_;
450
1197
                                        for (_w_it = _w_collection; _w_it != NULL; _w_it = _w_it->next) {
451
1198
                                                GtkWidget* _w;
452
1199
                                                _w = (GtkWidget*) _w_it->data;
453
1200
                                                {
454
1201
                                                        if (GTK_IS_MENU (_w)) {
455
 
                                                                GtkWidget* _tmp19_;
456
 
                                                                GtkMenu* _tmp20_;
 
1202
                                                                GtkWidget* _tmp70_;
 
1203
                                                                GtkMenu* _tmp71_;
457
1204
                                                                GtkMenu* _y;
458
 
                                                                GList* _tmp21_ = NULL;
459
 
                                                                GList* _tmp22_;
460
 
                                                                guint _tmp23_;
461
 
                                                                GList* _tmp24_ = NULL;
462
 
                                                                GList* _tmp25_ = NULL;
463
 
                                                                GList* _tmp26_;
464
 
                                                                guint _tmp27_;
465
 
                                                                _tmp19_ = _w;
466
 
                                                                _tmp20_ = _g_object_ref0 (GTK_IS_MENU (_tmp19_) ? ((GtkMenu*) _tmp19_) : NULL);
467
 
                                                                _y = _tmp20_;
468
 
                                                                _tmp21_ = gtk_container_get_children ((GtkContainer*) _y);
469
 
                                                                _tmp22_ = _tmp21_;
470
 
                                                                _tmp23_ = g_list_length (_tmp22_);
471
 
                                                                g_debug ("stream-view-tile.vala:368: _y before has %u children", _tmp23_);
472
 
                                                                _g_list_free0 (_tmp22_);
473
 
                                                                _tmp24_ = gtk_container_get_children ((GtkContainer*) _y);
 
1205
                                                                GList* _tmp72_ = NULL;
 
1206
                                                                _tmp70_ = _w;
 
1207
                                                                _tmp71_ = _g_object_ref0 (GTK_IS_MENU (_tmp70_) ? ((GtkMenu*) _tmp70_) : NULL);
 
1208
                                                                _y = _tmp71_;
 
1209
                                                                _tmp72_ = gtk_container_get_children ((GtkContainer*) _y);
474
1210
                                                                {
475
1211
                                                                        GList* _x_collection;
476
1212
                                                                        GList* _x_it;
477
 
                                                                        _x_collection = _tmp24_;
 
1213
                                                                        _x_collection = _tmp72_;
478
1214
                                                                        for (_x_it = _x_collection; _x_it != NULL; _x_it = _x_it->next) {
479
1215
                                                                                GtkWidget* _x;
480
1216
                                                                                _x = (GtkWidget*) _x_it->data;
486
1222
                                                                        }
487
1223
                                                                        _g_list_free0 (_x_collection);
488
1224
                                                                }
489
 
                                                                _tmp25_ = gtk_container_get_children ((GtkContainer*) _y);
490
 
                                                                _tmp26_ = _tmp25_;
491
 
                                                                _tmp27_ = g_list_length (_tmp26_);
492
 
                                                                g_debug ("stream-view-tile.vala:375: _y after has %u children", _tmp27_);
493
 
                                                                _g_list_free0 (_tmp26_);
494
1225
                                                                _g_object_unref0 (_y);
495
1226
                                                        }
496
1227
                                                        gtk_container_remove ((GtkContainer*) _i, _w);
517
1248
                _a_collection = _accounts;
518
1249
                _a_collection_length1 = _accounts_length1;
519
1250
                for (_a_it = 0; _a_it < _accounts_length1; _a_it = _a_it + 1) {
520
 
                        gchar* _tmp28_;
 
1251
                        gchar* _tmp73_;
521
1252
                        gchar* _a;
522
 
                        _tmp28_ = g_strdup (_a_collection[_a_it]);
523
 
                        _a = _tmp28_;
 
1253
                        _tmp73_ = g_strdup (_a_collection[_a_it]);
 
1254
                        _a = _tmp73_;
524
1255
                        {
525
1256
                                gchar* _account = NULL;
526
1257
                                gchar* _service = NULL;
527
1258
                                gchar* _mid = NULL;
528
 
                                gchar** _tmp29_;
529
 
                                gchar** _tmp30_ = NULL;
530
 
                                gchar** _tmp31_;
531
 
                                gint _tmp31__length1;
532
 
                                gint __tmp31__size_;
533
 
                                gchar* _tmp32_;
534
 
                                gchar* _tmp33_;
535
 
                                gchar* _tmp34_;
536
 
                                gchar* _tmp35_;
537
 
                                GwibberGtkActionBoxItem* _tmp36_ = NULL;
 
1259
                                gchar** _tmp74_;
 
1260
                                gchar** _tmp75_ = NULL;
 
1261
                                gchar** _tmp76_;
 
1262
                                gint _tmp76__length1;
 
1263
                                gint __tmp76__size_;
 
1264
                                gchar* _tmp77_;
 
1265
                                gchar* _tmp78_;
 
1266
                                gchar* _tmp79_;
 
1267
                                gchar* _tmp80_;
 
1268
                                GwibberGtkActionBoxItem* _tmp81_ = NULL;
538
1269
                                GwibberGtkActionBoxItem* action_item;
539
 
                                _tmp30_ = _tmp29_ = g_strsplit (_a, ":", 0);
540
 
                                _tmp31_ = _tmp30_;
541
 
                                _tmp31__length1 = _vala_array_length (_tmp29_);
542
 
                                __tmp31__size_ = _vala_array_length (_tmp29_);
543
 
                                _tmp32_ = g_strdup (_tmp31_[0]);
 
1270
                                _tmp75_ = _tmp74_ = g_strsplit (_a, ":", 0);
 
1271
                                _tmp76_ = _tmp75_;
 
1272
                                _tmp76__length1 = _vala_array_length (_tmp74_);
 
1273
                                __tmp76__size_ = _vala_array_length (_tmp74_);
 
1274
                                _tmp77_ = g_strdup (_tmp76_[0]);
544
1275
                                _g_free0 (_account);
545
 
                                _account = _tmp32_;
546
 
                                _tmp33_ = g_strdup (_tmp31_[1]);
 
1276
                                _account = _tmp77_;
 
1277
                                _tmp78_ = g_strdup (_tmp76_[1]);
547
1278
                                _g_free0 (_service);
548
 
                                _service = _tmp33_;
549
 
                                _tmp34_ = g_strdup (_tmp31_[2]);
 
1279
                                _service = _tmp78_;
 
1280
                                _tmp79_ = g_strdup (_tmp76_[2]);
550
1281
                                _g_free0 (_mid);
551
 
                                _mid = _tmp34_;
 
1282
                                _mid = _tmp79_;
552
1283
                                if (_vala_string_array_contains (icon_displayed, icon_displayed_length1, _account)) {
553
 
                                        _tmp31_ = (_vala_array_free (_tmp31_, _tmp31__length1, (GDestroyNotify) g_free), NULL);
 
1284
                                        _tmp76_ = (_vala_array_free (_tmp76_, _tmp76__length1, (GDestroyNotify) g_free), NULL);
554
1285
                                        _g_free0 (_mid);
555
1286
                                        _g_free0 (_service);
556
1287
                                        _g_free0 (_account);
557
1288
                                        _g_free0 (_a);
558
1289
                                        continue;
559
1290
                                }
560
 
                                _tmp35_ = g_strdup (_account);
561
 
                                _vala_array_add1 (&icon_displayed, &icon_displayed_length1, &_icon_displayed_size_, _tmp35_);
562
 
                                _tmp36_ = gwibber_gtk_action_box_item_new (_service, _stream, _account, _mid, self->priv->sender, "");
563
 
                                action_item = g_object_ref_sink (_tmp36_);
 
1291
                                _tmp80_ = g_strdup (_account);
 
1292
                                _vala_array_add1 (&icon_displayed, &icon_displayed_length1, &_icon_displayed_size_, _tmp80_);
 
1293
                                _tmp81_ = gwibber_gtk_action_box_item_new (_service, _data2_->_stream, _account, _mid, self->priv->sender, "");
 
1294
                                action_item = g_object_ref_sink (_tmp81_);
564
1295
                                gtk_container_add ((GtkContainer*) self->priv->action_box, (GtkWidget*) action_item);
565
 
                                g_signal_connect_object (action_item, "reply", (GCallback) __lambda16__gwibber_gtk_action_box_item_reply, self, 0);
 
1296
                                g_signal_connect_object (action_item, "reply", (GCallback) __lambda17__gwibber_gtk_action_box_item_reply, self, 0);
566
1297
                                _g_object_unref0 (action_item);
567
 
                                _tmp31_ = (_vala_array_free (_tmp31_, _tmp31__length1, (GDestroyNotify) g_free), NULL);
 
1298
                                _tmp76_ = (_vala_array_free (_tmp76_, _tmp76__length1, (GDestroyNotify) g_free), NULL);
568
1299
                                _g_free0 (_mid);
569
1300
                                _g_free0 (_service);
570
1301
                                _g_free0 (_account);
577
1308
        } else {
578
1309
                gtk_widget_reparent ((GtkWidget*) self->priv->icon_box, (GtkWidget*) self->priv->lalignment);
579
1310
        }
580
 
        _tmp37_ = gwibber_utils_avatar_path (self->priv->_utils, _icon_uri);
581
 
        _avatar_cache_image = _tmp37_;
 
1311
        if (self->priv->_cache_avatar_id > 0) {
 
1312
                g_source_remove (self->priv->_cache_avatar_id);
 
1313
        }
 
1314
        _tmp82_ = gwibber_utils_avatar_path (self->priv->_utils, _data2_->_icon_uri);
 
1315
        _avatar_cache_image = _tmp82_;
582
1316
        if (_avatar_cache_image != NULL) {
583
 
                gtk_image_set_from_file (self->priv->icon, _avatar_cache_image);
 
1317
                gtk_image_set_from_file ((GtkImage*) self->priv->icon, _avatar_cache_image);
584
1318
        } else {
585
 
                gtk_image_set_from_icon_name (self->priv->icon, "stock_person", GTK_ICON_SIZE_DIALOG);
 
1319
                guint _tmp83_;
 
1320
                gtk_image_set_from_icon_name ((GtkImage*) self->priv->icon, "stock_person", GTK_ICON_SIZE_DIALOG);
 
1321
                _tmp83_ = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, __lambda18__gsource_func, block2_data_ref (_data2_), block2_data_unref);
 
1322
                self->priv->_cache_avatar_id = _tmp83_;
586
1323
        }
587
 
        if (g_strcmp0 (_stream, "user") == 0) {
 
1324
        if (g_strcmp0 (_data2_->_stream, "user") == 0) {
588
1325
                gtk_widget_set_no_show_all ((GtkWidget*) self->priv->icon_box, TRUE);
589
1326
                gtk_widget_hide ((GtkWidget*) self->priv->icon_box);
590
1327
        } else {
591
1328
                gtk_widget_set_no_show_all ((GtkWidget*) self->priv->icon_box, FALSE);
592
1329
                gtk_widget_show ((GtkWidget*) self->priv->icon_box);
593
1330
        }
594
 
        _tmp38_ = g_strdup (_url);
 
1331
        _tmp84_ = g_strdup (_url);
595
1332
        _g_free0 (self->priv->url);
596
 
        self->priv->url = _tmp38_;
597
 
        g_signal_parse_name ("button-press-event", GTK_TYPE_WIDGET, &_tmp39_, NULL, FALSE);
598
 
        g_signal_handlers_disconnect_matched ((GtkWidget*) self->priv->icon_box, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp39_, 0, NULL, (GCallback) _gwibber_gtk_stream_view_tile_on_avatar_click_gtk_widget_button_press_event, self);
 
1333
        self->priv->url = _tmp84_;
 
1334
        g_signal_parse_name ("button-press-event", GTK_TYPE_WIDGET, &_tmp85_, NULL, FALSE);
 
1335
        g_signal_handlers_disconnect_matched ((GtkWidget*) self->priv->icon_box, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp85_, 0, NULL, (GCallback) _gwibber_gtk_stream_view_tile_on_avatar_click_gtk_widget_button_press_event, self);
599
1336
        g_signal_connect_object ((GtkWidget*) self->priv->icon_box, "button-press-event", (GCallback) _gwibber_gtk_stream_view_tile_on_avatar_click_gtk_widget_button_press_event, self, 0);
600
1337
        if (((gint) _likes) == 0) {
601
1338
                gtk_widget_hide ((GtkWidget*) self->priv->likes_hbox);
607
1344
                        gtk_widget_show_all ((GtkWidget*) self->priv->likes_hbox);
608
1345
                } else {
609
1346
                        if (((gint) _likes) == 1) {
610
 
                                gchar* _tmp40_ = NULL;
611
 
                                gchar* _tmp41_;
612
 
                                gchar* _tmp42_;
613
 
                                gchar* _tmp43_;
614
 
                                gchar* _tmp44_;
615
 
                                gchar* _tmp45_;
616
 
                                const gchar* _tmp46_ = NULL;
617
 
                                gchar* _tmp47_;
618
 
                                gchar* _tmp48_;
619
 
                                gchar* _tmp49_;
620
 
                                gchar* _tmp50_;
621
 
                                _tmp40_ = double_to_string (_likes);
622
 
                                _tmp41_ = _tmp40_;
623
 
                                _tmp42_ = g_strconcat ("<span font_size='small'>", _tmp41_, NULL);
624
 
                                _tmp43_ = _tmp42_;
625
 
                                _tmp44_ = g_strconcat (_tmp43_, " ", NULL);
626
 
                                _tmp45_ = _tmp44_;
627
 
                                _tmp46_ = _ ("person liked this");
628
 
                                _tmp47_ = g_strconcat (_tmp45_, _tmp46_, NULL);
629
 
                                _tmp48_ = _tmp47_;
630
 
                                _tmp49_ = g_strconcat (_tmp48_, "</span>", NULL);
631
 
                                _tmp50_ = _tmp49_;
632
 
                                gtk_label_set_markup (self->priv->likes_count, _tmp50_);
633
 
                                _g_free0 (_tmp50_);
634
 
                                _g_free0 (_tmp48_);
635
 
                                _g_free0 (_tmp45_);
636
 
                                _g_free0 (_tmp43_);
637
 
                                _g_free0 (_tmp41_);
 
1347
                                gchar* _tmp86_ = NULL;
 
1348
                                gchar* _tmp87_;
 
1349
                                gchar* _tmp88_;
 
1350
                                gchar* _tmp89_;
 
1351
                                gchar* _tmp90_;
 
1352
                                gchar* _tmp91_;
 
1353
                                const gchar* _tmp92_ = NULL;
 
1354
                                gchar* _tmp93_;
 
1355
                                gchar* _tmp94_;
 
1356
                                gchar* _tmp95_;
 
1357
                                gchar* _tmp96_;
 
1358
                                _tmp86_ = double_to_string (_likes);
 
1359
                                _tmp87_ = _tmp86_;
 
1360
                                _tmp88_ = g_strconcat ("<span font_size='small'>", _tmp87_, NULL);
 
1361
                                _tmp89_ = _tmp88_;
 
1362
                                _tmp90_ = g_strconcat (_tmp89_, " ", NULL);
 
1363
                                _tmp91_ = _tmp90_;
 
1364
                                _tmp92_ = _ ("person liked this");
 
1365
                                _tmp93_ = g_strconcat (_tmp91_, _tmp92_, NULL);
 
1366
                                _tmp94_ = _tmp93_;
 
1367
                                _tmp95_ = g_strconcat (_tmp94_, "</span>", NULL);
 
1368
                                _tmp96_ = _tmp95_;
 
1369
                                gtk_label_set_markup (self->priv->likes_count, _tmp96_);
 
1370
                                _g_free0 (_tmp96_);
 
1371
                                _g_free0 (_tmp94_);
 
1372
                                _g_free0 (_tmp91_);
 
1373
                                _g_free0 (_tmp89_);
 
1374
                                _g_free0 (_tmp87_);
638
1375
                                gtk_widget_set_no_show_all ((GtkWidget*) self->priv->likes_hbox, FALSE);
639
1376
                                gtk_widget_show_all ((GtkWidget*) self->priv->likes_hbox);
640
1377
                        } else {
641
1378
                                if (((gint) _likes) > 1) {
642
 
                                        gchar* _tmp51_ = NULL;
643
 
                                        gchar* _tmp52_;
644
 
                                        gchar* _tmp53_;
645
 
                                        gchar* _tmp54_;
646
 
                                        gchar* _tmp55_;
647
 
                                        gchar* _tmp56_;
648
 
                                        const gchar* _tmp57_ = NULL;
649
 
                                        gchar* _tmp58_;
650
 
                                        gchar* _tmp59_;
651
 
                                        gchar* _tmp60_;
652
 
                                        gchar* _tmp61_;
653
 
                                        _tmp51_ = double_to_string (_likes);
654
 
                                        _tmp52_ = _tmp51_;
655
 
                                        _tmp53_ = g_strconcat ("<span font_size='small'>", _tmp52_, NULL);
656
 
                                        _tmp54_ = _tmp53_;
657
 
                                        _tmp55_ = g_strconcat (_tmp54_, " ", NULL);
658
 
                                        _tmp56_ = _tmp55_;
659
 
                                        _tmp57_ = _ ("people liked this");
660
 
                                        _tmp58_ = g_strconcat (_tmp56_, _tmp57_, NULL);
661
 
                                        _tmp59_ = _tmp58_;
662
 
                                        _tmp60_ = g_strconcat (_tmp59_, "</span>", NULL);
663
 
                                        _tmp61_ = _tmp60_;
664
 
                                        gtk_label_set_markup (self->priv->likes_count, _tmp61_);
665
 
                                        _g_free0 (_tmp61_);
666
 
                                        _g_free0 (_tmp59_);
667
 
                                        _g_free0 (_tmp56_);
668
 
                                        _g_free0 (_tmp54_);
669
 
                                        _g_free0 (_tmp52_);
 
1379
                                        gchar* _tmp97_ = NULL;
 
1380
                                        gchar* _tmp98_;
 
1381
                                        gchar* _tmp99_;
 
1382
                                        gchar* _tmp100_;
 
1383
                                        gchar* _tmp101_;
 
1384
                                        gchar* _tmp102_;
 
1385
                                        const gchar* _tmp103_ = NULL;
 
1386
                                        gchar* _tmp104_;
 
1387
                                        gchar* _tmp105_;
 
1388
                                        gchar* _tmp106_;
 
1389
                                        gchar* _tmp107_;
 
1390
                                        _tmp97_ = double_to_string (_likes);
 
1391
                                        _tmp98_ = _tmp97_;
 
1392
                                        _tmp99_ = g_strconcat ("<span font_size='small'>", _tmp98_, NULL);
 
1393
                                        _tmp100_ = _tmp99_;
 
1394
                                        _tmp101_ = g_strconcat (_tmp100_, " ", NULL);
 
1395
                                        _tmp102_ = _tmp101_;
 
1396
                                        _tmp103_ = _ ("people liked this");
 
1397
                                        _tmp104_ = g_strconcat (_tmp102_, _tmp103_, NULL);
 
1398
                                        _tmp105_ = _tmp104_;
 
1399
                                        _tmp106_ = g_strconcat (_tmp105_, "</span>", NULL);
 
1400
                                        _tmp107_ = _tmp106_;
 
1401
                                        gtk_label_set_markup (self->priv->likes_count, _tmp107_);
 
1402
                                        _g_free0 (_tmp107_);
 
1403
                                        _g_free0 (_tmp105_);
 
1404
                                        _g_free0 (_tmp102_);
 
1405
                                        _g_free0 (_tmp100_);
 
1406
                                        _g_free0 (_tmp98_);
670
1407
                                        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->likes_hbox, FALSE);
671
1408
                                        gtk_widget_show_all ((GtkWidget*) self->priv->likes_hbox);
672
1409
                                }
673
1410
                        }
674
1411
                }
675
1412
        }
676
 
        if (g_strcmp0 (_stream, "links") == 0) {
677
 
                gchar* _tmp62_;
678
 
                gchar* _tmp63_;
679
 
                gchar* _tmp64_;
680
 
                gchar* _tmp65_;
681
 
                gchar* _tmp66_;
682
 
                gchar* _tmp67_;
683
 
                gchar* _tmp68_;
684
 
                gchar* _tmp69_;
685
 
                gchar* link_str;
686
 
                gchar* _tmp70_;
687
 
                gchar* _tmp71_;
688
 
                gchar* _tmp72_;
689
 
                _tmp62_ = g_strconcat ("<a href='", _link_url, NULL);
690
 
                _tmp63_ = _tmp62_;
691
 
                _tmp64_ = g_strconcat (_tmp63_, "'>", NULL);
692
 
                _tmp65_ = _tmp64_;
693
 
                _tmp66_ = g_strconcat (_tmp65_, _link_name, NULL);
694
 
                _tmp67_ = _tmp66_;
695
 
                _tmp68_ = g_strconcat (_tmp67_, "</a>\n", NULL);
696
 
                _tmp69_ = _tmp68_;
697
 
                _g_free0 (_tmp67_);
698
 
                _g_free0 (_tmp65_);
699
 
                _g_free0 (_tmp63_);
700
 
                link_str = _tmp69_;
701
 
                _tmp70_ = g_strconcat (link_str, _link_desc, NULL);
702
 
                _g_free0 (link_str);
703
 
                link_str = _tmp70_;
704
 
                _tmp71_ = g_strconcat (link_str, "\n", NULL);
705
 
                _g_free0 (link_str);
706
 
                link_str = _tmp71_;
707
 
                _tmp72_ = g_strconcat (link_str, _link_caption, NULL);
708
 
                _g_free0 (link_str);
709
 
                link_str = _tmp72_;
710
 
                gtk_label_set_markup (self->priv->message, link_str);
711
 
                _g_free0 (link_str);
712
 
        } else {
713
 
                gtk_label_set_markup (self->priv->message, _html);
714
 
        }
715
 
        _tmp73_ = strlen (_img_url);
716
 
        if (_tmp73_ > 0) {
717
 
                gchar* _tmp74_;
718
 
                gchar* img_str;
719
 
                gchar* _tmp75_;
720
 
                gint _tmp76_;
721
 
                _tmp74_ = g_strdup (_html);
722
 
                img_str = _tmp74_;
723
 
                _tmp75_ = g_strconcat (img_str, "\n\n", NULL);
724
 
                _g_free0 (img_str);
725
 
                img_str = _tmp75_;
726
 
                _tmp76_ = strlen (_img_name);
727
 
                if (_tmp76_ > 0) {
728
 
                        gchar* _tmp77_;
729
 
                        gchar* _tmp78_;
730
 
                        gchar* _tmp79_;
731
 
                        gchar* _tmp80_;
732
 
                        gchar* _tmp81_;
733
 
                        gchar* _tmp82_;
734
 
                        gchar* _tmp83_;
735
 
                        gchar* _tmp84_;
736
 
                        gchar* _tmp85_;
737
 
                        _tmp77_ = g_strconcat ("<a href='", _img_url, NULL);
738
 
                        _tmp78_ = _tmp77_;
739
 
                        _tmp79_ = g_strconcat (_tmp78_, "'>", NULL);
740
 
                        _tmp80_ = _tmp79_;
741
 
                        _tmp81_ = g_strconcat (_tmp80_, _img_name, NULL);
742
 
                        _tmp82_ = _tmp81_;
743
 
                        _tmp83_ = g_strconcat (_tmp82_, "</a>", NULL);
744
 
                        _tmp84_ = _tmp83_;
745
 
                        _tmp85_ = g_strconcat (img_str, _tmp84_, NULL);
746
 
                        _g_free0 (img_str);
747
 
                        img_str = _tmp85_;
748
 
                        _g_free0 (_tmp84_);
749
 
                        _g_free0 (_tmp82_);
750
 
                        _g_free0 (_tmp80_);
751
 
                        _g_free0 (_tmp78_);
752
 
                } else {
753
 
                        gchar* _tmp86_;
754
 
                        gchar* _tmp87_;
755
 
                        gchar* _tmp88_;
756
 
                        gchar* _tmp89_;
757
 
                        gchar* _tmp90_;
758
 
                        gchar* _tmp91_;
759
 
                        gchar* _tmp92_;
760
 
                        gchar* _tmp93_;
761
 
                        gchar* _tmp94_;
762
 
                        _tmp86_ = g_strconcat ("<a href='", _img_url, NULL);
763
 
                        _tmp87_ = _tmp86_;
764
 
                        _tmp88_ = g_strconcat (_tmp87_, "'>", NULL);
765
 
                        _tmp89_ = _tmp88_;
766
 
                        _tmp90_ = g_strconcat (_tmp89_, _img_url, NULL);
767
 
                        _tmp91_ = _tmp90_;
768
 
                        _tmp92_ = g_strconcat (_tmp91_, "</a>", NULL);
769
 
                        _tmp93_ = _tmp92_;
770
 
                        _tmp94_ = g_strconcat (img_str, _tmp93_, NULL);
771
 
                        _g_free0 (img_str);
772
 
                        img_str = _tmp94_;
773
 
                        _g_free0 (_tmp93_);
774
 
                        _g_free0 (_tmp91_);
775
 
                        _g_free0 (_tmp89_);
776
 
                        _g_free0 (_tmp87_);
777
 
                }
778
 
                gtk_label_set_markup (self->priv->message, img_str);
779
 
                _g_free0 (img_str);
780
 
        }
781
 
        _tmp95_ = atol (_timestamp);
782
 
        _tmp96_ = gwibber_utils_generate_time_string (self->priv->_utils, (guint) _tmp95_);
783
 
        _g_free0 (self->priv->time_string);
784
 
        self->priv->time_string = _tmp96_;
785
 
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
786
 
        gtk_widget_hide ((GtkWidget*) self->priv->reply_to);
787
 
        _tmp97_ = g_strdup ("<span font_weight='light' font_size='small' color='#999'>");
788
 
        reply_to_string = _tmp97_;
789
 
        if (self->priv->_show_fullname) {
790
 
                gboolean _tmp99_ = FALSE;
791
 
                if (_reply_name != NULL) {
792
 
                        gint _tmp100_;
793
 
                        _tmp100_ = strlen (_reply_name);
794
 
                        _tmp99_ = _tmp100_ > 0;
795
 
                } else {
796
 
                        _tmp99_ = FALSE;
797
 
                }
798
 
                _tmp98_ = _tmp99_;
799
 
        } else {
800
 
                _tmp98_ = FALSE;
801
 
        }
802
 
        if (_tmp98_) {
803
 
                const gchar* _tmp101_ = NULL;
804
 
                gchar* _tmp102_;
805
 
                gchar* _tmp103_;
806
 
                gchar* _tmp104_;
807
 
                gchar* _tmp105_;
808
 
                gchar* _tmp106_;
809
 
                gchar* _tmp107_;
 
1413
        gtk_label_set_markup (self->priv->message, _data2_->_html);
 
1414
        _data2_->link_str = NULL;
 
1415
        if (g_strcmp0 (_data2_->_stream, "links") == 0) {
810
1416
                gchar* _tmp108_;
811
1417
                gchar* _tmp109_;
812
1418
                gchar* _tmp110_;
814
1420
                gchar* _tmp112_;
815
1421
                gchar* _tmp113_;
816
1422
                gchar* _tmp114_;
817
 
                _tmp101_ = _ ("in reply to");
818
 
                _tmp102_ = g_strconcat (" ", _tmp101_, NULL);
819
 
                _tmp103_ = _tmp102_;
820
 
                _tmp104_ = g_strconcat (_tmp103_, " <a href='", NULL);
821
 
                _tmp105_ = _tmp104_;
822
 
                _tmp106_ = g_strconcat (_tmp105_, _reply_url, NULL);
823
 
                _tmp107_ = _tmp106_;
824
 
                _tmp108_ = g_strconcat (_tmp107_, "'>", NULL);
 
1423
                gchar* _tmp115_;
 
1424
                _tmp108_ = g_strconcat ("<a href='", _link_url, NULL);
825
1425
                _tmp109_ = _tmp108_;
826
 
                _tmp110_ = g_strconcat (_tmp109_, _reply_name, NULL);
 
1426
                _tmp110_ = g_strconcat (_tmp109_, "'>", NULL);
827
1427
                _tmp111_ = _tmp110_;
828
 
                _tmp112_ = g_strconcat (_tmp111_, "</a>", NULL);
 
1428
                _tmp112_ = g_strconcat (_tmp111_, _link_name, NULL);
829
1429
                _tmp113_ = _tmp112_;
830
 
                _tmp114_ = g_strconcat (reply_to_string, _tmp113_, NULL);
831
 
                _g_free0 (reply_to_string);
832
 
                reply_to_string = _tmp114_;
 
1430
                _tmp114_ = g_strconcat (_tmp113_, "</a>\n", NULL);
 
1431
                _g_free0 (_data2_->link_str);
 
1432
                _data2_->link_str = _tmp114_;
833
1433
                _g_free0 (_tmp113_);
834
1434
                _g_free0 (_tmp111_);
835
1435
                _g_free0 (_tmp109_);
836
 
                _g_free0 (_tmp107_);
837
 
                _g_free0 (_tmp105_);
838
 
                _g_free0 (_tmp103_);
839
 
                gtk_widget_show ((GtkWidget*) self->priv->reply_to);
840
 
        } else {
841
 
                gboolean _tmp115_ = FALSE;
842
 
                if (_reply_nick != NULL) {
843
 
                        gint _tmp116_;
844
 
                        _tmp116_ = strlen (_reply_nick);
845
 
                        _tmp115_ = _tmp116_ > 0;
846
 
                } else {
847
 
                        _tmp115_ = FALSE;
848
 
                }
849
 
                if (_tmp115_) {
850
 
                        const gchar* _tmp117_ = NULL;
851
 
                        gchar* _tmp118_;
852
 
                        gchar* _tmp119_;
853
 
                        gchar* _tmp120_;
854
 
                        gchar* _tmp121_;
855
 
                        gchar* _tmp122_;
856
 
                        gchar* _tmp123_;
857
 
                        gchar* _tmp124_;
858
 
                        gchar* _tmp125_;
859
 
                        gchar* _tmp126_;
860
 
                        gchar* _tmp127_;
861
 
                        gchar* _tmp128_;
862
 
                        gchar* _tmp129_;
863
 
                        gchar* _tmp130_;
864
 
                        _tmp117_ = _ ("in reply to");
865
 
                        _tmp118_ = g_strconcat (" ", _tmp117_, NULL);
866
 
                        _tmp119_ = _tmp118_;
867
 
                        _tmp120_ = g_strconcat (_tmp119_, " <a href='", NULL);
868
 
                        _tmp121_ = _tmp120_;
869
 
                        _tmp122_ = g_strconcat (_tmp121_, _reply_url, NULL);
870
 
                        _tmp123_ = _tmp122_;
871
 
                        _tmp124_ = g_strconcat (_tmp123_, "'>", NULL);
872
 
                        _tmp125_ = _tmp124_;
873
 
                        _tmp126_ = g_strconcat (_tmp125_, _reply_nick, NULL);
874
 
                        _tmp127_ = _tmp126_;
875
 
                        _tmp128_ = g_strconcat (_tmp127_, "</a>", NULL);
876
 
                        _tmp129_ = _tmp128_;
877
 
                        _tmp130_ = g_strconcat (reply_to_string, _tmp129_, NULL);
878
 
                        _g_free0 (reply_to_string);
879
 
                        reply_to_string = _tmp130_;
880
 
                        _g_free0 (_tmp129_);
881
 
                        _g_free0 (_tmp127_);
882
 
                        _g_free0 (_tmp125_);
883
 
                        _g_free0 (_tmp123_);
884
 
                        _g_free0 (_tmp121_);
885
 
                        _g_free0 (_tmp119_);
886
 
                        gtk_widget_show ((GtkWidget*) self->priv->reply_to);
887
 
                }
888
 
        }
889
 
        _tmp131_ = g_strconcat (reply_to_string, "</span>", NULL);
890
 
        _g_free0 (reply_to_string);
891
 
        reply_to_string = _tmp131_;
892
 
        gtk_label_set_markup (self->priv->reply_to, reply_to_string);
893
 
        gtk_widget_hide ((GtkWidget*) self->priv->retweeted_by);
894
 
        _tmp132_ = g_strdup ("<span font_weight='light' font_size='small' color='#999'>");
895
 
        retweeted_by_string = _tmp132_;
 
1436
                _tmp115_ = g_strconcat (_data2_->link_str, _link_desc, NULL);
 
1437
                _g_free0 (_data2_->link_str);
 
1438
                _data2_->link_str = _tmp115_;
 
1439
                gtk_label_set_markup (self->priv->message, _data2_->link_str);
 
1440
        }
 
1441
        _data2_->video_str = NULL;
 
1442
        if (g_strcmp0 (_data2_->_stream, "videos") == 0) {
 
1443
                gchar* _tmp116_;
 
1444
                gchar* _tmp117_;
 
1445
                gchar* _tmp118_;
 
1446
                gchar* _tmp119_;
 
1447
                gchar* _tmp120_;
 
1448
                gchar* _tmp121_;
 
1449
                gchar* _tmp122_;
 
1450
                gchar* _tmp123_;
 
1451
                _tmp116_ = g_strconcat ("<a href='", _video_url, NULL);
 
1452
                _tmp117_ = _tmp116_;
 
1453
                _tmp118_ = g_strconcat (_tmp117_, "'>", NULL);
 
1454
                _tmp119_ = _tmp118_;
 
1455
                _tmp120_ = g_strconcat (_tmp119_, _video_name, NULL);
 
1456
                _tmp121_ = _tmp120_;
 
1457
                _tmp122_ = g_strconcat (_tmp121_, "</a>\n", NULL);
 
1458
                _g_free0 (_data2_->video_str);
 
1459
                _data2_->video_str = _tmp122_;
 
1460
                _g_free0 (_tmp121_);
 
1461
                _g_free0 (_tmp119_);
 
1462
                _g_free0 (_tmp117_);
 
1463
                _tmp123_ = g_strconcat (_data2_->video_str, _data2_->_html, NULL);
 
1464
                _g_free0 (_data2_->video_str);
 
1465
                _data2_->video_str = _tmp123_;
 
1466
                gtk_label_set_markup (self->priv->message, _data2_->video_str);
 
1467
        }
 
1468
        _tmp124_ = strlen (self->priv->img_uri);
 
1469
        if (_tmp124_ > 0) {
 
1470
                Block5Data* _data5_;
 
1471
                guint _tmp125_;
 
1472
                _data5_ = g_slice_new0 (Block5Data);
 
1473
                _data5_->_ref_count_ = 1;
 
1474
                _data5_->_data2_ = block2_data_ref (_data2_);
 
1475
                _data5_->img_str = NULL;
 
1476
                _tmp125_ = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 200, __lambda19__gsource_func, block5_data_ref (_data5_), block5_data_unref);
 
1477
                self->priv->img_id = _tmp125_;
 
1478
                block5_data_unref (_data5_);
 
1479
                _data5_ = NULL;
 
1480
        }
 
1481
        _tmp126_ = atol (_timestamp);
 
1482
        _tmp127_ = gwibber_utils_generate_time_string (self->priv->_utils, (guint) _tmp126_);
 
1483
        _g_free0 (self->priv->time_string);
 
1484
        self->priv->time_string = _tmp127_;
 
1485
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
 
1486
        gtk_widget_hide ((GtkWidget*) self->priv->reply_to);
 
1487
        _tmp128_ = g_strdup ("<span font_weight='light' font_size='small' color='#999'>");
 
1488
        reply_to_string = _tmp128_;
896
1489
        if (self->priv->_show_fullname) {
897
 
                gboolean _tmp134_ = FALSE;
898
 
                if (_retweet_name != NULL) {
899
 
                        gint _tmp135_;
900
 
                        _tmp135_ = strlen (_retweet_name);
901
 
                        _tmp134_ = _tmp135_ > 0;
 
1490
                gboolean _tmp130_ = FALSE;
 
1491
                if (_reply_name != NULL) {
 
1492
                        gint _tmp131_;
 
1493
                        _tmp131_ = strlen (_reply_name);
 
1494
                        _tmp130_ = _tmp131_ > 0;
902
1495
                } else {
903
 
                        _tmp134_ = FALSE;
 
1496
                        _tmp130_ = FALSE;
904
1497
                }
905
 
                _tmp133_ = _tmp134_;
 
1498
                _tmp129_ = _tmp130_;
906
1499
        } else {
907
 
                _tmp133_ = FALSE;
 
1500
                _tmp129_ = FALSE;
908
1501
        }
909
 
        if (_tmp133_) {
910
 
                const gchar* _tmp136_ = NULL;
 
1502
        if (_tmp129_) {
 
1503
                const gchar* _tmp132_ = NULL;
 
1504
                gchar* _tmp133_;
 
1505
                gchar* _tmp134_;
 
1506
                gchar* _tmp135_;
 
1507
                gchar* _tmp136_;
911
1508
                gchar* _tmp137_;
912
1509
                gchar* _tmp138_;
913
1510
                gchar* _tmp139_;
915
1512
                gchar* _tmp141_;
916
1513
                gchar* _tmp142_;
917
1514
                gchar* _tmp143_;
918
 
                _tmp136_ = _ ("shared by");
919
 
                _tmp137_ = g_strconcat (" ", _tmp136_, NULL);
 
1515
                gchar* _tmp144_;
 
1516
                gchar* _tmp145_;
 
1517
                _tmp132_ = _ ("in reply to");
 
1518
                _tmp133_ = g_strconcat (" ", _tmp132_, NULL);
 
1519
                _tmp134_ = _tmp133_;
 
1520
                _tmp135_ = g_strconcat (_tmp134_, " <a href='", NULL);
 
1521
                _tmp136_ = _tmp135_;
 
1522
                _tmp137_ = g_strconcat (_tmp136_, _reply_url, NULL);
920
1523
                _tmp138_ = _tmp137_;
921
 
                _tmp139_ = g_strconcat (_tmp138_, " ", NULL);
 
1524
                _tmp139_ = g_strconcat (_tmp138_, "'>", NULL);
922
1525
                _tmp140_ = _tmp139_;
923
 
                _tmp141_ = g_strconcat (_tmp140_, _retweet_name, NULL);
 
1526
                _tmp141_ = g_strconcat (_tmp140_, _reply_name, NULL);
924
1527
                _tmp142_ = _tmp141_;
925
 
                _tmp143_ = g_strconcat (retweeted_by_string, _tmp142_, NULL);
926
 
                _g_free0 (retweeted_by_string);
927
 
                retweeted_by_string = _tmp143_;
 
1528
                _tmp143_ = g_strconcat (_tmp142_, "</a>", NULL);
 
1529
                _tmp144_ = _tmp143_;
 
1530
                _tmp145_ = g_strconcat (reply_to_string, _tmp144_, NULL);
 
1531
                _g_free0 (reply_to_string);
 
1532
                reply_to_string = _tmp145_;
 
1533
                _g_free0 (_tmp144_);
928
1534
                _g_free0 (_tmp142_);
929
1535
                _g_free0 (_tmp140_);
930
1536
                _g_free0 (_tmp138_);
931
 
                gtk_widget_show ((GtkWidget*) self->priv->retweeted_by);
 
1537
                _g_free0 (_tmp136_);
 
1538
                _g_free0 (_tmp134_);
 
1539
                gtk_widget_show ((GtkWidget*) self->priv->reply_to);
932
1540
        } else {
933
 
                gboolean _tmp144_ = FALSE;
934
 
                if (_retweet_nick != NULL) {
935
 
                        gint _tmp145_;
936
 
                        _tmp145_ = strlen (_retweet_nick);
937
 
                        _tmp144_ = _tmp145_ > 0;
 
1541
                gboolean _tmp146_ = FALSE;
 
1542
                if (_reply_nick != NULL) {
 
1543
                        gint _tmp147_;
 
1544
                        _tmp147_ = strlen (_reply_nick);
 
1545
                        _tmp146_ = _tmp147_ > 0;
938
1546
                } else {
939
 
                        _tmp144_ = FALSE;
 
1547
                        _tmp146_ = FALSE;
940
1548
                }
941
 
                if (_tmp144_) {
942
 
                        const gchar* _tmp146_ = NULL;
943
 
                        gchar* _tmp147_;
944
 
                        gchar* _tmp148_;
 
1549
                if (_tmp146_) {
 
1550
                        const gchar* _tmp148_ = NULL;
945
1551
                        gchar* _tmp149_;
946
1552
                        gchar* _tmp150_;
947
1553
                        gchar* _tmp151_;
948
1554
                        gchar* _tmp152_;
949
1555
                        gchar* _tmp153_;
950
 
                        _tmp146_ = _ ("shared by");
951
 
                        _tmp147_ = g_strconcat (" ", _tmp146_, NULL);
952
 
                        _tmp148_ = _tmp147_;
953
 
                        _tmp149_ = g_strconcat (_tmp148_, " ", NULL);
 
1556
                        gchar* _tmp154_;
 
1557
                        gchar* _tmp155_;
 
1558
                        gchar* _tmp156_;
 
1559
                        gchar* _tmp157_;
 
1560
                        gchar* _tmp158_;
 
1561
                        gchar* _tmp159_;
 
1562
                        gchar* _tmp160_;
 
1563
                        gchar* _tmp161_;
 
1564
                        _tmp148_ = _ ("in reply to");
 
1565
                        _tmp149_ = g_strconcat (" ", _tmp148_, NULL);
954
1566
                        _tmp150_ = _tmp149_;
955
 
                        _tmp151_ = g_strconcat (_tmp150_, _retweet_nick, NULL);
 
1567
                        _tmp151_ = g_strconcat (_tmp150_, " <a href='", NULL);
956
1568
                        _tmp152_ = _tmp151_;
957
 
                        _tmp153_ = g_strconcat (retweeted_by_string, _tmp152_, NULL);
958
 
                        _g_free0 (retweeted_by_string);
959
 
                        retweeted_by_string = _tmp153_;
 
1569
                        _tmp153_ = g_strconcat (_tmp152_, _reply_url, NULL);
 
1570
                        _tmp154_ = _tmp153_;
 
1571
                        _tmp155_ = g_strconcat (_tmp154_, "'>", NULL);
 
1572
                        _tmp156_ = _tmp155_;
 
1573
                        _tmp157_ = g_strconcat (_tmp156_, _reply_nick, NULL);
 
1574
                        _tmp158_ = _tmp157_;
 
1575
                        _tmp159_ = g_strconcat (_tmp158_, "</a>", NULL);
 
1576
                        _tmp160_ = _tmp159_;
 
1577
                        _tmp161_ = g_strconcat (reply_to_string, _tmp160_, NULL);
 
1578
                        _g_free0 (reply_to_string);
 
1579
                        reply_to_string = _tmp161_;
 
1580
                        _g_free0 (_tmp160_);
 
1581
                        _g_free0 (_tmp158_);
 
1582
                        _g_free0 (_tmp156_);
 
1583
                        _g_free0 (_tmp154_);
960
1584
                        _g_free0 (_tmp152_);
961
1585
                        _g_free0 (_tmp150_);
962
 
                        _g_free0 (_tmp148_);
 
1586
                        gtk_widget_show ((GtkWidget*) self->priv->reply_to);
 
1587
                }
 
1588
        }
 
1589
        _tmp162_ = g_strconcat (reply_to_string, "</span>", NULL);
 
1590
        _g_free0 (reply_to_string);
 
1591
        reply_to_string = _tmp162_;
 
1592
        gtk_label_set_markup (self->priv->reply_to, reply_to_string);
 
1593
        gtk_widget_hide ((GtkWidget*) self->priv->retweeted_by);
 
1594
        _tmp163_ = g_strdup ("<span font_weight='light' font_size='small' color='#999'>");
 
1595
        retweeted_by_string = _tmp163_;
 
1596
        if (self->priv->_show_fullname) {
 
1597
                gboolean _tmp165_ = FALSE;
 
1598
                if (_retweet_name != NULL) {
 
1599
                        gint _tmp166_;
 
1600
                        _tmp166_ = strlen (_retweet_name);
 
1601
                        _tmp165_ = _tmp166_ > 0;
 
1602
                } else {
 
1603
                        _tmp165_ = FALSE;
 
1604
                }
 
1605
                _tmp164_ = _tmp165_;
 
1606
        } else {
 
1607
                _tmp164_ = FALSE;
 
1608
        }
 
1609
        if (_tmp164_) {
 
1610
                const gchar* _tmp167_ = NULL;
 
1611
                gchar* _tmp168_;
 
1612
                gchar* _tmp169_;
 
1613
                gchar* _tmp170_;
 
1614
                gchar* _tmp171_;
 
1615
                gchar* _tmp172_;
 
1616
                gchar* _tmp173_;
 
1617
                gchar* _tmp174_;
 
1618
                _tmp167_ = _ ("shared by");
 
1619
                _tmp168_ = g_strconcat (" ", _tmp167_, NULL);
 
1620
                _tmp169_ = _tmp168_;
 
1621
                _tmp170_ = g_strconcat (_tmp169_, " ", NULL);
 
1622
                _tmp171_ = _tmp170_;
 
1623
                _tmp172_ = g_strconcat (_tmp171_, _retweet_name, NULL);
 
1624
                _tmp173_ = _tmp172_;
 
1625
                _tmp174_ = g_strconcat (retweeted_by_string, _tmp173_, NULL);
 
1626
                _g_free0 (retweeted_by_string);
 
1627
                retweeted_by_string = _tmp174_;
 
1628
                _g_free0 (_tmp173_);
 
1629
                _g_free0 (_tmp171_);
 
1630
                _g_free0 (_tmp169_);
 
1631
                gtk_widget_show ((GtkWidget*) self->priv->retweeted_by);
 
1632
        } else {
 
1633
                gboolean _tmp175_ = FALSE;
 
1634
                if (_retweet_nick != NULL) {
 
1635
                        gint _tmp176_;
 
1636
                        _tmp176_ = strlen (_retweet_nick);
 
1637
                        _tmp175_ = _tmp176_ > 0;
 
1638
                } else {
 
1639
                        _tmp175_ = FALSE;
 
1640
                }
 
1641
                if (_tmp175_) {
 
1642
                        const gchar* _tmp177_ = NULL;
 
1643
                        gchar* _tmp178_;
 
1644
                        gchar* _tmp179_;
 
1645
                        gchar* _tmp180_;
 
1646
                        gchar* _tmp181_;
 
1647
                        gchar* _tmp182_;
 
1648
                        gchar* _tmp183_;
 
1649
                        gchar* _tmp184_;
 
1650
                        _tmp177_ = _ ("shared by");
 
1651
                        _tmp178_ = g_strconcat (" ", _tmp177_, NULL);
 
1652
                        _tmp179_ = _tmp178_;
 
1653
                        _tmp180_ = g_strconcat (_tmp179_, " ", NULL);
 
1654
                        _tmp181_ = _tmp180_;
 
1655
                        _tmp182_ = g_strconcat (_tmp181_, _retweet_nick, NULL);
 
1656
                        _tmp183_ = _tmp182_;
 
1657
                        _tmp184_ = g_strconcat (retweeted_by_string, _tmp183_, NULL);
 
1658
                        _g_free0 (retweeted_by_string);
 
1659
                        retweeted_by_string = _tmp184_;
 
1660
                        _g_free0 (_tmp183_);
 
1661
                        _g_free0 (_tmp181_);
 
1662
                        _g_free0 (_tmp179_);
963
1663
                        gtk_widget_show ((GtkWidget*) self->priv->retweeted_by);
964
1664
                }
965
1665
        }
966
 
        _tmp154_ = g_strconcat (retweeted_by_string, "</span>", NULL);
 
1666
        _tmp185_ = g_strconcat (retweeted_by_string, "</span>", NULL);
967
1667
        _g_free0 (retweeted_by_string);
968
 
        retweeted_by_string = _tmp154_;
 
1668
        retweeted_by_string = _tmp185_;
969
1669
        gtk_label_set_markup (self->priv->retweeted_by, retweeted_by_string);
970
1670
        gtk_widget_queue_resize ((GtkWidget*) self);
971
1671
        gtk_widget_show ((GtkWidget*) self);
973
1673
        _g_free0 (reply_to_string);
974
1674
        _g_free0 (_avatar_cache_image);
975
1675
        icon_displayed = (_vala_array_free (icon_displayed, icon_displayed_length1, (GDestroyNotify) g_free), NULL);
976
 
        _g_free0 (_tmp10_);
 
1676
        _g_free0 (_tmp61_);
977
1677
        _g_free0 (display_name);
 
1678
        block2_data_unref (_data2_);
 
1679
        _data2_ = NULL;
 
1680
}
 
1681
 
 
1682
 
 
1683
static void gwibber_gtk_stream_view_tile_load_avatar_async_data_free (gpointer _data) {
 
1684
        GwibberGtkStreamViewTileLoadAvatarAsyncData* data;
 
1685
        data = _data;
 
1686
        _g_free0 (data->url);
 
1687
        _g_object_unref0 (data->cicon);
 
1688
        _g_object_unref0 (data->self);
 
1689
        g_slice_free (GwibberGtkStreamViewTileLoadAvatarAsyncData, data);
 
1690
}
 
1691
 
 
1692
 
 
1693
static void gwibber_gtk_stream_view_tile_load_avatar_async (GwibberGtkStreamViewTile* self, const gchar* url, GtkImage* cicon, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1694
        GwibberGtkStreamViewTileLoadAvatarAsyncData* _data_;
 
1695
        _data_ = g_slice_new0 (GwibberGtkStreamViewTileLoadAvatarAsyncData);
 
1696
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, gwibber_gtk_stream_view_tile_load_avatar_async);
 
1697
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, gwibber_gtk_stream_view_tile_load_avatar_async_data_free);
 
1698
        _data_->self = _g_object_ref0 (self);
 
1699
        _data_->url = g_strdup (url);
 
1700
        _data_->cicon = _g_object_ref0 (cicon);
 
1701
        gwibber_gtk_stream_view_tile_load_avatar_async_co (_data_);
 
1702
}
 
1703
 
 
1704
 
 
1705
static void gwibber_gtk_stream_view_tile_load_avatar_finish (GwibberGtkStreamViewTile* self, GAsyncResult* _res_) {
 
1706
        GwibberGtkStreamViewTileLoadAvatarAsyncData* _data_;
 
1707
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
1708
}
 
1709
 
 
1710
 
 
1711
static void gwibber_gtk_stream_view_tile_load_avatar_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
1712
        GwibberGtkStreamViewTileLoadAvatarAsyncData* data;
 
1713
        data = _user_data_;
 
1714
        data->_source_object_ = source_object;
 
1715
        data->_res_ = _res_;
 
1716
        gwibber_gtk_stream_view_tile_load_avatar_async_co (data);
 
1717
}
 
1718
 
 
1719
 
 
1720
static gchar* string_replace (const gchar* self, const gchar* old, const gchar* replacement) {
 
1721
        gchar* result = NULL;
 
1722
        gchar* _tmp0_ = NULL;
 
1723
        gchar* _tmp1_;
 
1724
        GRegex* _tmp2_ = NULL;
 
1725
        GRegex* _tmp3_;
 
1726
        GRegex* regex;
 
1727
        gchar* _tmp4_ = NULL;
 
1728
        gchar* _tmp5_;
 
1729
        GError * _inner_error_ = NULL;
 
1730
        g_return_val_if_fail (self != NULL, NULL);
 
1731
        g_return_val_if_fail (old != NULL, NULL);
 
1732
        g_return_val_if_fail (replacement != NULL, NULL);
 
1733
        _tmp0_ = g_regex_escape_string (old, -1);
 
1734
        _tmp1_ = _tmp0_;
 
1735
        _tmp2_ = g_regex_new (_tmp1_, 0, 0, &_inner_error_);
 
1736
        _tmp3_ = _tmp2_;
 
1737
        _g_free0 (_tmp1_);
 
1738
        regex = _tmp3_;
 
1739
        if (_inner_error_ != NULL) {
 
1740
                if (_inner_error_->domain == G_REGEX_ERROR) {
 
1741
                        goto __catch2_g_regex_error;
 
1742
                }
 
1743
                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);
 
1744
                g_clear_error (&_inner_error_);
 
1745
                return NULL;
 
1746
        }
 
1747
        _tmp4_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);
 
1748
        _tmp5_ = _tmp4_;
 
1749
        if (_inner_error_ != NULL) {
 
1750
                _g_regex_unref0 (regex);
 
1751
                if (_inner_error_->domain == G_REGEX_ERROR) {
 
1752
                        goto __catch2_g_regex_error;
 
1753
                }
 
1754
                _g_regex_unref0 (regex);
 
1755
                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);
 
1756
                g_clear_error (&_inner_error_);
 
1757
                return NULL;
 
1758
        }
 
1759
        result = _tmp5_;
 
1760
        _g_regex_unref0 (regex);
 
1761
        return result;
 
1762
        _g_regex_unref0 (regex);
 
1763
        goto __finally2;
 
1764
        __catch2_g_regex_error:
 
1765
        {
 
1766
                GError * e;
 
1767
                e = _inner_error_;
 
1768
                _inner_error_ = NULL;
 
1769
                g_assert_not_reached ();
 
1770
                _g_error_free0 (e);
 
1771
        }
 
1772
        __finally2:
 
1773
        if (_inner_error_ != NULL) {
 
1774
                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);
 
1775
                g_clear_error (&_inner_error_);
 
1776
                return NULL;
 
1777
        }
 
1778
}
 
1779
 
 
1780
 
 
1781
static gboolean gwibber_gtk_stream_view_tile_load_avatar_async_co (GwibberGtkStreamViewTileLoadAvatarAsyncData* data) {
 
1782
        switch (data->_state_) {
 
1783
                case 0:
 
1784
                goto _state_0;
 
1785
                case 1:
 
1786
                goto _state_1;
 
1787
                default:
 
1788
                g_assert_not_reached ();
 
1789
        }
 
1790
        _state_0:
 
1791
        data->_tmp0_ = NULL;
 
1792
        data->_tmp0_ = g_file_new_for_uri (data->url);
 
1793
        data->file = data->_tmp0_;
 
1794
        data->_state_ = 1;
 
1795
        g_file_read_async (data->file, G_PRIORITY_DEFAULT, data->self->priv->cancellable, gwibber_gtk_stream_view_tile_load_avatar_async_ready, data);
 
1796
        return FALSE;
 
1797
        _state_1:
 
1798
        data->_tmp1_ = NULL;
 
1799
        data->_tmp1_ = g_file_read_finish (data->file, data->_res_, &data->_inner_error_);
 
1800
        data->stream = data->_tmp1_;
 
1801
        if (data->_inner_error_ != NULL) {
 
1802
                goto __catch1_g_error;
 
1803
        }
 
1804
        data->pixbuf = NULL;
 
1805
        data->_tmp2_ = NULL;
 
1806
        data->_tmp2_ = gdk_pixbuf_new_from_stream_at_scale ((GInputStream*) data->stream, 48, 48, FALSE, data->self->priv->cancellable, &data->_inner_error_);
 
1807
        data->_tmp3_ = data->_tmp2_;
 
1808
        if (data->_inner_error_ != NULL) {
 
1809
                _g_object_unref0 (data->pixbuf);
 
1810
                _g_object_unref0 (data->stream);
 
1811
                goto __catch1_g_error;
 
1812
        }
 
1813
        _g_object_unref0 (data->pixbuf);
 
1814
        data->pixbuf = data->_tmp3_;
 
1815
        if (GDK_IS_PIXBUF (data->pixbuf)) {
 
1816
                gtk_image_set_from_pixbuf (data->cicon, data->pixbuf);
 
1817
                gtk_widget_show ((GtkWidget*) data->cicon);
 
1818
                data->_tmp4_ = NULL;
 
1819
                data->_tmp4_ = g_get_user_cache_dir ();
 
1820
                data->_tmp5_ = NULL;
 
1821
                data->_tmp5_ = string_replace (data->url, "/", "");
 
1822
                data->_tmp6_ = data->_tmp5_;
 
1823
                data->_tmp7_ = NULL;
 
1824
                data->_tmp7_ = g_build_path (G_DIR_SEPARATOR_S, data->_tmp4_, "gwibber/avatars", data->_tmp6_, NULL);
 
1825
                data->_tmp8_ = data->_tmp7_;
 
1826
                _g_free0 (data->_tmp6_);
 
1827
                data->cimage = data->_tmp8_;
 
1828
                data->_tmp9_ = g_strdup ("png");
 
1829
                _g_free0 (data->t);
 
1830
                data->t = data->_tmp9_;
 
1831
                data->_tmp12_ = g_str_has_suffix (data->cimage, "JPG");
 
1832
                if (data->_tmp12_) {
 
1833
                        data->_tmp11_ = TRUE;
 
1834
                } else {
 
1835
                        data->_tmp13_ = g_str_has_suffix (data->cimage, "jpeg");
 
1836
                        data->_tmp11_ = data->_tmp13_;
 
1837
                }
 
1838
                if (data->_tmp11_) {
 
1839
                        data->_tmp10_ = TRUE;
 
1840
                } else {
 
1841
                        data->_tmp14_ = g_str_has_suffix (data->cimage, "jpg");
 
1842
                        data->_tmp10_ = data->_tmp14_;
 
1843
                }
 
1844
                if (data->_tmp10_) {
 
1845
                        data->_tmp15_ = g_strdup ("jpeg");
 
1846
                        _g_free0 (data->t);
 
1847
                        data->t = data->_tmp15_;
 
1848
                }
 
1849
                gdk_pixbuf_save (data->pixbuf, data->cimage, data->t, &data->_inner_error_, NULL);
 
1850
                if (data->_inner_error_ != NULL) {
 
1851
                        _g_free0 (data->cimage);
 
1852
                        _g_object_unref0 (data->pixbuf);
 
1853
                        _g_object_unref0 (data->stream);
 
1854
                        goto __catch1_g_error;
 
1855
                }
 
1856
                _g_free0 (data->cimage);
 
1857
        }
 
1858
        _g_object_unref0 (data->pixbuf);
 
1859
        _g_object_unref0 (data->stream);
 
1860
        goto __finally1;
 
1861
        __catch1_g_error:
 
1862
        {
 
1863
                data->e = data->_inner_error_;
 
1864
                data->_inner_error_ = NULL;
 
1865
                g_debug ("stream-view-tile.vala:773: Error trying to load %s: %s", data->url, data->e->message);
 
1866
                gtk_image_set_from_icon_name (data->cicon, "stock_person", GTK_ICON_SIZE_DIALOG);
 
1867
                _g_error_free0 (data->e);
 
1868
        }
 
1869
        __finally1:
 
1870
        if (data->_inner_error_ != NULL) {
 
1871
                _g_object_unref0 (data->file);
 
1872
                _g_free0 (data->t);
 
1873
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
1874
                g_clear_error (&data->_inner_error_);
 
1875
                return FALSE;
 
1876
        }
 
1877
        _g_object_unref0 (data->file);
 
1878
        _g_free0 (data->t);
 
1879
        if (data->_state_ == 0) {
 
1880
                g_simple_async_result_complete_in_idle (data->_async_result);
 
1881
        } else {
 
1882
                g_simple_async_result_complete (data->_async_result);
 
1883
        }
 
1884
        g_object_unref (data->_async_result);
 
1885
        return FALSE;
 
1886
}
 
1887
 
 
1888
 
 
1889
static void gwibber_gtk_stream_view_tile_load_thumbnail_async_data_free (gpointer _data) {
 
1890
        GwibberGtkStreamViewTileLoadThumbnailAsyncData* data;
 
1891
        data = _data;
 
1892
        _g_free0 (data->img_markup);
 
1893
        _g_object_unref0 (data->self);
 
1894
        g_slice_free (GwibberGtkStreamViewTileLoadThumbnailAsyncData, data);
 
1895
}
 
1896
 
 
1897
 
 
1898
static void gwibber_gtk_stream_view_tile_load_thumbnail_async (GwibberGtkStreamViewTile* self, const gchar* img_markup, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1899
        GwibberGtkStreamViewTileLoadThumbnailAsyncData* _data_;
 
1900
        _data_ = g_slice_new0 (GwibberGtkStreamViewTileLoadThumbnailAsyncData);
 
1901
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, gwibber_gtk_stream_view_tile_load_thumbnail_async);
 
1902
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, gwibber_gtk_stream_view_tile_load_thumbnail_async_data_free);
 
1903
        _data_->self = _g_object_ref0 (self);
 
1904
        _data_->img_markup = g_strdup (img_markup);
 
1905
        gwibber_gtk_stream_view_tile_load_thumbnail_async_co (_data_);
 
1906
}
 
1907
 
 
1908
 
 
1909
static void gwibber_gtk_stream_view_tile_load_thumbnail_finish (GwibberGtkStreamViewTile* self, GAsyncResult* _res_) {
 
1910
        GwibberGtkStreamViewTileLoadThumbnailAsyncData* _data_;
 
1911
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
1912
}
 
1913
 
 
1914
 
 
1915
static void gwibber_gtk_stream_view_tile_load_thumbnail_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
1916
        GwibberGtkStreamViewTileLoadThumbnailAsyncData* data;
 
1917
        data = _user_data_;
 
1918
        data->_source_object_ = source_object;
 
1919
        data->_res_ = _res_;
 
1920
        gwibber_gtk_stream_view_tile_load_thumbnail_async_co (data);
 
1921
}
 
1922
 
 
1923
 
 
1924
static gboolean gwibber_gtk_stream_view_tile_load_thumbnail_async_co (GwibberGtkStreamViewTileLoadThumbnailAsyncData* data) {
 
1925
        switch (data->_state_) {
 
1926
                case 0:
 
1927
                goto _state_0;
 
1928
                case 1:
 
1929
                goto _state_1;
 
1930
                default:
 
1931
                g_assert_not_reached ();
 
1932
        }
 
1933
        _state_0:
 
1934
        memset (&data->_tmp0_, 0, sizeof (GtkAllocation));
 
1935
        gtk_widget_get_allocation ((GtkWidget*) data->self->priv->message, &data->_tmp0_);
 
1936
        data->alloc = data->_tmp0_;
 
1937
        data->self->priv->img_id = (guint) 0;
 
1938
        data->_tmp1_ = NULL;
 
1939
        data->_tmp1_ = gwibber_gtk_stream_view_tile_fix_image_uri (data->self, data->self->priv->img_uri);
 
1940
        data->_tmp2_ = data->_tmp1_;
 
1941
        data->_tmp3_ = NULL;
 
1942
        data->_tmp3_ = g_file_new_for_uri (data->_tmp2_);
 
1943
        data->_tmp4_ = data->_tmp3_;
 
1944
        _g_free0 (data->_tmp2_);
 
1945
        data->file = data->_tmp4_;
 
1946
        data->_state_ = 1;
 
1947
        g_file_read_async (data->file, G_PRIORITY_DEFAULT, data->self->priv->cancellable, gwibber_gtk_stream_view_tile_load_thumbnail_async_ready, data);
 
1948
        return FALSE;
 
1949
        _state_1:
 
1950
        data->_tmp5_ = NULL;
 
1951
        data->_tmp5_ = g_file_read_finish (data->file, data->_res_, &data->_inner_error_);
 
1952
        data->stream = data->_tmp5_;
 
1953
        if (data->_inner_error_ != NULL) {
 
1954
                goto __catch3_g_error;
 
1955
        }
 
1956
        data->pixbuf = NULL;
 
1957
        data->_tmp6_ = NULL;
 
1958
        data->_tmp6_ = gdk_pixbuf_new_from_stream_at_scale ((GInputStream*) data->stream, data->alloc.width - 24, 100, TRUE, data->self->priv->cancellable, &data->_inner_error_);
 
1959
        data->_tmp7_ = data->_tmp6_;
 
1960
        if (data->_inner_error_ != NULL) {
 
1961
                _g_object_unref0 (data->pixbuf);
 
1962
                _g_object_unref0 (data->stream);
 
1963
                goto __catch3_g_error;
 
1964
        }
 
1965
        _g_object_unref0 (data->pixbuf);
 
1966
        data->pixbuf = data->_tmp7_;
 
1967
        if (GDK_IS_PIXBUF (data->pixbuf)) {
 
1968
                gtk_image_set_from_pixbuf ((GtkImage*) data->self->priv->thumbnail, data->pixbuf);
 
1969
                gtk_widget_show ((GtkWidget*) data->self->priv->thumbnail);
 
1970
                gtk_widget_set_no_show_all ((GtkWidget*) data->self->priv->thumb_box, FALSE);
 
1971
                gtk_widget_show ((GtkWidget*) data->self->priv->thumb_box);
 
1972
        }
 
1973
        gtk_label_set_markup (data->self->priv->message, data->img_markup);
 
1974
        _g_object_unref0 (data->pixbuf);
 
1975
        _g_object_unref0 (data->stream);
 
1976
        goto __finally3;
 
1977
        __catch3_g_error:
 
1978
        {
 
1979
                data->e = data->_inner_error_;
 
1980
                data->_inner_error_ = NULL;
 
1981
                g_debug ("stream-view-tile.vala:802: Error trying to load %s: %s", data->self->priv->img_uri, data->e->message);
 
1982
                gtk_widget_hide ((GtkWidget*) data->self->priv->thumbnail);
 
1983
                gtk_widget_set_no_show_all ((GtkWidget*) data->self->priv->thumb_box, TRUE);
 
1984
                gtk_widget_hide ((GtkWidget*) data->self->priv->thumb_box);
 
1985
                _g_error_free0 (data->e);
 
1986
        }
 
1987
        __finally3:
 
1988
        if (data->_inner_error_ != NULL) {
 
1989
                _g_object_unref0 (data->file);
 
1990
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
1991
                g_clear_error (&data->_inner_error_);
 
1992
                return FALSE;
 
1993
        }
 
1994
        _g_object_unref0 (data->file);
 
1995
        if (data->_state_ == 0) {
 
1996
                g_simple_async_result_complete_in_idle (data->_async_result);
 
1997
        } else {
 
1998
                g_simple_async_result_complete (data->_async_result);
 
1999
        }
 
2000
        g_object_unref (data->_async_result);
 
2001
        return FALSE;
 
2002
}
 
2003
 
 
2004
 
 
2005
static gboolean string_contains (const gchar* self, const gchar* needle) {
 
2006
        gboolean result = FALSE;
 
2007
        gchar* _tmp0_ = NULL;
 
2008
        g_return_val_if_fail (self != NULL, FALSE);
 
2009
        g_return_val_if_fail (needle != NULL, FALSE);
 
2010
        _tmp0_ = strstr ((gchar*) self, (gchar*) needle);
 
2011
        result = _tmp0_ != NULL;
 
2012
        return result;
 
2013
}
 
2014
 
 
2015
 
 
2016
static glong string_strnlen (gchar* str, glong maxlen) {
 
2017
        glong result = 0L;
 
2018
        gchar* _tmp0_ = NULL;
 
2019
        gchar* end;
 
2020
        _tmp0_ = memchr (str, 0, (gsize) maxlen);
 
2021
        end = _tmp0_;
 
2022
        if (end == NULL) {
 
2023
                result = maxlen;
 
2024
                return result;
 
2025
        } else {
 
2026
                result = (glong) (end - str);
 
2027
                return result;
 
2028
        }
 
2029
}
 
2030
 
 
2031
 
 
2032
static gchar* string_substring (const gchar* self, glong offset, glong len) {
 
2033
        gchar* result = NULL;
 
2034
        glong string_length = 0L;
 
2035
        gboolean _tmp0_ = FALSE;
 
2036
        gchar* _tmp3_ = NULL;
 
2037
        g_return_val_if_fail (self != NULL, NULL);
 
2038
        if (offset >= 0) {
 
2039
                _tmp0_ = len >= 0;
 
2040
        } else {
 
2041
                _tmp0_ = FALSE;
 
2042
        }
 
2043
        if (_tmp0_) {
 
2044
                glong _tmp1_;
 
2045
                _tmp1_ = string_strnlen ((gchar*) self, offset + len);
 
2046
                string_length = _tmp1_;
 
2047
        } else {
 
2048
                gint _tmp2_;
 
2049
                _tmp2_ = strlen (self);
 
2050
                string_length = (glong) _tmp2_;
 
2051
        }
 
2052
        if (offset < 0) {
 
2053
                offset = string_length + offset;
 
2054
                g_return_val_if_fail (offset >= 0, NULL);
 
2055
        } else {
 
2056
                g_return_val_if_fail (offset <= string_length, NULL);
 
2057
        }
 
2058
        if (len < 0) {
 
2059
                len = string_length - offset;
 
2060
        }
 
2061
        g_return_val_if_fail ((offset + len) <= string_length, NULL);
 
2062
        _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
 
2063
        result = _tmp3_;
 
2064
        return result;
 
2065
}
 
2066
 
 
2067
 
 
2068
static gchar* gwibber_gtk_stream_view_tile_fix_image_uri (GwibberGtkStreamViewTile* self, const gchar* uri) {
 
2069
        gchar* result = NULL;
 
2070
        gchar* _tmp0_;
 
2071
        gchar* ret;
 
2072
        gboolean _tmp1_ = FALSE;
 
2073
        gboolean _tmp2_;
 
2074
        g_return_val_if_fail (self != NULL, NULL);
 
2075
        g_return_val_if_fail (uri != NULL, NULL);
 
2076
        _tmp0_ = g_strdup (uri);
 
2077
        ret = _tmp0_;
 
2078
        _tmp2_ = string_contains (uri, "imgur.com");
 
2079
        if (_tmp2_) {
 
2080
                gboolean _tmp3_;
 
2081
                _tmp3_ = g_str_has_suffix (uri, ".png");
 
2082
                _tmp1_ = !_tmp3_;
 
2083
        } else {
 
2084
                _tmp1_ = FALSE;
 
2085
        }
 
2086
        if (_tmp1_) {
 
2087
                const gchar* _tmp4_ = NULL;
 
2088
                gchar* _tmp5_ = NULL;
 
2089
                gchar* last;
 
2090
                gchar* _tmp6_ = NULL;
 
2091
                _tmp4_ = g_strrstr (uri, "/");
 
2092
                _tmp5_ = string_substring (_tmp4_, (glong) 1, (glong) (-1));
 
2093
                last = _tmp5_;
 
2094
                _tmp6_ = g_strdup_printf ("http://i.imgur.com/%s.png", last);
 
2095
                _g_free0 (ret);
 
2096
                ret = _tmp6_;
 
2097
                _g_free0 (last);
 
2098
        } else {
 
2099
                gboolean _tmp7_;
 
2100
                _tmp7_ = string_contains (uri, "youtube.com");
 
2101
                if (_tmp7_) {
 
2102
                        const gchar* _tmp8_ = NULL;
 
2103
                        gchar* _tmp9_ = NULL;
 
2104
                        gchar* id;
 
2105
                        gboolean _tmp10_;
 
2106
                        gchar* _tmp23_ = NULL;
 
2107
                        _tmp8_ = g_strrstr (uri, "/");
 
2108
                        _tmp9_ = string_substring (_tmp8_, (glong) 1, (glong) (-1));
 
2109
                        id = _tmp9_;
 
2110
                        _tmp10_ = string_contains (uri, "watch?v=");
 
2111
                        if (_tmp10_) {
 
2112
                                gboolean _tmp11_;
 
2113
                                _tmp11_ = string_contains (uri, "&");
 
2114
                                if (_tmp11_) {
 
2115
                                        gchar** _tmp12_;
 
2116
                                        gchar** _tmp13_ = NULL;
 
2117
                                        gchar** _tmp14_;
 
2118
                                        gint _tmp14__length1;
 
2119
                                        gchar** _tmp15_;
 
2120
                                        gchar** _tmp16_ = NULL;
 
2121
                                        gchar** _tmp17_;
 
2122
                                        gint _tmp17__length1;
 
2123
                                        gchar* _tmp18_;
 
2124
                                        _tmp13_ = _tmp12_ = g_strsplit (uri, "v=", 0);
 
2125
                                        _tmp14_ = _tmp13_;
 
2126
                                        _tmp14__length1 = _vala_array_length (_tmp12_);
 
2127
                                        _tmp16_ = _tmp15_ = g_strsplit (_tmp14_[1], "&", 0);
 
2128
                                        _tmp17_ = _tmp16_;
 
2129
                                        _tmp17__length1 = _vala_array_length (_tmp15_);
 
2130
                                        _tmp18_ = g_strdup (_tmp17_[0]);
 
2131
                                        _g_free0 (id);
 
2132
                                        id = _tmp18_;
 
2133
                                        _tmp17_ = (_vala_array_free (_tmp17_, _tmp17__length1, (GDestroyNotify) g_free), NULL);
 
2134
                                        _tmp14_ = (_vala_array_free (_tmp14_, _tmp14__length1, (GDestroyNotify) g_free), NULL);
 
2135
                                } else {
 
2136
                                        gchar** _tmp19_;
 
2137
                                        gchar** _tmp20_ = NULL;
 
2138
                                        gchar** _tmp21_;
 
2139
                                        gint _tmp21__length1;
 
2140
                                        gchar* _tmp22_;
 
2141
                                        _tmp20_ = _tmp19_ = g_strsplit (uri, "v=", 0);
 
2142
                                        _tmp21_ = _tmp20_;
 
2143
                                        _tmp21__length1 = _vala_array_length (_tmp19_);
 
2144
                                        _tmp22_ = g_strdup (_tmp21_[1]);
 
2145
                                        _g_free0 (id);
 
2146
                                        id = _tmp22_;
 
2147
                                        _tmp21_ = (_vala_array_free (_tmp21_, _tmp21__length1, (GDestroyNotify) g_free), NULL);
 
2148
                                }
 
2149
                        }
 
2150
                        _tmp23_ = g_strdup_printf ("http://img.youtube.com/vi/%s/default.jpg", id);
 
2151
                        _g_free0 (ret);
 
2152
                        ret = _tmp23_;
 
2153
                        _g_free0 (id);
 
2154
                }
 
2155
        }
 
2156
        result = ret;
 
2157
        return result;
978
2158
}
979
2159
 
980
2160
 
984
2164
        g_return_val_if_fail (self != NULL, FALSE);
985
2165
        g_app_info_launch_default_for_uri (self->priv->url, NULL, &_inner_error_);
986
2166
        if (_inner_error_ != NULL) {
987
 
                goto __catch1_g_error;
 
2167
                goto __catch4_g_error;
988
2168
        }
989
 
        goto __finally1;
990
 
        __catch1_g_error:
 
2169
        goto __finally4;
 
2170
        __catch4_g_error:
991
2171
        {
992
2172
                gchar* _tmp0_;
993
2173
                gchar* _tmp1_;
995
2175
                _inner_error_ = NULL;
996
2176
                _tmp0_ = g_strconcat ("Unable to launch: ", self->priv->url, NULL);
997
2177
                _tmp1_ = _tmp0_;
998
 
                g_warning ("stream-view-tile.vala:540: %s", _tmp1_);
 
2178
                g_warning ("stream-view-tile.vala:843: %s", _tmp1_);
999
2179
                _g_free0 (_tmp1_);
1000
2180
        }
1001
 
        __finally1:
 
2181
        __finally4:
1002
2182
        if (_inner_error_ != NULL) {
1003
2183
                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);
1004
2184
                g_clear_error (&_inner_error_);
1027
2207
}
1028
2208
 
1029
2209
 
 
2210
GwibberService* gwibber_gtk_stream_view_tile_get_service (GwibberGtkStreamViewTile* self) {
 
2211
        GwibberService* result;
 
2212
        g_return_val_if_fail (self != NULL, NULL);
 
2213
        result = self->priv->_service;
 
2214
        return result;
 
2215
}
 
2216
 
 
2217
 
 
2218
void gwibber_gtk_stream_view_tile_set_service (GwibberGtkStreamViewTile* self, GwibberService* value) {
 
2219
        GwibberService* _tmp0_;
 
2220
        g_return_if_fail (self != NULL);
 
2221
        _tmp0_ = _g_object_ref0 (value);
 
2222
        _g_object_unref0 (self->priv->_service);
 
2223
        self->priv->_service = _tmp0_;
 
2224
        g_object_notify ((GObject *) self, "service");
 
2225
}
 
2226
 
 
2227
 
1030
2228
gboolean gwibber_gtk_stream_view_tile_get_show_fullname (GwibberGtkStreamViewTile* self) {
1031
2229
        gboolean result;
1032
2230
        g_return_val_if_fail (self != NULL, FALSE);
1087
2285
}
1088
2286
 
1089
2287
 
1090
 
static gboolean _lambda17_ (const gchar* uri, GwibberGtkStreamViewTile* self) {
 
2288
static gboolean _lambda20_ (const gchar* uri, GwibberGtkStreamViewTile* self) {
1091
2289
        gboolean result = FALSE;
1092
2290
        gboolean _tmp0_;
1093
2291
        g_return_val_if_fail (uri != NULL, FALSE);
1096
2294
                SoupURI* _tmp1_ = NULL;
1097
2295
                SoupURI* url;
1098
2296
                gboolean _tmp2_;
1099
 
                g_debug ("stream-view-tile.vala:123: URI is %s", uri);
 
2297
                g_debug ("stream-view-tile.vala:165: URI is %s", uri);
1100
2298
                _tmp1_ = soup_uri_new (uri);
1101
2299
                url = _tmp1_;
1102
2300
                _tmp2_ = g_str_has_suffix (url->path, "tag");
1276
2474
}
1277
2475
 
1278
2476
 
1279
 
static gboolean __lambda17__gtk_label_activate_link (GtkLabel* _sender, const gchar* uri, gpointer self) {
1280
 
        gboolean result;
1281
 
        result = _lambda17_ (uri, self);
1282
 
        return result;
1283
 
}
1284
 
 
1285
 
 
1286
 
static gboolean _lambda18_ (GwibberGtkStreamViewTile* self) {
1287
 
        gboolean result = FALSE;
1288
 
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
1289
 
        result = FALSE;
1290
 
        return result;
1291
 
}
1292
 
 
1293
 
 
1294
 
static gboolean __lambda18__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
1295
 
        gboolean result;
1296
 
        result = _lambda18_ (self);
1297
 
        return result;
1298
 
}
1299
 
 
1300
 
 
1301
 
static gboolean _lambda19_ (GwibberGtkStreamViewTile* self) {
1302
 
        gboolean result = FALSE;
1303
 
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
1304
 
        result = FALSE;
1305
 
        return result;
1306
 
}
1307
 
 
1308
 
 
1309
 
static gboolean __lambda19__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
1310
 
        gboolean result;
1311
 
        result = _lambda19_ (self);
1312
 
        return result;
1313
 
}
1314
 
 
1315
 
 
1316
 
static gboolean _lambda20_ (GwibberGtkStreamViewTile* self) {
1317
 
        gboolean result = FALSE;
1318
 
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
1319
 
        result = FALSE;
1320
 
        return result;
1321
 
}
1322
 
 
1323
 
 
1324
 
static gboolean __lambda20__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
1325
 
        gboolean result;
1326
 
        result = _lambda20_ (self);
 
2477
static gboolean __lambda20__gtk_label_activate_link (GtkLabel* _sender, const gchar* uri, gpointer self) {
 
2478
        gboolean result;
 
2479
        result = _lambda20_ (uri, self);
1327
2480
        return result;
1328
2481
}
1329
2482
 
1330
2483
 
1331
2484
static gboolean _lambda21_ (GwibberGtkStreamViewTile* self) {
1332
2485
        gboolean result = FALSE;
1333
 
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
 
2486
        GError * _inner_error_ = NULL;
 
2487
        if (self->priv->img_src != NULL) {
 
2488
                GdkScreen* _tmp0_ = NULL;
 
2489
                _tmp0_ = gdk_screen_get_default ();
 
2490
                gtk_show_uri (_tmp0_, self->priv->img_src, (guint32) 0, &_inner_error_);
 
2491
                if (_inner_error_ != NULL) {
 
2492
                        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);
 
2493
                        g_clear_error (&_inner_error_);
 
2494
                        return FALSE;
 
2495
                }
 
2496
        }
1334
2497
        result = FALSE;
1335
2498
        return result;
1336
2499
}
1337
2500
 
1338
2501
 
1339
 
static gboolean __lambda21__gtk_widget_leave_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
 
2502
static gboolean __lambda21__gtk_widget_button_release_event (GtkWidget* _sender, GdkEventButton* event, gpointer self) {
1340
2503
        gboolean result;
1341
2504
        result = _lambda21_ (self);
1342
2505
        return result;
1343
2506
}
1344
2507
 
1345
2508
 
 
2509
static gboolean _lambda22_ (GwibberGtkStreamViewTile* self) {
 
2510
        gboolean result = FALSE;
 
2511
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
 
2512
        result = FALSE;
 
2513
        return result;
 
2514
}
 
2515
 
 
2516
 
 
2517
static gboolean __lambda22__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
 
2518
        gboolean result;
 
2519
        result = _lambda22_ (self);
 
2520
        return result;
 
2521
}
 
2522
 
 
2523
 
 
2524
static gboolean _lambda23_ (GwibberGtkStreamViewTile* self) {
 
2525
        gboolean result = FALSE;
 
2526
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
 
2527
        result = FALSE;
 
2528
        return result;
 
2529
}
 
2530
 
 
2531
 
 
2532
static gboolean __lambda23__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
 
2533
        gboolean result;
 
2534
        result = _lambda23_ (self);
 
2535
        return result;
 
2536
}
 
2537
 
 
2538
 
 
2539
static gboolean _lambda24_ (GwibberGtkStreamViewTile* self) {
 
2540
        gboolean result = FALSE;
 
2541
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
 
2542
        result = FALSE;
 
2543
        return result;
 
2544
}
 
2545
 
 
2546
 
 
2547
static gboolean __lambda24__gtk_widget_enter_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
 
2548
        gboolean result;
 
2549
        result = _lambda24_ (self);
 
2550
        return result;
 
2551
}
 
2552
 
 
2553
 
 
2554
static gboolean _lambda25_ (GwibberGtkStreamViewTile* self) {
 
2555
        gboolean result = FALSE;
 
2556
        gwibber_gtk_stream_view_tile_update_time_area_wrapper (self);
 
2557
        result = FALSE;
 
2558
        return result;
 
2559
}
 
2560
 
 
2561
 
 
2562
static gboolean __lambda25__gtk_widget_leave_notify_event (GtkWidget* _sender, GdkEventCrossing* event, gpointer self) {
 
2563
        gboolean result;
 
2564
        result = _lambda25_ (self);
 
2565
        return result;
 
2566
}
 
2567
 
 
2568
 
1346
2569
static GObject * gwibber_gtk_stream_view_tile_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
1347
2570
        GObject * obj;
1348
2571
        GObjectClass * parent_class;
1352
2575
        GtkAlignment* _tmp2_ = NULL;
1353
2576
        GtkAlignment* _tmp3_ = NULL;
1354
2577
        GtkEventBox* _tmp4_ = NULL;
1355
 
        GtkImage* _tmp5_ = NULL;
 
2578
        GwibberGtkStreamViewAvatar* _tmp5_ = NULL;
1356
2579
        GtkVBox* _tmp6_ = NULL;
1357
2580
        GtkHBox* _tmp7_ = NULL;
1358
2581
        GtkHBox* hbox;
1361
2584
        GtkLabel* _tmp10_ = NULL;
1362
2585
        GwibberGtkActionBox* _tmp11_ = NULL;
1363
2586
        GtkLabel* _tmp12_ = NULL;
1364
 
        GtkLabel* _tmp13_ = NULL;
1365
 
        GtkLabel* _tmp14_ = NULL;
1366
 
        GtkHBox* _tmp15_ = NULL;
1367
 
        GtkImage* _tmp16_ = NULL;
 
2587
        GtkEventBox* _tmp13_ = NULL;
 
2588
        GtkHBox* _tmp14_ = NULL;
 
2589
        GtkHBox* thumb_hbox;
 
2590
        GwibberGtkStreamViewAvatar* _tmp15_ = NULL;
 
2591
        GtkVBox* _tmp16_ = NULL;
 
2592
        GtkLabel* _tmp17_ = NULL;
 
2593
        GtkLabel* _tmp18_ = NULL;
 
2594
        GtkHBox* _tmp19_ = NULL;
 
2595
        GtkImage* _tmp20_ = NULL;
1368
2596
        GtkImage* likes_icon;
1369
 
        GtkLabel* _tmp17_ = NULL;
 
2597
        GtkLabel* _tmp21_ = NULL;
 
2598
        GCancellable* _tmp22_ = NULL;
1370
2599
        parent_class = G_OBJECT_CLASS (gwibber_gtk_stream_view_tile_parent_class);
1371
2600
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
1372
2601
        self = GWIBBER_GTK_STREAM_VIEW_TILE (obj);
 
2602
        _g_list_free0 (self->priv->_to_disconnect);
 
2603
        self->priv->_to_disconnect = NULL;
1373
2604
        g_signal_connect_object ((GtkWidget*) self, "draw", (GCallback) _gwibber_gtk_stream_view_tile_on_draw_gtk_widget_draw, self, 0);
1374
2605
        _tmp0_ = (GtkAlignment*) gtk_alignment_new (0.0f, 0.0f, 1.0f, 1.0f);
1375
2606
        _g_object_unref0 (self->priv->align);
1392
2623
        _g_object_unref0 (self->priv->icon_box);
1393
2624
        self->priv->icon_box = g_object_ref_sink (_tmp4_);
1394
2625
        gtk_event_box_set_visible_window (self->priv->icon_box, FALSE);
1395
 
        _tmp5_ = (GtkImage*) gtk_image_new_from_icon_name ("stock_person", GTK_ICON_SIZE_DIALOG);
 
2626
        _tmp5_ = gwibber_gtk_stream_view_avatar_new ();
1396
2627
        _g_object_unref0 (self->priv->icon);
1397
2628
        self->priv->icon = g_object_ref_sink (_tmp5_);
1398
2629
        gtk_container_add ((GtkContainer*) self->priv->icon_box, (GtkWidget*) self->priv->icon);
1438
2669
        gtk_label_set_line_wrap_mode (self->priv->message, PANGO_WRAP_WORD_CHAR);
1439
2670
        gtk_misc_set_alignment ((GtkMisc*) self->priv->message, 0.0f, 0.0f);
1440
2671
        gtk_box_pack_start ((GtkBox*) self->priv->vbox, (GtkWidget*) self->priv->message, FALSE, FALSE, (guint) 2);
1441
 
        g_signal_connect_object (self->priv->message, "activate-link", (GCallback) __lambda17__gtk_label_activate_link, self, 0);
1442
 
        _tmp13_ = (GtkLabel*) gtk_label_new ("");
 
2672
        g_signal_connect_object (self->priv->message, "activate-link", (GCallback) __lambda20__gtk_label_activate_link, self, 0);
 
2673
        _tmp13_ = (GtkEventBox*) gtk_event_box_new ();
 
2674
        _g_object_unref0 (self->priv->thumb_box);
 
2675
        self->priv->thumb_box = g_object_ref_sink (_tmp13_);
 
2676
        gtk_event_box_set_visible_window (self->priv->thumb_box, FALSE);
 
2677
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->thumb_box, TRUE);
 
2678
        _tmp14_ = (GtkHBox*) gtk_hbox_new (FALSE, 2);
 
2679
        thumb_hbox = g_object_ref_sink (_tmp14_);
 
2680
        gtk_box_pack_start ((GtkBox*) self->priv->vbox, (GtkWidget*) thumb_hbox, FALSE, FALSE, (guint) 4);
 
2681
        gtk_box_pack_start ((GtkBox*) thumb_hbox, (GtkWidget*) self->priv->thumb_box, FALSE, FALSE, (guint) 4);
 
2682
        g_signal_connect_object ((GtkWidget*) self->priv->thumb_box, "button-release-event", (GCallback) __lambda21__gtk_widget_button_release_event, self, 0);
 
2683
        _tmp15_ = gwibber_gtk_stream_view_avatar_new ();
 
2684
        _g_object_unref0 (self->priv->thumbnail);
 
2685
        self->priv->thumbnail = g_object_ref_sink (_tmp15_);
 
2686
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->thumbnail, TRUE);
 
2687
        gtk_container_add ((GtkContainer*) self->priv->thumb_box, (GtkWidget*) self->priv->thumbnail);
 
2688
        gtk_widget_hide ((GtkWidget*) self->priv->thumb_box);
 
2689
        _tmp16_ = (GtkVBox*) gtk_vbox_new (FALSE, 0);
 
2690
        _g_object_unref0 (self->priv->comments_box);
 
2691
        self->priv->comments_box = g_object_ref_sink (_tmp16_);
 
2692
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->comments_box, TRUE);
 
2693
        gtk_box_pack_start ((GtkBox*) self->priv->vbox, (GtkWidget*) self->priv->comments_box, FALSE, FALSE, (guint) 4);
 
2694
        _tmp17_ = (GtkLabel*) gtk_label_new ("");
1443
2695
        _g_object_unref0 (self->priv->reply_to);
1444
 
        self->priv->reply_to = g_object_ref_sink (_tmp13_);
 
2696
        self->priv->reply_to = g_object_ref_sink (_tmp17_);
1445
2697
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->reply_to, TRUE);
1446
2698
        gtk_label_set_markup (self->priv->reply_to, "<span font_weight='light' font_size='small'></span>");
1447
2699
        gtk_misc_set_alignment ((GtkMisc*) self->priv->reply_to, 0.0f, 0.5f);
1448
2700
        gtk_box_pack_start ((GtkBox*) self->priv->vbox, (GtkWidget*) self->priv->reply_to, FALSE, FALSE, (guint) 2);
1449
 
        _tmp14_ = (GtkLabel*) gtk_label_new ("");
 
2701
        _tmp18_ = (GtkLabel*) gtk_label_new ("");
1450
2702
        _g_object_unref0 (self->priv->retweeted_by);
1451
 
        self->priv->retweeted_by = g_object_ref_sink (_tmp14_);
 
2703
        self->priv->retweeted_by = g_object_ref_sink (_tmp18_);
1452
2704
        gtk_label_set_markup (self->priv->retweeted_by, "<span font_weight='light' font_size='small'></span>");
1453
2705
        gtk_misc_set_alignment ((GtkMisc*) self->priv->retweeted_by, 0.0f, 0.5f);
1454
2706
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->retweeted_by, TRUE);
1455
2707
        gtk_box_pack_start ((GtkBox*) self->priv->vbox, (GtkWidget*) self->priv->retweeted_by, FALSE, FALSE, (guint) 2);
1456
 
        _tmp15_ = (GtkHBox*) gtk_hbox_new (FALSE, 0);
 
2708
        _tmp19_ = (GtkHBox*) gtk_hbox_new (FALSE, 0);
1457
2709
        _g_object_unref0 (self->priv->likes_hbox);
1458
 
        self->priv->likes_hbox = g_object_ref_sink (_tmp15_);
 
2710
        self->priv->likes_hbox = g_object_ref_sink (_tmp19_);
1459
2711
        gtk_widget_set_no_show_all ((GtkWidget*) self->priv->likes_hbox, TRUE);
1460
 
        _tmp16_ = (GtkImage*) gtk_image_new_from_file ("/usr/share/gwibber/ui/icons/streams/16x16/favorite.png");
1461
 
        likes_icon = g_object_ref_sink (_tmp16_);
 
2712
        _tmp20_ = (GtkImage*) gtk_image_new_from_file ("/usr/share/gwibber/ui/icons/streams/16x16/favorite.png");
 
2713
        likes_icon = g_object_ref_sink (_tmp20_);
1462
2714
        gtk_box_pack_start ((GtkBox*) self->priv->likes_hbox, (GtkWidget*) likes_icon, FALSE, FALSE, (guint) 2);
1463
 
        _tmp17_ = (GtkLabel*) gtk_label_new ("");
 
2715
        _tmp21_ = (GtkLabel*) gtk_label_new ("");
1464
2716
        _g_object_unref0 (self->priv->likes_count);
1465
 
        self->priv->likes_count = g_object_ref_sink (_tmp17_);
 
2717
        self->priv->likes_count = g_object_ref_sink (_tmp21_);
1466
2718
        gtk_box_pack_start ((GtkBox*) self->priv->likes_hbox, (GtkWidget*) self->priv->likes_count, FALSE, FALSE, (guint) 0);
1467
2719
        gtk_box_pack_start ((GtkBox*) self->priv->vbox, (GtkWidget*) self->priv->likes_hbox, FALSE, FALSE, (guint) 2);
1468
 
        g_signal_connect_object ((GtkWidget*) self, "enter-notify-event", (GCallback) __lambda18__gtk_widget_enter_notify_event, self, 0);
1469
 
        g_signal_connect_object ((GtkWidget*) self->priv->icon_box, "enter-notify-event", (GCallback) __lambda19__gtk_widget_enter_notify_event, self, 0);
1470
 
        g_signal_connect_object ((GtkWidget*) self->priv->message, "enter-notify-event", (GCallback) __lambda20__gtk_widget_enter_notify_event, self, 0);
1471
 
        g_signal_connect_object ((GtkWidget*) self, "leave-notify-event", (GCallback) __lambda21__gtk_widget_leave_notify_event, self, 0);
 
2720
        g_signal_connect_object ((GtkWidget*) self, "enter-notify-event", (GCallback) __lambda22__gtk_widget_enter_notify_event, self, 0);
 
2721
        g_signal_connect_object ((GtkWidget*) self->priv->icon_box, "enter-notify-event", (GCallback) __lambda23__gtk_widget_enter_notify_event, self, 0);
 
2722
        g_signal_connect_object ((GtkWidget*) self->priv->message, "enter-notify-event", (GCallback) __lambda24__gtk_widget_enter_notify_event, self, 0);
 
2723
        g_signal_connect_object ((GtkWidget*) self, "leave-notify-event", (GCallback) __lambda25__gtk_widget_leave_notify_event, self, 0);
 
2724
        _tmp22_ = g_cancellable_new ();
 
2725
        _g_object_unref0 (self->priv->cancellable);
 
2726
        self->priv->cancellable = _tmp22_;
1472
2727
        notify_init ("Gwibber");
1473
2728
        _g_object_unref0 (likes_icon);
 
2729
        _g_object_unref0 (thumb_hbox);
1474
2730
        _g_object_unref0 (hbox);
1475
2731
        return obj;
1476
2732
}
1485
2741
        G_OBJECT_CLASS (klass)->constructor = gwibber_gtk_stream_view_tile_constructor;
1486
2742
        G_OBJECT_CLASS (klass)->finalize = gwibber_gtk_stream_view_tile_finalize;
1487
2743
        g_object_class_install_property (G_OBJECT_CLASS (klass), GWIBBER_GTK_STREAM_VIEW_TILE_UTILS, g_param_spec_object ("utils", "utils", "utils", GWIBBER_TYPE_UTILS, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
 
2744
        g_object_class_install_property (G_OBJECT_CLASS (klass), GWIBBER_GTK_STREAM_VIEW_TILE_SERVICE, g_param_spec_object ("service", "service", "service", GWIBBER_TYPE_SERVICE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
1488
2745
        g_object_class_install_property (G_OBJECT_CLASS (klass), GWIBBER_GTK_STREAM_VIEW_TILE_SHOW_FULLNAME, g_param_spec_boolean ("show-fullname", "show-fullname", "show-fullname", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT));
1489
2746
        g_signal_new ("reply", GWIBBER_GTK_TYPE_STREAM_VIEW_TILE, G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (GwibberGtkStreamViewTileClass, reply), NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING_STRING, G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
1490
2747
}
1494
2751
        gchar* _tmp0_;
1495
2752
        self->priv = GWIBBER_GTK_STREAM_VIEW_TILE_GET_PRIVATE (self);
1496
2753
        self->priv->_update_time_area_id = (guint) 0;
 
2754
        self->priv->_cache_avatar_id = (guint) 0;
1497
2755
        self->uid = (guint) 0;
1498
2756
        self->priv->sender = NULL;
1499
2757
        self->priv->url = NULL;
1513
2771
        _g_object_unref0 (self->priv->icon);
1514
2772
        _g_object_unref0 (self->priv->private);
1515
2773
        _g_object_unref0 (self->priv->vbox);
 
2774
        _g_object_unref0 (self->priv->comments_box);
1516
2775
        _g_object_unref0 (self->priv->likes_hbox);
1517
2776
        _g_object_unref0 (self->priv->likes_count);
1518
2777
        _g_object_unref0 (self->priv->name);
1519
2778
        _g_object_unref0 (self->priv->time);
1520
2779
        _g_object_unref0 (self->priv->message);
 
2780
        _g_object_unref0 (self->priv->thumbnail);
 
2781
        _g_object_unref0 (self->priv->thumb_box);
1521
2782
        _g_object_unref0 (self->priv->reply_to);
1522
2783
        _g_object_unref0 (self->priv->retweeted_by);
1523
2784
        _g_object_unref0 (self->priv->_utils);
 
2785
        _g_object_unref0 (self->priv->_service);
 
2786
        _g_list_free0 (self->priv->_to_disconnect);
1524
2787
        _g_free0 (self->priv->sender);
1525
2788
        _g_free0 (self->priv->url);
1526
2789
        _g_free0 (self->priv->time_string);
1527
2790
        _g_object_unref0 (self->priv->action_box);
 
2791
        _g_object_unref0 (self->priv->cancellable);
 
2792
        _g_free0 (self->priv->img_uri);
 
2793
        _g_free0 (self->priv->img_src);
1528
2794
        G_OBJECT_CLASS (gwibber_gtk_stream_view_tile_parent_class)->finalize (obj);
1529
2795
}
1530
2796
 
1548
2814
                case GWIBBER_GTK_STREAM_VIEW_TILE_UTILS:
1549
2815
                g_value_set_object (value, gwibber_gtk_stream_view_tile_get_utils (self));
1550
2816
                break;
 
2817
                case GWIBBER_GTK_STREAM_VIEW_TILE_SERVICE:
 
2818
                g_value_set_object (value, gwibber_gtk_stream_view_tile_get_service (self));
 
2819
                break;
1551
2820
                case GWIBBER_GTK_STREAM_VIEW_TILE_SHOW_FULLNAME:
1552
2821
                g_value_set_boolean (value, gwibber_gtk_stream_view_tile_get_show_fullname (self));
1553
2822
                break;
1565
2834
                case GWIBBER_GTK_STREAM_VIEW_TILE_UTILS:
1566
2835
                gwibber_gtk_stream_view_tile_set_utils (self, g_value_get_object (value));
1567
2836
                break;
 
2837
                case GWIBBER_GTK_STREAM_VIEW_TILE_SERVICE:
 
2838
                gwibber_gtk_stream_view_tile_set_service (self, g_value_get_object (value));
 
2839
                break;
1568
2840
                case GWIBBER_GTK_STREAM_VIEW_TILE_SHOW_FULLNAME:
1569
2841
                gwibber_gtk_stream_view_tile_set_show_fullname (self, g_value_get_boolean (value));
1570
2842
                break;