ergtkcellrendererborder.c

Go to the documentation of this file.

/*
 * File Name: ergtkcellrendererborder.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 "ergtkcellrendererborder.h"


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

// class-specific properties
typedef enum
        {
            PROP_NOT_USED = 0,      // not sure whether param_id zero is allowed
            PROP_BORDER_WIDTH,      // border width in pixels
            PROP_BORDER_OFFSET,     // border offset from boundaries in pixels
            PROP_BORDER_COLOR,      // border colour as a string
            NUM_PROPS
        } prop_t;

// instance private data
typedef struct
        {
            guint       border_width;           // border width in pixels
            guint       border_offset;          // border offset from boundaries in pixels
            gchar       *border_color;          // border colour as a string
        } erGtkCellRendererBorderPrivate;
    

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

static const gchar      *PROPNAME_BORDER_WIDTH  = "border-width";
static const gchar      *PROPNAME_BORDER_OFFSET = "border-offset";
static const gchar      *PROPNAME_BORDER_COLOR  = "border-color";


//----------------------------------------------------------------------------
// 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 render_impl (GtkCellRenderer *cell,
                         GdkWindow       *window,
                         GtkWidget       *widget,
                         GdkRectangle    *bg_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_border_class_init     (erGtkCellRendererBorderClass *klass);
static void     ergtk_cell_renderer_border_init           (erGtkCellRendererBorder *thiz);
static void     ergtk_cell_renderer_border_finalize       (GObject *obj);


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

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

    if (class_type == 0)
    {
        static const GTypeInfo class_info =
        {
            sizeof(erGtkCellRendererBorderClass),                   // class_size
            NULL,                                                   // base_init
            NULL,                                                   // base_finalize
            (GClassInitFunc) ergtk_cell_renderer_border_class_init, // class_init
            NULL,                                                   // class_finalize
            NULL,                                                   // class_data
            sizeof(erGtkCellRendererBorder),                        // instance_size
            0,                                                      // n_preallocs
            (GInstanceInitFunc) ergtk_cell_renderer_border_init,    // instance_init
            NULL                                                    // value_table
        };

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

    return class_type;
}


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

    GParamSpec  *pspec;

    // 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;
    object_class->get_property  = get_property_impl;
    object_class->set_property  = set_property_impl;
    object_class->finalize      = ergtk_cell_renderer_border_finalize;

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

    // install custom properties
    //   border width
    pspec = g_param_spec_uint( PROPNAME_BORDER_WIDTH,
                               PROPNAME_BORDER_WIDTH,
                               "Border width in pixels",
                               0,      // min.
                               10,     // max.
                               1,      // default
                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT );
    g_object_class_install_property( object_class, PROP_BORDER_WIDTH, pspec);
    //   border offset
    pspec = g_param_spec_uint( PROPNAME_BORDER_OFFSET,
                               PROPNAME_BORDER_OFFSET,
                               "Border width in pixels",
                               0,      // min.
                               10,     // max.
                               0,      // default
                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT );
    g_object_class_install_property( object_class, PROP_BORDER_OFFSET, pspec);
    //   border colour
    pspec = g_param_spec_string( PROPNAME_BORDER_COLOR,
                                 PROPNAME_BORDER_COLOR,
                                 "Border colour as a string",
                                 "",        // default
                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT );
    g_object_class_install_property( object_class, PROP_BORDER_COLOR, pspec);
}


// instance init
static void ergtk_cell_renderer_border_init (erGtkCellRendererBorder *thiz)
{
    g_return_if_fail( IS_ERGTK_CELL_RENDERER_BORDER(thiz) );

    erGtkCellRendererBorderPrivate *priv = ERGTK_CELL_RENDERER_BORDER_GET_PRIVATE(thiz);

    // instance data
    //   public
    //   private
    priv->border_color = NULL;
}


// finalize instance
static void ergtk_cell_renderer_border_finalize (GObject *obj)
{
    g_return_if_fail( IS_ERGTK_CELL_RENDERER_BORDER(obj) );

    erGtkCellRendererBorderPrivate *priv = ERGTK_CELL_RENDERER_BORDER_GET_PRIVATE(obj);

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

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


// create object
GtkCellRenderer *ergtk_cell_renderer_border_new (void)
{
    erGtkCellRendererBorder        *thiz = (erGtkCellRendererBorder*) g_object_new(ERGTK_CELL_RENDERER_BORDER_TYPE, NULL);
    //erGtkCellRendererBorderPrivate *priv = ERGTK_CELL_RENDERER_BORDER_GET_PRIVATE(thiz);

    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_BORDER(object) );

    erGtkCellRendererBorderPrivate *priv = ERGTK_CELL_RENDERER_BORDER_GET_PRIVATE(object);

    switch (param_id)
    {
        case PROP_BORDER_WIDTH:
            g_value_set_uint (value, priv->border_width);
            break;

        case PROP_BORDER_OFFSET:
            g_value_set_uint (value, priv->border_offset);
            break;

        case PROP_BORDER_COLOR:
            g_value_set_string (value, priv->border_color);
            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( IS_ERGTK_CELL_RENDERER_BORDER(object) );

    erGtkCellRendererBorderPrivate *priv = ERGTK_CELL_RENDERER_BORDER_GET_PRIVATE(object);

    guint        u;
    gchar        **cpp;

    switch (param_id)
    {
        case PROP_BORDER_WIDTH:
            u = g_value_get_uint(value);
            priv->border_width = u;
            LOGPRINTF("border-width set to [%u]", u);
            break;

        case PROP_BORDER_OFFSET:
            u = g_value_get_uint(value);
            priv->border_offset = u;
            LOGPRINTF("border-offset set to [%u]", u);
            break;

        case PROP_BORDER_COLOR:
            cpp = &(priv->border_color);
            g_free(*cpp);
            *cpp = g_strdup(g_value_get_string(value));
            LOGPRINTF("border-color set to [%s]", *cpp);
            break;

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


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

    erGtkCellRendererBorder        *thiz = (erGtkCellRendererBorder *) cell;
    erGtkCellRendererBorderPrivate *priv = ERGTK_CELL_RENDERER_BORDER_GET_PRIVATE(thiz);

    gint border = priv->border_offset;
    gint x      = 0               + border;
    gint y      = bg_area->y      + border;
    gint w      = bg_area->x      + bg_area->width - (2 * border) - 1;
    gint h      = bg_area->height                  - (2 * border);

    gtk_paint_box( widget->style, 
                   window, 
                   GTK_STATE_NORMAL,
                   GTK_SHADOW_NONE, 
                   NULL, widget, "ergtkcellrendererborder", 
                   x, y, w, h );
}