ergtkentry.c

Go to the documentation of this file.

/*
 * 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/>.
 */

/**
 * \file ergtkentry.c
 * \brief ereader gtk library - GtkEntry object adapted for ereader system
 *
 * forces visibility ON during entry (not during editing)
 * 
 * Copyright (C) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

// system include files
#include <string.h>
#include <ctype.h>
#include <gtk/gtk.h>

// ereader library includes

// local includes
#include "ergtk_log.h"
#include "ergtkentry.h"

// simulate overloading gtk_entry_set_text()
#undef gtk_entry_set_text


// instance private data
typedef struct
        {
            gboolean     visible;           // false = protect text entry by displaying '***'
            GString      *invisible_text;   // old entry text stored while entry has focus
        } erGtkEntryPrivate;

// local data
static GtkEntryClass* g_parent_class = NULL;

// class-specific signals for erGtkEntry

// overloaded methods for base class

// overloaded signal handlers for base class
static gboolean ergtk_entry_focus_in    (GtkWidget *widget, GdkEventFocus *event);
static gboolean ergtk_entry_focus_out   (GtkWidget *widget, GdkEventFocus *event);
static void     ergtk_entry_changed     (GtkEditable *widget);

// implementation of virtual methods

// local functions
static void     ergtk_entry_class_init      (erGtkEntryClass *klass);
static void     ergtk_entry_editable_init   (GtkEditableClass *iface);
static void     ergtk_entry_init            (erGtkEntry *input_entry);
static void     ergtk_entry_finalize        (GObject *obj);


GtkWidget* ergtk_entry_new()
{
    LOGPRINTF("entry");
    erGtkEntry* item = (erGtkEntry *) g_object_new(ERGTK_ENTRY_TYPE, NULL);

    return GTK_WIDGET(item);
}

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

    if (class_type == 0)
    {
        static const GTypeInfo class_info =
        {
            sizeof(erGtkEntryClass),
            NULL,               /* base_init */
            NULL,               /* base_finalize */
            (GClassInitFunc) ergtk_entry_class_init,
            NULL,               /* class_finalize */
            NULL,               /* class_data */
            sizeof(erGtkEntry),
            0,                  /* n_preallocs */
            (GInstanceInitFunc) ergtk_entry_init,
            NULL                /* *value_table */            
        };
        class_type = g_type_register_static(GTK_TYPE_ENTRY, "erGtkEntry", &class_info, 0);

        static const GInterfaceInfo editable_info =
        {
            (GInterfaceInitFunc)ergtk_entry_editable_init, /* interface_init */
            NULL, /* interface_finalize */
            NULL  /* interface_data */
        };
        g_type_add_interface_static(class_type, GTK_TYPE_EDITABLE, &editable_info);
    }

    return class_type;
}

// init class
static void ergtk_entry_class_init(erGtkEntryClass *klass)
{
    LOGPRINTF("entry");

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

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

    // overload some virtual methods
    widget_class->focus_in_event  = ergtk_entry_focus_in;
    widget_class->focus_out_event = ergtk_entry_focus_out;
    object_class->finalize        = ergtk_entry_finalize;

    // reserve space for instance private data
    g_type_class_add_private (klass, sizeof(erGtkEntryPrivate));
}

// init GtkEditable interface
static void ergtk_entry_editable_init(GtkEditableClass *iface)
{
    LOGPRINTF("entry");

    iface->changed = ergtk_entry_changed;
}

// init instance
static void ergtk_entry_init(erGtkEntry *er_entry)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ENTRY(er_entry));

    GtkEntry  *entry  = (GtkEntry  *) er_entry;
    GtkWidget *widget = (GtkWidget *) er_entry;
    
    erGtkEntryPrivate *priv = ERGTK_ENTRY_GET_PRIVATE(er_entry);

    // E-ink display requires a non-blinking cursur
    g_object_set(gtk_widget_get_settings(widget), "gtk-cursor-blink", FALSE, NULL);
    
    // set default attributes
    gtk_entry_set_editable(entry, TRUE);
    gtk_entry_set_visibility(entry, TRUE);
                  
    // instance-private data
    priv->visible        = TRUE;
    priv->invisible_text = g_string_new("");
}

// finalize instance
static void ergtk_entry_finalize (GObject *obj)
{
    LOGPRINTF("entry: obj [%p]", obj);
    g_return_if_fail( ERGTK_IS_ENTRY(obj) );

    erGtkEntryPrivate *priv = ERGTK_ENTRY_GET_PRIVATE(obj);

    // destroy instance data
    //   private
    g_string_free(priv->invisible_text, TRUE);
    //   public: none

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


// public methods


// signal handlers
static gboolean ergtk_entry_focus_in(GtkWidget *widget, GdkEventFocus *event)
{
    LOGPRINTF("entry");
    g_return_val_if_fail(ERGTK_IS_ENTRY(widget), FALSE);

    gboolean    rc = FALSE;
    GtkEntry    *entry    = (GtkEntry   *) widget;
    erGtkEntry  *er_entry = (erGtkEntry *) widget;

    erGtkEntryPrivate *priv = ERGTK_ENTRY_GET_PRIVATE(er_entry);

    // chain to parent class
    if (g_parent_class->parent_class.focus_in_event)
    {
        rc = g_parent_class->parent_class.focus_in_event(widget, event);
    }

    // original code: if protected, show content when empty
    // work-around  : if protected, hide content and show empty entry field
    priv->visible = gtk_entry_get_visibility(entry);
    if (priv->visible == FALSE)
    {
        const gchar *text = gtk_entry_get_text(entry);
#if 0
        // Original code, to be restored when GtkEntry problem fixed
        // Seems to be fixed in GTK 2.15.0
        if (text[0] == '\0')
        {
            gtk_entry_set_visibility(entry, TRUE);
        }
#else
        // Work-around for problem in GtkEntry that hides
        // input method (keyboard) when focus is set on GtkEntry with visibility=FALSE
        g_string_assign( priv->invisible_text, text );
        gtk_entry_set_text( entry, "" );
        gtk_entry_set_visibility(entry, TRUE);
#endif
    }
    
    return rc;
}

static gboolean ergtk_entry_focus_out(GtkWidget *widget, GdkEventFocus *event)
{
    LOGPRINTF("entry");
    g_return_val_if_fail(ERGTK_IS_ENTRY(widget), FALSE);

    gboolean    rc = FALSE;
    GtkEntry    *entry    = GTK_ENTRY(widget);
    erGtkEntry  *er_entry = ERGTK_ENTRY(widget);

    erGtkEntryPrivate *priv = ERGTK_ENTRY_GET_PRIVATE(er_entry);

    // chain to parent class
    if (g_parent_class->parent_class.focus_out_event)
    {
        rc = g_parent_class->parent_class.focus_out_event(widget, event);
    }

    // de-select characters
    gtk_editable_select_region(GTK_EDITABLE(entry), -1, -1);

    // original code: if protected, hide content
    // work-around  : if protected, restore original con16tent when no new content, then hide content
    if (priv->visible == FALSE)
    {
#if 0
        // Original code, to be restored when GtkEntry problem fixed
        // Seems to be fixed in GTK 2.15.0
#else
        // Work-around for problem in GtkEntry that hides
        // input method (keyboard) when focus is set on GtkEntry with visibility=FALSE
        const gchar *text = gtk_entry_get_text(entry);
        if ( text[0] == '\0' )
        {
            gtk_entry_set_text( entry, priv->invisible_text->str );
        }
#endif
        gtk_entry_set_visibility(entry, FALSE);
    }
    
    return rc;
}

static void ergtk_entry_changed(GtkEditable *editable)
{
    LOGPRINTF("entry");
    g_return_if_fail(ERGTK_IS_ENTRY(editable));

    erGtkEntry *er_entry = (erGtkEntry *) editable;
    GtkEntry   *entry    = (GtkEntry   *) editable;
    GtkWidget  *widget   = (GtkWidget  *) editable;

    erGtkEntryPrivate *priv = ERGTK_ENTRY_GET_PRIVATE(er_entry);

    // for protected object, show content when empty
    if (   priv->visible == FALSE
        && gtk_widget_is_focus(widget) )
    {
        const gchar *text = gtk_entry_get_text(entry);
        if (text[0] == '\0')
        {
            gtk_entry_set_visibility(entry, TRUE);
        }
    }
}