ergtkcellrenderertext.c

Go to the documentation of this file.

/*
 * File Name: ergtkcellrenderertext.c
 */

/*
 * 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) 2009 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <glib.h>

// ereader include files, between < >

// local include files, between " "
#include "ergtk_log.h"
#include "ergtkcellrenderertext.h"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------

// class-specific properties
typedef enum
        {
            PROP_NOT_USED = 0,  // not sure whether param_id zero is allowed
            PROP_FONT,          // font definition
            PROP_HEIGHT,        // line height
            PROP_TEXT,          // text to be displayed
            PROP_COLOR,
            NUM_PROPS
        } prop_t;

// instance private data
typedef struct
        {
            guint       n_lines;       // number of text lines to be displayed

            struct                     // details of each line:                             
            {
                gchar   *font;         // font definition
                guint   height;        // line height
                gchar   *text;         // text to be rendered
                gchar   *color;        // text color         
            } details[ ERGTK_CELL_RENDERER_TEXT_MAX_LINES ];

        } erGtkCellRendererTextPrivate;
    

//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

static const gchar      *PROPNAME_FONT   = "font";
static const gchar      *PROPNAME_HEIGHT = "height";
static const gchar      *PROPNAME_TEXT   = "text";
static const gchar      *PROPNAME_COLOR  = "foreground";


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static GtkCellRendererTextClass* g_parent_class = NULL;


//============================================================================
// Local Function Definitions
//============================================================================

// Functions for GObject derived object:
//   Overloaded methods for base class
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 get_size_impl(GtkCellRenderer *cell,
                          GtkWidget       *widget,
                          GdkRectangle    *cell_area,
                          gint            *x_offset,
                          gint            *y_offset,
                          gint            *width,
                          gint            *height);

static void render_impl (GtkCellRenderer *cell,
                         GdkWindow       *window,
                         GtkWidget       *widget,
                         GdkRectangle    *background_area,
                         GdkRectangle    *cell_area,
                         GdkRectangle    *expose_area,
                         guint            flags);

//   Overloaded signal handlers for base class

//   Implementation of virtual methods

//   Local functions
static void     ergtk_cell_renderer_text_class_init     (erGtkCellRendererTextClass *klass);
static void     ergtk_cell_renderer_text_init           (erGtkCellRendererText *thiz);
static void     ergtk_cell_renderer_text_finalize       (GObject *obj);


//============================================================================
// Functions Implementation
//============================================================================

// get object type
GType ergtk_cell_renderer_text_get_type (void)
{
    static GType class_type = 0;

    if (class_type == 0)
    {
        static const GTypeInfo class_info =
        {
            sizeof(erGtkCellRendererTextClass),                     // class_size
            NULL,                                                   // base_init
            NULL,                                                   // base_finalize
            (GClassInitFunc) ergtk_cell_renderer_text_class_init,   // class_init
            NULL,                                                   // class_finalize
            NULL,                                                   // class_data
            sizeof(erGtkCellRendererText),                          // instance_size
            0,                                                      // n_preallocs
            (GInstanceInitFunc) ergtk_cell_renderer_text_init,      // instance_init
            NULL                                                    // value_table
        };

        class_type = g_type_register_static( GTK_TYPE_CELL_RENDERER_TEXT,   // parent_type
                                             "erGtkCellRendererText",       // type_name
                                             &class_info,                   // info
                                             0 );                           // flags
    }

    return class_type;
}


// class init
static void ergtk_cell_renderer_text_class_init (erGtkCellRendererTextClass* klass)
{
    GObjectClass         *object_class        = (GObjectClass *) klass;
    GtkCellRendererClass *cell_renderer_class = (GtkCellRendererClass *) klass;

    gint        line;
    GParamSpec  *pspec;
    GString     *prop_name = g_string_new("");
    GString     *prop_ext  = g_string_new("");

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

    // overload some virtual methods
    cell_renderer_class->render = render_impl;
    cell_renderer_class->get_size = get_size_impl;
    object_class->get_property  = get_property_impl;
    object_class->set_property  = set_property_impl;
    object_class->finalize      = ergtk_cell_renderer_text_finalize;

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

    // install custom properties
    for ( line = 0 ; line < ERGTK_CELL_RENDERER_TEXT_MAX_LINES ; line++ )
    {
        g_string_printf(prop_ext, "-%d", line);

        // font
        g_string_assign(prop_name, PROPNAME_FONT);
        g_string_append(prop_name, prop_ext->str);
        pspec = g_param_spec_string( prop_name->str,
                                     prop_name->str,
                                     "Font definition for n-th line",
                                     "",        // default
                                     G_PARAM_READWRITE | G_PARAM_CONSTRUCT );
        g_object_class_install_property( object_class, PROP_FONT + (line * NUM_PROPS), pspec);

        // line height
        g_string_assign(prop_name, PROPNAME_HEIGHT);
        g_string_append(prop_name, prop_ext->str);
        pspec = g_param_spec_uint( prop_name->str,
                                   prop_name->str,
                                   "Line height for n-th line",
                                   0,      // min.
                                   200,    // max.
                                   10,     // default
                                   G_PARAM_READWRITE | G_PARAM_CONSTRUCT );
        g_object_class_install_property( object_class, PROP_HEIGHT + (line * NUM_PROPS), pspec);

        // text
        g_string_assign(prop_name, PROPNAME_TEXT);
        g_string_append(prop_name, prop_ext->str);
        pspec = g_param_spec_string( prop_name->str,
                                     prop_name->str,
                                     "Text for n-th line",
                                     "",        // default
                                     G_PARAM_READWRITE | G_PARAM_CONSTRUCT );
        g_object_class_install_property( object_class, PROP_TEXT + (line * NUM_PROPS), pspec);

        // color
        g_string_assign(prop_name, PROPNAME_COLOR);
        g_string_append(prop_name, prop_ext->str);
        pspec = g_param_spec_string( prop_name->str,
                                     prop_name->str,
                                     "Color for n-th line",
                                     "black",      // default
                                     G_PARAM_READWRITE | G_PARAM_CONSTRUCT );
        g_object_class_install_property( object_class, PROP_COLOR + (line * NUM_PROPS), pspec);
    }

    // clean up
    if (prop_name) { g_string_free(prop_name, TRUE); }
    if (prop_ext ) { g_string_free(prop_ext , TRUE); }
}


// instance init
static void ergtk_cell_renderer_text_init (erGtkCellRendererText *thiz)
{
    g_return_if_fail( IS_ERGTK_CELL_RENDERER_TEXT(thiz) );

    erGtkCellRendererTextPrivate *priv = ERGTK_CELL_RENDERER_TEXT_GET_PRIVATE(thiz);

    gint    line;

    // instance data
    //   public
    //   private
    priv->n_lines = 1;
    for ( line = 0 ; line < ERGTK_CELL_RENDERER_TEXT_MAX_LINES ; line++ )
    {
        priv->details[line].font = NULL;
        priv->details[line].text = NULL;
        priv->details[line].color = NULL;
    }
}


// finalize instance
static void ergtk_cell_renderer_text_finalize (GObject *obj)
{
    g_return_if_fail( IS_ERGTK_CELL_RENDERER_TEXT(obj) );

    erGtkCellRendererTextPrivate *priv = ERGTK_CELL_RENDERER_TEXT_GET_PRIVATE(obj);

    gint    line;

    // destroy instance data
    //   private
    for ( line = 0 ; line < ERGTK_CELL_RENDERER_TEXT_MAX_LINES ; line++ )
    {
        g_free(priv->details[line].font);
        g_free(priv->details[line].text);
        g_free(priv->details[line].color);
    }
    //   public: none

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


// create object
GtkCellRenderer *ergtk_cell_renderer_text_new (const guint n_lines)
{
    erGtkCellRendererText        *thiz = (erGtkCellRendererText*) g_object_new(ERGTK_CELL_RENDERER_TEXT_TYPE, NULL);
    erGtkCellRendererTextPrivate *priv = ERGTK_CELL_RENDERER_TEXT_GET_PRIVATE(thiz);

    priv->n_lines = MIN( n_lines, ERGTK_CELL_RENDERER_TEXT_MAX_LINES );

    return (GtkCellRenderer*) thiz;
}


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

    erGtkCellRendererTextPrivate *priv = ERGTK_CELL_RENDERER_TEXT_GET_PRIVATE(object);

    const gint   line = param_id / NUM_PROPS;
    const prop_t prop = param_id % NUM_PROPS;

    if (   prop == PROP_NOT_USED
        || line >= ERGTK_CELL_RENDERER_TEXT_MAX_LINES )
    {
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
        return;
    }

    switch (prop)
    {
        case PROP_FONT:
            g_value_set_string (value, priv->details[line].font);
            break; 

        case PROP_HEIGHT:
            g_value_set_uint (value, priv->details[line].height);
            break;

        case PROP_TEXT:
            g_value_set_string (value, priv->details[line].text);
            break;

        case PROP_COLOR:
            g_value_set_string (value, priv->details[line].color);
            break;

        default:
            ; // ignore
    }
}


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

    erGtkCellRendererTextPrivate *priv = ERGTK_CELL_RENDERER_TEXT_GET_PRIVATE(object);

    guint        u;
    gchar        **cpp;
    const gint   line = param_id / NUM_PROPS;
    const prop_t prop = param_id % NUM_PROPS;

    if (   prop == PROP_NOT_USED
        || line >= ERGTK_CELL_RENDERER_TEXT_MAX_LINES )
    {
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
        return;
    }

    switch (prop)
    {
        case PROP_FONT:
            cpp = &(priv->details[line].font);
            g_free(*cpp);
            *cpp = g_strdup(g_value_get_string(value));
            LOGPRINTF("font[%d] set to [%s]", line, *cpp);
            break; 

        case PROP_HEIGHT:
            u = g_value_get_uint(value);
            priv->details[line].height = u;
            LOGPRINTF("height[%d] set to [%u]", line, u);
            break;

        case PROP_TEXT:
            cpp = &(priv->details[line].text);
            g_free(*cpp);
            *cpp = g_strdup(g_value_get_string(value));
            LOGPRINTF("text[%d] set to [%s]", line, *cpp);
            break;

        case PROP_COLOR:
            g_free(priv->details[line].color);
            priv->details[line].color = g_strdup(g_value_get_string(value));
            break;

        default:
            ; // ignore
    }
}


// Quick fix for 0002830: Content view sometimes uses wrong item height 
static void get_size_impl(GtkCellRenderer *cell,
                          GtkWidget       *widget,
                          GdkRectangle    *cell_area,
                          gint            *x_offset,
                          gint            *y_offset,
                          gint            *width,
                          gint            *height)
{
    static const int FIXED_HEIGHT = 60;
    static const int MIN_WIDTH = 100;
    gint calc_width  = cell->xpad * 2 + MIN_WIDTH;
    gint calc_height = cell->ypad * 2 + FIXED_HEIGHT;

    if (cell_area && cell_area->width > calc_width) calc_width = cell_area->width;

    if (width) *width = calc_width;
    if (height) *height = calc_height;

    if (cell_area) {
        if (x_offset) {
            *x_offset = cell->xalign * (cell_area->width - calc_width);
            *x_offset = MAX (*x_offset, 0);
        }

        if (y_offset) {
            *y_offset = cell->yalign * (cell_area->height - calc_height);
            *y_offset = MAX (*y_offset, 0);
        }
    }
}
// Quick fix end


// render one cell
static void render_impl (GtkCellRenderer *cell,
                         GdkWindow       *window,
                         GtkWidget       *widget,
                         GdkRectangle    *background_area,
                         GdkRectangle    *cell_area,
                         GdkRectangle    *expose_area,
                         guint            flags)
{
    g_return_if_fail( IS_ERGTK_CELL_RENDERER_TEXT(cell) );

    erGtkCellRendererText        *thiz = (erGtkCellRendererText *) cell;
    erGtkCellRendererTextPrivate *priv = ERGTK_CELL_RENDERER_TEXT_GET_PRIVATE(thiz);

    guint           line;
    gint            height;
    gboolean        ok;
    const gint      max_y          = cell_area->y + cell_area->height;
    GdkRectangle    sub_cell_area  = *cell_area;
    GdkRectangle    sub_expose_area;
    const gchar     *font;
    const gchar     *text;
    const gchar     *color;
    gchar           *font_default = NULL;

    // get default font
    g_object_get( thiz,
                  PROPNAME_FONT, &font_default,
                  NULL );

    // gtkcellrenderertext renderer omits the foreground 
    // color for selected lines so they default to black
    // to avoid this behaviour, we clear the selected bit
    flags &= ~GTK_CELL_RENDERER_SELECTED;

    // render each line of text
    for ( line = 0 ; line < priv->n_lines ; line++ )
    {
        // set properties for this line
        font = priv->details[line].font;
        if (   font    == NULL
            || font[0] == '\0' )
        {
            font = font_default;
        }
        text = priv->details[line].text;
        if ( text == NULL )
        {
            text = "";
        }
        color = priv->details[line].color;
        if (color == NULL) color = "black";
        g_object_set( thiz,
                      PROPNAME_FONT, font,
                      PROPNAME_TEXT, text,
                      PROPNAME_COLOR, color,
                      NULL );
        LOGPRINTF("line [%d] font [%s] text [%s] color [%s] flags [%d]", line, font, text, color, flags);
        
        // determine line height
        //TODO gtk_cell_renderer_text_set_fixed_height_from_font( GTK_CELL_RENDERER_TEXT(thiz), 1 );
        //TODO gtk_cell_renderer_get_fixed_size( GTK_CELL_RENDERER(thiz), NULL, &height );
        height = priv->details[line].height;

        // render current line
        sub_cell_area.y      = MIN( sub_cell_area.y,  max_y                    );
        sub_cell_area.height = MIN( height,          (max_y - sub_cell_area.y) );
        if ( sub_cell_area.height > 0 )
        {
            sub_expose_area = *expose_area;
            ok = gdk_rectangle_intersect( &sub_cell_area, &sub_expose_area, &sub_expose_area );
            if (ok)
            {
                g_parent_class->parent_class.render( cell,
                                                     window,
                                                     widget,
                                                     background_area,
                                                     &sub_cell_area,
                                                     &sub_expose_area,
                                                     flags );
            }
        }

        // advance to next line's vertical offset
        sub_cell_area.y += sub_cell_area.height;
    }

    // restore default font
    g_object_set( thiz,
                  PROPNAME_FONT, font_default,
                  NULL );

    // clean up
    g_free(font_default);

}