/*
 * meta.c - stuff to do with displaying meta data information in the UI.
 */


#include "lodju.h"


static GtkWidget *meta_filename;
static GtkWidget *meta_caption;
static GtkWidget *meta_private;
static GtkWidget *meta_public;
static GtkWidget *meta_drawingarea;
static GtkWidget *menu_item_0;
static GtkWidget *menu_item_90;
static GtkWidget *menu_item_180;
static GtkWidget *menu_item_270;
static GtkProgressBar *meta_progress_bar;


void meta_set_widgets(GladeXML *xml)
{
    meta_filename = glade_xml_get_widget(xml, "meta_filename");
    meta_caption = glade_xml_get_widget(xml, "meta_caption");
    meta_private = glade_xml_get_widget(xml, "meta_private");
    meta_public = glade_xml_get_widget(xml, "meta_public");
    meta_drawingarea = glade_xml_get_widget(xml, "meta_drawingarea");
    menu_item_0 = glade_xml_get_widget(xml, "0_degrees");
    menu_item_90 = glade_xml_get_widget(xml, "90_degrees");
    menu_item_180 = glade_xml_get_widget(xml, "180_degrees");
    menu_item_270 = glade_xml_get_widget(xml, "270_degrees");
    meta_progress_bar = 
    	GTK_PROGRESS_BAR(glade_xml_get_widget(xml, "meta_progress_bar"));
}


void on_meta_caption_changed(GtkEditable *editable, gpointer user_data)
{
    gchar *new_caption;

    new_caption = gtk_editable_get_chars(GTK_EDITABLE(meta_caption), 0, -1);
    image_list_set_attribute("caption", new_caption);
    g_free(new_caption);
}


/*
 * The stupid GtkEntry widget sends the "changed" signal even when it is
 * us using the gtk_entry_set_text function, instead of only sending it
 * when the user doing the change, like the docs say. As a workaround,
 * whenever we change the caption, we first disconnect the signal handler,
 * then re-connect it again.
 */
static void set_caption(const gchar *caption)
{
    gtk_signal_handler_block_by_func(GTK_OBJECT(meta_caption), 
				     on_meta_caption_changed,
				     NULL);
    gtk_entry_set_text(GTK_ENTRY(meta_caption), caption);
    gtk_signal_handler_unblock_by_func(GTK_OBJECT(meta_caption),
				       on_meta_caption_changed, 
				       NULL);
}

void on_meta_privacy_toggled(GtkToggleButton *button, gpointer user_data)
{
    const gchar *state;

    if (gtk_toggle_button_get_active(button)) {
	if (button == GTK_TOGGLE_BUTTON(meta_private))
    	    state = "private";
	else
    	    state = "public";
	image_list_set_attribute("privacy", state);
    }
}


static void get_drawing_area_size(gint *width, gint *height)
{
    gint x;
    gint y;
    gint depth;

    if (meta_drawingarea == NULL ||
    	GTK_WIDGET(meta_drawingarea)->window == NULL) {
	*width = 0;
	*height = 0;
    } else {
	gdk_window_get_geometry(GTK_WIDGET(meta_drawingarea)->window,
	    	    	    	&x, &y, width, height, &depth);
    }
}


static void clear_image_area(void)
{
    if (meta_drawingarea != NULL && 
    	GTK_WIDGET(meta_drawingarea)->window != NULL)
    	gdk_window_clear(GTK_WIDGET(meta_drawingarea)->window);
}


static gint attempt_to_draw_image(Image *image)
{
    gint pixbuf_width;
    gint pixbuf_height;
    gint window_width;
    gint window_height;
    gint x;
    gint y;
    GdkPixbuf *pixbuf;
    
    get_drawing_area_size(&window_width, &window_height);
    pixbuf = pixbuf_get_from_image(image, window_width, window_height);
    if (pixbuf == NULL)
    	return -1;

    pixbuf_width = gdk_pixbuf_get_width(pixbuf);
    pixbuf_height = gdk_pixbuf_get_height(pixbuf);
    if (pixbuf_width > window_width || pixbuf_height > window_height) {
	x = 0;
	y = 0;
    } else {
	x = (window_width - pixbuf_width) / 2;
	y = (window_height - pixbuf_height) / 2;
    }

    gdk_pixbuf_render_to_drawable(pixbuf,
	GTK_WIDGET(meta_drawingarea)->window,
	GTK_WIDGET(meta_drawingarea)->style->fg_gc[GTK_STATE_NORMAL],
	0, 0,
	x, y,
	pixbuf_width, pixbuf_height,
	GDK_RGB_DITHER_NORMAL, 0, 0);

    gdk_pixbuf_unref(pixbuf);
    
    return 0;
}


void meta_draw_image(void)
{
    Image *image;
    
    clear_image_area();
    image = image_list_get_selected();
    if (image != NULL) {
	/* 
	 * To avoid inifinite mutual recursion, we don't start background
	 * loading of an image here, so we also don't care if the image
	 * drawing succeeded or not.
	 */
	(void) attempt_to_draw_image(image);
    }
    image_list_draw_thumbnails();
}


static void clear_image(void)
{
    pixbuf_load_stop();
    meta_draw_image(); /* clear image area? */
}


void meta_clear(void)
{
    set_caption("");
    gtk_label_set_text(GTK_LABEL(meta_filename), "");
    clear_image();
}


static void draw_image_or_start_loading(void)
{
    Image *image;

    clear_image_area();
    image = image_list_get_selected();
    if (image != NULL && attempt_to_draw_image(image) == -1) {
	pixbuf_load_start(image_get_attribute(image, "filename"), 
			  meta_draw_image, meta_set_progress_bar);
    }
}


void meta_fill(Image *image)
{
    const gchar *filename;
    const gchar *caption;
    const gchar *rotation;
    const gchar *privacy;
    GtkWidget *item;
    GtkWidget *button;

    filename = image_get_attribute(image, "filename");
    caption = image_get_attribute(image, "caption");
    rotation = image_get_attribute(image, "rotation");
    privacy = image_get_attribute(image, "privacy");

    gtk_label_set_text(GTK_LABEL(meta_filename), filename);

    set_caption(caption);

    if (strcmp(rotation, "270") == 0)
    	item = menu_item_270;
    else if (strcmp(rotation, "180") == 0)
    	item = menu_item_180;
    else if (strcmp(rotation, "90") == 0)
    	item = menu_item_90;
    else
    	item = menu_item_0;
    if (item != NULL)
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);

    if (strcmp(privacy, "private") == 0)
    	button = meta_private;
    else
    	button = meta_public;
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);

    draw_image_or_start_loading();
}


void meta_set_progress_bar(gfloat percentage)
{
    gtk_progress_bar_update(meta_progress_bar, percentage);
}


gboolean on_meta_drawingarea_expose_event(GtkWidget *widget, GdkEvent *event, 
					  gpointer data)
{
    meta_draw_image();
    return TRUE;
}


gboolean on_meta_drawingarea_configure_event(GtkWidget *widget, 
    	    	    	    	    	     GdkEvent *event, 
					     gpointer data)
{
    draw_image_or_start_loading();
    return TRUE;
}