Main Page | Modules | Data Structures | File List | Data Fields | Globals | Related Pages

gtask-cell-renderer-progress.c

Go to the documentation of this file.
00001 /*
00002  * Copyright (C) 2002 Naba Kumar <kh_naba@users.sourceforge.net>
00003  * heavily modified by Jörgen Scheibengruber <mfcn@gmx.de>
00004  * borrowed from gnome-system-monitor and modified yet some more
00005  */
00006 #include <stdlib.h>
00007 #include <stdio.h>
00008 
00009 #include <gtask/gtask-generic-task.h>
00010 
00011 #include <gtask-ui/gtask-cell-renderer-progress.h>
00012 
00013 #include "gtask-ui-util.h"
00014 
00016 /* @{ */
00017 
00018 enum {
00019   PROP_0,
00020   C_PROP_VALUE,
00021   C_PROP_ACTIVITY_STATE
00022 }; 
00023 
00024 static gpointer parent_class;
00025 
00026 static void
00027 gtask_cell_renderer_progress_init( GTaskCellRendererProgress *cell );
00028 
00029 static void
00030 gtask_cell_renderer_progress_class_init( GTaskCellRendererProgressClass *klass );
00031 
00032 static void
00033 gtask_cell_renderer_progress_finalize( GObject *object );
00034 
00035 static void
00036 gtask_cell_renderer_progress_get_property( GObject    *object,
00037                                            guint       param_id,
00038                                            GValue     *value,
00039                                            GParamSpec *pspec );
00040 
00041 static void
00042 gtask_cell_renderer_progress_set_property( GObject      *object,
00043                                            guint         param_id,
00044                                            const GValue *value,
00045                                            GParamSpec   *pspec );
00046 
00047 static void
00048 gtask_cell_renderer_progress_get_size( GtkCellRenderer *cell,
00049                                        GtkWidget       *widget,
00050                                        GdkRectangle    *cell_area,
00051                                        gint            *x_offset,
00052                                        gint            *y_offset,
00053                                        gint            *width,
00054                                        gint            *height );
00055 
00056 static void
00057 gtask_cell_renderer_progress_render( GtkCellRenderer *cell,
00058                                      GdkWindow       *window,
00059                                      GtkWidget       *widget,
00060                                      GdkRectangle    *background_area,
00061                                      GdkRectangle    *cell_area,
00062                                      GdkRectangle    *expose_area,
00063                                      guint            flags );
00064 
00065 GtkType gtask_cell_renderer_progress_get_type( void ) {
00066         static GtkType type = 0;
00067 
00068         if( !type ) {
00069                 static const GTypeInfo info = {
00070                         sizeof( GTaskCellRendererProgressClass ),
00071                         NULL,           /* base_init */
00072                         NULL,           /* base_finalize */
00073                         (GClassInitFunc) gtask_cell_renderer_progress_class_init,
00074                         NULL,           /* class_finalize */
00075                         NULL,           /* class_data */
00076                         sizeof( GTaskCellRendererProgress ),
00077                         0,              /* n_preallocs */
00078                         (GInstanceInitFunc) gtask_cell_renderer_progress_init,
00079                 };
00080 
00081                 type = g_type_register_static( GTK_TYPE_CELL_RENDERER,
00082                                        "GTaskCellRendererProgress",
00083                                        &info,
00084                                        0);
00085         }
00086 
00087         return type;
00088 }
00089 
00090 static void
00091 gtask_cell_renderer_progress_init( GTaskCellRendererProgress *cell ) {
00092     GTaskCellRendererProgressPrivate *private;
00093 
00094     private = g_new0( GTaskCellRendererProgressPrivate, 1 );
00095 
00096     private->value = 0;
00097 
00098     cell->private = private;
00099 }
00100 
00101 static void
00102 gtask_cell_renderer_progress_class_init( GTaskCellRendererProgressClass *klass) {
00103         GObjectClass         *object_class = G_OBJECT_CLASS( klass );
00104         GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS( klass );
00105 
00106         parent_class = g_type_class_peek_parent( klass );
00107   
00108         object_class->finalize = gtask_cell_renderer_progress_finalize;
00109   
00110         object_class->get_property = gtask_cell_renderer_progress_get_property;
00111         object_class->set_property = gtask_cell_renderer_progress_set_property;
00112 
00113         cell_class->get_size = gtask_cell_renderer_progress_get_size;
00114         cell_class->render = gtask_cell_renderer_progress_render;
00115   
00116         g_object_class_install_property( object_class,
00117                                      C_PROP_VALUE,
00118                                      g_param_spec_float( "value",
00119                                                          "Value",
00120                                                          "Value of the progress bar.",
00121                                                          0, 100, 0,
00122                                                          G_PARAM_READWRITE));
00123 
00124 
00125     g_object_class_install_property( object_class,
00126                                      C_PROP_ACTIVITY_STATE,
00127                                      g_param_spec_enum( "activity-state",
00128                                                        "Task Activity State",
00129                                                        "The activity state of the task.",
00130                                                        GTASK_ACTIVITY_STATE_TYPE,
00131                                                        GTASK_ACTIVITY_STATE_INACTIVE,
00132                                                        G_PARAM_READWRITE));
00133 
00134 }
00135 
00136 static void
00137 gtask_cell_renderer_progress_get_property( GObject     *object,
00138                                            guint       param_id,
00139                                            GValue     *value,
00140                                            GParamSpec *pspec )
00141 {
00142         GTaskCellRendererProgress        *cell = GTASK_CELL_RENDERER_PROGRESS(object);
00143     GTaskCellRendererProgressPrivate *private = cell->private;
00144 
00145         switch( param_id ) {
00146                 case C_PROP_VALUE:
00147                         g_value_set_float( value, private->value );
00148                         break;
00149         case C_PROP_ACTIVITY_STATE:
00150             g_value_set_int( value, private->activity_state );
00151             break;
00152                 default:
00153                         G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
00154         }
00155 }
00156 
00157 static void
00158 gtask_cell_renderer_progress_set_property( GObject       *object,
00159                                            guint         param_id,
00160                                            const GValue *value,
00161                                            GParamSpec   *pspec )
00162 {
00163         GTaskCellRendererProgress        *cell = GTASK_CELL_RENDERER_PROGRESS(object);
00164     GTaskCellRendererProgressPrivate *private = cell->private;
00165 
00166         switch( param_id ) {
00167                 case C_PROP_VALUE:
00168                         private->value = g_value_get_float( value );
00169                 g_object_notify( object, "value" );
00170                         break;
00171         case C_PROP_ACTIVITY_STATE:
00172             private->activity_state = g_value_get_enum( value );
00173             g_object_notify( object, "activity-state" );
00174             break;
00175                 default:
00176                         G_OBJECT_WARN_INVALID_PROPERTY_ID( object, param_id, pspec );
00177         }
00178 }
00179 
00180 static void
00181 gtask_cell_renderer_progress_get_size( GtkCellRenderer *cell,
00182                                        GtkWidget       *widget,
00183                                        GdkRectangle    *cell_area,
00184                                        gint            *x_offset,
00185                                        gint            *y_offset,
00186                                        gint            *width,
00187                                        gint            *height)
00188 {
00189         //GTaskCellRendererProgress *cellprogress = (GTaskCellRendererProgress *) cell;
00190 
00191 /* Always return 1 here. Doesn't make to much sense,
00192  * but providing the real width would make it
00193  * impossible for the bar to shrink again.
00194  */
00195     /* TODO fix these dirty hacks */
00196     /* TODO have properties that are set to the maximum lengths
00197      * of text we are expecting and do something reasonable */
00198         if (width)
00199                 *width = 108;
00200         if (height)
00201                 *height = 26;
00202 }
00203 
00204 GtkCellRenderer*
00205 gtask_cell_renderer_progress_new( void ) {
00206         return GTK_CELL_RENDERER( g_object_new( GTASK_CELL_RENDERER_PROGRESS_TYPE, NULL ) );
00207 }
00208 
00209 static void
00210 gtask_cell_renderer_progress_render( GtkCellRenderer *cell,
00211                                   GdkWindow       *window,
00212                                   GtkWidget       *widget,
00213                                   GdkRectangle    *background_area,
00214                                   GdkRectangle    *cell_area,
00215                                   GdkRectangle    *expose_area,
00216                                   guint            flags)
00217 {
00218         GTaskCellRendererProgress *cell_progress = GTASK_CELL_RENDERER_PROGRESS( cell );
00219         int x, y, w, h;
00220 
00221     /* the progress bar will have a set width for now */
00222         x = cell_area->x + 4;
00223         y = cell_area->y + 2;
00224     w = 100;
00225         h = cell_area->height - 4;
00226 
00227     gtask_ui_draw_progressbar( widget,
00228                                window,
00229                                cell_area,
00230                                cell_progress->private->value,
00231                                cell_progress->private->activity_state,
00232                                x,
00233                                y,
00234                                w,
00235                                h );
00236 }
00237 
00238 static void
00239 gtask_cell_renderer_progress_finalize( GObject *obj ) {
00240         GTaskCellRendererProgress *cell = GTASK_CELL_RENDERER_PROGRESS( obj );
00241 
00242         g_free( cell->private );
00243   
00244         if( G_OBJECT_CLASS( parent_class )->finalize )
00245             G_OBJECT_CLASS( parent_class )->finalize( obj );
00246 }
00247 
00248 /* @} */

Generated on Mon Feb 2 21:33:25 2004 for libgtask-ui by doxygen 1.3.4