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 other impl specific header files */
  32
  33 /* 'private'/'protected' functions */
  34 static void modest_widget_factory_class_init    (ModestWidgetFactoryClass *klass);
  35 static void modest_widget_factory_init          (ModestWidgetFactory *obj);
  36 static void modest_widget_factory_finalize      (GObject *obj);
  37
  38
  39 /* callbacks */
  40 static void on_folder_selected         (ModestFolderView *folder_view,
  41                                         TnyMsgFolderIface *folder,
  42                                         ModestWidgetFactory *self);
  43 static void on_message_selected        (ModestHeaderView *header_view, TnyMsgIface *msg,
  44                                         ModestWidgetFactory *self);
  45 static void on_header_status_update    (ModestHeaderView *header_view, const gchar *msg,
  46                                         gint status_id, ModestWidgetFactory *self);
  47 static void on_msg_link_hover          (ModestMsgView *msgview, const gchar* link,
  48                                         ModestWidgetFactory *self);
  49 static void on_msg_link_clicked        (ModestMsgView *msgview, const gchar* link,
  50                                         ModestWidgetFactory *self);
  51 static void on_msg_attachment_clicked  (ModestMsgView *msgview, int index,
  52                                         ModestWidgetFactory *self);
  53
  54 /* list my signals */
  55 enum {
  56         /* MY_SIGNAL_1, */
  57         /* MY_SIGNAL_2, */
  58         LAST_SIGNAL
  59 };
  60
  61
  62 enum _StatusID {
  63         STATUS_ID_HEADER,
  64         STATUS_ID_FOLDER,
  65         STATUS_ID_MESSAGE,
  66
  67         STATUS_ID_NUM
  68 };
  69 typedef enum _StatusID StatusID;
  70
  71 typedef struct _ModestWidgetFactoryPrivate ModestWidgetFactoryPrivate;
  72 struct _ModestWidgetFactoryPrivate {
  73
  74         ModestTnyAccountStore *account_store;
  75         ModestAccountMgr      *account_mgr;
  76         ModestConf            *conf;
  77
  78         ModestHeaderView      *header_view;
  79         ModestFolderView      *folder_view;
  80         ModestMsgView         *msg_preview;
  81
  82         GtkWidget             *progress_bar;
  83         GtkWidget             *status_bar;
  84
  85         gboolean              auto_connect;
  86
  87         StatusID              status_bar_ctx[STATUS_ID_NUM];
  88
  89 };
  90 #define MODEST_WIDGET_FACTORY_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  91                                                    MODEST_TYPE_WIDGET_FACTORY, \
  92                                                    ModestWidgetFactoryPrivate))
  93 /* globals */
  94 static GObjectClass *parent_class = NULL;
  95
  96 /* uncomment the following if you have defined any signals */
  97 /* static guint signals[LAST_SIGNAL] = {0}; */
  98
  99 GType
 100 modest_widget_factory_get_type (void)
 101 {
 102         static GType my_type = 0;
 103         if (!my_type) {
 104                 static const GTypeInfo my_info = {
 105                         sizeof(ModestWidgetFactoryClass),
 106                         NULL,           /* base init */
 107                         NULL,           /* base finalize */
 108                         (GClassInitFunc) modest_widget_factory_class_init,
 109                         NULL,           /* class finalize */
 110                         NULL,           /* class data */
 111                         sizeof(ModestWidgetFactory),
 112                         1,              /* n_preallocs */
 113                         (GInstanceInitFunc) modest_widget_factory_init,
 114                 };
 115                 my_type = g_type_register_static (G_TYPE_OBJECT,
 116                                                   "ModestWidgetFactory",
 117                                                   &my_info, 0);
 118         }
 119         return my_type;
 120 }
 121
 122 static void
 123 modest_widget_factory_class_init (ModestWidgetFactoryClass *klass)
 124 {
 125         GObjectClass *gobject_class;
 126         gobject_class = (GObjectClass*) klass;
 127
 128         parent_class            = g_type_class_peek_parent (klass);
 129         gobject_class->finalize = modest_widget_factory_finalize;
 130
 131         g_type_class_add_private (gobject_class, sizeof(ModestWidgetFactoryPrivate));
 132 }
 133
 134 static void
 135 modest_widget_factory_init (ModestWidgetFactory *obj)
 136 {
 137         ModestWidgetFactoryPrivate *priv;
 138         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(obj);
 139
 140         priv->conf          = NULL;
 141         priv->account_mgr   = NULL;
 142         priv->account_store = NULL;
 143
 144         priv->progress_bar = gtk_progress_bar_new ();
 145         gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(priv->progress_bar),
 146                                        1.0);
 147         priv->status_bar   = gtk_statusbar_new ();
 148         gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(priv->status_bar),
 149                                            FALSE);
 150
 151         priv->status_bar_ctx[STATUS_ID_HEADER] =
 152                 gtk_statusbar_get_context_id (GTK_STATUSBAR(priv->status_bar),
 153                                               "header");
 154         priv->status_bar_ctx[STATUS_ID_MESSAGE] =
 155                 gtk_statusbar_get_context_id (GTK_STATUSBAR(priv->status_bar),
 156                                               "message");
 157         priv->status_bar_ctx[STATUS_ID_FOLDER] =
 158                 gtk_statusbar_get_context_id (GTK_STATUSBAR(priv->status_bar),
 159                                               "folder");
 160 }
 161
 162 static void
 163 modest_widget_factory_finalize (GObject *obj)
 164 {
 165         ModestWidgetFactoryPrivate *priv;
 166         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(obj);
 167
 168         if (priv->account_mgr) {
 169                 g_object_unref (G_OBJECT(priv->account_mgr));
 170                 priv->account_mgr = NULL;
 171         }
 172
 173         if (priv->conf) {
 174                 g_object_unref (G_OBJECT(priv->conf));
 175                 priv->conf = NULL;
 176         }
 177
 178         if (priv->account_store) {
 179                 g_object_unref (G_OBJECT(priv->account_store));
 180                 priv->account_store = NULL;
 181         }
 182 }
 183
 184
 185 static gboolean
 186 init_widgets (ModestWidgetFactory *self)
 187 {
 188         ModestWidgetFactoryPrivate *priv;
 189         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 190
 191         /* folder view */
 192         if (!(priv->folder_view =
 193               MODEST_FOLDER_VIEW(modest_folder_view_new
 194                                  (TNY_ACCOUNT_STORE_IFACE(priv->account_store))))) {
 195                 g_printerr ("modest: cannot instantiate folder view\n");
 196                 return FALSE;
 197         }
 198
 199         /* header view */
 200         if (!(priv->header_view =
 201               MODEST_HEADER_VIEW(modest_header_view_new
 202                                  (NULL, NULL,MODEST_HEADER_VIEW_STYLE_NORMAL)))) {
 203                 g_printerr ("modest: cannot instantiate header view\n");
 204                 return FALSE;
 205         }
 206
 207         /* msg preview */
 208         if (!(priv->msg_preview = MODEST_MSG_VIEW(modest_msg_view_new (NULL)))) {
 209                 g_printerr ("modest: cannot instantiate header view\n");
 210                 return FALSE;
 211         }
 212
 213         if (priv->auto_connect) {
 214                 g_signal_connect (G_OBJECT(priv->header_view), "message_selected",
 215                                   G_CALLBACK(on_message_selected), self);
 216                 g_signal_connect (G_OBJECT(priv->folder_view), "folder_selected",
 217                                   G_CALLBACK(on_folder_selected), self);
 218                 g_signal_connect (G_OBJECT(priv->header_view), "status_update",
 219                                   G_CALLBACK(on_header_status_update), self);
 220                 g_signal_connect (G_OBJECT(priv->msg_preview), "link_clicked",
 221                                   G_CALLBACK(on_msg_link_clicked), self);
 222                 g_signal_connect (G_OBJECT(priv->msg_preview), "link_hover",
 223                                   G_CALLBACK(on_msg_link_hover), self);
 224                 g_signal_connect (G_OBJECT(priv->msg_preview), "attachment_clicked",
 225                                   G_CALLBACK(on_msg_attachment_clicked), self);
 226         }
 227
 228         return TRUE;
 229 }
 230
 231
 232 ModestWidgetFactory*
 233 modest_widget_factory_new (ModestConf *conf,
 234                            ModestTnyAccountStore *account_store,
 235                            ModestAccountMgr *account_mgr,
 236                            gboolean auto_connect)
 237 {
 238         GObject *obj;
 239         ModestWidgetFactoryPrivate *priv;
 240
 241         g_return_val_if_fail (account_store, NULL);
 242         g_return_val_if_fail (account_mgr, NULL);
 243         g_return_val_if_fail (conf, NULL);
 244
 245         obj  = g_object_new(MODEST_TYPE_WIDGET_FACTORY, NULL);
 246         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(obj);
 247
 248         priv->auto_connect = auto_connect;
 249
 250         g_object_ref (G_OBJECT(conf));
 251         priv->conf = conf;
 252
 253         g_object_ref (G_OBJECT(account_mgr));
 254         priv->account_mgr = account_mgr;
 255
 256         g_object_ref (G_OBJECT(account_store));
 257         priv->account_store = account_store;
 258
 259         if (!init_widgets (MODEST_WIDGET_FACTORY(obj))) {
 260                 g_printerr ("modest: widget factory failed to init widgets\n");
 261                 g_object_unref (obj);
 262                 return NULL;
 263         }
 264
 265         return MODEST_WIDGET_FACTORY(obj);
 266 }
 267
 268
 269
 270
 271 ModestFolderView*
 272 modest_widget_factory_get_folder_view (ModestWidgetFactory *self)
 273 {
 274         g_return_val_if_fail (self, NULL);
 275         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->folder_view;
 276 }
 277
 278
 279 ModestHeaderView*
 280 modest_widget_factory_get_header_view (ModestWidgetFactory *self)
 281 {
 282         g_return_val_if_fail (self, NULL);
 283         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->header_view;
 284 }
 285
 286
 287 ModestMsgView*
 288 modest_widget_factory_get_msg_preview (ModestWidgetFactory *self)
 289 {
 290         g_return_val_if_fail (self, NULL);
 291         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->msg_preview;
 292 }
 293
 294
 295 ModestAccountView*
 296 modest_widget_factory_get_account_view (ModestWidgetFactory *self)
 297 {
 298         ModestWidgetFactoryPrivate *priv;
 299
 300         g_return_val_if_fail (self, NULL);
 301         priv =  MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 302
 303         return modest_account_view_new (priv->account_mgr);
 304 }
 305
 306
 307
 308 GtkWidget*
 309 modest_widget_factory_get_progress_bar (ModestWidgetFactory *self)
 310 {
 311         g_return_val_if_fail (self, NULL);
 312         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->progress_bar;
 313 }
 314
 315
 316 GtkWidget*
 317 modest_widget_factory_get_status_bar (ModestWidgetFactory *self)
 318 {
 319         g_return_val_if_fail (self, NULL);
 320         return MODEST_WIDGET_FACTORY_GET_PRIVATE(self)->status_bar;
 321 }
 322
 323
 324 GtkWidget*
 325 modest_widget_factory_get_store_combo (ModestWidgetFactory *self)
 326 {
 327         GtkWidget *combo;
 328         GtkListStore *store;
 329         GtkTreeIter iter;
 330         const gchar **protos, **cursor;
 331
 332         g_return_val_if_fail (self, NULL);
 333
 334         combo = gtk_combo_box_new_text ();
 335         cursor = protos = modest_proto_store_protos ();
 336         while (cursor && *cursor) {
 337                 gtk_combo_box_append_text (GTK_COMBO_BOX(combo),
 338                                            (const gchar*)*cursor);
 339                 ++cursor;
 340         }
 341         gtk_combo_box_set_active (GTK_COMBO_BOX(combo), 0);
 342
 343         return combo;
 344 }
 345
 346
 347
 348 static void
 349 on_folder_selected (ModestFolderView *folder_view, TnyMsgFolderIface *folder,
 350                     ModestWidgetFactory *self)
 351 {
 352         ModestWidgetFactoryPrivate *priv;
 353         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 354
 355         modest_header_view_set_folder (priv->header_view, folder);
 356 }
 357
 358
 359 static void
 360 on_message_selected (ModestHeaderView *folder_view, TnyMsgIface *msg,
 361                      ModestWidgetFactory *self)
 362 {
 363         ModestWidgetFactoryPrivate *priv;
 364         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 365
 366         modest_msg_view_set_message (priv->msg_preview, msg);
 367 }
 368
 369
 370 static void
 371 on_header_status_update (ModestHeaderView *header_view, const gchar *msg,
 372                          gint status_id, ModestWidgetFactory *self)
 373 {
 374         ModestWidgetFactoryPrivate *priv;
 375         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 376
 377         if (msg && status_id) {
 378                 gchar *msg = g_strdup_printf ("%s", msg);
 379                 gtk_progress_bar_pulse (GTK_PROGRESS_BAR(priv->progress_bar));
 380                 gtk_statusbar_push (GTK_STATUSBAR(priv->status_bar),
 381                                        priv->status_bar_ctx[STATUS_ID_HEADER],
 382                                        msg);
 383                 g_free (msg);
 384         } else {
 385                 gtk_statusbar_pop (GTK_STATUSBAR(priv->status_bar),
 386                                    priv->status_bar_ctx[STATUS_ID_HEADER]);
 387                 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(priv->progress_bar),
 388                                                1.0);
 389         }
 390 }
 391
 392
 393 static void
 394 on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
 395                    ModestWidgetFactory *self)
 396 {
 397         ModestWidgetFactoryPrivate *priv;
 398         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 399
 400         if (link)
 401                 gtk_statusbar_push (GTK_STATUSBAR(priv->status_bar),
 402                                     priv->status_bar_ctx[STATUS_ID_MESSAGE],
 403                                     link);
 404         else
 405                 gtk_statusbar_pop (GTK_STATUSBAR(priv->status_bar),
 406                                    priv->status_bar_ctx[STATUS_ID_MESSAGE]);
 407
 408 }
 409
 410
 411 static void
 412 on_msg_link_clicked  (ModestMsgView *msgview, const gchar* link,
 413                       ModestWidgetFactory *self)
 414 {
 415         ModestWidgetFactoryPrivate *priv;
 416         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 417
 418         if (link) {
 419                 gchar *msg = g_strdup_printf (_("Opening %s..."), link);
 420                 gtk_statusbar_push (GTK_STATUSBAR(priv->status_bar),
 421                                     priv->status_bar_ctx[STATUS_ID_MESSAGE],
 422                                     msg);
 423                 g_free (msg);
 424         }
 425 }
 426
 427 static void
 428 on_msg_attachment_clicked  (ModestMsgView *msgview, int index,
 429                             ModestWidgetFactory *self)
 430 {
 431         ModestWidgetFactoryPrivate *priv;
 432         priv = MODEST_WIDGET_FACTORY_GET_PRIVATE(self);
 433
 434         gchar *msg = g_strdup_printf (_("Opening attachment %d..."), index);
 435         gtk_statusbar_push (GTK_STATUSBAR(priv->status_bar),
 436                             priv->status_bar_ctx[STATUS_ID_MESSAGE],
 437                             msg);
 438         g_free (msg);
 439 }