1 /**
2 * @file enclosure-list-view.c enclosures/podcast handling GUI
3 *
4 * Copyright (C) 2005-2016 Lars Windolf <lars.windolf@gmx.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "enclosure_list_view.h"
22
23 #include <string.h>
24
25 #include "common.h"
26 #include "conf.h"
27 #include "debug.h"
28 #include "enclosure.h"
29 #include "item.h"
30 #include "metadata.h"
31 #include "ui/liferea_dialog.h"
32 #include "ui/media_player.h"
33 #include "ui/popup_menu.h"
34 #include "ui/ui_common.h"
35
36 /* enclosure list view implementation */
37
38 enum {
39 ES_NAME_STR,
40 ES_MIME_STR,
41 ES_DOWNLOADED,
42 ES_SIZE,
43 ES_SIZE_STR,
44 ES_SERIALIZED,
45 ES_LEN
46 };
47
48 #define ENCLOSURE_LIST_VIEW_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), ENCLOSURE_LIST_VIEW_TYPE, EnclosureListViewPrivate))
49
50 struct EnclosureListViewPrivate {
51 GSList *enclosures; /**< list of currently presented enclosures */
52
53 GtkWidget *container; /**< container the list is embedded in */
54 GtkWidget *expander; /**< expander that shows/hides the list */
55 GtkWidget *treeview;
56 GtkTreeStore *treestore;
57 };
58
59 static GObjectClass *parent_class = NULL;
60
61 G_DEFINE_TYPE (EnclosureListView, enclosure_list_view, G_TYPE_OBJECT);
62
63 static void
enclosure_list_view_finalize(GObject * object)64 enclosure_list_view_finalize (GObject *object)
65 {
66 G_OBJECT_CLASS (parent_class)->finalize (object);
67 }
68
69 static void
enclosure_list_view_destroy_cb(GtkWidget * widget,EnclosureListView * elv)70 enclosure_list_view_destroy_cb (GtkWidget *widget, EnclosureListView *elv)
71 {
72 g_object_unref (elv);
73 }
74
75 static void
enclosure_list_view_class_init(EnclosureListViewClass * klass)76 enclosure_list_view_class_init (EnclosureListViewClass *klass)
77 {
78 GObjectClass *object_class = G_OBJECT_CLASS (klass);
79
80 parent_class = g_type_class_peek_parent (klass);
81
82 object_class->finalize = enclosure_list_view_finalize;
83
84 g_type_class_add_private (object_class, sizeof(EnclosureListViewPrivate));
85 }
86
87 static void
enclosure_list_view_init(EnclosureListView * elv)88 enclosure_list_view_init (EnclosureListView *elv)
89 {
90 elv->priv = ENCLOSURE_LIST_VIEW_GET_PRIVATE (elv);
91 }
92
93 static enclosurePtr
enclosure_list_view_get_selected_enclosure(EnclosureListView * elv,GtkTreeIter * iter)94 enclosure_list_view_get_selected_enclosure (EnclosureListView *elv, GtkTreeIter *iter)
95 {
96 gchar *str;
97 enclosurePtr enclosure;
98
99 gtk_tree_model_get (GTK_TREE_MODEL (elv->priv->treestore), iter, ES_SERIALIZED, &str, -1);
100 enclosure = enclosure_from_string (str);
101 g_free (str);
102
103 return enclosure;
104 }
105
106 static gboolean
on_enclosure_list_button_press(GtkWidget * treeview,GdkEventButton * event,gpointer user_data)107 on_enclosure_list_button_press (GtkWidget *treeview, GdkEventButton *event, gpointer user_data)
108 {
109 GdkEventButton *eb = (GdkEventButton *)event;
110 GtkTreePath *path;
111 GtkTreeIter iter;
112 EnclosureListView *elv = (EnclosureListView *)user_data;
113
114 if ((event->type != GDK_BUTTON_PRESS) || (3 != eb->button))
115 return FALSE;
116
117 /* avoid handling header clicks */
118 if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (treeview)))
119 return FALSE;
120
121 if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (treeview), (gint)event->x, (gint)event->y, &path, NULL, NULL, NULL))
122 return FALSE;
123
124 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (elv->priv->treestore), &iter, path))
125 ui_popup_enclosure_menu (enclosure_list_view_get_selected_enclosure (elv, &iter), eb->button, eb->time);
126
127 return TRUE;
128 }
129
130 static gboolean
on_enclosure_list_popup_menu(GtkWidget * widget,gpointer user_data)131 on_enclosure_list_popup_menu (GtkWidget *widget, gpointer user_data)
132 {
133 GtkTreeView *treeview = GTK_TREE_VIEW (widget);
134 GtkTreeModel *model;
135 GtkTreeIter iter;
136 EnclosureListView *elv = (EnclosureListView *)user_data;
137
138 if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (treeview), &model, &iter)) {
139 ui_popup_enclosure_menu (enclosure_list_view_get_selected_enclosure (elv, &iter), 3, 0);
140 return TRUE;
141 }
142
143 return FALSE;
144 }
145
146 static gboolean
on_enclosure_list_activate(GtkTreeView * treeview,GtkTreePath * path,GtkTreeViewColumn * column,gpointer user_data)147 on_enclosure_list_activate (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
148 {
149 GtkTreeIter iter;
150 GtkTreeModel *model;
151 EnclosureListView *elv = (EnclosureListView *)user_data;
152
153 if (gtk_tree_selection_get_selected (gtk_tree_view_get_selection (treeview), &model, &iter)) {
154 on_popup_open_enclosure (enclosure_list_view_get_selected_enclosure (elv, &iter));
155 return TRUE;
156 }
157
158 return FALSE;
159 }
160
161 EnclosureListView *
enclosure_list_view_new()162 enclosure_list_view_new ()
163 {
164 EnclosureListView *elv;
165 GtkCellRenderer *renderer;
166 GtkTreeViewColumn *column;
167 GtkWidget *widget;
168
169 elv = ENCLOSURE_LIST_VIEW (g_object_new (ENCLOSURE_LIST_VIEW_TYPE, NULL));
170
171 /* Use a vbox to allow media player insertion */
172 elv->priv->container = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
173 gtk_widget_set_name (GTK_WIDGET (elv->priv->container), "enclosureview");
174
175 elv->priv->expander = gtk_expander_new (_("Attachments"));
176 gtk_box_pack_end (GTK_BOX (elv->priv->container), elv->priv->expander, TRUE, TRUE, 0);
177
178 widget = gtk_scrolled_window_new (NULL, NULL);
179 /* FIXME: Setting a fixed size is not nice, but a workaround for the
180 enclosure list view being hidden as 1px size in Ubuntu */
181 gtk_widget_set_size_request (widget, -1, 75);
182 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
183 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
184 gtk_container_add (GTK_CONTAINER (elv->priv->expander), widget);
185
186 elv->priv->treeview = gtk_tree_view_new ();
187 gtk_container_add (GTK_CONTAINER (widget), elv->priv->treeview);
188 gtk_widget_show (elv->priv->treeview);
189
190 elv->priv->treestore = gtk_tree_store_new (ES_LEN,
191 G_TYPE_STRING, /* ES_NAME_STR */
192 G_TYPE_STRING, /* ES_MIME_STR */
193 G_TYPE_BOOLEAN, /* ES_DOWNLOADED */
194 G_TYPE_ULONG, /* ES_SIZE */
195 G_TYPE_STRING, /* ES_SIZE_STRING */
196 G_TYPE_STRING /* ES_SERIALIZED */
197 );
198 gtk_tree_view_set_model (GTK_TREE_VIEW (elv->priv->treeview), GTK_TREE_MODEL(elv->priv->treestore));
199
200 /* explicitely no translation for invisible column headers... */
201
202 renderer = gtk_cell_renderer_text_new ();
203 column = gtk_tree_view_column_new_with_attributes ("Size", renderer,
204 "text", ES_SIZE_STR,
205 NULL);
206 gtk_tree_view_append_column (GTK_TREE_VIEW (elv->priv->treeview), column);
207
208 renderer = gtk_cell_renderer_text_new ();
209 column = gtk_tree_view_column_new_with_attributes ("URL", renderer,
210 "text", ES_NAME_STR,
211 NULL);
212 gtk_tree_view_append_column (GTK_TREE_VIEW (elv->priv->treeview), column);
213 gtk_tree_view_column_set_sort_column_id (column, ES_NAME_STR);
214 gtk_tree_view_column_set_expand (column, TRUE);
215 g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
216
217 renderer = gtk_cell_renderer_text_new ();
218 column = gtk_tree_view_column_new_with_attributes ("MIME", renderer,
219 "text", ES_MIME_STR,
220 NULL);
221 gtk_tree_view_append_column (GTK_TREE_VIEW (elv->priv->treeview), column);
222
223 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (elv->priv->treeview), FALSE);
224
225 g_signal_connect (G_OBJECT (elv->priv->treeview), "button_press_event", G_CALLBACK (on_enclosure_list_button_press), (gpointer)elv);
226 g_signal_connect (G_OBJECT (elv->priv->treeview), "row-activated", G_CALLBACK (on_enclosure_list_activate), (gpointer)elv);
227 g_signal_connect (G_OBJECT (elv->priv->treeview), "popup_menu", G_CALLBACK (on_enclosure_list_popup_menu), (gpointer)elv);
228
229 g_signal_connect_object (elv->priv->container, "destroy", G_CALLBACK (enclosure_list_view_destroy_cb), elv, 0);
230
231 return elv;
232 }
233
234 GtkWidget *
enclosure_list_view_get_widget(EnclosureListView * elv)235 enclosure_list_view_get_widget (EnclosureListView *elv)
236 {
237 return elv->priv->container;
238 }
239
240 void
enclosure_list_view_load(EnclosureListView * elv,itemPtr item)241 enclosure_list_view_load (EnclosureListView *elv, itemPtr item)
242 {
243 GSList *list, *filteredList;
244 guint len;
245
246 /* Ugly workaround to prevent race on startup when item is selected
247 but enclosure list view not yet initialized. */
248 if (!elv)
249 return;
250
251 /* cleanup old content */
252 gtk_tree_store_clear (elv->priv->treestore);
253 list = elv->priv->enclosures;
254 while (list) {
255 enclosure_free ((enclosurePtr)list->data);
256 list = g_slist_next (list);
257 }
258 g_slist_free (elv->priv->enclosures);
259 elv->priv->enclosures = NULL;
260
261 /* load list into tree view */
262 filteredList = NULL;
263 list = metadata_list_get_values (item->metadata, "enclosure");
264 while (list) {
265 enclosurePtr enclosure = enclosure_from_string (list->data);
266 if (enclosure) {
267 GtkTreeIter iter;
268 gchar *sizeStr;
269 guint size = enclosure->size;
270
271 /* The following literals are the enclosure list size units */
272 gchar *unit = _(" Bytes");
273 if (size > 1024) {
274 size /= 1024;
275 unit = _("kB");
276 }
277 if (size > 1024) {
278 size /= 1024;
279 unit = _("MB");
280 }
281 if (size > 1024) {
282 size /= 1024;
283 unit = _("GB");
284 }
285 /* The following literal is the format string for enclosure sizes (number + unit string) */
286 if (size > 0)
287 sizeStr = g_strdup_printf (_("%d%s"), size, unit);
288 else
289 sizeStr = g_strdup ("");
290
291 gtk_tree_store_append (elv->priv->treestore, &iter, NULL);
292 gtk_tree_store_set (elv->priv->treestore, &iter,
293 ES_NAME_STR, enclosure->url,
294 ES_MIME_STR, enclosure->mime?enclosure->mime:"",
295 ES_DOWNLOADED, enclosure->downloaded,
296 ES_SIZE, enclosure->size,
297 ES_SIZE_STR, sizeStr,
298 ES_SERIALIZED, list->data,
299 -1);
300 g_free (sizeStr);
301
302 elv->priv->enclosures = g_slist_append (elv->priv->enclosures, enclosure);
303
304 // Filter unwanted MIME types (we only want audio/* and video/*)
305 if (enclosure->mime &&
306 (g_str_has_prefix (enclosure->mime, "video/") ||
307 (g_str_has_prefix (enclosure->mime, "audio/")))) {
308 filteredList = g_slist_append (filteredList, list->data);
309 }
310 }
311
312 list = g_slist_next (list);
313 }
314
315 /* decide visibility of the list */
316 len = g_slist_length (elv->priv->enclosures);
317 if (len == 0) {
318 enclosure_list_view_hide (elv);
319 return;
320 }
321
322 gtk_widget_show_all (elv->priv->container);
323
324 /* update list title */
325 gchar *text = g_strdup_printf (ngettext("%d attachment", "%d attachments", len), len);
326 gtk_expander_set_label (GTK_EXPANDER (elv->priv->expander), text);
327 g_free (text);
328
329 /* Load the optional media player plugin */
330 if (g_slist_length (filteredList) > 0) {
331 liferea_media_player_load (elv->priv->container, filteredList);
332 }
333 }
334
335 void
enclosure_list_view_select(EnclosureListView * elv,guint position)336 enclosure_list_view_select (EnclosureListView *elv, guint position)
337 {
338 GtkTreeIter iter;
339
340 if (!gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (elv->priv->treestore), &iter, NULL, position))
341 return;
342
343 gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (elv->priv->treeview)), &iter);
344 }
345
346 void
enclosure_list_view_hide(EnclosureListView * elv)347 enclosure_list_view_hide (EnclosureListView *elv)
348 {
349 if (!elv)
350 return;
351
352 gtk_widget_hide (GTK_WIDGET (elv->priv->container));
353 }
354
355 /* callback for preferences and enclosure type handling */
356
357 static void
on_selectcmdok_clicked(const gchar * filename,gpointer user_data)358 on_selectcmdok_clicked (const gchar *filename, gpointer user_data)
359 {
360 GtkWidget *dialog = (GtkWidget *)user_data;
361 gchar *utfname;
362
363 if (!filename)
364 return;
365
366 utfname = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL);
367 if (utfname) {
368 gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (dialog, "enc_cmd_entry")), utfname);
369 g_free (utfname);
370 }
371 }
372
373 static void
on_selectcmd_pressed(GtkButton * button,gpointer user_data)374 on_selectcmd_pressed (GtkButton *button, gpointer user_data)
375 {
376 GtkWidget *dialog = (GtkWidget *)user_data;
377 const gchar *utfname;
378 gchar *name;
379
380 utfname = gtk_entry_get_text (GTK_ENTRY (liferea_dialog_lookup (dialog,"enc_cmd_entry")));
381 name = g_filename_from_utf8 (utfname, -1, NULL, NULL, NULL);
382 if (name) {
383 ui_choose_file (_("Choose File"), "gtk-open", FALSE, on_selectcmdok_clicked, name, NULL, NULL, NULL, dialog);
384 g_free (name);
385 }
386 }
387
388 /* dialog used for both changing and adding new definitions */
389 static void
on_adddialog_response(GtkDialog * dialog,gint response_id,gpointer user_data)390 on_adddialog_response (GtkDialog *dialog, gint response_id, gpointer user_data)
391 {
392 gchar *typestr;
393 gboolean new = FALSE;
394 enclosurePtr enclosure;
395 encTypePtr etp;
396
397 if (response_id == GTK_RESPONSE_OK) {
398 etp = g_object_get_data (G_OBJECT (dialog), "type");
399 typestr = g_object_get_data (G_OBJECT (dialog), "typestr");
400 enclosure = g_object_get_data (G_OBJECT (dialog), "enclosure");
401
402 if (!etp) {
403 new = TRUE;
404 etp = g_new0 (struct encType, 1);
405 if (!strchr (typestr, '/'))
406 etp->extension = g_strdup (typestr);
407 else
408 etp->mime = g_strdup (typestr);
409 } else {
410 g_free (etp->cmd);
411 }
412 etp->cmd = g_strdup (gtk_entry_get_text (GTK_ENTRY (liferea_dialog_lookup (GTK_WIDGET (dialog), "enc_cmd_entry"))));
413 etp->permanent = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "enc_always_btn")));
414 if (new)
415 enclosure_mime_type_add (etp);
416 else
417 enclosure_mime_types_save ();
418
419 /* now we have ensured an existing type configuration and
420 can launch the URL for which we configured the type */
421 if (enclosure)
422 on_popup_open_enclosure (enclosure);
423
424 g_free (typestr);
425 }
426 gtk_widget_destroy (GTK_WIDGET (dialog));
427 }
428
429 /* either type or url and typestr are optional */
430 static void
ui_enclosure_type_setup(encTypePtr type,enclosurePtr enclosure,gchar * typestr)431 ui_enclosure_type_setup (encTypePtr type, enclosurePtr enclosure, gchar *typestr)
432 {
433 GtkWidget *dialog;
434 gchar *tmp;
435
436 dialog = liferea_dialog_new ("enclosure_handler");
437 if (type) {
438 typestr = type->mime?type->mime:type->extension;
439 gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (dialog, "enc_cmd_entry")), type->cmd);
440 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (dialog, "enc_always_btn")), TRUE);
441 }
442
443 if (!strchr(typestr, '/'))
444 tmp = g_strdup_printf (_("File Extension .%s"), typestr);
445 else
446 tmp = g_strdup_printf ("%s", typestr);
447 gtk_label_set_text (GTK_LABEL (liferea_dialog_lookup (dialog, "enc_type_label")), tmp);
448 g_free (tmp);
449
450 g_object_set_data (G_OBJECT(dialog), "typestr", g_strdup (typestr));
451 g_object_set_data (G_OBJECT(dialog), "enclosure", enclosure);
452 g_object_set_data (G_OBJECT(dialog), "type", type);
453 g_signal_connect (G_OBJECT(dialog), "response", G_CALLBACK(on_adddialog_response), type);
454 g_signal_connect (G_OBJECT(liferea_dialog_lookup(dialog, "enc_cmd_select_btn")), "clicked", G_CALLBACK(on_selectcmd_pressed), dialog);
455 gtk_widget_show (dialog);
456
457 }
458
459 void
on_popup_open_enclosure(gpointer callback_data)460 on_popup_open_enclosure (gpointer callback_data)
461 {
462 gchar *typestr, *tmp = NULL;
463 enclosurePtr enclosure = (enclosurePtr)callback_data;
464 encTypePtr etp_tmp = NULL, etp_found = NULL;
465 GSList *iter;
466
467 /* 1.) Always try to determine the file extension... */
468
469 /* find extension by looking for last '.' */
470 typestr = strrchr (enclosure->url, '.');
471 if (typestr)
472 typestr = tmp = g_strdup (typestr + 1);
473
474 /* handle case where there is a slash after the '.' */
475 if (typestr && strrchr (typestr, '/'))
476 typestr = strrchr (typestr, '/');
477
478 /* handle case where there is no '.' at all */
479 if (!typestr && strrchr (enclosure->url, '/'))
480 typestr = strrchr (enclosure->url, '/');
481
482 /* if we found no extension we map to dummy type "data" */
483 if (!typestr)
484 typestr = tmp = g_strdup ("data");
485
486 /* strip GET parameters from typestr */
487 g_strdelimit (typestr, "?", 0);
488
489 debug2 (DEBUG_CACHE, "url:%s, mime:%s", enclosure->url, enclosure->mime);
490
491 /* 2.) Search for type configuration based on MIME or file extension... */
492 iter = (GSList *)enclosure_mime_types_get ();
493 while (iter) {
494 etp_tmp = (encTypePtr)(iter->data);
495 if (enclosure->mime && etp_tmp->mime) {
496 /* match know MIME types and stop looking if found */
497 if (!strcmp(enclosure->mime, etp_tmp->mime)) {
498 etp_found = etp_tmp;
499 break;
500 }
501 } else if (etp_tmp->extension) {
502 /* match known file extensions and keep looking for matching MIME type */
503 if (!strcmp(typestr, etp_tmp->extension)) {
504 etp_found = etp_tmp;
505 }
506 }
507 iter = g_slist_next (iter);
508 }
509
510 if (etp_found) {
511 enclosure_download (etp_found, enclosure->url, TRUE);
512 } else {
513 if (enclosure->mime)
514 ui_enclosure_type_setup (NULL, enclosure, enclosure->mime);
515 else
516 ui_enclosure_type_setup (NULL, enclosure, typestr);
517 }
518
519 g_free (tmp);
520 }
521
522 void
on_popup_save_enclosure(gpointer callback_data)523 on_popup_save_enclosure (gpointer callback_data)
524 {
525 enclosurePtr enclosure = (enclosurePtr)callback_data;
526
527 enclosure_download (NULL, enclosure->url, TRUE);
528 }
529
530 void
ui_enclosure_change_type(encTypePtr type)531 ui_enclosure_change_type (encTypePtr type)
532 {
533 ui_enclosure_type_setup (type, NULL, NULL);
534 }
535
536 void
on_popup_copy_enclosure(gpointer callback_data)537 on_popup_copy_enclosure (gpointer callback_data)
538 {
539 enclosurePtr enclosure = (enclosurePtr)callback_data;
540
541 gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_PRIMARY), enclosure->url, -1);
542 gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), enclosure->url, -1);
543 }
544