ergtklistview.c

Go to the documentation of this file.

/**
 * \file ergtklistview.c
 * \brief ereader gtk library - GtkTreeView 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 "ergtklistview.h"



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


// local functions


// implementation of virtual methods
static void             add_move_binding        (GtkBindingSet      *binding_set,
                                                 guint               keyval,
                                                 GdkModifierType     modmask,
                                                 erGtkListViewKeyPress navigate);


// signal handlers
static void             on_realize              (GtkWidget          *widget);

static gboolean         on_pre_move_cursor      (erGtkListView      *er_listview,
                                                 erGtkListViewKeyPress 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 gboolean         on_motion_notify_event  (GtkWidget          *widget, 
                                                 GdkEventMotion     *event);

static void             on_column_notify_title  (GObject            *object,
                                                 GParamSpec         *arg1,
                                                 gpointer           user_data);

static gboolean         on_focus_in             (GtkWidget          *widget, 
                                                 gpointer           data);

static gboolean         on_focus_out            (GtkWidget          *widget, 
                                                 gpointer           data);

//
// Mandatory widget functions
//

static void ergtk_list_view_class_init (erGtkListViewClass* klass)
{
    GObjectClass    *object_class = (GObjectClass*  )klass;
    GtkWidgetClass  *widget_class = (GtkWidgetClass*)klass;
    
    GtkBindingSet   *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
    widget_class->realize              = on_realize;
    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;
    widget_class->motion_notify_event  = on_motion_notify_event;

    // signal handlers
    klass->pre_move_cursor = on_pre_move_cursor;

    gtk_widget_class_install_style_property (widget_class,
                                             g_param_spec_int ("column-spacing",
                                                               P_("Column spacing"),
                                                               P_("Empty pixels between columns"),
                                                               0, G_MAXINT, 0,
                                                               GTK_PARAM_READABLE));

    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 (erGtkListViewClass, 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);
    
    add_move_binding(binding_set, GDK_Up,           0, ERGTK_LIST_VIEW_PRESS_SHORT_UP);
    add_move_binding(binding_set, GDK_KP_Up,        0, ERGTK_LIST_VIEW_PRESS_SHORT_UP);

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

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

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

    add_move_binding(binding_set, GDK_Page_Up,      0, ERGTK_LIST_VIEW_PRESS_LONG_UP);
    add_move_binding(binding_set, GDK_KP_Page_Up,   0, ERGTK_LIST_VIEW_PRESS_LONG_UP);
    
    add_move_binding(binding_set, GDK_Page_Down,    0, ERGTK_LIST_VIEW_PRESS_LONG_DOWN);
    add_move_binding(binding_set, GDK_KP_Page_Down, 0, ERGTK_LIST_VIEW_PRESS_LONG_DOWN);

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

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

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


// init instance
static void ergtk_list_view_init (erGtkListView *er_listview)
{
    g_return_if_fail(ERGTK_IS_LIST_VIEW(er_listview));

    GtkTreeView*  treeview = (GtkTreeView*) er_listview;
    //GtkWidget*    widget = (GtkWidget*) er_listview;
   
    // override defaults of GtkTreeView
    gtk_tree_view_set_headers_clickable(treeview, FALSE);
    gtk_tree_view_set_enable_search(treeview, FALSE);

    // initialise private data
    er_listview->row_height       = -1;
    er_listview->is_forced_height = FALSE;
    er_listview->is_button_down   = FALSE;
}


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

    if (class_type == 0)
    {
        static const GTypeInfo class_info =
        {
            sizeof(erGtkListViewClass),
            NULL,               /* base_init */
            NULL,               /* base_finalize */
            (GClassInitFunc) ergtk_list_view_class_init,
            NULL,               /* class_finalize */
            NULL,               /* class_data */
            sizeof(erGtkListView),
            0,                  /* n_preallocs */
            (GInstanceInitFunc) ergtk_list_view_init,
            NULL                /* *value_table */            
            
        };
        class_type = g_type_register_static(GTK_TYPE_TREE_VIEW, "erGtkListView", &class_info, 0);
    }

    return class_type;
}


GtkWidget *ergtk_list_view_new (void)
{
    return g_object_new (ERGTK_TYPE_LIST_VIEW, NULL);
}


GtkWidget *ergtk_list_view_new_with_model (GtkTreeModel *model)
{
    return g_object_new (ERGTK_TYPE_LIST_VIEW, "model", model, NULL);
}


gint ergtk_list_view_append_column ( erGtkListView     *er_listview,
                                     GtkTreeViewColumn *column      )
{
    g_return_val_if_fail( ERGTK_IS_LIST_VIEW(er_listview), 0 );
    g_return_val_if_fail( GTK_IS_TREE_VIEW_COLUMN(column), 0 );

    const gchar *title    = gtk_tree_view_column_get_title(column);
    GtkTreeView *treeview = (GtkTreeView *) er_listview;

    gint              num_columns    = 0;     // return value
    GtkWidget         *widget        = NULL;
    GtkWidget         *label         = NULL;
    GtkWidget         *event_box     = NULL;
    GtkBox            *vbox          = NULL;
    const gchar       *listview_name = gtk_widget_get_name( (GtkWidget*)er_listview );
    gchar             *header_name   = g_strdup_printf("%s-header", listview_name);

    LOGPRINTF("entry: title [%s]", title);

    // insert filler column for spacing
    if ( gtk_tree_view_get_column(treeview, 0) != NULL )
    {
       GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
       g_object_set( G_OBJECT(renderer),
                     "xpad", 0,
                     "ypad", 0,
                     "text", "",
                     NULL );
       GtkTreeViewColumn *filler_column = gtk_tree_view_column_new_with_attributes( "", renderer, NULL );
       gtk_tree_view_column_set_sizing(filler_column, GTK_TREE_VIEW_COLUMN_FIXED);
       gtk_tree_view_append_column(treeview, filler_column);
    }

    // set custom header for column
    if (title)
    {
        widget = gtk_tree_view_column_get_widget(column);
        if (widget == NULL)
        {
            //   column
            //     |-- widget vbox
            //           |-- label
            //           |-- event_box
            //
            widget = gtk_vbox_new(FALSE, 0);
            vbox = GTK_BOX(widget);
            //
            label = gtk_label_new( title );
            gtk_widget_set_name(label, header_name);
            gtk_misc_set_alignment( GTK_MISC(label), 0.0, 0.0);
            gtk_box_pack_start(vbox, label, FALSE, FALSE, 0);
            //
            event_box = gtk_event_box_new();
            gtk_widget_set_name(event_box, header_name);
            // TODO: replace hardcoded event-box height with a new style property
            gtk_widget_set_size_request(event_box, -1, 15);
            GTK_WIDGET_UNSET_FLAGS(event_box, GTK_CAN_FOCUS);
            gtk_box_pack_start(vbox, event_box, FALSE, FALSE, 0);
            //
            gtk_widget_show_all(widget);
            gtk_tree_view_column_set_widget(column, widget);

            // tell me when column title changes
            g_signal_connect(column, "notify::title", G_CALLBACK(on_column_notify_title), label);
        }
    }

    // add column to tree view
    num_columns = gtk_tree_view_append_column(treeview, column);

    // clean up
    g_free(header_name);

    return num_columns;
}


// on column title changed
static void on_column_notify_title ( GObject            *object,
                                     GParamSpec         *arg1,
                                     gpointer           user_data )
{
    LOGPRINTF("entry");
    g_return_if_fail(GTK_IS_TREE_VIEW_COLUMN(object));
    g_return_if_fail(GTK_IS_LABEL(user_data));

    GtkTreeViewColumn   *column = GTK_TREE_VIEW_COLUMN(object);
    GtkLabel            *label  = GTK_LABEL(user_data);

    if (column && label)
    {
        gtk_label_set_text(label, gtk_tree_view_column_get_title(column));
    }
}


//
// Public widget methods
//

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

    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);
    }
}


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

    GtkWidgetClass      *parent_widget_class = GTK_WIDGET_CLASS(g_parent_class);
    GtkTreeView         *treeview    = (GtkTreeView  *) widget;
    erGtkListView       *er_listview = (erGtkListView*) widget;

    GList               *columns = NULL;
    GList               *p_col;
    GtkTreeViewColumn   *col;
    gint                col_idx;
    GList               *renderers = NULL;
    GList               *p_rend;
    GtkCellRenderer     *rend;
    GtkWidget           *child = NULL;
    GtkAllocation       child_allocation;
    gint                focus_line_width = 0;
    gint                column_spacing   = 0;
    gint                filler_width     = 0;
    gint                row_height       = 1;
    gboolean            is_forced_height = er_listview->is_forced_height;
    gint                height;

    LOGPRINTF("entry");
    
    // chain to parent class
    if (parent_widget_class->size_allocate)
    {
        parent_widget_class->size_allocate(widget, allocation);
    }

    // get style properties
    gtk_widget_style_get( widget,
                          "column-spacing",   &column_spacing,
                          "focus-line-width", &focus_line_width,
                          NULL );
    filler_width = column_spacing - (2 * focus_line_width);
    if (filler_width < 0)
    {
        filler_width = 0;
    }

    // adjust width of column headers
    // get max. current column height
    columns = gtk_tree_view_get_columns(treeview);
    for ( p_col = columns, col_idx = 0 ;
          p_col ;
          p_col = p_col->next, col_idx++ )
    {
        col = GTK_TREE_VIEW_COLUMN(p_col->data);

        if (col_idx % 2 == 0)
        {
            // data column
            //   set header width
            child = gtk_tree_view_column_get_widget(col);
            if (child)
            {
                child_allocation       = child->allocation;
                child_allocation.width = gtk_tree_view_column_get_width(col);
                child_allocation.width -= 2 * focus_line_width;
                gtk_widget_size_allocate(child, &child_allocation);
            }

            // adjust max. column height, if needed
            // note: this (probably) reflects the height of the first row only
            if ( !is_forced_height )
            {
                gtk_tree_view_column_cell_get_size(col, NULL, NULL, NULL, NULL, &height );
                LOGPRINTF("height [%d]", height);
                if (height > row_height)
                {
                    row_height = height;
                }
            }
        }
        else
        {
            // filler column
            //   set column width
            gtk_tree_view_column_set_min_width(col, filler_width);
        }
    }

    // force height of first row to all rows
    if (is_forced_height)
    {
        row_height = er_listview->row_height;
    }
    else
    {
        er_listview->row_height = row_height;
    }
    row_height -= 2 * focus_line_width;
    for ( p_col = columns, col_idx = 0 ;
          p_col ;
          p_col = p_col->next, col_idx++ )
    {
        col = GTK_TREE_VIEW_COLUMN(p_col->data);

        if (col_idx % 2 == 0)
        {
            // data column
            //   get cell renderers
            //   set fixed height on each renderer
            renderers = gtk_tree_view_column_get_cell_renderers(col);
            for ( p_rend = renderers ; p_rend ; p_rend = p_rend->next )
            {
                rend = GTK_CELL_RENDERER(p_rend->data);
                gtk_cell_renderer_set_fixed_size(rend, -1, row_height);
            }
            g_list_free(renderers);
            renderers = NULL;
        }
    }

    // clean up
    g_list_free(columns);
    columns = NULL;
}


static gboolean on_button_press_event (GtkWidget      *widget,
                                       GdkEventButton *event)
{
    g_return_val_if_fail(ERGTK_IS_LIST_VIEW(widget), FALSE);

    GtkTreeView     *treeview    = (GtkTreeView  *) widget;
    erGtkListView   *er_listview = (erGtkListView*) widget;
    GtkTreePath     *path = NULL;
    gint            *pi;
    gint            item_idx = 0;
    gboolean        ok;

    LOGPRINTF("entry: x y [%lf %lf] button [%d]", event->x, event->y, event->button);
    
    // find treeview item with this event
    ok = gtk_tree_view_get_path_at_pos(treeview, event->x, event->y, &path, NULL, NULL, NULL);
    if (ok  &&  path)
    {
        pi = gtk_tree_path_get_indices(path);
        if (pi)
        {
            item_idx = *pi;
        }
    }
    LOGPRINTF("item_idx [%d]", item_idx);

    // act only on left-button single-click 
    if (   ok
        && path
        && event->button == 1
        && event->type   == GDK_BUTTON_PRESS )
    {
        // store button-press info
        er_listview->is_button_down     = TRUE;
        er_listview->press_event_button = event->button;
        er_listview->press_event_state  = event->state;
        er_listview->press_event_x      = event->x;
        er_listview->press_event_y      = event->y;

        // remember treeview item with this event
        er_listview->press_item_idx = item_idx;

        // move cursor to selected item
        ergtk_list_view_set_cursor(er_listview, item_idx);
    }
    else
    {
        er_listview->is_button_down = FALSE;
    }
    LOGPRINTF("is_down [%d] item_idx [%d]", er_listview->is_button_down, item_idx);
    
    // clean up
    if (path) { gtk_tree_path_free(path); }

    return TRUE;  // stop event handling right now, no calls to other handlers
}


static gboolean on_button_release_event (GtkWidget      *widget,
                                         GdkEventButton *event)
{
    g_return_val_if_fail(ERGTK_IS_LIST_VIEW(widget), FALSE);

    GtkTreeView     *treeview    = (GtkTreeView  *) widget;
    erGtkListView   *er_listview = (erGtkListView*) widget;
    GtkTreePath     *path = NULL;
    gint            *pi;
    gint            item_idx = 0;
    gboolean        ok;
    
    // find treeview item with this event
    ok = gtk_tree_view_get_path_at_pos(treeview, event->x, event->y, &path, NULL, NULL, NULL);
    if (ok && path)
    {
        // find item index
        pi = gtk_tree_path_get_indices(path);
        if (pi)
        {
            item_idx = *pi;
        }

        // act only on item that has received the left-button-down event
        if (   event->button == 1
            && er_listview->is_button_down
            && er_listview->press_event_button == event->button
            && er_listview->press_item_idx     == item_idx     )
        {
            LOGPRINTF("activate row [%d]", item_idx);
            gtk_tree_view_row_activated(treeview, path, NULL);
        }
    }

    // remember button not down
    er_listview->is_button_down = FALSE;
    
    // clean up
    if (path) { gtk_tree_path_free(path); }

    return TRUE;  // stop event handling right now, no calls to other handlers
}


static gboolean on_motion_notify_event(GtkWidget *widget, 
                                       GdkEventMotion *event)
{
    // ignore drag-and-drop and rubberbanding
    return TRUE;
}


static void on_realize(GtkWidget *widget)
{
    GtkWidgetClass  *parent_widget_class = GTK_WIDGET_CLASS(g_parent_class);

    // call parent first
    if (parent_widget_class->realize)
    {
        parent_widget_class->realize(widget);
    }
    
    // disable pointer motion events
    GdkEventMask mask = gdk_window_get_events(widget->window);
    gdk_window_set_events(widget->window, mask & ~(GDK_POINTER_MOTION_MASK));
}


void ergtk_list_view_get_cursor (erGtkListView *er_listview, gint *row)
{
    GtkTreeView     *treeview = (GtkTreeView*) er_listview;
    GtkTreePath     *path = NULL;
    gint            *pi;
    gint            currow = -1;        // cursor row, return value

    g_return_if_fail(ERGTK_LIST_VIEW(er_listview));

    if (row != NULL)
    {
        path = gtk_tree_path_new();
        gtk_tree_view_get_cursor(treeview, &path, NULL);
        if (path == NULL)
        {
            LOGPRINTF("no cursor set");
        }
        else
        {
            pi = gtk_tree_path_get_indices(path);
            if (pi)
            {
                currow = *pi;
            }
        }
        gtk_tree_path_free(path);

        *row = currow;
    }
}


void ergtk_list_view_get_view_size (erGtkListView *er_listview, gint *num_rows, gint *num_items)
{
    g_return_if_fail(ERGTK_IS_LIST_VIEW(er_listview));

    GtkTreeView             *treeview = (GtkTreeView*) er_listview;
    GdkRectangle            visible_rect;
    GtkTreePath             *path = NULL;
    gboolean                ok;
    gint                    *pi;
    gint                    vertical_separator = 0;

    LOGPRINTF("entry");
    
    // get style properties
    gtk_widget_style_get( GTK_WIDGET(er_listview),
                          "vertical-separator", &vertical_separator,
                          NULL );

    // get maximum number of rows visible
    if (num_rows != NULL)
    { 
        // calculate max. number of items in treeview
        gtk_tree_view_get_visible_rect(treeview, &visible_rect);
        if (   visible_rect.height     > 0
            && er_listview->row_height > 0 )
        {
            *num_rows = visible_rect.height / (er_listview->row_height + vertical_separator);
        }
        else
        {
            *num_rows = 1;
        }
        LOGPRINTF("num_rows [%d]", *num_rows);
    }
    
    // get current number of items
    if (num_items != NULL)
    { 
        pi   = NULL;
        ok   = gtk_tree_view_get_visible_range(treeview, NULL, &path);
        if (ok  &&  path)
        {
            pi = gtk_tree_path_get_indices(path);
        }

        if (pi)
        {
            *num_items = *pi + 1;
        }
        else
        {
            *num_items = 0;
        }
        LOGPRINTF("num_items [%d]", *num_items);

        // clean up
        if (path) { gtk_tree_path_free(path); }
        path = NULL;
    }
    LOGPRINTF("leave");
}


void ergtk_list_view_set_cursor (erGtkListView  *er_listview, gint row)
{
    g_return_if_fail(ERGTK_IS_LIST_VIEW(er_listview));

    GtkTreeView      *treeview  = (GtkTreeView*) er_listview;
    GtkWidget        *widget    = (GtkWidget  *) er_listview;
    GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
    
    GtkTreePath *path = NULL;  
    gint num_rows = 0;
    gint num_items = 0;
    
    LOGPRINTF("entry: row %d", row);

    ergtk_list_view_get_view_size(er_listview, &num_rows, &num_items); 
    LOGPRINTF("num_rows %d, num_items %d", num_rows, num_items);

    // force row within valid range
    if (row >= num_items)
    {
        row = num_items - 1;
    }
    if (row < 0)
    {
        row = -1;
    }

    // create path from index and set cursor
    if (num_items > 0)
    {
        path = gtk_tree_path_new_from_indices(row, -1);
        gtk_widget_grab_focus (widget);
        gtk_tree_selection_select_path(selection, path);  
        gtk_tree_view_set_cursor(treeview, path, NULL, FALSE);
    }

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

    return;
}


void ergtk_list_view_set_focus_mode (erGtkListView *er_listview, 
                                     gboolean      focus_in,
                                     gboolean      focus_out)
{
    LOGPRINTF("entry");

    if (!focus_in)
    {
        // block focus-in events 
        g_signal_connect(G_OBJECT(er_listview), "focus-in-event", G_CALLBACK (on_focus_in), NULL);
    }
    if (!focus_out)
    {
        // block focus-out events 
        g_signal_connect(G_OBJECT(er_listview), "focus-out-event", G_CALLBACK (on_focus_out), NULL);
    }
}


void ergtk_list_view_set_row_height (erGtkListView *er_listview, gint row_height)
{
    g_return_if_fail(ERGTK_IS_LIST_VIEW(er_listview));

    gint        focus_line_width = 0;

    LOGPRINTF("entry");

    if (row_height > 0)
    {
        gtk_widget_style_get( GTK_WIDGET(er_listview),
                              "focus-line-width", &focus_line_width,
                              NULL );
        er_listview->row_height       = row_height + (2 * focus_line_width);
        er_listview->is_forced_height = TRUE;
    }
    else
    {
        er_listview->row_height       = -1;
        er_listview->is_forced_height = FALSE;
    }
}


//
// Internal functions
//

static gboolean on_pre_move_cursor (erGtkListView         *er_listview,
                                    erGtkListViewKeyPress navigate     )
{
    GtkTreeView     *treeview = (GtkTreeView *) er_listview;

    gboolean        rc;  
    GtkTreePath     *path = NULL;
    gint            currow   = 0;       // cursor row
    gint            num_rows = 0;       // number of rows
    gint            num_items = 0;      // number of items currently displayed

    g_return_val_if_fail (ERGTK_LIST_VIEW (er_listview), FALSE);

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

    ergtk_list_view_get_cursor(er_listview, &currow);
    ergtk_list_view_get_view_size(er_listview, &num_rows, &num_items); 

    LOGPRINTF("navigate [%d] currow [%d] num_rows [%d] num_items [%d]",
               navigate,     currow,     num_rows,     num_items       );

    switch (navigate)
    {
    case ERGTK_LIST_VIEW_PRESS_SHORT_UP:
        if (currow > 0)
        {
            // move up line in view
            g_signal_emit_by_name(er_listview, "move-cursor", GTK_MOVEMENT_DISPLAY_LINES, -1, &rc);
        }
        else 
        {      
            // emit signal
            g_signal_emit_by_name(er_listview, "navigate-cursor", ERGTK_LIST_VIEW_PRESS_SHORT_UP);
        }
        break;
        
    case ERGTK_LIST_VIEW_PRESS_SHORT_DOWN:
        if (currow + 1 < num_items)
        {
            g_signal_emit_by_name (er_listview, "move-cursor", GTK_MOVEMENT_DISPLAY_LINES, 1, &rc);
        }
        else
        {
            g_signal_emit_by_name(er_listview, "navigate-cursor", ERGTK_LIST_VIEW_PRESS_SHORT_DOWN);
        }
        break;
        
    case ERGTK_LIST_VIEW_PRESS_LONG_UP:
        g_signal_emit_by_name(er_listview, "navigate-cursor", ERGTK_LIST_VIEW_PRESS_LONG_UP);
        break;
        
    case ERGTK_LIST_VIEW_PRESS_LONG_DOWN:
        g_signal_emit_by_name(er_listview, "navigate-cursor", ERGTK_LIST_VIEW_PRESS_LONG_DOWN);
        break;
        
    case ERGTK_LIST_VIEW_PRESS_ACTIVATE:
        gtk_tree_view_row_activated(treeview, path, NULL);
        break;

    default:
        g_assert_not_reached();
        break;
    }

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

    return TRUE;
}


static void
add_move_binding (GtkBindingSet         *binding_set,
                  guint                 keyval,
                  GdkModifierType       modmask,
                  erGtkListViewKeyPress navigate)
{
    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 gboolean on_focus_in(GtkWidget *widget, gpointer data)
{
    LOGPRINTF("entry");

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


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

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