Update of /cvsroot/gtkpod/gtkpod/src
In directory sc8-pr-cvs2.sourceforge.net:/tmp/cvs-serv19510/src

Modified Files:
      Tag: fetchcover_development_branch
        display_coverart.c details.c details.h display_coverart.h 
        Makefile.am 
Added Files:
      Tag: fetchcover_development_branch
        fetchcover.h fetchcover.c 
Log Message:
- fetchcover.c and fetchcover.h included in development branch src and 
Makefile.am
- files modified to allow compilation:
        details.c
        details.h
        display_coverart.c
        display_coverart.h
- gtkpod.glade modified to display new button and window

--- NEW FILE: fetchcover.h ---
#ifndef __FETCHCOVER_H__
#define __FETCHCOVER_H__

#include <string.h>
#include <gtk/gtk.h>
#include <libgnomecanvas/libgnomecanvas.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include "display.h"
#include "display_private.h"
#include "details.h"
#include "itdb.h"
#include "display_coverart.h"
#include "prefs.h"


void fetchcover_start (Track *track);
void on_fetchcover_fetch_button (GtkWidget *widget, gpointer data);

#endif

--- NEW FILE: fetchcover.c ---
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "fetchcover.h"
#include "display_coverart.h"

#define FETCHCOVER_DEBUG 1

#ifdef HAVE_CURL
#include <curl/curl.h>

/* Declarations */
static void fetchcover_debug(const gchar *format, ...);
static void fetchcover_addurl(GString* url);
static void fetchcover_freeurls();
static void *safe_realloc(void *ptr, size_t size);
static size_t fetchcover_curl_write_func(void *ptr, size_t itemsize, size_t 
numitems, void *data);
static void fetchcover_next(gboolean new_album);
static void fetchcover_next_button(GtkWidget *widget, gpointer data);
static void fetchcover_cleanup();
static void fetchcover_cancel_button(GtkWidget *widget, gpointer data);
static void fetchcover_save_button(GtkWidget *widget, gpointer data);

struct chunk
{
        gchar *memory;
        size_t size;
};

#define FETCHCOVER_MAXURL 16

static GString *fetchcover_urls[FETCHCOVER_MAXURL] = { NULL };
static gint fetchcover_url = 0;

static void fetchcover_addurl(GString* url)
{
        fetchcover_debug("fetchcover_addurl: adding %s", url->str);
        gint i;
        for (i = 0; i < FETCHCOVER_MAXURL; i++)
        {
                if (fetchcover_urls[i] == NULL)
                {
                        fetchcover_urls[i] = g_string_new(NULL);
                        g_string_assign(fetchcover_urls[i], url->str);
                        break;
                }
        }
}

static void fetchcover_freeurls()
{
        fetchcover_debug("fetchcover_freeurls");
        gint i;
        for (i = 0; i < FETCHCOVER_MAXURL; i++)
        {
                if (fetchcover_urls[i] != NULL)
                {
                        g_string_free(fetchcover_urls[i], TRUE);
                        fetchcover_urls[i] = NULL;
                }
        }
}

static Track *fetchcover_track = NULL;
struct chunk fetchcover_curl_data;
static gchar *fetchcover_imgpath = NULL;

#define IMGSCALE 256
GnomeCanvas *fetchcover_canvas;
GnomeCanvasItem *fetchcover_canvasitem;
GdkPixbuf *fetchcover_coverimg;

static void *safe_realloc(void *ptr, size_t size)
{
        if (ptr)
                return realloc(ptr, size);
        else
                return malloc(size);
}

static size_t fetchcover_curl_write_func(void *ptr, size_t itemsize, size_t 
numitems, void *data)
{
        size_t size = itemsize * numitems;
        struct chunk *mem = (struct chunk*)data;
        mem->memory = (gchar*)safe_realloc(mem->memory, mem->size + size + 1);
        
        if (mem->memory)
        {
                memcpy(&(mem->memory[mem->size]), ptr, size);
                mem->size += size;
                mem->memory[mem->size] = 0;
        }
        return size;
}

/**
 * fetchcover_next:
 *
 * @new_album: need to get new url list?
 *
 * Gets new image URL list if necessary,
 * downloads next image to memory,
 * shows it in a GnomeCanvas in the fetchcover_window.
 */
static void fetchcover_next(gboolean new_album)
{
        fetchcover_debug("fetchcover_next: getting cover for:\n- Artist: %s\n- 
Album:  %s",
                                                                                
                                                                        
fetchcover_track->artist, fetchcover_track->album);
        
        if (fetchcover_imgpath)
        {
                remove(fetchcover_imgpath);
                g_free(fetchcover_imgpath);
                fetchcover_imgpath = NULL;
        }
        
        if (new_album)
        {
                /* This key for Amazon web services belongs to Charlie Head */
                const gchar amazonkey[21] = "10K4YZTZFS562NG7EZR2";
                
                /* possible internationalization: support
                 * different tld's (ja, fr, ca, etc.) - Amarok does this.
                 * we assume a lot here.. may not work
                 * for some international artists? --chead
                 */
                GString *url = g_string_new(NULL);
                g_string_printf(url,
                        
"http://xml.amazon.com/onca/xml3?t=webservices-20&dev-t=%s&KeywordSearch=%s+%s&mode=music&type=lite&locale=us&page=1&f=xml";,
                        amazonkey, fetchcover_track->artist, 
fetchcover_track->album);
                        
                gint i; for (i = 0; i < url->len; i++)
                {
                        if (url->str[i] == ' ')
                                url->str[i] = '+';
                }
                
                fetchcover_debug("fetchcover_next: amazon xml url: %s", 
url->str);
                
                fetchcover_curl_data.memory = NULL;
                fetchcover_curl_data.size = 0;
                
                CURL *curl;
                curl_global_init(CURL_GLOBAL_ALL);
                curl = curl_easy_init();
                curl_easy_setopt(curl, CURLOPT_URL, url->str);
                curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, 
fetchcover_curl_write_func);
                curl_easy_setopt(curl, CURLOPT_WRITEDATA, 
(void*)&fetchcover_curl_data);
                curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
                curl_easy_perform(curl);
                curl_easy_cleanup(curl);
                g_string_free(url, TRUE);
                
                if (!fetchcover_curl_data.memory || fetchcover_curl_data.size 
<= 0)
                {
                        printf("fetchcover_next: curl fetch failed\n");
                        if (fetchcover_curl_data.memory)
                        {
                                g_free(fetchcover_curl_data.memory);
                                fetchcover_curl_data.memory = NULL;
                                fetchcover_curl_data.size = 0;
                        }
                        return;
                }
                
                xmlDocPtr doc;
                xmlNodePtr cur;
                xmlChar *key;
                
                if ((doc = xmlReadMemory(fetchcover_curl_data.memory, 
fetchcover_curl_data.size, "amazon.xml", NULL, 0)) == NULL)
                {
                        printf("fetchcover_next: amazon xml parse failed\n");
                        if (fetchcover_curl_data.memory)
                        {
                                g_free(fetchcover_curl_data.memory);
                                fetchcover_curl_data.memory = NULL;
                                fetchcover_curl_data.size = 0;
                        }
                        return;
                }
                if ((cur = xmlDocGetRootElement(doc)) == NULL)
                {
                        printf("fetchcover_next: amazon xml is empty\n");
                        xmlFreeDoc(doc);
                        if (fetchcover_curl_data.memory)
                        {
                                g_free(fetchcover_curl_data.memory);
                                fetchcover_curl_data.memory = NULL;
                                fetchcover_curl_data.size = 0;
                        }
                        return;
                }
                
                cur = cur->xmlChildrenNode;
                while (cur != NULL)
                {
                        if ((!xmlStrcmp(cur->name, (const xmlChar*)"Details")))
                        {
                                xmlNodePtr details = cur->xmlChildrenNode;
                                while (details != NULL)
                                {
                                        if ((!xmlStrcmp(details->name, (const 
xmlChar*)"ImageUrlLarge")))
                                        {
                                                key = xmlNodeListGetString(doc, 
details->xmlChildrenNode, 1);
                                                GString *imgurl = 
g_string_new((gchar*)key);
                                                fetchcover_addurl(imgurl);
                                                g_string_free(imgurl, TRUE);
                                                xmlFree(key);
                                        }
                                        details = details->next;
                                }
                        }
                        cur = cur->next;
                }
                
                xmlFreeDoc(doc);
                
                if (fetchcover_urls[0] == NULL)
                {
                        fetchcover_debug("fetchcover_next: no covers found\n");
                        printf("fetchcover failed to find any covers\n");       
                        gtkpod_warning(_("No cover images were found for this 
album."));
                        if (fetchcover_curl_data.memory)
                        {
                                g_free(fetchcover_curl_data.memory);
                                fetchcover_curl_data.memory = NULL;
                                fetchcover_curl_data.size = 0;
                        }
                        return;
                }
                
                if (fetchcover_curl_data.memory)
                {
                        g_free(fetchcover_curl_data.memory);
                        fetchcover_curl_data.memory = NULL;
                        fetchcover_curl_data.size = 0;
                }
                
                fetchcover_url = -1;
        }
        
        fetchcover_url++;
        if (fetchcover_url >= FETCHCOVER_MAXURL)
                fetchcover_url = 0;
        if (fetchcover_urls[fetchcover_url] == NULL)
                fetchcover_url = 0;
        
        fetchcover_debug("fetchcover_next: img %d", fetchcover_url);
        
        fetchcover_curl_data.size = 0;
        
        CURL *curl;
        curl_global_init(CURL_GLOBAL_ALL);
        curl = curl_easy_init();
        curl_easy_setopt(curl, CURLOPT_URL, 
fetchcover_urls[fetchcover_url]->str);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, 
fetchcover_curl_write_func);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&fetchcover_curl_data);
        curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl-agent/1.0");
        curl_easy_perform(curl);
        curl_easy_cleanup(curl);
        
        g_return_if_fail(fetchcover_curl_data.memory);
        
        if (strstr(fetchcover_curl_data.memory, "<html>") != NULL)
        {
                printf("fetchcover_next: http error (probably 404 or server 
error\n");
                return;
        }
        
        FILE *tmpf = NULL;
        ExtraTrackData *etd = fetchcover_track->userdata;
        g_return_if_fail(etd);
        
        gchar *dir = g_path_get_dirname(etd->pc_path_utf8);
        gchar *template = prefs_get_string("coverart_template");
        gchar **template_items = g_strsplit(template, ";", 0);
        
        gchar *filename = get_string_from_template(fetchcover_track, 
*template_items, FALSE);
        
        gchar *path = NULL;
        if (strstr(*template_items, ".jpg") != NULL)
                path = g_build_filename(dir, filename, NULL);
        else
                path = g_build_filename(dir, g_strconcat(filename, ".jpg", 
NULL), NULL);
        fetchcover_imgpath = path;
                
        fetchcover_debug("fetchcover_next: saving cover image to %s", path);
        
        if ((tmpf = fopen(path, "wb")) == NULL)
        {
                printf("fetchcover_next: fopen failed\n");
                if (fetchcover_curl_data.memory)
                {
                        g_free(fetchcover_curl_data.memory);
                        fetchcover_curl_data.memory = NULL;
                        fetchcover_curl_data.size = 0;
                }
        }
        
        if (fwrite(fetchcover_curl_data.memory, fetchcover_curl_data.size, 1, 
tmpf) != 1)
        {
                printf("fetchcover_next: fwrite failed\n");
                if (fetchcover_curl_data.memory)
                {
                        g_free(fetchcover_curl_data.memory);
                        fetchcover_curl_data.memory = NULL;
                        fetchcover_curl_data.size = 0;
                }
        }
        
        fclose(tmpf);
        
        GError *error = NULL;
        fetchcover_coverimg = gdk_pixbuf_new_from_file(path, &error);
        if (error != NULL)
        {
                printf("fetchcover_next: gdk_pixbuf_new_from_file failed\n");
                if (fetchcover_curl_data.memory)
                {
                        g_free(fetchcover_curl_data.memory);
                        fetchcover_curl_data.memory = NULL;
                        fetchcover_curl_data.size = 0;
                }
        }
        
        GdkPixbuf *scaled = gdk_pixbuf_scale_simple(fetchcover_coverimg, 
IMGSCALE, IMGSCALE, GDK_INTERP_NEAREST);
        gnome_canvas_item_set(fetchcover_canvasitem, "pixbuf", scaled);
        
        /*remove(path);*/
        g_free(fetchcover_curl_data.memory);
        fetchcover_curl_data.memory = NULL;
        fetchcover_curl_data.size = 0;
        g_strfreev(template_items);
        g_free(template);
        g_free(filename);
        /*g_free(path);*/
}

/**
 * fetchcover_next_button:
 *
 * @widget: widget
 * @data: data
 *
 * Callback. Create new thread for fetchcover_next.
 */
static void fetchcover_next_button(GtkWidget *widget, gpointer data)
{
        GThread *next = NULL;
        next = g_thread_create((GThreadFunc)fetchcover_next, (gboolean*)FALSE, 
FALSE, NULL);
        
        if (!next)
        {
                printf("fetchcover_next_button: thread creation failed\n");
                return;
        }
}
/**
 * fetchcover_cleanup:
 *
 * Scrub-a-dub-dub.
 */
static void fetchcover_cleanup()
{
        fetchcover_freeurls();
        if (fetchcover_imgpath)
        {
                remove (fetchcover_imgpath);
                g_free (fetchcover_imgpath);
                fetchcover_imgpath = NULL;
        }
        if (fetchcover_curl_data.memory)
        {
                g_free (fetchcover_curl_data.memory);
                fetchcover_curl_data.memory = NULL;
                fetchcover_curl_data.size = 0;
        }
}

/**
 * fetchcover_cancel_button:
 *
 * @widget: widget
 * @data: data
 *
 * Callback. Destroy window, clean up.
 * Called when "Cancel" clicked from fetchcover_window.
 */
static void fetchcover_cancel_button(GtkWidget *widget, gpointer data)
{
        fetchcover_cleanup();
        gtk_widget_destroy(gtk_widget_get_toplevel(widget));
}

/**
 * fetchcover_save_button:
 * @widget: widget
 * @data: data
 *
 * Callback. Destroy window, clean up. Leave cover image
 * where it is on disk. Set thumbnails, update details window.
 * Called when "Save Cover" clicked from fetchcover_window.
 */
static void fetchcover_save_button(GtkWidget *widget, gpointer data)
{
        Detail *detail = details_get_selected_detail ();
        
        if (fetchcover_imgpath)
        {
                if (details_writethrough(detail))
                {
                        GList *list;
                        for (list = detail->tracks; list; list = list->next)
                        {
                                ExtraTrackData *etd;
                                Track *track = list->data;
                                
                                if (!track)
                                        break;
                                
                                etd = track->userdata;
                                gp_track_set_thumbnails(track, 
fetchcover_imgpath);
                                etd->tchanged = TRUE;
                        }
                }
                else
                {
                        ExtraTrackData *etd = fetchcover_track->userdata;
                        if (etd)
                        {
                                gp_track_set_thumbnails(fetchcover_track, 
fetchcover_imgpath);
                                etd->tchanged = TRUE;
                        }
                }
                
                detail->changed = TRUE;
                details_update_thumbnail(detail);
                details_update_buttons(detail);
        }
        
        fetchcover_cleanup();
        gtk_widget_destroy(gtk_widget_get_toplevel(widget));
}

#endif /* HAVE_CURL */

/**
 * fetchcover_start:
 *
 * Create fetchcover_window, get album cover from Amazon
 *
 * @track: track to look up images for
 */
void fetchcover_start(Track *track)
{
#ifdef HAVE_CURL
        GtkWidget *fetchcover_window;
        GtkWidget *cancel_button;
        GtkWidget *save_button;
        GtkWidget *next_button;
        GtkWidget *vbox;
        GladeXML *fetchcover_xml;
        GThread *next = NULL;
        GError *error = NULL;
        gchar *default_file_path;
        
        g_return_if_fail(track);
        
        fetchcover_xml = glade_xml_new(xml_file, "fetchcover_window", NULL);
        
        fetchcover_window       = gtkpod_xml_get_widget(fetchcover_xml, 
"fetchcover_window");
        cancel_button   = gtkpod_xml_get_widget(fetchcover_xml, 
"fetchcover_cancel_button");
        save_button = gtkpod_xml_get_widget(fetchcover_xml, 
"fetchcover_save_button");
        next_button = gtkpod_xml_get_widget(fetchcover_xml, 
"fetchcover_next_button");
        vbox = gtkpod_xml_get_widget(fetchcover_xml, "fetchcover_vbox");
                
        g_return_if_fail(fetchcover_window);
        g_return_if_fail(cancel_button);
        g_return_if_fail(save_button);
        g_return_if_fail(next_button);
        g_return_if_fail(vbox);

        g_object_unref (fetchcover_xml); 
        
        default_file_path = get_default_cover_file_path ();
        g_return_if_fail(default_file_path);
        
        fetchcover_coverimg = gdk_pixbuf_new_from_file(default_file_path, 
&error);
        if (error != NULL)
        {
                printf("fetchcover_start: error loading default cover image: %s 
(%d)\n", error->message, error->code);
                return;
        }
        fetchcover_debug("fetchcover_start: loaded default cover file %s", 
default_file_path);
        
        fetchcover_canvas = GNOME_CANVAS(gnome_canvas_new());
        gtk_widget_set_size_request(GTK_WIDGET(fetchcover_canvas), IMGSCALE, 
IMGSCALE);
        gnome_canvas_set_scroll_region(fetchcover_canvas, 0.0, 0.0, IMGSCALE, 
IMGSCALE);
        fetchcover_canvasitem = 
gnome_canvas_item_new(gnome_canvas_root(fetchcover_canvas),
                GNOME_TYPE_CANVAS_PIXBUF, NULL);
        gnome_canvas_item_set(fetchcover_canvasitem, "pixbuf", 
fetchcover_coverimg);
        
        gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(fetchcover_canvas), TRUE, 
TRUE, 0);
        gtk_widget_show(GTK_WIDGET(fetchcover_canvas));
        
        g_signal_connect(next_button, "clicked", 
G_CALLBACK(fetchcover_next_button), NULL);
        g_signal_connect(cancel_button, "clicked", 
G_CALLBACK(fetchcover_cancel_button), NULL);
        g_signal_connect(save_button, "clicked", 
G_CALLBACK(fetchcover_save_button), NULL);
        
        fetchcover_freeurls();
        fetchcover_track = track;
        
        next = g_thread_create((GThreadFunc)fetchcover_next, (gboolean*)TRUE, 
FALSE, NULL);
        
        if (!next)
        {
                printf("fetchcover_start: thread creation failed\n");
                return;
        }
#endif /* HAVE_CURL */
}

/**
 * fetchcover_fetch_button:
 *
 * @widget: widget
 * @data: data
 *
 * Callback. Start cover selection.
 * Called when "Fetch Cover..." clicked from details_window.
 */
void on_fetchcover_fetch_button (GtkWidget *widget, gpointer data)
{
        printf ("YES I AM TRYING TO KICK OFF!!\n");
#ifdef HAVE_CURL
        Detail *detail = details_get_selected_detail ();
        Track *track = detail->track;
        fetchcover_start(track);
#endif /* HAVE_CURL */
}

static void fetchcover_debug(const gchar *format, ...)
{
        if (FETCHCOVER_DEBUG)
        {
                va_list args;
                va_start(args, format);
                gchar *s = g_strdup_vprintf(format, args);
                va_end(args);
                printf("%s\n", s);
                fflush(stdout);
                g_free(s);
        }
}

Index: display_coverart.c
===================================================================
RCS file: /cvsroot/gtkpod/gtkpod/src/display_coverart.c,v
retrieving revision 1.7
retrieving revision 1.7.2.1
diff -u -d -r1.7 -r1.7.2.1
--- display_coverart.c  27 Feb 2007 22:42:44 -0000      1.7
+++ display_coverart.c  12 Mar 2007 21:57:39 -0000      1.7.2.1
@@ -103,6 +103,18 @@
 #endif
 
 /**
+ * get_default_file_path:
+ *
+ * Uitlity method to allow other functions to access the path
+ * initilialised as DEFAULT_COVER_FILE
+ *
+ */
+ gchar *get_default_cover_file_path ()
+ {
+               return DEFAULT_FILE;
+ }
+
+/**
  * draw_blank_cdimage:
  *
  * creates a blank "black" pixbuf cd image to represent the

Index: details.c
===================================================================
RCS file: /cvsroot/gtkpod/gtkpod/src/details.c,v
retrieving revision 1.20
retrieving revision 1.20.2.1
diff -u -d -r1.20 -r1.20.2.1
--- details.c   27 Feb 2007 22:42:44 -0000      1.20
+++ details.c   12 Mar 2007 21:57:39 -0000      1.20.2.1
@@ -34,6 +34,7 @@
 #include "details.h"
 #include "fileselection.h"
 #include "misc.h"
+#include "fetchcover.h"
 #include "misc_track.h"
 #include "prefs.h"
 #include <string.h>
@@ -48,22 +49,6 @@
 /* List with all detail windows */
 static GList *details = NULL;
 
-struct _Detail
-{
-    GladeXML *xml;      /* XML info                           */
-    GtkWidget *window;  /* pointer to details window          */
-    iTunesDB *itdb;     /* pointer to the original itdb       */
-    GList *orig_tracks; /* tracks displayed in details window */
-    GList *tracks;      /* tracks displayed in details window */
-    Track *track;       /* currently displayed track          */
-    gboolean artwork_ok;/* artwork can be displayed or not    */
-    gboolean changed;   /* at lease one track was changed     */
-
-};
-
-typedef struct _Detail Detail;
-
-
 /* string constants for preferences */
 static const gchar *DETAILS_WINDOW_DEFX="details_window_defx";
 static const gchar *DETAILS_WINDOW_DEFY="details_window_defy";
@@ -71,8 +56,6 @@
 
 
 /* Declarations */
-static void details_update_buttons (Detail *detail);
-static void details_update_thumbnail (Detail *detail);
 static void details_set_track (Detail *detail, Track *track);
 static void details_free (Detail *detail);
 static void details_get_item (Detail *detail, T_item item,
@@ -105,7 +88,7 @@
 
 
 /* Query the state of the writethrough checkbox */
-static gboolean details_writethrough (Detail *detail)
+gboolean details_writethrough (Detail *detail)
 {
     GtkWidget *w;
 
@@ -1102,7 +1085,7 @@
 
 
 /* Render the Apply button insensitive as long as no changes were done */
-static void details_update_buttons (Detail *detail)
+void details_update_buttons (Detail *detail)
 {
     GtkWidget *w;
     gchar *buf;
@@ -1199,7 +1182,7 @@
 }
 
 /* Update the displayed thumbnail */
-static void details_update_thumbnail (Detail *detail)
+void details_update_thumbnail (Detail *detail)
 {
     Thumb *thumb;
     GtkImage *img;
@@ -1268,7 +1251,6 @@
     g_free (buf);
 }
 
-
 /* Set the display to @track */
 static void details_set_track (Detail *detail, Track *track)
 {
@@ -1464,6 +1446,11 @@
                      G_CALLBACK (details_button_set_artwork_clicked),
                      detail);
 
+               w = gtkpod_xml_get_widget (detail->xml, 
"details_button_fetch_cover");
+    g_signal_connect (w, "clicked",
+                       G_CALLBACK (on_fetchcover_fetch_button),
+          detail);
+               
     w = gtkpod_xml_get_widget (detail->xml, "details_button_remove_artwork");
     g_signal_connect (w, "clicked",
                      G_CALLBACK (details_button_remove_artwork_clicked),
@@ -1550,3 +1537,9 @@
        details_remove_track_intern (detail, track);
     }
 }
+
+/* Returns the detail struct currently selected in details */
+Detail *details_get_selected_detail ()
+{
+        return details->data;
+}
\ No newline at end of file

Index: details.h
===================================================================
RCS file: /cvsroot/gtkpod/gtkpod/src/details.h,v
retrieving revision 1.4
retrieving revision 1.4.4.1
diff -u -d -r1.4 -r1.4.4.1
--- details.h   9 Dec 2005 15:59:12 -0000       1.4
+++ details.h   12 Mar 2007 21:57:39 -0000      1.4.4.1
@@ -36,9 +36,29 @@
  
 #include <gtk/gtk.h>
 #include "itdb.h"
+#include <glade/glade.h>
+
+struct _Detail
+{
+    GladeXML *xml;      /* XML info                           */
+    GtkWidget *window;  /* pointer to details window          */
+    iTunesDB *itdb;     /* pointer to the original itdb       */
+    GList *orig_tracks; /* tracks displayed in details window */
+    GList *tracks;      /* tracks displayed in details window */
+    Track *track;       /* currently displayed track          */
+    gboolean artwork_ok;/* artwork can be displayed or not    */
+    gboolean changed;   /* at lease one track was changed     */
+
+};
+
+typedef struct _Detail Detail;
 
 /* details window */
 void details_edit (GList *selected_tracks);
 void details_update_default_sizes (void);
 void details_remove_track (Track *track);
+gboolean details_writethrough (Detail *detail);
+void details_update_thumbnail (Detail *detail);
+void details_update_buttons (Detail *detail);
+Detail *details_get_selected_detail ();
 #endif

Index: display_coverart.h
===================================================================
RCS file: /cvsroot/gtkpod/gtkpod/src/display_coverart.h,v
retrieving revision 1.4
retrieving revision 1.4.2.1
diff -u -d -r1.4 -r1.4.2.1
--- display_coverart.h  27 Feb 2007 22:42:44 -0000      1.4
+++ display_coverart.h  12 Mar 2007 21:57:39 -0000      1.4.2.1
@@ -41,6 +41,7 @@
 
 extern const gchar *DISPLAY_COVER_SHOW;
 
+gchar *get_default_cover_file_path ();
 void init_default_file (gchar *progpath);
 void coverart_sort_images (GtkSortType order);
 void coverart_select_cover (Itdb_Track *track);

Index: Makefile.am
===================================================================
RCS file: /cvsroot/gtkpod/gtkpod/src/Makefile.am,v
retrieving revision 1.62
retrieving revision 1.62.2.1
diff -u -d -r1.62 -r1.62.2.1
--- Makefile.am 20 Feb 2007 14:11:23 -0000      1.62
+++ Makefile.am 12 Mar 2007 21:57:39 -0000      1.62.2.1
@@ -38,6 +38,7 @@
     display.h display_private.h \
     display_itdb.c display_itdb.h \
     display_spl.c display_tracks.c \
+    fetchcover.c fetchcover.h \
     file.c file.h file_export.c \
     file_convert.c file_convert.h \
     file_itunesdb.c \


-------------------------------------------------------------------------
Take Surveys. Earn Cash. Influence the Future of IT
Join SourceForge.net's Techsay panel and you'll get the chance to share your
opinions on IT & business topics through brief surveys-and earn cash
http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
_______________________________________________
gtkpod-cvs2 mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/gtkpod-cvs2

Reply via email to