git.maemo.org Git - modest/blob - src/maemo/modest-progress-bar-widget.c

   1 /* Copyright (c) 2006, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  * * Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  * * Redistributions in binary form must reproduce the above copyright
  11  *   notice, this list of conditions and the following disclaimer in the
  12  *   documentation and/or other materials provided with the distribution.
  13  * * Neither the name of the Nokia Corporation nor the names of its
  14  *   contributors may be used to endorse or promote products derived from
  15  *   this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  18  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  19  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include <glib/gi18n.h>
  31 #include <gtk/gtk.h>
  32 #include <widgets/modest-combo-box.h>
  33 #include "modest-progress-bar-widget.h"
  34 #include <string.h>
  35
  36 /* 'private'/'protected' functions */
  37 static void modest_progress_bar_widget_class_init (ModestProgressBarWidgetClass *klass);
  38 static void modest_progress_bar_widget_init       (ModestProgressBarWidget *obj);
  39 static void modest_progress_bar_widget_finalize   (GObject *obj);
  40
  41 static void modest_progress_bar_add_operation    (ModestProgressObject *self,
  42                                                     ModestMailOperation  *mail_op);
  43
  44 static void modest_progress_bar_remove_operation (ModestProgressObject *self,
  45                                                     ModestMailOperation  *mail_op);
  46
  47 static void on_progress_changed                    (ModestMailOperation  *mail_op,
  48                                                     ModestProgressBarWidget *self);
  49
  50 static gboolean     progressbar_clean        (GtkProgressBar *bar);
  51
  52 #define XALIGN 1
  53 #define YALIGN 0.5
  54 #define XSPACE 1
  55 #define YSPACE 0
  56
  57 #define LOWER 0
  58 #define UPPER 150
  59
  60 /* list my signals  */
  61 /* enum { */
  62 /*      LAST_SIGNAL */
  63 /* }; */
  64
  65 typedef struct _ObservableData ObservableData;
  66 struct _ObservableData {
  67         guint signal_handler;
  68         ModestMailOperation *mail_op;
  69 };
  70
  71 typedef struct _ModestProgressBarWidgetPrivate ModestProgressBarWidgetPrivate;
  72 struct _ModestProgressBarWidgetPrivate {
  73         GSList              *observables;
  74         ModestMailOperation *current;
  75
  76         GtkWidget *progress_bar;
  77 };
  78 #define MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  79                                                  MODEST_TYPE_PROGRESS_BAR_WIDGET, \
  80                                                  ModestProgressBarWidgetPrivate))
  81
  82 /* globals */
  83 static GtkContainerClass *parent_class = NULL;
  84
  85 /* uncomment the following if you have defined any signals */
  86 /* static guint signals[LAST_SIGNAL] = {0}; */
  87
  88 static void
  89 modest_progress_object_init (gpointer g, gpointer iface_data)
  90 {
  91         ModestProgressObjectIface *klass = (ModestProgressObjectIface *)g;
  92
  93         klass->add_operation_func = modest_progress_bar_add_operation;
  94         klass->remove_operation_func = modest_progress_bar_remove_operation;
  95 }
  96
  97
  98 GType
  99 modest_progress_bar_widget_get_type (void)
 100 {
 101         static GType my_type = 0;
 102         if (!my_type) {
 103                 static const GTypeInfo my_info = {
 104                         sizeof(ModestProgressBarWidgetClass),
 105                         NULL,           /* base init */
 106                         NULL,           /* base finalize */
 107                         (GClassInitFunc) modest_progress_bar_widget_class_init,
 108                         NULL,           /* class finalize */
 109                         NULL,           /* class data */
 110                         sizeof(ModestProgressBarWidget),
 111                         1,              /* n_preallocs */
 112                         (GInstanceInitFunc) modest_progress_bar_widget_init,
 113                         NULL
 114                 };
 115
 116                 static const GInterfaceInfo modest_progress_object_info =
 117                 {
 118                   (GInterfaceInitFunc) modest_progress_object_init, /* interface_init */
 119                   NULL,         /* interface_finalize */
 120                   NULL          /* interface_data */
 121                 };
 122
 123                 my_type = g_type_register_static (GTK_TYPE_VBOX,
 124                                                   "ModestProgressBarWidget",
 125                                                   &my_info, 0);
 126
 127                 g_type_add_interface_static (my_type, MODEST_TYPE_PROGRESS_OBJECT,
 128                                              &modest_progress_object_info);
 129         }
 130         return my_type;
 131 }
 132
 133 static void
 134 modest_progress_bar_widget_class_init (ModestProgressBarWidgetClass *klass)
 135 {
 136         GObjectClass *gobject_class;
 137         gobject_class = (GObjectClass*) klass;
 138
 139         parent_class            = g_type_class_peek_parent (klass);
 140         gobject_class->finalize = modest_progress_bar_widget_finalize;
 141
 142         g_type_class_add_private (gobject_class, sizeof(ModestProgressBarWidgetPrivate));
 143
 144         /* signal definitions go here, e.g.: */
 145 /*      signals[DATA_CHANGED_SIGNAL] = */
 146 /*              g_signal_new ("data_changed", */
 147 /*                            G_TYPE_FROM_CLASS (klass), */
 148 /*                            G_SIGNAL_RUN_FIRST, */
 149 /*                            G_STRUCT_OFFSET(ModestProgressBarWidgetClass, data_changed), */
 150 /*                            NULL, NULL, */
 151 /*                            g_cclosure_marshal_VOID__VOID, */
 152 /*                            G_TYPE_NONE, 0); */
 153 }
 154
 155 static void
 156 modest_progress_bar_widget_init (ModestProgressBarWidget *self)
 157 {
 158
 159         ModestProgressBarWidgetPrivate *priv;
 160         GtkWidget *align = NULL;
 161         GtkRequisition req;
 162         GtkAdjustment *adj;
 163
 164         priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE(self);
 165
 166         /* Build GtkProgressBar */
 167         align = gtk_alignment_new(XALIGN, YALIGN, XSPACE, YSPACE);
 168         adj = (GtkAdjustment *) gtk_adjustment_new (0, LOWER, UPPER, 0, 0, 0);
 169         priv->progress_bar = gtk_progress_bar_new_with_adjustment (adj);
 170         req.width = 50;
 171         req.height = 64;
 172         gtk_progress_set_text_alignment (GTK_PROGRESS (priv->progress_bar), 0, 0.5);
 173         gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (priv->progress_bar), PANGO_ELLIPSIZE_END);
 174         gtk_widget_size_request (priv->progress_bar, &req);
 175         gtk_container_add (GTK_CONTAINER (align), priv->progress_bar);
 176
 177         /* Add progress bar widget */
 178         gtk_box_pack_start (GTK_BOX(self), align, TRUE, TRUE, 0);
 179         gtk_container_add(GTK_CONTAINER(align), priv->progress_bar);
 180         gtk_widget_show_all (GTK_WIDGET(self));
 181 }
 182
 183 static void
 184 destroy_observable_data (ObservableData *data)
 185 {
 186         g_signal_handler_disconnect (data->mail_op, data->signal_handler);
 187         g_object_unref (data->mail_op);
 188 }
 189
 190 static void
 191 modest_progress_bar_widget_finalize (GObject *obj)
 192 {
 193         ModestProgressBarWidgetPrivate *priv;
 194
 195         priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE(obj);
 196         if (priv->observables) {
 197                 GSList *tmp;
 198
 199                 for (tmp = priv->observables; tmp; tmp = g_slist_next (tmp)) {
 200                         destroy_observable_data ((ObservableData *) tmp->data);
 201                         g_free (tmp->data);
 202                 }
 203                 g_slist_free (priv->observables);
 204                 priv->observables = NULL;
 205         }
 206
 207         G_OBJECT_CLASS(parent_class)->finalize (obj);
 208 }
 209
 210
 211 static void
 212 modest_progress_bar_add_operation (ModestProgressObject *self,
 213                                    ModestMailOperation  *mail_op)
 214 {
 215         ModestProgressBarWidget *me;
 216         ObservableData *data;
 217         ModestProgressBarWidgetPrivate *priv;
 218
 219         me = MODEST_PROGRESS_BAR_WIDGET (self);
 220         priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE (me);
 221
 222         data = g_malloc0 (sizeof (ObservableData));
 223         data->mail_op = g_object_ref (mail_op);
 224         data->signal_handler = g_signal_connect (data->mail_op,
 225                                                  "progress-changed",
 226                                                  G_CALLBACK (on_progress_changed),
 227                                                  me);
 228
 229         if (priv->observables == NULL) {
 230                 priv->current = mail_op;
 231         }
 232         priv->observables = g_slist_append (priv->observables, data);
 233
 234         /* Call progress_change handler to initialize progress message */
 235 /*      on_progress_changed (mail_op, me); */
 236 }
 237
 238 static gint
 239 compare_observable_data (ObservableData *data1, ObservableData *data2)
 240 {
 241         if (data1->mail_op == data2->mail_op)
 242                 return 0;
 243         else
 244                 return 1;
 245 }
 246
 247 static void
 248 modest_progress_bar_remove_operation (ModestProgressObject *self,
 249                                         ModestMailOperation  *mail_op)
 250 {
 251         ModestProgressBarWidget *me;
 252         ModestProgressBarWidgetPrivate *priv;
 253         GSList *link;
 254         ObservableData *tmp_data = NULL;
 255
 256         me = MODEST_PROGRESS_BAR_WIDGET (self);
 257         priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE (me);
 258
 259         /* Find item */
 260         tmp_data = g_malloc0 (sizeof (ObservableData));
 261         tmp_data->mail_op = g_object_ref (mail_op);
 262         link = g_slist_find_custom (priv->observables,
 263                                     tmp_data,
 264                                     (GCompareFunc) compare_observable_data);
 265
 266         /* Remove the item */
 267         if (link) {
 268                 priv->observables = g_slist_remove_link (priv->observables, link);
 269                 destroy_observable_data ((ObservableData *) link->data);
 270         }
 271
 272         /* Update the current mail operation */
 273         if (priv->current == mail_op) {
 274                 if (priv->observables)
 275                         priv->current = ((ObservableData *) priv->observables->data)->mail_op;
 276                 else
 277                         priv->current = NULL;
 278
 279                 /* Refresh the view */
 280                 progressbar_clean (GTK_PROGRESS_BAR (priv->progress_bar));
 281         }
 282
 283         /* free */
 284         g_free(tmp_data);
 285 }
 286
 287 static void
 288 on_progress_changed (ModestMailOperation  *mail_op,
 289                      ModestProgressBarWidget *self)
 290 {
 291         ModestProgressBarWidgetPrivate *priv;
 292         gboolean determined = FALSE;
 293         ModestMailOperationId id;
 294
 295         priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE (self);
 296
 297         /* If the mail operation is the currently shown one */
 298         if (priv->current == mail_op) {
 299                 gchar *msg = NULL;
 300                 gint done = modest_mail_operation_get_task_done (mail_op);
 301                 gint total = modest_mail_operation_get_task_total (mail_op);
 302
 303                 determined = (done > 0 && total > 0);
 304                 id = modest_mail_operation_get_id (mail_op);
 305
 306                 switch (id) {
 307                 case MODEST_MAIL_OPERATION_ID_RECEIVE:
 308                         if (determined)
 309                                 msg = g_strdup_printf(_("mcen_me_receiving"), done, total);
 310                         else
 311                                 msg = g_strdup(_("mail_me_receiving"));
 312                         break;
 313                 case MODEST_MAIL_OPERATION_ID_SEND:
 314                         if (determined)
 315                                 msg = g_strdup_printf(_("mcen_me_sending"), done, total);
 316                         else
 317                                 msg = g_strdup(_("mail_me_sending"));
 318                         break;
 319
 320                 case MODEST_MAIL_OPERATION_ID_OPEN:
 321                         msg = g_strdup(_("mail_me_opening"));
 322                         break;
 323                 default:
 324                         msg = g_strdup("");
 325                 }
 326
 327                 modest_progress_bar_widget_set_progress (self, msg, done, total);
 328                 g_free (msg);
 329         }
 330 }
 331
 332 static gboolean
 333 progressbar_clean (GtkProgressBar *bar)
 334 {
 335         gtk_progress_bar_set_fraction (bar, 0);
 336         gtk_progress_bar_set_text (bar, 0);
 337         return FALSE;
 338 }
 339
 340
 341 GtkWidget*
 342 modest_progress_bar_widget_new ()
 343 {
 344         return GTK_WIDGET (g_object_new (MODEST_TYPE_PROGRESS_BAR_WIDGET, NULL));
 345 }
 346
 347
 348 void
 349 modest_progress_bar_widget_set_progress   (ModestProgressBarWidget *self,
 350                                            const gchar *message,
 351                                            gint done,
 352                                            gint total)
 353 {
 354         ModestProgressBarWidgetPrivate *priv;
 355
 356         priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE (self);
 357
 358         /* Set progress */
 359         if (total != 0)
 360                 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (priv->progress_bar),
 361                                                (gdouble)done/(gdouble)total);
 362         else
 363                 gtk_progress_bar_pulse (GTK_PROGRESS_BAR (priv->progress_bar));
 364
 365         /* Set text */
 366         gtk_progress_bar_set_text (GTK_PROGRESS_BAR (priv->progress_bar), message);
 367 }
 368