git.maemo.org Git - modest/blob - src/modest-widget-factory.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 "modest-widget-factory.h"
  31 #include <tny-account-store-iface.h>
  32 #include <tny-device-iface.h>
  33
  34 /* 'private'/'protected' functions */
  35 static void modest_widget_factory_class_init    (ModestWidgetFactoryClass *klass);
  36 static void modest_widget_factory_init          (ModestWidgetFactory *obj);
  37 static void modest_widget_factory_finalize      (GObject *obj);
  38
  39
  40 /* callbacks */
  41 static void on_folder_selected         (ModestFolderView *folder_view,
  42                                         TnyMsgFolderIface *folder,
  43                                         ModestWidgetFactory *self);
  44 static void on_message_selected        (ModestHeaderView *header_view, TnyMsgIface *msg,
  45                                         ModestWidgetFactory *self);
  46 static void on_header_status_update    (ModestHeaderView *header_view, const gchar *msg,
  47                                         gint status_id, ModestWidgetFactory *self);
  48 static void on_msg_link_hover          (ModestMsgView *msgview, const gchar* link,
  49                                         ModestWidgetFactory *self);
  50 static void on_msg_link_clicked        (ModestMsgView *msgview, const gchar* link,
  51                                         ModestWidgetFactory *self);
  52 static void on_msg_attachment_clicked  (ModestMsgView *msgview, int index,
  53                                         ModestWidgetFactory *self);
  54
  55 static void on_connection_changed (TnyDeviceIface *device, gboolean online,
  56                                    ModestWidgetFactory *self);
  57 static void on_online_toggle_toggled (GtkToggleButton *toggle, ModestWidgetFactory *factory);
  58
  59
  60 /* list my signals */
  61 enum {
  62         /* MY_SIGNAL_1, */
  63         /* MY_SIGNAL_2, */
  64         LAST_SIGNAL
  65 };
  66
  67 typedef struct _ModestWidgetFactoryPrivate ModestWidgetFactoryPrivate;
  68 struct _ModestWidgetFactoryPrivate {
  69
  70         ModestTnyAccountStore *account_store;
  71         ModestAccountMgr      *account_mgr;
  72         ModestConf            *conf;
  73
  74         ModestHeaderView      *header_view;
  75         ModestFolderView      *folder_view;
  76         ModestMsgView         *msg_preview;
  77
  78         GtkWidget             *progress_bar;
  79         GtkWidget             *status_bar;
  80
  81         GtkWidget             *online_toggle;
  82 };
  83 #define MODEST_WIDGET_FACTORY_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  84                                                    MODEST_TYPE_WIDGET_FACTORY, \
  85                                                    ModestWidgetFactoryPrivate))
  86 /* globals */
  87 static GObjectClass *parent_class = NULL;
  88
  89 /* uncomment the following if you have defined any signals */
  90 /* static guint signals[LAST_SIGNAL] = {0}; */
  91
  92 GType
  93 modest_widget_factory_get_type (void)
  94 {
  95         static GType my_type = 0;
  96         if (!my_type) {
  97                 static const GTypeInfo my_info = {
  98                         sizeof(ModestWidgetFactoryClass),
  99                         NULL,           /* base init */
 100                         NULL,           /* base finalize */
 101                         (GClassInitFunc) modest_widget_factory_class_init,
 102                         NULL,           /* class finalize */
 103                         NULL,           /* class data */
 104                         sizeof(ModestWidgetFactory),
 105                         1,              /* n_preallocs */
 106                         (GInstanceInitFunc) modest_widget_factory_init,
 107                 };
 108                 my_type = g_type_register_static (G_TYPE_OBJECT,
 109                                                   "ModestWidgetFactory",
 110                                                   &my_info, 0);
 111         }
 112         return my_type;
 113 }
 114
 115 static void
 116 modest_widget_factory_class_init (ModestWidgetFactoryClass *klass)
 117 {
 118         GObjectClass *gobject_class;
 119         gobject_class = (GObjectClass*) klass;
 120
 121         parent_class            = g_type_class_peek_parent (klass);
 122         gobject_class->finalize = modest_widget_factory_finalize;
 123
 124         g_type_class_add_private (gobject_class, sizeof(ModestWidgetFactoryPrivate));
 125 }
 126
 127 static void
 128 modest_widget_factory_init (ModestWidgetFactory *obj)
 129 {
 130         ModestWidgetFactoryPrivate *priv;
 131         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(obj);
 132
 133         priv->conf          = NULL;
 134         priv->account_mgr   = NULL;
 135         priv->account_store = NULL;
 136
 137         priv->progress_bar = gtk_progress_bar_new ();
 138         gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(priv->progress_bar),
 139                                        1.0);
 140         priv->status_bar   = gtk_statusbar_new ();
 141         gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(priv->status_bar),
 142                                            FALSE);
 143 }
 144
 145 static void
 146 modest_widget_factory_finalize (GObject *obj)
 147 {
 148         ModestWidgetFactoryPrivate *priv;
 149         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(obj);
 150
 151         if (priv->account_mgr) {
 152                 g_object_unref (G_OBJECT(priv->account_mgr));
 153                 priv->account_mgr = NULL;
 154         }
 155
 156         if (priv->conf) {
 157                 g_object_unref (G_OBJECT(priv->conf));
 158                 priv->conf = NULL;
 159         }
 160
 161         if (priv->account_store) {
 162                 g_object_unref (G_OBJECT(priv->account_store));
 163                 priv->account_store = NULL;
 164         }
 165 }
 166
 167
 168
 169 static void
 170 init_signals (ModestWidgetFactory *self)
 171 {
 172
 173         TnyDeviceIface *device;
 174         ModestWidgetFactoryPrivate *priv;
 175
 176         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 177
 178         g_signal_connect (G_OBJECT(priv->header_view), "message_selected",
 179                           G_CALLBACK(on_message_selected), self);
 180         g_signal_connect (G_OBJECT(priv->folder_view), "folder_selected",
 181                           G_CALLBACK(on_folder_selected), self);
 182         g_signal_connect (G_OBJECT(priv->header_view), "status_update",
 183                           G_CALLBACK(on_header_status_update), self);
 184         g_signal_connect (G_OBJECT(priv->msg_preview), "link_clicked",
 185                           G_CALLBACK(on_msg_link_clicked), self);
 186         g_signal_connect (G_OBJECT(priv->msg_preview), "link_hover",
 187                           G_CALLBACK(on_msg_link_hover), self);
 188         g_signal_connect (G_OBJECT(priv->msg_preview), "attachment_clicked",
 189                           G_CALLBACK(on_msg_attachment_clicked), self);
 190
 191         /* FIXME: const casting is evil ==> tinymail */
 192         device = (TnyDeviceIface*)tny_account_store_iface_get_device
 193                 (TNY_ACCOUNT_STORE_IFACE(priv->account_store));
 194         if (device) {
 195                 g_signal_connect (G_OBJECT(device), "connection_changed",
 196                                   G_CALLBACK(on_connection_changed), self);
 197                 g_signal_connect (G_OBJECT(priv->online_toggle), "toggled",
 198                                   G_CALLBACK(on_online_toggle_toggled), self);
 199
 200                 /* init toggle in correct state */
 201                 on_connection_changed (device,
 202                                        tny_device_iface_is_online (device),
 203                                        self);
 204         }
 205 }
 206
 207 static gboolean
 208 init_widgets (ModestWidgetFactory *self)
 209 {
 210         ModestWidgetFactoryPrivate *priv;
 211         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 212
 213         /* folder view */
 214         if (!(priv->folder_view =
 215               MODEST_FOLDER_VIEW(modest_folder_view_new (priv->account_store)))) {
 216                 g_printerr ("modest: cannot instantiate folder view\n");
 217                 return FALSE;
 218         }
 219
 220         /* header view */
 221         if (!(priv->header_view =
 222               MODEST_HEADER_VIEW(modest_header_view_new
 223                                  (NULL, NULL,MODEST_HEADER_VIEW_STYLE_NORMAL)))) {
 224                 g_printerr ("modest: cannot instantiate header view\n");
 225                 return FALSE;
 226         }
 227
 228
 229         /* msg preview */
 230         if (!(priv->msg_preview = MODEST_MSG_VIEW(modest_msg_view_new (NULL)))) {
 231                 g_printerr ("modest: cannot instantiate header view\n");
 232                 return FALSE;
 233         }
 234
 235
 236         /* online/offline combo */
 237         priv->online_toggle = gtk_toggle_button_new ();
 238
 239         init_signals (self);
 240
 241         return TRUE;
 242 }
 243
 244
 245 ModestWidgetFactory*
 246 modest_widget_factory_new (ModestConf *conf,
 247                            ModestTnyAccountStore *account_store,
 248                            ModestAccountMgr *account_mgr)
 249 {
 250         GObject *obj;
 251         ModestWidgetFactoryPrivate *priv;
 252
 253         g_return_val_if_fail (account_store, NULL);
 254         g_return_val_if_fail (account_mgr, NULL);
 255         g_return_val_if_fail (conf, NULL);
 256
 257         obj  = g_object_new(MODEST_TYPE_WIDGET_FACTORY, NULL);
 258         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(obj);
 259
 260         g_object_ref (G_OBJECT(conf));
 261         priv->conf = conf;
 262
 263         g_object_ref (G_OBJECT(account_mgr));
 264         priv->account_mgr = account_mgr;
 265
 266         g_object_ref (G_OBJECT(account_store));
 267         priv->account_store = account_store;
 268
 269         if (!init_widgets (MODEST_WIDGET_FACTORY(obj))) {
 270                 g_printerr ("modest: widget factory failed to init widgets\n");
 271                 g_object_unref (obj);
 272                 return NULL;
 273         }
 274
 275         return MODEST_WIDGET_FACTORY(obj);
 276 }
 277
 278
 279
 280
 281 ModestFolderView*
 282 modest_widget_factory_get_folder_view (ModestWidgetFactory *self)
 283 {
 284         g_return_val_if_fail (self, NULL);
 285         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->folder_view;
 286 }
 287
 288
 289 ModestHeaderView*
 290 modest_widget_factory_get_header_view (ModestWidgetFactory *self)
 291 {
 292         g_return_val_if_fail (self, NULL);
 293         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->header_view;
 294 }
 295
 296
 297 ModestMsgView*
 298 modest_widget_factory_get_msg_preview (ModestWidgetFactory *self)
 299 {
 300         g_return_val_if_fail (self, NULL);
 301         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->msg_preview;
 302 }
 303
 304
 305 ModestAccountView*
 306 modest_widget_factory_get_account_view (ModestWidgetFactory *self)
 307 {
 308         ModestWidgetFactoryPrivate *priv;
 309
 310         g_return_val_if_fail (self, NULL);
 311         priv =  MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 312
 313         return modest_account_view_new (priv->account_mgr);
 314 }
 315
 316
 317
 318 GtkWidget*
 319 modest_widget_factory_get_progress_bar (ModestWidgetFactory *self)
 320 {
 321         g_return_val_if_fail (self, NULL);
 322         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->progress_bar;
 323 }
 324
 325
 326 GtkWidget*
 327 modest_widget_factory_get_status_bar (ModestWidgetFactory *self)
 328 {
 329         g_return_val_if_fail (self, NULL);
 330         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->status_bar;
 331 }
 332
 333
 334 GtkWidget*
 335 modest_widget_factory_get_combo_box (ModestWidgetFactory *self, ModestComboBoxType type)
 336 {
 337         GtkWidget *combo_box;
 338         const gchar **protos, **cursor;
 339
 340         g_return_val_if_fail (self, NULL);
 341
 342         combo_box = gtk_combo_box_new_text ();
 343
 344         switch (type) {
 345         case MODEST_COMBO_BOX_TYPE_STORE_PROTOS:
 346                 cursor = protos = modest_proto_store_protos ();
 347                 break;
 348         case MODEST_COMBO_BOX_TYPE_TRANSPORT_PROTOS:
 349                 cursor = protos = modest_proto_transport_protos ();
 350                 break;
 351         case MODEST_COMBO_BOX_TYPE_SECURITY_PROTOS:
 352                 cursor = protos = modest_proto_security_protos ();
 353                 break;
 354         case MODEST_COMBO_BOX_TYPE_AUTH_PROTOS:
 355                 cursor = protos = modest_proto_auth_protos ();
 356                 break;
 357         default:
 358                 g_assert_not_reached ();
 359         }
 360         while (cursor && *cursor) {
 361                 gtk_combo_box_append_text (GTK_COMBO_BOX(combo_box),
 362                                            (const gchar*)*cursor);
 363                 ++cursor;
 364         }
 365         gtk_combo_box_set_active (GTK_COMBO_BOX(combo_box), 0);
 366
 367         return combo_box;
 368 }
 369
 370
 371
 372
 373 GtkWidget*
 374 modest_widget_factory_get_online_toggle (ModestWidgetFactory *self)
 375 {
 376         g_return_val_if_fail (self, NULL);
 377         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->online_toggle;
 378 }
 379
 380
 381
 382 static void
 383 on_folder_selected (ModestFolderView *folder_view, TnyMsgFolderIface *folder,
 384                     ModestWidgetFactory *self)
 385 {
 386         ModestWidgetFactoryPrivate *priv;
 387         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 388
 389         modest_header_view_set_folder (priv->header_view, folder);
 390 }
 391
 392
 393 static void
 394 on_message_selected (ModestHeaderView *folder_view, TnyMsgIface *msg,
 395                      ModestWidgetFactory *self)
 396 {
 397         ModestWidgetFactoryPrivate *priv;
 398         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 399
 400         modest_msg_view_set_message (priv->msg_preview, msg);
 401 }
 402
 403
 404 /*
 405  * below some stuff to clearup statusbar messages after 1,5 seconds....
 406  */
 407 typedef struct {
 408         GtkWidget *status_bar;
 409         GtkWidget *progress_bar;
 410         guint     msg_id;
 411 } StatusRemoveData;
 412
 413
 414 static gboolean
 415 on_statusbar_remove_msg (StatusRemoveData *data)
 416 {
 417         gtk_statusbar_remove (GTK_STATUSBAR(data->status_bar), 0, data->msg_id);
 418         g_free (data);
 419
 420         gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(data->progress_bar), 1.0);
 421
 422         return FALSE;
 423 }
 424
 425
 426 static void
 427 statusbar_push (ModestWidgetFactory *self, guint context_id, const gchar *msg)
 428 {
 429         guint id;
 430         StatusRemoveData *data;
 431         ModestWidgetFactoryPrivate *priv;
 432
 433         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 434
 435         if (!msg)
 436                 return;
 437
 438         id = gtk_statusbar_push (GTK_STATUSBAR(priv->status_bar), 0, msg);
 439
 440         data = g_new (StatusRemoveData, 1);
 441         data->status_bar   = priv->status_bar;
 442         data->progress_bar = priv->progress_bar;
 443         data->msg_id     = id;
 444
 445         g_timeout_add (1500, (GSourceFunc)on_statusbar_remove_msg, data);
 446 }
 447 /****************************************************************************/
 448
 449
 450 static void
 451 on_header_status_update (ModestHeaderView *header_view, const gchar *msg,
 452                          gint status_id, ModestWidgetFactory *self)
 453 {
 454         ModestWidgetFactoryPrivate *priv;
 455
 456         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 457
 458         gtk_progress_bar_pulse (GTK_PROGRESS_BAR(priv->progress_bar));
 459         statusbar_push (self, 0, msg);
 460 }
 461
 462
 463 static void
 464 on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
 465                    ModestWidgetFactory *self)
 466 {
 467         ModestWidgetFactoryPrivate *priv;
 468         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 469
 470         statusbar_push (self, 0, link);
 471
 472 }
 473
 474
 475 static void
 476 on_msg_link_clicked  (ModestMsgView *msgview, const gchar* link,
 477                       ModestWidgetFactory *self)
 478 {
 479         gchar *msg;
 480         msg = g_strdup_printf (_("Opening %s..."), link);
 481         statusbar_push (self, 0, msg);
 482         g_free (msg);
 483 }
 484
 485 static void
 486 on_msg_attachment_clicked  (ModestMsgView *msgview, int index,
 487                             ModestWidgetFactory *self)
 488 {
 489         gchar *msg;
 490
 491         msg = g_strdup_printf (_("Opening attachment %d..."), index);
 492         statusbar_push (self, 0, msg);
 493
 494         g_free (msg);
 495 }
 496
 497
 498 static void
 499 on_connection_changed (TnyDeviceIface *device, gboolean online,
 500                        ModestWidgetFactory *self)
 501 {
 502         ModestWidgetFactoryPrivate *priv;
 503         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 504
 505         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->online_toggle),
 506                                       online);
 507         gtk_button_set_label (GTK_BUTTON(priv->online_toggle),
 508                               online ? _("Online") : _("Offline"));
 509
 510         statusbar_push (self, 0, online ? _("Modest went online") : _("Modest went offline"));
 511 }
 512
 513
 514 static void
 515 on_online_toggle_toggled (GtkToggleButton *toggle, ModestWidgetFactory *self)
 516 {
 517         gboolean online;
 518         const TnyDeviceIface *device;
 519         ModestWidgetFactoryPrivate *priv;
 520
 521         priv    = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 522         online  = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(priv->online_toggle));
 523         device  = tny_account_store_iface_get_device
 524                 (TNY_ACCOUNT_STORE_IFACE(priv->account_store));
 525
 526         /* FIXME: const casting should not be necessary ==> tinymail */
 527         if (online)  /* we're moving to online state */
 528                 tny_device_iface_force_online ((TnyDeviceIface*)device);
 529         else  /* we're moving to offline state */
 530                 tny_device_iface_force_offline ((TnyDeviceIface*)device);
 531 }