erGtkIconView.c

Go to the documentation of this file.

/**
 * \file erGtkIconView.c
 * \brief ereader gtk library - GtkIconView object adapted for ereader system
 */
 
/*
 * This file is part of libergtk.
 *
 * libergtk is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * libergtk is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */
 
// system include files
#include <string.h>
#include <ctype.h>
#include <gtk/gtk.h>
#include <math.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkprivate.h>

// ereader library includes

// local includes
#include "ergtk_log.h"
#include "eri18n.h"
#include "erGtkIconView.h"
#include "gtkiconview_private.h"

#define UNUSED(x) (void)(x)


// The type name of class.
const gchar *type_name = "erGtkIconView";

// class-specific properties
typedef enum
{
    PROP_NOT_USED = 0,   // not sure whether param_id zero is allowed
    PROP_NAVIGATE_MODE, // 
    NUM_PROPS
} prop_t;

// instance private data
typedef struct
{
    gchar *navigate_mode; // "normal-navigate-mode" doesn't translate.
                           // "simple-navigate-mode" translates up/down to left/right.
} erGtkIconViewPrivate;

static const gchar *PROPNAME_NAVIGATE_MODE = "navigate-mode";

static const gchar *normal_navigate_mode = "normal-navigate-mode";
static const gchar *simple_navigate_mode = "simple-navigate-mode";

// local data
static GtkIconViewClass* g_parent_class = NULL;
static guint pre_move_signal = 0;
static guint navigate_cursor_signal = 0;

// implementation of virtual methods
static void             add_move_bindings       (GtkBindingSet      *binding_set, 
                                                 const gchar *navigate_mode);
static void             add_move_binding        (GtkBindingSet      *binding_set,
                                                 guint               keyval,
                                                 GdkModifierType     modmask,
                                                 erGtkIconViewKeyPress navigate);

static void             remove_move_bindings(GtkBindingSet *binding_set);
static void             remove_move_binding(GtkBindingSet         *binding_set,
                                            guint                 keyval,
                                            GdkModifierType       modmask);

static void             force_cursor_present    (erGtkIconView      *er_iconview);

static void             destroy_impl            (GtkObject          *object);

// signal handlers
static gboolean         on_pre_move_cursor      (erGtkIconView      *er_iconview,
                                                 erGtkIconViewKeyPress navigate);

static void             on_style_set            (GtkWidget          *widget, 
                                                 GtkStyle           *previous_style);

static void             on_size_allocate        (GtkWidget          *widget, 
                                                 GtkAllocation      *allocation);

static gboolean         on_button_press_event   (GtkWidget          *widget,
                                                 GdkEventButton     *event);

static gboolean         on_button_release_event (GtkWidget          *widget,
                                                 GdkEventButton     *event);

static void             get_property_impl ( GObject    *object,
                                            guint       param_id,
                                            GValue     *value,
                                            GParamSpec *pspec );

static void             set_property_impl ( GObject      *object,
                                            guint         param_id,
                                            const GValue *value,
                                            GParamSpec   *pspec );

static void             finalize_impl (GObject *object);


static void             on_model_row_changed    (GtkTreeModel       *model,
                                                 GtkTreePath        *path,
                                                 GtkTreeIter        *iter,
                                                 gpointer           user_data);

static void             on_model_row_inserted   (GtkTreeModel       *model,
                                                 GtkTreePath        *path,
                                                 GtkTreeIter        *iter,
                                                 gpointer           user_data);

static gboolean         on_focus_out            (GtkWidget          *widget, 
                                                 gpointer           data);
/*
static gboolean         on_focus_in             (GtkWidget          *widget, 
                                                 gpointer           data);
*/
static void             scale_pixbuf            (erGtkIconView      *er_iconview,
                                                 GtkTreeModel       *model,
                                                 GtkTreeIter        *iter);


//
// Mandatory widget functions
//

static void ergtk_icon_view_class_init(erGtkIconViewClass* klass)
{
    LOGPRINTF("entry");

    GObjectClass   *object_class     = (GObjectClass*  )klass;
    GtkObjectClass *gtk_object_class = (GtkObjectClass*)klass;
    GtkWidgetClass *widget_class     = (GtkWidgetClass*)klass;

    GParamSpec *pspec;
    
    GtkBindingSet *binding_set;
    binding_set = gtk_binding_set_by_class (klass);

    // remember parent class struct, needed for chaining up to parent class
    g_parent_class = g_type_class_peek_parent(klass);

    // overload virtual methods
    gtk_object_class->destroy = destroy_impl;
    widget_class->style_set            = on_style_set;
    widget_class->size_allocate        = on_size_allocate;
    widget_class->button_press_event   = on_button_press_event;
    widget_class->button_release_event = on_button_release_event;
    
    object_class->get_property = get_property_impl;
    object_class->set_property = set_property_impl;
    object_class->finalize = finalize_impl;
    
    // reserve space for instance private data
    g_type_class_add_private (klass, sizeof(erGtkIconViewPrivate));

    // install custom properties
    // navigate mode
    const gchar * default_navigate_mode = normal_navigate_mode;
    pspec = g_param_spec_string( PROPNAME_NAVIGATE_MODE,
                                 PROPNAME_NAVIGATE_MODE,
                                 "Normal or simple navigate mode?",
                                 default_navigate_mode,
                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
    g_object_class_install_property(object_class, PROP_NAVIGATE_MODE, pspec);

    // signal handlers
    klass->pre_move_cursor = on_pre_move_cursor;

    // install custom style properties
    gtk_widget_class_install_style_property (widget_class,
                                             g_param_spec_int ("item-width",
                                                               P_("Item width"),
                                                               P_("Width in pixels occupied by text and pixbuf"),
                                                               G_MININT, G_MAXINT, 0,
                                                               GTK_PARAM_READABLE));

    gtk_widget_class_install_style_property (widget_class,
                                             g_param_spec_int ("item-height",
                                                               P_("Item height"),
                                                               P_("Height in pixels occupied by text and pixbuf"),
                                                               G_MININT, G_MAXINT, 0,
                                                               GTK_PARAM_READABLE));

    gtk_widget_class_install_style_property (widget_class,
                                             g_param_spec_int ("item-n-textlines",
                                                               P_("Textlines for item"),
                                                               P_("Number of textlines in item"),
                                                               G_MININT, G_MAXINT, 0,
                                                               GTK_PARAM_READABLE));

    // install custom signals
    pre_move_signal = g_signal_new ("pre-move-cursor",
                                    G_TYPE_FROM_CLASS (object_class),
                                    G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
                                    G_STRUCT_OFFSET (erGtkIconViewClass, pre_move_cursor),
                                    NULL, NULL,
                                    gtk_marshal_VOID__ENUM,
                                    G_TYPE_NONE,  
                                    1,            
                                    G_TYPE_INT);

    navigate_cursor_signal = g_signal_new("navigate-cursor",
                                          G_TYPE_FROM_CLASS (object_class),
                                          G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
                                          0,
                                          NULL, NULL,
                                          gtk_marshal_VOID__ENUM,
                                          G_TYPE_NONE,  
                                          1,            
                                          G_TYPE_INT);
    
    // custom key bindings
    // add_move_bindings(binding_set, default_navigate_mode);
}

// init instance
static void ergtk_icon_view_init(erGtkIconView *er_iconview)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(er_iconview));

    GtkIconView*  iconview = (GtkIconView*) er_iconview;
//    GtkWidget*    widget = (GtkWidget*) er_iconview;
   
    er_iconview->previous = NULL;
    er_iconview->next     = NULL;
    er_iconview->num_rows = 0;
    er_iconview->num_cols = 0;
    
    // override defaults of GtkIconView
    gtk_icon_view_set_margin(iconview, 0);
    gtk_icon_view_set_row_spacing(iconview, 0);
    gtk_icon_view_set_column_spacing(iconview, 0);
}


GType ergtk_icon_view_get_type(void)
{
    static GType class_type = 0;

    if (class_type == 0)
    {
        static const GTypeInfo class_info =
        {
            sizeof(erGtkIconViewClass),
            NULL,               /* base_init */
            NULL,               /* base_finalize */
            (GClassInitFunc) ergtk_icon_view_class_init,
            NULL,               /* class_finalize */
            NULL,               /* class_data */
            sizeof(erGtkIconView),
            0,                  /* n_preallocs */
            (GInstanceInitFunc) ergtk_icon_view_init,
            NULL                /* *value_table */
        };
        class_type = g_type_register_static(GTK_TYPE_ICON_VIEW, type_name, &class_info, 0);
    }

    return class_type;
}


GtkWidget *ergtk_icon_view_new()
{
    LOGPRINTF("entry");

    return g_object_new (ERGTK_TYPE_ICON_VIEW, NULL);
}


GtkWidget *ergtk_icon_view_new_with_model (GtkTreeModel *model)
{
    GtkWidget*      widget;

    LOGPRINTF("entry");
    g_return_val_if_fail(model, NULL);

    widget = g_object_new (ERGTK_TYPE_ICON_VIEW, NULL);
    ergtk_icon_view_set_model( ERGTK_ICON_VIEW(widget), model);

    return widget;
}

//
// Public widget methods
//

void ergtk_icon_view_set_model (erGtkIconView *er_iconview, GtkTreeModel *model)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(er_iconview));

    GtkIconView         *iconview = (GtkIconView*) er_iconview;
    GtkTreeModel        *iconview_model = gtk_icon_view_get_model(iconview);

    // disconnect signal handlers to old model
    if (iconview_model)
    {
        g_signal_handlers_disconnect_by_func(iconview_model, on_model_row_changed,  er_iconview);
        g_signal_handlers_disconnect_by_func(iconview_model, on_model_row_inserted, er_iconview);
    }

    // chain to parent class
    gtk_icon_view_set_model(iconview, model);
    iconview_model = model;

    // connect signal handlers to new model
    if (iconview_model)
    {
        g_signal_connect_after(model, "row-changed",  G_CALLBACK(on_model_row_changed),  er_iconview);
        g_signal_connect_after(model, "row-inserted", G_CALLBACK(on_model_row_inserted), er_iconview);
    }
}


static void on_model_row_changed(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data)
{
    UNUSED(path);
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(user_data));

    erGtkIconView   *er_iconview = (erGtkIconView *) user_data;

    // resize pixbuf as needed
    scale_pixbuf(er_iconview, model, iter);
}


static void on_model_row_inserted(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data)
{
    UNUSED(path);
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(user_data));

    erGtkIconView   *er_iconview = (erGtkIconView *) user_data;

    // resize pixbuf as needed
    scale_pixbuf(er_iconview, model, iter);
}


static gboolean on_focus_out(GtkWidget *widget, gpointer data)
{
    UNUSED(widget);
    UNUSED(data);
    LOGPRINTF("entry");

    // Return TRUE to stop other handlers from being invoked for the event 
    return  TRUE;
}


static gboolean on_focus_in(GtkWidget *widget, gpointer data)
{
    UNUSED(widget);
    UNUSED(data);
    LOGPRINTF("entry");

    // Return TRUE to stop other handlers from being invoked for the event 
    return  TRUE;
}


static void scale_pixbuf(erGtkIconView *er_iconview, GtkTreeModel *model, GtkTreeIter *iter)
{
    LOGPRINTF("entry");

    GtkIconView     *iconview    = (GtkIconView *) er_iconview;
    gint            pixbuf_column = gtk_icon_view_get_pixbuf_column(iconview);
    gint            pixbuf_width  = 0;
    gint            pixbuf_height = 0;
    gint            icon_width  = 0;
    gint            icon_height = 0;
    gint            x;
    gint            y;
    gint            w;
    gint            h;
    float           scale_horizontal;
    float           scale_vertical;
    GdkPixbuf       *pixbuf_old = NULL;
    GdkPixbuf       *pixbuf_new = NULL;
    GtkListStore    *list_store = NULL;
    GtkTreeStore    *tree_store = NULL;

    // resize pixbuf as needed
    LOGPRINTF("pixbuf_column [%d]", pixbuf_column);
    if (pixbuf_column >= 0)
    {
        // get icon size
        ergtk_icon_view_get_icon_size(er_iconview, &icon_width, &icon_height);
        if (icon_width > 0  &&  icon_height > 0)
        {
            // get pixbuf
            gtk_tree_model_get( model, iter,
                                pixbuf_column, &pixbuf_old,
                                -1 );
            if (pixbuf_old)
            {
                pixbuf_width  = gdk_pixbuf_get_width(pixbuf_old);
                pixbuf_height = gdk_pixbuf_get_height(pixbuf_old);
            }

            // update pixbuf as needed
            if (   pixbuf_width  <= icon_width
                && pixbuf_height <= icon_height )
            {
                // pixmap fits in icon: no conversion
            }
            else if (   10 * pixbuf_width  <= 12 * icon_width
                     && 10 * pixbuf_height <= 12 * icon_height )
            {
                // pixmap max. 20% too large: crop to fit icon
                if (pixbuf_width <= icon_width)
                {
                    x = 0;
                    w = pixbuf_width;
                }
                else
                {
                    x = (pixbuf_width - icon_width ) / 2;
                    w = icon_width;
                }
                if (pixbuf_height <= icon_height)
                {
                    y = 0;
                    h = pixbuf_height;
                }
                else
                {
                    y = (pixbuf_height - icon_height) / 2;
                    h = icon_height;
                }
                pixbuf_new = gdk_pixbuf_new_subpixbuf(pixbuf_old, x, y, w, h);
            }
            else
            {
                // pixmap more than 20% too large: scale down to fit icon, keep aspect ratio
                scale_horizontal = ((float) icon_width ) / ((float) pixbuf_width );
                scale_vertical   = ((float) icon_height) / ((float) pixbuf_height);
                if (scale_horizontal < scale_vertical)
                {
                    w = ((float) pixbuf_width ) * scale_horizontal;
                    h = ((float) pixbuf_height) * scale_horizontal;
                }
                else
                {
                    w = ((float) pixbuf_width ) * scale_vertical;
                    h = ((float) pixbuf_height) * scale_vertical;
                }
                pixbuf_new = gdk_pixbuf_scale_simple(pixbuf_old, w, h, GDK_INTERP_BILINEAR);
            }

            // update model with new pixbuf
            if (pixbuf_new)
            {
                if ( GTK_IS_LIST_STORE(model) )
                {
                    list_store = GTK_LIST_STORE(model);
                    g_assert(list_store);
                    gtk_list_store_set( list_store, iter,
                                        pixbuf_column, pixbuf_new,
                                        -1 );
                }
                else if ( GTK_IS_TREE_STORE(model) )
                {
                    tree_store = GTK_TREE_STORE(model);
                    g_assert(tree_store);
                    gtk_tree_store_set( tree_store, iter,
                                        pixbuf_column, pixbuf_new,
                                        -1 );
                }
                else
                {
                    ERRORPRINTF("unexpected model type, cannot set new pixbuf");
                }
            }
        }
    }

    // clean up
    if (pixbuf_old) { g_object_unref(pixbuf_old); }
    if (pixbuf_new) { g_object_unref(pixbuf_new); }
}


static void destroy_impl(GtkObject *object)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(object));

    erGtkIconView*  er_iconview = (erGtkIconView*) object;
    GtkObjectClass* parent_object_class = GTK_OBJECT_CLASS(g_parent_class);

    // disconnect model, if any
    ergtk_icon_view_set_model(er_iconview, NULL);

    // chain to parent class
    if (parent_object_class->destroy)
    {
        parent_object_class->destroy(object);
    }
}


static void on_style_set(GtkWidget *widget, GtkStyle *previous_style)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(widget));

    GtkIconView         *iconview = (GtkIconView*) widget;
    GtkIconViewCellInfo *info;

    gint icon_width = 0;
    gint icon_height = 0;
    gint text_height = 0;
    gint spacing = 0;
    gint item_width = 0;
    gint item_height = 0;
    gint item_n_textlines = 0;        

    GtkWidgetClass* parent_widget_class = GTK_WIDGET_CLASS(g_parent_class);
        
    // chain to parent class
    if (parent_widget_class->style_set)
    {
        parent_widget_class->style_set(widget, previous_style);
    }
    
    gtk_widget_style_get(widget,
                         "item-width", &item_width,
                         "item-height", &item_height,
                         "item-n-textlines", &item_n_textlines,
                         NULL);

    // set icon view properties
    //
    if ((item_width > 0) && (item_height > 0))
    {
        gtk_icon_view_set_item_width(iconview, item_width);
    }

    // set text cell properties
    //
    info = g_list_nth_data (iconview->priv->cell_list, iconview->priv->text_cell);
    if (info != NULL)
    {
        // set text padding to zero
        gtk_object_set( GTK_OBJECT(info->cell),
                        "xpad", 0,
                        NULL       );

        // set text height
        if (item_n_textlines > 0)
        {
            gtk_cell_renderer_text_set_fixed_height_from_font(GTK_CELL_RENDERER_TEXT(info->cell), item_n_textlines);
        }
        gtk_cell_renderer_get_size(GTK_CELL_RENDERER(info->cell), widget, NULL, NULL, NULL, NULL, &text_height);
    }

    // set pixbuf cell properties
    //
    info = g_list_nth_data (iconview->priv->cell_list, iconview->priv->pixbuf_cell);
    if ((info != NULL) && (item_width > 0) && (item_height > 0))
    {    
        spacing = gtk_icon_view_get_spacing(iconview);
        icon_width = item_width;
        icon_height = item_height - text_height - spacing;

        gtk_cell_renderer_set_fixed_size(GTK_CELL_RENDERER(info->cell), icon_width, icon_height);
    }
}


static void on_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(widget));

    GtkWidgetClass *parent_widget_class = GTK_WIDGET_CLASS(g_parent_class);

    erGtkIconView  *er_iconview = (erGtkIconView*) widget;
    GtkIconView    *iconview    = (GtkIconView  *) widget;
    gint item_width = 0;
    gint item_height = 0;
    gint focus_line_width = 0;
    gint row_space = 0;
    gint col_space = 0;
    
    // chain to parent class
    if (parent_widget_class->size_allocate)
    {
        parent_widget_class->size_allocate(widget, allocation);
    }
   
    gtk_widget_style_get(widget,
                         "item-width", &item_width,
                         "item-height", &item_height,
                         "focus-line-width", &focus_line_width,
                         NULL);

    if ((item_width > 0) && (item_height > 0))
    {
        // adjust size for padding
        item_height += 2 * focus_line_width;
        item_width  += 2 * focus_line_width;
     
        // calculate available space for rows 
        row_space = gtk_icon_view_get_row_spacing(iconview);
        er_iconview->num_rows = (allocation->height + row_space) / (item_height + row_space);
        
        // calculate available space for columns
        col_space = gtk_icon_view_get_column_spacing(iconview);
        er_iconview->num_cols = (allocation->width + col_space) / (item_width + col_space);
    }
}


static gboolean on_button_press_event (GtkWidget      *widget,
                                       GdkEventButton *event)
{
    LOGPRINTF("entry");
    g_return_val_if_fail(ERGTK_IS_ICON_VIEW(widget), FALSE);

    GtkWidgetClass  *parent_widget_class = GTK_WIDGET_CLASS(g_parent_class);
    GtkIconView     *iconview = (GtkIconView*) widget;
    
    // ignore double-/triple-clicks
    if ((event->button == 1) && (event->type != GDK_BUTTON_PRESS))
    {
        event->type = GDK_NOTHING;
        iconview->priv->last_single_clicked = NULL;
        iconview->priv->pressed_button = -1;
    }
    
    // chain to parent class
    if (parent_widget_class->button_press_event)
    {
        parent_widget_class->button_press_event(widget, event);
    }

    return TRUE;
}


static gboolean on_button_release_event(GtkWidget      *widget,
                                        GdkEventButton *event)
{
    LOGPRINTF("entry");
    g_return_val_if_fail(ERGTK_IS_ICON_VIEW(widget), FALSE);

    GtkTreePath     *path = NULL;
    GtkIconViewItem *item = NULL;
    gint             index = 0;
    GtkWidgetClass  *parent_widget_class = GTK_WIDGET_CLASS(g_parent_class);
    GtkIconView     *iconview = (GtkIconView*) widget;
    
    // activate item when single clicked and multi-select (shift/control) is not pressed
    //
    if ( (iconview->priv->pressed_button == event->button) &&
         ((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == 0) )
    {
        // find path at the button release position
        path = gtk_icon_view_get_path_at_pos(iconview, event->x, event->y);
        if (path)
        {
            // find item in path
            index = gtk_tree_path_get_indices(path)[0];
            item = g_list_nth_data(iconview->priv->items, index);
            
            // check if this item was the last one single clicked
            if (item == iconview->priv->last_single_clicked)
            {
                // activate this item
                gtk_icon_view_item_activated(iconview, path);
            }
        }        
        
        iconview->priv->last_single_clicked = NULL;
    }
    
    // chain to parent class
    if (parent_widget_class->button_release_event)
    {
        parent_widget_class->button_release_event(widget, event);
    }
    
    // clean up
    if (path) { gtk_tree_path_free(path); }
    
    return TRUE;
}


void ergtk_icon_view_set_next(erGtkIconView *er_iconview, erGtkIconView *next)
{
    LOGPRINTF("entry");
    g_return_if_fail(                ERGTK_IS_ICON_VIEW(er_iconview));
    g_return_if_fail(next == NULL || ERGTK_IS_ICON_VIEW(next       ));
    
    er_iconview->next = next;
}


void ergtk_icon_view_set_previous(erGtkIconView *er_iconview, erGtkIconView *previous)
{
    LOGPRINTF("entry");
    g_return_if_fail(                    ERGTK_IS_ICON_VIEW(er_iconview));
    g_return_if_fail(previous == NULL || ERGTK_IS_ICON_VIEW(previous   ));

    er_iconview->previous = previous;
}


void ergtk_icon_view_get_cursor(erGtkIconView *er_iconview, gint *row, gint *col)
{
    GtkIconView     *iconview = (GtkIconView*) er_iconview;

    gint    r = 0;
    gint    c = 0;

    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(er_iconview));

    force_cursor_present(er_iconview);

    if (iconview->priv->cursor_item)
    {
        r = iconview->priv->cursor_item->row;
        c = iconview->priv->cursor_item->col;
    }

    if (row != NULL)
    {
        *row = r;
    }

    if (col != NULL)
    {
        *col = c;
    }
}


void ergtk_icon_view_get_view_size(erGtkIconView *er_iconview, gint *num_rows, gint *num_cols, gint *num_items)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(er_iconview));

    GtkIconView     *iconview = (GtkIconView*) er_iconview;
    
    if (num_rows != NULL)
    { 
        *num_rows = er_iconview->num_rows;
    }
    
    if (num_cols != NULL)
    { 
        *num_cols = er_iconview->num_cols;
    }
    
    if (num_items != NULL)
    { 
        *num_items = g_list_length(iconview->priv->items);
    }

    LOGPRINTF("leave");
}


void ergtk_icon_view_get_icon_size(erGtkIconView *er_iconview, gint *icon_width, gint *icon_height)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(er_iconview));

    GtkIconView         *iconview = (GtkIconView*) er_iconview;
    GtkIconViewCellInfo *info;

    // get pixbuf cell properties
    info = g_list_nth_data (iconview->priv->cell_list, iconview->priv->pixbuf_cell);
    if (info && info->cell)
    {    
        gtk_cell_renderer_get_fixed_size(GTK_CELL_RENDERER(info->cell), icon_width, icon_height);
    }
    else
    {
        if (icon_width)
        {
            *icon_width = 0;
        }
        if (icon_height)
        {
            *icon_height = 0;
        }
    }
}


// move cursor to specified position
// row < 0           : move to last row present
// col < 0           : move to last item present in requested row
// row < 0, col < 0  : move to last item present
// non-existing item : move to last item present in requested col or
//                     move to last item present when requested col not present
void ergtk_icon_view_set_cursor(erGtkIconView  *er_iconview, gint row, gint col)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ICON_VIEW(er_iconview));

    GtkIconView     *iconview = (GtkIconView*) er_iconview;
    GtkWidget       *widget   = (GtkWidget  *) er_iconview;
    
    GtkTreePath *path = NULL;  
    gint index = 0;
    gint num_rows = 0;
    gint num_cols = 0;
    gint num_items = 0;
    gint last_row;
    gint last_col;
    gint last_row_last_col;
    
    LOGPRINTF("entry: row [%d] col [%d]", row, col);

    ergtk_icon_view_get_view_size(er_iconview, &num_rows, &num_cols, &num_items); 
    LOGPRINTF("num_rows [%d] num_cols [%d] num_items [%d]", num_rows, num_cols, num_items);

    if (num_items <= 0)
    {
        WARNPRINTF("no items, quit");
        return;
    }

    if (num_rows <= 0  ||  num_cols <= 0)
    {
        WARNPRINTF("no space allocated, num_rows [%d] num_cols [%d]",
                   num_rows, num_cols );
        return;
    }

    last_row          = (num_items - 1) / num_cols;
    last_row_last_col = (num_items - 1) % num_cols;

    // correct row, if needed
    if (last_row == 0)
    {
        // only one row present: use this one
        row = 0;
    }
    else
    {
        // multiple rows present: decide which one to use
        if (row < 0)
        {
            // no row requested: use last row
            row = last_row;
        }
        else if (row > last_row)
        {
            // requested row not present: use last row or before-last row
            if (col <= last_row_last_col)
            {
                // no col requested                  : use last row
                // requested col present on last row : use last row
                row = last_row;
            }
            else
            {
                // col requested not present on last row: use before-last row
                row = last_row - 1;
            }
        }
    }

    // correct column, if needed
    if (row == last_row)
    {
        last_col = last_row_last_col;
    }
    else
    {
        last_col = num_cols - 1;
    }
    if (col < 0  ||  col > last_col)
    {
        // col not requested: use last column on row
        // col not present  : use last column on row
        col = last_col;
    }
    LOGPRINTF("calculated: col [%d] row [%d]", col, row);

    // create path from index and set cursor
    index = (row * num_cols) + col;
    path = gtk_tree_path_new_from_indices(index, -1);
    gtk_widget_grab_focus (widget);
    gtk_icon_view_select_path(iconview, path);  
    gtk_icon_view_set_cursor(iconview, path, NULL, FALSE);

    // clean up
    if (path) { gtk_tree_path_free(path); }

    return;
}


void ergtk_icon_view_set_focus_mode(erGtkIconView          *er_iconview, 
                                    gboolean               focus_in,
                                    gboolean               focus_out)
{
    if (!focus_in)
    {
        // block focus-in events 
        g_signal_connect(G_OBJECT(er_iconview), "focus-in-event", G_CALLBACK (on_focus_in), NULL);
    }
    if (!focus_out)
    {
        // block focus-out events 
        g_signal_connect(G_OBJECT(er_iconview), "focus-out-event", G_CALLBACK (on_focus_out), NULL);
    }
}


//
// Internal functions
//

static void force_cursor_present (erGtkIconView *er_iconview)
{
    LOGPRINTF("entry");

    GtkIconView     *iconview = (GtkIconView*) er_iconview;

    if ( !iconview->priv->cursor_item )
    {
        // no cursor: set cursor on first item
        WARNPRINTF("no cursor, force to (0,0)");
        ergtk_icon_view_set_cursor(er_iconview, 0, 0);
    }
}


static gboolean on_pre_move_cursor (erGtkIconView         *er_iconview,
                                    erGtkIconViewKeyPress navigate)
{
    LOGPRINTF("entry");

    gboolean        ret = FALSE;  
    GtkIconView     *iconview = (GtkIconView*) er_iconview;
    GtkTreePath     *path = NULL;

    gint curcol = 0;
    gint currow = 0;
    gint num_rows = 0;
    gint num_cols = 0;
    gint num_items = 0;
    gint row_items = 0;
    gint last_row = 0;
    gint last_row_last_col = 0;
    gint step = 0;
    
    LOGPRINTF("entry: navigate [%d]", navigate);
    g_return_val_if_fail (ERGTK_ICON_VIEW (er_iconview), FALSE);

    if (!GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (er_iconview)))
    {
        WARNPRINTF("widget has no focus");
        return FALSE;
    }

    force_cursor_present(er_iconview);
    
    ergtk_icon_view_get_cursor(er_iconview, &currow, &curcol);
    ergtk_icon_view_get_view_size(er_iconview, &num_rows, &num_cols, &num_items); 

    // calculate number of items in this row
    if (currow == num_rows)
    {
        row_items = num_items - (num_cols*(num_rows-1));
    }
    else
    {
        row_items = num_cols;
    }
    
    // number of items in last row
    if ((currow+1) == num_rows)
    {
        row_items = num_items - (num_cols*(num_rows-1));
    }
    
    last_row = (num_items - 1) / num_cols;
    last_row_last_col = (num_items - 1) % num_cols;
    
    LOGPRINTF("curcol [%d] currow [%d]",  curcol, currow);
    LOGPRINTF("num_cols [%d] num_rows [%d] num_items [%d] row_items [%d] last_row [%d] last_row_last_col [%d]", 
              num_cols, num_rows, num_items, row_items, last_row, last_row_last_col );

    switch (navigate)
    {
    case ERGTK_ICON_VIEW_PRESS_SHORT_UP:
        if (currow > 0)
        {
            // move up line in view
            g_signal_emit_by_name(er_iconview, "move-cursor", GTK_MOVEMENT_DISPLAY_LINES, -1, &ret);
        }
        else 
        {
            gint items_previous = 0;
            if (er_iconview->previous) 
            {
                ergtk_icon_view_get_view_size(er_iconview->previous, NULL, NULL, &items_previous);
            }
            
            if (items_previous > 0)
            {                
                // move up view
                ergtk_icon_view_set_cursor(er_iconview->previous, -1, curcol);
            }
            else
            {
                // no view above, emit signal
                g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_SHORT_UP);
            }
        }
        break;
        
    case ERGTK_ICON_VIEW_PRESS_SHORT_DOWN:
        if (currow < last_row)
        {
            if (((currow+1)*row_items)+curcol < num_items)
            {
                // move down line in view
                g_signal_emit_by_name (er_iconview, "move-cursor", GTK_MOVEMENT_DISPLAY_LINES, 1, &ret);
            }
            else
            {
                // no item directly below so move to end of view
                g_signal_emit_by_name (er_iconview, "move-cursor", GTK_MOVEMENT_BUFFER_ENDS, 1, &ret);
            }
        }
        else
        {
            gint item_next = 0;
            if (er_iconview->next) 
            {
                ergtk_icon_view_get_view_size(er_iconview->next, NULL, NULL, &item_next);
            }

            if (item_next > 0) 
            {
                // move down view
                ergtk_icon_view_set_cursor(er_iconview->next, 0, curcol);
            }
            else
            {
                // no view below, emit signal
                g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_SHORT_DOWN);
            }
        }
        break;
        
    case ERGTK_ICON_VIEW_PRESS_SHORT_LEFT:
        if (curcol > 0)
        {
            g_signal_emit_by_name (er_iconview, "move-cursor", GTK_MOVEMENT_VISUAL_POSITIONS, -1, &ret);
        }
        else
        {
            if (currow > 0)
            {
                // already at start of the line, move to last item of previous line
                ergtk_icon_view_set_cursor(er_iconview, currow-1, -1);
            }
            else if (er_iconview->previous)
            {
                // already at start of line, move to the end of the previous row
                ergtk_icon_view_set_cursor(er_iconview->previous, -1, -1);
            }
            else 
            {
                // already at start of the first line, emit signal
                g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_SHORT_LEFT);
            }
        }
        break;
        
    case ERGTK_ICON_VIEW_PRESS_SHORT_RIGHT:
        if ( ((curcol+1) < row_items) && !((currow == last_row) && (curcol == last_row_last_col)) )
        {
                g_signal_emit_by_name (er_iconview, "move-cursor", GTK_MOVEMENT_VISUAL_POSITIONS, 1, &ret);
        }
        else 
        {
       if (currow < last_row)
            {
                // already at end of the line, move to first item of next line
                ergtk_icon_view_set_cursor(er_iconview, currow+1, 0);
            }
            else if (er_iconview->next)
            {
                // already at end of line, move to first item of next row
                ergtk_icon_view_set_cursor(er_iconview->next, 0, 0);
            }
            else 
            {
                // already at end of the last line, emit signal
                g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_SHORT_RIGHT);
            }
        }
        break;
        
    case ERGTK_ICON_VIEW_PRESS_LONG_UP:
        g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_LONG_UP);
        break;
        
    case ERGTK_ICON_VIEW_PRESS_LONG_DOWN:
        g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_LONG_DOWN);
        break;
        
    case ERGTK_ICON_VIEW_PRESS_LONG_LEFT:
        if (curcol > 0)
        {
            // move to first in line
            step = 1 - (curcol+1);
            g_signal_emit_by_name (er_iconview, "move-cursor", GTK_MOVEMENT_VISUAL_POSITIONS, step, &ret);
        }
        else
        {
            if (currow > 0)
            {
                // already at start of line, move up one line
                on_pre_move_cursor(er_iconview, ERGTK_ICON_VIEW_PRESS_SHORT_UP);
            }
            else if (er_iconview->previous)
            {
                // already at start of line, move to the start of the previous row
                ergtk_icon_view_set_cursor(er_iconview->previous, -1, 0);
            }
            else 
            {
                // already at start of first line
                g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_LONG_LEFT);
            }
        }
        break;
        
    case ERGTK_ICON_VIEW_PRESS_LONG_RIGHT:
        if ((curcol+1) < row_items)
        {
            // move to last in line
            if (currow == last_row)
            {
                step = last_row_last_col - curcol;
            }
            else
            {
                step = row_items - (curcol+1);
            }
            g_signal_emit_by_name (er_iconview, "move-cursor", GTK_MOVEMENT_VISUAL_POSITIONS, step, &ret);
        }
        else
        {
            if (currow < last_row)
            {
                // already at end of line, move to next line
                on_pre_move_cursor(er_iconview, ERGTK_ICON_VIEW_PRESS_SHORT_DOWN);
            }
            else if (er_iconview->next)
            {
                // already at end of line, move to end of next row
                ergtk_icon_view_set_cursor(er_iconview->next, 0, -1);
            }
            else 
            {
                // already at end of last line
                g_signal_emit_by_name(er_iconview, "navigate-cursor", ERGTK_ICON_VIEW_PRESS_LONG_RIGHT);
            }
        }
        break;

    case ERGTK_ICON_VIEW_PRESS_ACTIVATE:
        path = gtk_tree_path_new();
        gtk_icon_view_get_cursor(iconview, &path, NULL);
        gtk_icon_view_item_activated(iconview, path);
        gtk_tree_path_free(path);
        path = NULL;
        break;

    default:
        g_assert_not_reached();
        break;
    }

    LOGPRINTF("leave");
    return TRUE;
}

static void add_move_bindings(GtkBindingSet *binding_set, const gchar * navigate_mode)
{
    LOGPRINTF("entry");
    g_return_if_fail(binding_set != NULL);

    gint n = strlen(simple_navigate_mode);
    if (g_strncasecmp(navigate_mode, simple_navigate_mode, n) == 0)
    {
        add_move_binding(binding_set, GDK_Up,           0, ERGTK_ICON_VIEW_PRESS_SHORT_LEFT);
        add_move_binding(binding_set, GDK_KP_Up,        0, ERGTK_ICON_VIEW_PRESS_SHORT_LEFT);

        add_move_binding(binding_set, GDK_Down,         0, ERGTK_ICON_VIEW_PRESS_SHORT_RIGHT);
        add_move_binding(binding_set, GDK_KP_Down,      0, ERGTK_ICON_VIEW_PRESS_SHORT_RIGHT);

        add_move_binding(binding_set, GDK_Page_Up,      0, ERGTK_ICON_VIEW_PRESS_LONG_UP);
        add_move_binding(binding_set, GDK_KP_Page_Up,   0, ERGTK_ICON_VIEW_PRESS_LONG_UP);
        
        add_move_binding(binding_set, GDK_Page_Down,    0, ERGTK_ICON_VIEW_PRESS_LONG_DOWN);
        add_move_binding(binding_set, GDK_KP_Page_Down, 0, ERGTK_ICON_VIEW_PRESS_LONG_DOWN);
    }
    else
    {
        add_move_binding(binding_set, GDK_Up,           0, ERGTK_ICON_VIEW_PRESS_SHORT_UP);
        add_move_binding(binding_set, GDK_KP_Up,        0, ERGTK_ICON_VIEW_PRESS_SHORT_UP);

        add_move_binding(binding_set, GDK_Down,         0, ERGTK_ICON_VIEW_PRESS_SHORT_DOWN);
        add_move_binding(binding_set, GDK_KP_Down,      0, ERGTK_ICON_VIEW_PRESS_SHORT_DOWN);

        add_move_binding(binding_set, GDK_Page_Up,      0, ERGTK_ICON_VIEW_PRESS_LONG_UP);
        add_move_binding(binding_set, GDK_KP_Page_Up,   0, ERGTK_ICON_VIEW_PRESS_LONG_UP);
        
        add_move_binding(binding_set, GDK_Page_Down,    0, ERGTK_ICON_VIEW_PRESS_LONG_DOWN);
        add_move_binding(binding_set, GDK_KP_Page_Down, 0, ERGTK_ICON_VIEW_PRESS_LONG_DOWN);
    }

    add_move_binding(binding_set, GDK_Left,         0, ERGTK_ICON_VIEW_PRESS_SHORT_LEFT);
    add_move_binding(binding_set, GDK_KP_Left,      0, ERGTK_ICON_VIEW_PRESS_SHORT_LEFT);

    add_move_binding(binding_set, GDK_Right,        0, ERGTK_ICON_VIEW_PRESS_SHORT_RIGHT);
    add_move_binding(binding_set, GDK_KP_Right,     0, ERGTK_ICON_VIEW_PRESS_SHORT_RIGHT);

    add_move_binding(binding_set, GDK_Home,         0, ERGTK_ICON_VIEW_PRESS_LONG_LEFT);
    add_move_binding(binding_set, GDK_KP_Home,      0, ERGTK_ICON_VIEW_PRESS_LONG_LEFT);

    add_move_binding(binding_set, GDK_End,          0, ERGTK_ICON_VIEW_PRESS_LONG_RIGHT);
    add_move_binding(binding_set, GDK_KP_End,       0, ERGTK_ICON_VIEW_PRESS_LONG_RIGHT);

    add_move_binding(binding_set, GDK_space,        0, ERGTK_ICON_VIEW_PRESS_ACTIVATE);
    add_move_binding(binding_set, GDK_Return,       0, ERGTK_ICON_VIEW_PRESS_ACTIVATE);
    add_move_binding(binding_set, GDK_ISO_Enter,    0, ERGTK_ICON_VIEW_PRESS_ACTIVATE);
    add_move_binding(binding_set, GDK_KP_Enter,     0, ERGTK_ICON_VIEW_PRESS_ACTIVATE);
}

static void add_move_binding(GtkBindingSet         *binding_set,
                             guint                 keyval,
                             GdkModifierType       modmask,
                             erGtkIconViewKeyPress navigate)
{
    LOGPRINTF("entry");

    gtk_binding_entry_add_signal(binding_set, keyval, modmask,
                                 "pre-move-cursor", 1,
                                 G_TYPE_ENUM, navigate);

    gtk_binding_entry_add_signal(binding_set, keyval, GDK_SHIFT_MASK,
                                 "pre-move-cursor", 1,
                                 G_TYPE_ENUM, navigate);

    if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
    {
        return;
    }

    gtk_binding_entry_add_signal(binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK,
                                 "pre-move-cursor", 1,
                                 G_TYPE_ENUM, navigate);

    gtk_binding_entry_add_signal(binding_set, keyval, GDK_CONTROL_MASK,
                                 "pre-move-cursor", 1,
                                 G_TYPE_ENUM, navigate);
}

static void remove_move_bindings(GtkBindingSet *binding_set)
{
    LOGPRINTF("entry");
    g_return_if_fail(binding_set != NULL);

    remove_move_binding(binding_set, GDK_Up,           0);
    remove_move_binding(binding_set, GDK_KP_Up,        0);

    remove_move_binding(binding_set, GDK_Down,         0);
    remove_move_binding(binding_set, GDK_KP_Down,      0);

    remove_move_binding(binding_set, GDK_Page_Up,      0);
    remove_move_binding(binding_set, GDK_KP_Page_Up,   0);

    remove_move_binding(binding_set, GDK_Page_Down,    0);
    remove_move_binding(binding_set, GDK_KP_Page_Down, 0);
      
    remove_move_binding(binding_set, GDK_Left,         0);
    remove_move_binding(binding_set, GDK_KP_Left,      0);

    remove_move_binding(binding_set, GDK_Right,        0);
    remove_move_binding(binding_set, GDK_KP_Right,     0);
    
    remove_move_binding(binding_set, GDK_Home,         0);
    remove_move_binding(binding_set, GDK_KP_Home,      0);
   
    remove_move_binding(binding_set, GDK_End,          0);
    remove_move_binding(binding_set, GDK_KP_End,       0);

    remove_move_binding(binding_set, GDK_space,        0);
    remove_move_binding(binding_set, GDK_Return,       0);
    remove_move_binding(binding_set, GDK_ISO_Enter,    0);
    remove_move_binding(binding_set, GDK_KP_Enter,     0);
}

static void remove_move_binding(GtkBindingSet         *binding_set,
                                guint                 keyval,
                                GdkModifierType       modmask)
{
    LOGPRINTF("entry");

    gtk_binding_entry_remove(binding_set, keyval, modmask);
    gtk_binding_entry_remove(binding_set, keyval, GDK_SHIFT_MASK);

    if ((modmask & GDK_CONTROL_MASK) == GDK_CONTROL_MASK)
    {
        return;
    }

    gtk_binding_entry_remove(binding_set, keyval, GDK_CONTROL_MASK | GDK_SHIFT_MASK);
    gtk_binding_entry_remove(binding_set, keyval, GDK_CONTROL_MASK);
}

// get class-specific property
static void get_property_impl ( GObject    *object,
                                guint       param_id,
                                GValue     *value,
                                GParamSpec *pspec )
{
    g_return_if_fail( ERGTK_IS_ICON_VIEW(object) );

    erGtkIconViewPrivate *priv = ERGTK_ICON_VIEW_GET_PRIVATE(object);

    switch (param_id)
    {
        case PROP_NAVIGATE_MODE:
            g_value_set_string (value, priv->navigate_mode);
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
    }
}


// set class-specific property
static void set_property_impl ( GObject      *object,
                                guint         param_id,
                                const GValue *value,
                                GParamSpec   *pspec )
{
    g_return_if_fail( ERGTK_IS_ICON_VIEW(object) );

    erGtkIconViewPrivate *priv = ERGTK_ICON_VIEW_GET_PRIVATE(object);

    gchar        **cpp;

    switch (param_id)
    {
        case PROP_NAVIGATE_MODE:
            {
                const gchar *navigate_mode = g_value_get_string(value);
                if (g_strncasecmp(navigate_mode, normal_navigate_mode, strlen(normal_navigate_mode))
                 && g_strncasecmp(navigate_mode, simple_navigate_mode, strlen(simple_navigate_mode)))
                {
                    WARNPRINTF("Invalid navigate mode: %s!", navigate_mode);
                }
                else
                {
                    cpp = &(priv->navigate_mode);
                    g_free(*cpp);
                    *cpp = g_strdup(g_value_get_string(value));
                    LOGPRINTF("navigate-mode set to [%s]", *cpp);
                    GtkBindingSet *binding_set = gtk_binding_set_find(type_name);
                    remove_move_bindings(binding_set);
                    add_move_bindings(binding_set, navigate_mode);
                }
            }
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
    }
}

// finalize instance
static void finalize_impl (GObject *obj)
{
    g_return_if_fail( ERGTK_IS_ICON_VIEW(obj) );

    erGtkIconViewPrivate *priv = ERGTK_ICON_VIEW_GET_PRIVATE(obj);

    // destroy instance data
    //   private
    g_free(priv->navigate_mode);
    //   public: none

    // chain to parent class
    ((GObjectClass*)g_parent_class)->finalize( obj );
}