gtask-cell-renderer-progress.c

Go to the documentation of this file.

/*
 * Copyright (C) 2002 Naba Kumar <kh_naba@users.sourceforge.net>
 * heavily modified by Jörgen Scheibengruber <mfcn@gmx.de>
 * borrowed from gnome-system-monitor and modified yet some more
 */
#include <stdlib.h>
#include <stdio.h>

#include <gtask/gtask-generic-task.h>

#include <gtask-ui/gtask-cell-renderer-progress.h>

#include "gtask-ui-util.h"

/* @{ */

enum {
  PROP_0,
  C_PROP_VALUE,
  C_PROP_ACTIVITY_STATE
}; 

static gpointer parent_class;

static void
gtask_cell_renderer_progress_init( GTaskCellRendererProgress *cell );

static void
gtask_cell_renderer_progress_class_init( GTaskCellRendererProgressClass *klass );

static void
gtask_cell_renderer_progress_finalize( GObject *object );

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

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

static void
gtask_cell_renderer_progress_get_size( GtkCellRenderer *cell,
                                       GtkWidget       *widget,
                                       GdkRectangle    *cell_area,
                                       gint            *x_offset,
                                       gint            *y_offset,
                                       gint            *width,
                                       gint            *height );

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

GtkType gtask_cell_renderer_progress_get_type( void ) {
        static GtkType type = 0;

        if( !type ) {
                static const GTypeInfo info = {
                        sizeof( GTaskCellRendererProgressClass ),
                        NULL,           /* base_init */
                        NULL,           /* base_finalize */
                        (GClassInitFunc) gtask_cell_renderer_progress_class_init,
                        NULL,           /* class_finalize */
                        NULL,           /* class_data */
                        sizeof( GTaskCellRendererProgress ),
                        0,              /* n_preallocs */
                        (GInstanceInitFunc) gtask_cell_renderer_progress_init,
                };

                type = g_type_register_static( GTK_TYPE_CELL_RENDERER,
                                       "GTaskCellRendererProgress",
                                       &info,
                                       0);
        }

        return type;
}

static void
gtask_cell_renderer_progress_init( GTaskCellRendererProgress *cell ) {
    GTaskCellRendererProgressPrivate *private;

    private = g_new0( GTaskCellRendererProgressPrivate, 1 );

    private->value = 0;

    cell->private = private;
}

static void
gtask_cell_renderer_progress_class_init( GTaskCellRendererProgressClass *klass) {
        GObjectClass         *object_class = G_OBJECT_CLASS( klass );
        GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS( klass );

        parent_class = g_type_class_peek_parent( klass );
  
        object_class->finalize = gtask_cell_renderer_progress_finalize;
  
        object_class->get_property = gtask_cell_renderer_progress_get_property;
        object_class->set_property = gtask_cell_renderer_progress_set_property;

        cell_class->get_size = gtask_cell_renderer_progress_get_size;
        cell_class->render = gtask_cell_renderer_progress_render;
  
        g_object_class_install_property( object_class,
                                     C_PROP_VALUE,
                                     g_param_spec_float( "value",
                                                         "Value",
                                                         "Value of the progress bar.",
                                                         0, 100, 0,
                                                         G_PARAM_READWRITE));


    g_object_class_install_property( object_class,
                                     C_PROP_ACTIVITY_STATE,
                                     g_param_spec_enum( "activity-state",
                                                       "Task Activity State",
                                                       "The activity state of the task.",
                                                       GTASK_ACTIVITY_STATE_TYPE,
                                                       GTASK_ACTIVITY_STATE_INACTIVE,
                                                       G_PARAM_READWRITE));

}

static void
gtask_cell_renderer_progress_get_property( GObject     *object,
                                           guint       param_id,
                                           GValue     *value,
                                           GParamSpec *pspec )
{
        GTaskCellRendererProgress        *cell = GTASK_CELL_RENDERER_PROGRESS(object);
    GTaskCellRendererProgressPrivate *private = cell->private;

        switch( param_id ) {
                case C_PROP_VALUE:
                        g_value_set_float( value, private->value );
                        break;
        case C_PROP_ACTIVITY_STATE:
            g_value_set_int( value, private->activity_state );
            break;
                default:
                        G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
        }
}

static void
gtask_cell_renderer_progress_set_property( GObject       *object,
                                           guint         param_id,
                                           const GValue *value,
                                           GParamSpec   *pspec )
{
        GTaskCellRendererProgress        *cell = GTASK_CELL_RENDERER_PROGRESS(object);
    GTaskCellRendererProgressPrivate *private = cell->private;

        switch( param_id ) {
                case C_PROP_VALUE:
                        private->value = g_value_get_float( value );
                g_object_notify( object, "value" );
                        break;
        case C_PROP_ACTIVITY_STATE:
            private->activity_state = g_value_get_enum( value );
            g_object_notify( object, "activity-state" );
            break;
                default:
                        G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
        }
}

static void
gtask_cell_renderer_progress_get_size( GtkCellRenderer *cell,
                                       GtkWidget       *widget,
                                       GdkRectangle    *cell_area,
                                       gint            *x_offset,
                                       gint            *y_offset,
                                       gint            *width,
                                       gint            *height)
{
        //GTaskCellRendererProgress *cellprogress = (GTaskCellRendererProgress *) cell;

/* Always return 1 here. Doesn't make to much sense,
 * but providing the real width would make it
 * impossible for the bar to shrink again.
 */
    /* TODO fix these dirty hacks */
    /* TODO have properties that are set to the maximum lengths
     * of text we are expecting and do something reasonable */
        if (width)
                *width = 108;
        if (height)
                *height = 26;
}

GtkCellRenderer*
gtask_cell_renderer_progress_new( void ) {
        return GTK_CELL_RENDERER( g_object_new( GTASK_CELL_RENDERER_PROGRESS_TYPE, NULL ) );
}

static void
gtask_cell_renderer_progress_render( GtkCellRenderer *cell,
                                  GdkWindow       *window,
                                  GtkWidget       *widget,
                                  GdkRectangle    *background_area,
                                  GdkRectangle    *cell_area,
                                  GdkRectangle    *expose_area,
                                  guint            flags)
{
        GTaskCellRendererProgress *cell_progress = GTASK_CELL_RENDERER_PROGRESS( cell );
        int x, y, w, h;

    /* the progress bar will have a set width for now */
        x = cell_area->x + 4;
        y = cell_area->y + 2;
    w = 100;
        h = cell_area->height - 4;

    gtask_ui_draw_progressbar( widget,
                               window,
                               cell_area,
                               cell_progress->private->value,
                               cell_progress->private->activity_state,
                               x,
                               y,
                               w,
                               h );
}

static void
gtask_cell_renderer_progress_finalize( GObject *obj ) {
        GTaskCellRendererProgress *cell = GTASK_CELL_RENDERER_PROGRESS( obj );

        g_free( cell->private );
  
        if( G_OBJECT_CLASS( parent_class )->finalize )
            G_OBJECT_CLASS( parent_class )->finalize( obj );
}

/* @} */

---