gtask-ui-util.c

Go to the documentation of this file.

#include "gtask-ui-util.h"

#include <string.h>
#include <glib.h>
#include <libgnomevfs/gnome-vfs-ops.h>
#include <gtask/gtask-file.h>

#include "gtask-internals.h"

#define valid_uri(uri) ( uri && strlen( uri ) > 0 )

static void
agg_file_list( gpointer key, gpointer value, gpointer data ) {
    GList **list = (GList **) data;

    *list = g_list_insert_sorted( *list, key, g_str_equal );
}

GTaskFileListInfo *
gtask_ui_get_file_list_info( GList *file_list ) {
    GHashTable        *dir_hash = g_hash_table_new( g_str_hash, g_str_equal );
    GTaskFileListInfo *info = g_new0( GTaskFileListInfo, 1 );
    gchar             *curr_dir = g_get_current_dir( );
    GList             *dir_list = NULL;

    info->files = file_list;

    while( file_list ) {
        GTaskFile  *file = (GTaskFile *) file_list->data;
        const char *uri = gtask_file_get_uri( file );
        char       *dir_uri;

        if( gtask_file_get_completed( file ) ) {
            info->num_completed_files++;
        }

        dir_uri = g_path_get_dirname( uri );

        if( strcmp( dir_uri, "." ) == 0 ) {
            g_free( dir_uri );
            dir_uri = g_strdup( curr_dir );
        }

        if( g_hash_table_lookup( dir_hash, dir_uri ) )
            g_free( dir_uri );
        else
            g_hash_table_insert( dir_hash, dir_uri, GINT_TO_POINTER( 1 ) );

        info->num_files++;
        file_list = g_list_next( file_list );
    }

    g_free( curr_dir );

    g_hash_table_foreach( dir_hash, agg_file_list, &dir_list );

    info->num_unique_directories = g_list_length( dir_list );
    info->unique_directories = dir_list;

    g_hash_table_destroy( dir_hash );

    return info;
}

void
gtask_ui_file_list_info_free( GTaskFileListInfo *info ) {
    g_list_free( info->files );

    g_list_foreach( info->unique_directories, (GFunc) g_free, NULL );
    g_list_free( info->unique_directories );

    g_free( info );
}

GTaskPreview *
gtask_preview_new( gchar *uri, gboolean is_thumbnail ) {
    GTaskPreview *preview = g_new0( GTaskPreview, 1 );

    preview->uri = uri;
    preview->is_thumbnail = is_thumbnail;

    return preview;
}

GSList *
gtask_ui_get_task_preview_options( GTaskGenericTask *task ) {
    GSList             *previews = NULL;

    GList              *file_list;

    const char         *uri;

    uri = gtask_generic_task_get_thumbnail_uri( task );

    if( valid_uri( uri ) ) {
        previews = g_slist_append( previews,
                                   gtask_preview_new( g_strdup( uri ), TRUE ) );
    }

    file_list = gtask_generic_task_get_files( task );

    if( g_list_length( file_list ) == 1 ) {
        GTaskFile *file = (GTaskFile *) file_list->data;
        GSList    *file_previews;

        file_previews = gtask_ui_get_file_preview_options( file );

        previews = g_slist_concat( previews, file_previews );
    } else {
        gchar *uri = g_build_filename( DATADIR,
                                       "pixmaps",
                                       "gnome-other.png",
                                       NULL );

        previews = g_slist_append( previews,
                                   gtask_preview_new( uri, FALSE ) );
    }

    return previews;
}

/* resolution order:
 * if the file is completed thumbnail that
 * then use the thumbnail uri
 * then use the main mime type
 * then use the fallback mime type
 * then use the best dinky graphic in the west boys!
 */
GSList *
gtask_ui_get_file_preview_options( GTaskFile *file ) {
    GSList      *previews = NULL;
    const gchar *uri;
    const gchar *mime_type;

    g_return_val_if_fail( GTASK_IS_FILE( file ), NULL );

    if( gtask_file_get_completed( file ) ) {
        const char *uri = gtask_file_get_uri( file );

        if( valid_uri( uri ) ) {
          previews = g_slist_append( previews,
                                   gtask_preview_new( g_strdup( uri ), TRUE ) );
        }
    }

    uri = gtask_file_get_thumbnail_uri( file );

    if( valid_uri( uri ) ) {
        g_slist_append( previews,
                       gtask_preview_new( g_strdup( uri ), TRUE ) );
    }

    mime_type = gtask_file_get_mime_type( file );

    if( mime_type ) {
        gchar **mime_split = g_strsplit( mime_type, "/", -1 );
        gchar  *mime_type_icon;
        gchar  *mime_type_uri;

        if( mime_split && mime_split[0] && mime_split[1] ) {
            mime_type_icon = g_strdup_printf( "gnome-mime-%s-%s.png",
                                              mime_split[0],
                                              mime_split[1] );

            mime_type_uri = g_build_filename( DATADIR,
                                              "pixmaps",
                                              "mimetypes",
                                              mime_type_icon,
                                              NULL );

            previews = g_slist_append( previews,
                                    gtask_preview_new( mime_type_uri, FALSE ) );

            g_free( mime_type_icon );
        }

        if( mime_split && mime_split[0] ) {
            mime_type_icon = g_strdup_printf( "gnome-mime-%s.png",
                                              mime_split[0] );

            mime_type_uri = g_build_filename( DATADIR,
                                              "pixmaps",
                                              "mimetypes",
                                              mime_type_icon,
                                              NULL );

            previews = g_slist_append( previews,
                                    gtask_preview_new( mime_type_uri, FALSE ) );

            g_free( mime_type_icon );
        } 

        g_strfreev( mime_split ); 
    }

    /* uber default here -- just an open umm . . box, yeah, just a box for the
     * moment */
    {
        gchar *uri = g_build_filename( DATADIR,
                                       "pixmaps",
                                       "gnome-other.png",
                                       NULL );

        previews = g_slist_append( previews,
                                   gtask_preview_new( uri, FALSE ) );
    }

    return previews;
}

void
gtask_preview_free( GTaskPreview *preview ) {
    g_free( preview->uri );

    g_free( preview );
}

void
gtask_preview_list_free( GSList *list ) {
    g_slist_foreach( list, (GFunc) gtask_preview_free, NULL );

    g_slist_free( list );
}


/* figures out how to get the preview -- either via thumbnailing
 * or ummm . . regular stuff . . and gets it, or maybe it doesn't
 * in which case -- tough luck buster
 *
 * @todo right now thumbnail generation happens in the main thread
 *       in the future it would be nice if we could delegate this off to
 *       another thread, return an intermediary preview and then
 *       register some callback to be run when the better preview is
 *       available.
 */
GdkPixbuf *
gtask_preview_get_pixbuf( GTaskPreview *preview,
                          GnomeThumbnailFactory *factory  )
{
    GdkPixbuf             *pix_buf = NULL;
    GnomeVFSFileInfo       info;
    char                  *thumb_uri;

    if( preview->is_thumbnail ) {
        GnomeVFSResult res = gnome_vfs_get_file_info( preview->uri, &info,
                                            GNOME_VFS_FILE_INFO_GET_MIME_TYPE |
                                            GNOME_VFS_FILE_INFO_DEFAULT );

        if( res != GNOME_VFS_OK )
            return NULL;


        thumb_uri = gnome_thumbnail_factory_lookup( factory,
                                                    preview->uri,
                                                    info.mtime );

        if( thumb_uri ) {
            pix_buf = gdk_pixbuf_new_from_file( thumb_uri, NULL );
        } else {
            pix_buf = gnome_thumbnail_factory_generate_thumbnail( factory,
                                                               preview->uri,
                                                               info.mime_type );

            if( pix_buf ) {
                gnome_thumbnail_factory_save_thumbnail( factory,
                                                        pix_buf,
                                                        preview->uri,
                                                        info.mtime );
            } else {
                gnome_thumbnail_factory_create_failed_thumbnail( factory,
                                                                 preview->uri,
                                                                 info.mtime );
            }
        }
    } else {
        pix_buf = gdk_pixbuf_new_from_file( preview->uri, NULL );
    }

    return pix_buf;
}

/*
GdkPixBuf *
gtask_ui_render_final_preview( GdkPixbuf *pixbuf,
                               GdkPixbuf *frame,
                               gboolean is_thumbnail,
                               guint bound )
{
}
*/

void
gtask_ui_draw_progressbar( GtkWidget *widget,
                        GdkWindow *window,
                        GdkRectangle *area,
                        float progress,
                        GTaskActivityState state,
                        int x,
                        int y,
                        int width,
                        int height )
{
    GdkGC     *gc;
    GdkColor  *color;
    GtkStyle  *text_style;
    int        perc_w;

    g_debug( "IN: gtask_draw_progressbar" );

    gc = gdk_gc_new( window );

    /* Draw the outline */
    gdk_gc_set_rgb_fg_color( gc, &widget->style->fg[GTK_STATE_NORMAL] );
    gdk_draw_rectangle( window, gc, TRUE, x, y, width, height );

    /* Draw the interior */
    gdk_gc_set_rgb_fg_color( gc, &widget->style->bg[GTK_STATE_NORMAL] );
    gdk_draw_rectangle( window, gc, TRUE, x + 1, y + 1, width - 2, height - 2 );

    perc_w = width - 4;
    perc_w = (int) ( perc_w * progress );

    switch( state ) {
        case GTASK_ACTIVITY_STATE_ACTIVE:
            color = &widget->style->bg[GTK_STATE_SELECTED];
            text_style = gtk_style_copy( widget->style );
            break;
        case GTASK_ACTIVITY_STATE_INACTIVE:
            color = &widget->style->bg[GTK_STATE_INSENSITIVE];
            text_style = gtk_style_copy( widget->style );
            break;
        case GTASK_ACTIVITY_STATE_COMPLETED:
            color = &widget->style->fg[GTK_STATE_NORMAL];

            text_style = gtk_style_copy( widget->style );

            text_style->fg[GTK_STATE_NORMAL] = widget->style->bg[GTK_STATE_NORMAL];
            text_style->bg[GTK_STATE_NORMAL] = widget->style->fg[GTK_STATE_NORMAL];
            break;
        default:
            color = &widget->style->fg[GTK_STATE_NORMAL];
            text_style = gtk_style_copy( widget->style );
            break;
    }

    gtk_style_attach( text_style, window );

    /* Draw the actual progress bar */
    gdk_gc_set_rgb_fg_color( gc, color );
    gdk_draw_rectangle( window, gc, TRUE, x + 2, y + 2, perc_w, height - 4);

    /* negative progress values imply that we are hiding the
     * progressbar text */
    if( progress >= 0 ) {
        int             pos;
        GtkStateType    gtk_state;
        PangoLayout    *layout;
        PangoRectangle  logical_rect;
        GdkRectangle   *cell_area = NULL;
        char           *text = g_strdup_printf ("%.0f%%", progress * 100);

        if( area == NULL )
            cell_area = g_new0( GdkRectangle, 1 );
        else 
            cell_area = area;

        layout = gtk_widget_create_pango_layout( widget, text );

        pango_layout_get_pixel_extents( layout, NULL, &logical_rect );

        pos = ( width - logical_rect.width ) / 2;

        /* Determine the state to render the text in */
        if( state == GTASK_ACTIVITY_STATE_INACTIVE ) {
            gtk_state = GTK_STATE_INSENSITIVE;
        } else if( state == GTASK_ACTIVITY_STATE_COMPLETED ) {
            gtk_state = GTK_STATE_NORMAL;
        } else if( perc_w < pos + logical_rect.width / 2 )
            gtk_state = GTK_STATE_NORMAL;
        else
            gtk_state = GTK_STATE_SELECTED;

        /* TODO -- need to get rectangle to draw on */
        //gtk_paint_layout( widget->style,
        gtk_paint_layout( text_style,
                          window,
                          gtk_state,
                          FALSE,
                          cell_area,
                          widget,
                          "progressbar",
                          x + pos,
                          y + ( height - logical_rect.height ) / 2 - 1,
                          layout );

        if( area == NULL )
                g_object_unref( G_OBJECT( cell_area ) );

        g_free( text );
        g_object_unref( G_OBJECT( layout ) );

    }

    g_object_unref( G_OBJECT( gc ) );
    g_object_unref( G_OBJECT( text_style ) );

    g_debug( "LEAVING: gtask_draw_progressbar" );
}

---