cover.c

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

display_zoomed_cover(GtkWidget *window, GtkWidget *event_area, gchar *song_filename) {

        GtkWidget * image_area;
        gint size;

        if (g_file_test (song_filename, G_FILE_TEST_IS_REGULAR) == TRUE) {

                size = cover_widths[options.cover_width];
                if (size == -1) {
                        size = cover_widths[options.cover_width-1];
                }

		cover_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
                g_signal_connect(G_OBJECT(cover_window), "button_press_event",
                                 G_CALLBACK(cover_window_close_cb), NULL);
                g_signal_connect(G_OBJECT(cover_window), "key_press_event",
                                 G_CALLBACK(cover_window_key_pressed), NULL);
                gtk_window_set_position(GTK_WINDOW(cover_window), GTK_WIN_POS_MOUSE);
	        gtk_widget_set_events(cover_window, GDK_BUTTON_PRESS_MASK);
               	gtk_window_set_modal(GTK_WINDOW(cover_window), TRUE);
        	gtk_window_set_transient_for(GTK_WINDOW(cover_window), GTK_WINDOW(window));
                gtk_window_set_decorated(GTK_WINDOW(cover_window), FALSE);

                image_area = gtk_image_new();
                gtk_widget_show(image_area);
                gtk_container_add (GTK_CONTAINER (cover_window), image_area);

                display_cover(image_area, event_area, size, size, song_filename, FALSE, FALSE);

                gtk_widget_set_size_request(cover_window, calculated_width, calculated_height);
                gtk_widget_show(cover_window);

        }
}


void 
display_cover(GtkWidget *image_area, GtkWidget *event_area, gint dest_width, gint dest_height, 
              gchar *song_filename, gboolean hide, gboolean bevel) {

        GdkPixbuf * cover_pixbuf;
        GdkPixbuf * cover_pixbuf_scaled;
        GdkPixbufFormat * format;
        gint width, height;
        gint scaled_width, scaled_height;
        gchar cover_filename[PATH_MAX];

        calculated_width = dest_width;
        calculated_height = dest_height;

        cover_pixbuf = NULL;

        if (strlen(song_filename)) {

                strcpy(cover_filename, find_cover_filename(song_filename));

                cover_pixbuf = gdk_pixbuf_new_from_file (cover_filename, NULL);

                if (cover_pixbuf != NULL) {

                        format = gdk_pixbuf_get_file_info(cover_filename, &width, &height);

                        /* don't scale when orginal size is smaller than cover defaults */

                        scaled_width =  dest_width;
                        scaled_height = dest_height;

                        if (width >= height) {

                                scaled_height = (height * (dest_height)) / width;

                        } else {

                                scaled_width = (width * (dest_width)) / height;
                        }

                        cover_pixbuf_scaled = gdk_pixbuf_scale_simple (cover_pixbuf, 
                                                                       scaled_width, scaled_height, 
                                                                       GDK_INTERP_TILES);
                        g_object_unref (cover_pixbuf);
                        cover_pixbuf = cover_pixbuf_scaled;

                        draw_cover_frame(cover_pixbuf, scaled_width, scaled_height, bevel);

                        calculated_width = scaled_width;
                        calculated_height = scaled_height;

                        gtk_image_set_from_pixbuf (GTK_IMAGE(image_area), cover_pixbuf);

                        if (!cover_show_flag && hide == TRUE) {
                                cover_show_flag = 1;      
                                gtk_widget_show(image_area);
                                gtk_widget_show(event_area);
                        }

                } else {
 
                        if (hide == TRUE) {
                                cover_show_flag = 0;      
                                gtk_widget_hide(image_area);
                                gtk_widget_hide(event_area);
                        }

                }

        }

}

void
insert_cover(GtkTextIter * iter) {

        GtkTreeModel * model;
        GtkTreeIter r_iter, t_iter;
        GtkTreePath * path;
        GtkTextBuffer * buffer;
        GdkPixbuf *pixbuf;
        GdkPixbuf *scaled;
        GdkPixbufFormat *format;
        gchar *song_filename;
        gchar cover_filename[PATH_MAX];
        gint k, i;
        gint width, height;
        gint d_cover_width, d_cover_height;
        gint scaled_width, scaled_height;

        buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(comment_view));

        /* get cover path */
        
        if (gtk_tree_selection_get_selected(music_select, &model, &r_iter)) {

                path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &r_iter);
                i = gtk_tree_path_get_depth(path);

                /* check if we at 3rd level (album) or 4th level (track) */

                if (i == 3 || i == 4) {

                        if (i == 3) { /* album selected */

                                if (gtk_tree_model_iter_nth_child(model, &t_iter, &r_iter, 0)) {
                                        gtk_tree_model_get(GTK_TREE_MODEL(model), &t_iter, 2, &song_filename, -1);
                                } else {
                                        return;
                                }

                        } else { /* track selected */
 
                                gtk_tree_model_get(GTK_TREE_MODEL(model), &r_iter, 2, &song_filename, -1);
 
                        }

                        strcpy(cover_filename, find_cover_filename(song_filename));
                        g_free (song_filename);

                        pixbuf = NULL;

                        /* load and display cover */

                        k = cover_widths[options.cover_width % N_COVER_WIDTHS];

                        if (k == -1) {

                                d_cover_width = d_cover_height = browser_size_x - SCROLLBAR_WIDTH;      

                        } else {

                                d_cover_width = d_cover_height = k;
                        }

                        pixbuf = gdk_pixbuf_new_from_file (cover_filename, NULL);

                        if (pixbuf != NULL) {

                                format = gdk_pixbuf_get_file_info(cover_filename, &width, &height);

                                /* don't scale when orginal size is smaller than cover defaults */

                                scaled_width =  d_cover_width;
                                scaled_height = d_cover_height;

                                if (width > d_cover_width || height > d_cover_height) {

                                        if (width >= height) {

                                                scaled_height = (height * d_cover_width) / width;

                                        } else {

                                                scaled_width = (width * d_cover_height) / height;

                                        }

                                        scaled = gdk_pixbuf_scale_simple (pixbuf, 
                                                                          scaled_width, scaled_height, 
                                                                          GDK_INTERP_TILES);
                                        g_object_unref (pixbuf);
                                        pixbuf = scaled;

                                } else {
                                        if (options.magnify_smaller_images) {

                                                scaled_height = (height * d_cover_width) / width;

                                                scaled = gdk_pixbuf_scale_simple (pixbuf, 
                                                                                  scaled_width, scaled_height, 
                                                                                  GDK_INTERP_TILES);
                                                g_object_unref (pixbuf);
                                                pixbuf = scaled;

                                        } else {

                                                scaled_width = width;
                                                scaled_height = height;
                                        }                               
                                }


                                draw_cover_frame(pixbuf, scaled_width, scaled_height, FALSE);

                                /* insert picture */

                                gtk_text_buffer_insert_pixbuf (buffer, iter, pixbuf);
                                gtk_text_buffer_insert (buffer, iter, "\n\n", -1);

                                g_object_unref (pixbuf);
                        }
                }

                gtk_tree_path_free(path);
        }
}

// vim: shiftwidth=8:tabstop=8:softtabstop=8 :