git.maemo.org Git - modest/blob - src/widgets/modest-window.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-window.h"
  31 #include "modest-window-priv.h"
  32 #include "modest-ui-actions.h"
  33 #include "modest-tny-platform-factory.h"
  34 #include "modest-runtime.h"
  35 #include "modest-window-mgr.h"
  36 #include "modest-defs.h"
  37 #include <string.h> /* for strcmp */
  38 #include <gdk/gdkkeysyms.h>
  39 #include <gdk/gdk.h>
  40 #include <gdk/gdkx.h>
  41 #include <X11/Xatom.h>
  42 #include <X11/XKBlib.h>
  43 #include <X11/Xdmcp.h>
  44 #ifdef MODEST_TOOLKIT_HILDON2
  45 #include <hildon/hildon-defines.h>
  46 #endif
  47
  48 /* 'private'/'protected' functions */
  49 static void modest_window_class_init (ModestWindowClass *klass);
  50 static void modest_window_init       (ModestWindow *obj);
  51 static void modest_window_finalize   (GObject *obj);
  52 static void modest_window_dispose    (GObject *obj);
  53
  54 static gdouble  modest_window_get_zoom_default           (ModestWindow *window);
  55
  56 static gboolean modest_window_zoom_plus_default          (ModestWindow *window);
  57
  58 static gboolean modest_window_zoom_minus_default         (ModestWindow *window);
  59
  60 static void     modest_window_disconnect_signals_default (ModestWindow *self);
  61
  62 static void     modest_window_show_progress_default      (ModestWindow *self,
  63                                                           gboolean show);
  64
  65 static void     modest_window_show_toolbar_default       (ModestWindow *window,
  66                                                           gboolean show_toolbar);
  67
  68 static void     modest_window_add_toolbar_default       (ModestWindow *window,
  69                                                          GtkToolbar *toolbar);
  70
  71 static void     modest_window_add_to_menu_default       (ModestWindow *self,
  72                                                          const gchar *label,
  73                                                          const gchar *accelerator,
  74                                                          ModestWindowMenuCallback callback,
  75                                                          ModestDimmingCallback dimming_callback);
  76
  77 static void     modest_window_add_item_to_menu_default  (ModestWindow *self,
  78                                                          GtkWidget *item,
  79                                                          ModestDimmingCallback dimming_callback);
  80
  81 static void     modest_window_set_title_default       (ModestWindow *window,
  82                                                        const gchar *title);
  83
  84 static void     modest_window_set_zoom_default           (ModestWindow *window,
  85                                                           gdouble zoom);
  86
  87 static gboolean on_key_pressed (GtkWidget *self, GdkEventKey *event, gpointer user_data);
  88 static void _make_zoom_buttons_grabeable (GtkWidget* widget);
  89 static gboolean _modest_window_map_event (GtkWidget *widget,
  90                                           GdkEvent *event,
  91                                           gpointer userdata);
  92 static void modest_window_pack_toolbar_not_implemented (ModestWindow *self,
  93                                                         GtkPackType pack_type,
  94                                                         GtkWidget *toolbar);
  95
  96
  97 /* list my signals  */
  98 enum {
  99         LAST_SIGNAL
 100 };
 101
 102 /* globals */
 103 static GObjectClass *parent_class = NULL;
 104
 105 /* uncomment the following if you have defined any signals */
 106 /* static guint signals[LAST_SIGNAL] = {0}; */
 107
 108 GType
 109 modest_window_get_type (void)
 110 {
 111         static GType my_type = 0;
 112         static GType parent_type = 0;
 113         if (!my_type) {
 114                 static const GTypeInfo my_info = {
 115                         sizeof(ModestWindowClass),
 116                         NULL,           /* base init */
 117                         NULL,           /* base finalize */
 118                         (GClassInitFunc) modest_window_class_init,
 119                         NULL,           /* class finalize */
 120                         NULL,           /* class data */
 121                         sizeof(ModestWindow),
 122                         1,              /* n_preallocs */
 123                         (GInstanceInitFunc) modest_window_init,
 124                         NULL
 125                 };
 126 #ifndef MODEST_TOOLKIT_GTK
 127 #ifdef MODEST_TOOLKIT_HILDON2
 128                 parent_type = HILDON_TYPE_STACKABLE_WINDOW;
 129 #else
 130                 parent_type = HILDON_TYPE_WINDOW;
 131 #endif
 132 #else
 133                 parent_type = GTK_TYPE_WINDOW;
 134 #endif
 135                 my_type = g_type_register_static (parent_type,
 136                                                   "ModestWindow",
 137                                                   &my_info,
 138                                                   G_TYPE_FLAG_ABSTRACT);
 139         }
 140         return my_type;
 141 }
 142
 143 static void
 144 modest_window_class_init (ModestWindowClass *klass)
 145 {
 146         GObjectClass *gobject_class;
 147         gobject_class = (GObjectClass*) klass;
 148
 149         parent_class            = g_type_class_peek_parent (klass);
 150         gobject_class->dispose  = modest_window_dispose;
 151         gobject_class->finalize = modest_window_finalize;
 152
 153         klass->set_zoom_func = modest_window_set_zoom_default;
 154         klass->get_zoom_func = modest_window_get_zoom_default;
 155         klass->zoom_plus_func = modest_window_zoom_plus_default;
 156         klass->zoom_minus_func = modest_window_zoom_minus_default;
 157         klass->show_toolbar_func = modest_window_show_toolbar_default;
 158         klass->add_toolbar_func = modest_window_add_toolbar_default;
 159         klass->add_to_menu_func = modest_window_add_to_menu_default;
 160         klass->add_item_to_menu_func = modest_window_add_item_to_menu_default;
 161         klass->set_title_func = modest_window_set_title_default;
 162         klass->disconnect_signals_func = modest_window_disconnect_signals_default;
 163         klass->show_progress_func = modest_window_show_progress_default;
 164         klass->pack_toolbar_func = modest_window_pack_toolbar_not_implemented;
 165
 166         g_type_class_add_private (gobject_class, sizeof(ModestWindowPrivate));
 167 }
 168
 169 static void
 170 modest_window_init (ModestWindow *obj)
 171 {
 172         ModestWindowPrivate *priv;
 173
 174         priv = MODEST_WINDOW_GET_PRIVATE(obj);
 175
 176         priv->ui_manager     = NULL;
 177         priv->ui_dimming_manager     = NULL;
 178         priv->toolbar        = NULL;
 179         priv->menubar        = NULL;
 180
 181         priv->dimming_state = NULL;
 182         priv->ui_dimming_enabled = TRUE;
 183         priv->active_account = NULL;
 184         priv->active_mailbox = NULL;
 185
 186         /* Connect signals */
 187         g_signal_connect (G_OBJECT (obj),
 188                           "key-press-event",
 189                           G_CALLBACK (on_key_pressed), NULL);
 190         g_signal_connect (G_OBJECT (obj), "map-event",
 191                           G_CALLBACK (_modest_window_map_event),
 192                           G_OBJECT (obj));
 193 }
 194
 195 static void
 196 modest_window_finalize (GObject *obj)
 197 {
 198         ModestWindowPrivate *priv;
 199
 200         priv = MODEST_WINDOW_GET_PRIVATE(obj);
 201
 202         if (priv->dimming_state != NULL) {
 203                 g_slice_free (DimmedState, priv->dimming_state);
 204                 priv->dimming_state = NULL;
 205         }
 206
 207         g_free (priv->active_account);
 208         g_free (priv->active_mailbox);
 209
 210         G_OBJECT_CLASS(parent_class)->finalize (obj);
 211 }
 212
 213 static void
 214 modest_window_dispose (GObject *obj)
 215 {
 216         ModestWindowPrivate *priv;
 217
 218         priv = MODEST_WINDOW_GET_PRIVATE(obj);
 219
 220         priv->ui_dimming_enabled = FALSE;
 221
 222         if (priv->ui_manager) {
 223                 g_object_unref (G_OBJECT(priv->ui_manager));
 224                 priv->ui_manager = NULL;
 225         }
 226         if (priv->ui_dimming_manager) {
 227                 g_object_run_dispose (G_OBJECT (priv->ui_dimming_manager));
 228                 g_object_unref (G_OBJECT(priv->ui_dimming_manager));
 229                 priv->ui_dimming_manager = NULL;
 230         }
 231
 232         G_OBJECT_CLASS(parent_class)->dispose (obj);
 233 }
 234
 235
 236
 237 const gchar*
 238 modest_window_get_active_account (ModestWindow *self)
 239 {
 240         g_return_val_if_fail (self, NULL);
 241         //g_warning ("%s: %s", __FUNCTION__, MODEST_WINDOW_GET_PRIVATE(self)->active_account);
 242         return MODEST_WINDOW_GET_PRIVATE(self)->active_account;
 243 }
 244
 245 void
 246 modest_window_set_active_account (ModestWindow *self, const gchar *active_account)
 247 {
 248         ModestWindowPrivate *priv;
 249
 250         g_return_if_fail (self);
 251         priv = MODEST_WINDOW_GET_PRIVATE(self);
 252
 253         //g_warning ("%s: %s", __FUNCTION__, active_account);
 254
 255         /* only 'real' account should be set here; for example the email signature
 256          * depends on the current account, so if you reply to a message in your
 257          * archive, it should take the signature from the real active account,
 258          * not the non-existing one from your mmc-pseudo-account
 259          */
 260         if (active_account && ((strcmp (active_account, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) == 0) ||
 261                                (strcmp (active_account, MODEST_MMC_ACCOUNT_ID) == 0))) {
 262                         g_warning ("%s: %s is not a valid active account",
 263                                    __FUNCTION__, active_account);
 264                         return;
 265         }
 266
 267         if (active_account == priv->active_account)
 268                 return;
 269         else {
 270                 g_free (priv->active_account);
 271                 priv->active_account = NULL;
 272                 if (active_account)
 273                         priv->active_account = g_strdup (active_account);
 274         }
 275 }
 276
 277 const gchar*
 278 modest_window_get_active_mailbox (ModestWindow *self)
 279 {
 280         g_return_val_if_fail (self, NULL);
 281         return MODEST_WINDOW_GET_PRIVATE(self)->active_mailbox;
 282 }
 283
 284 void
 285 modest_window_set_active_mailbox (ModestWindow *self, const gchar *active_mailbox)
 286 {
 287         ModestWindowPrivate *priv;
 288
 289         g_return_if_fail (self);
 290         priv = MODEST_WINDOW_GET_PRIVATE(self);
 291
 292         if (active_mailbox == priv->active_mailbox)
 293                 return;
 294         else {
 295                 g_free (priv->active_mailbox);
 296                 priv->active_mailbox = NULL;
 297                 if (active_mailbox)
 298                         priv->active_mailbox = g_strdup (active_mailbox);
 299         }
 300 }
 301
 302 void
 303 modest_window_check_dimming_rules (ModestWindow *self)
 304 {
 305         ModestWindowPrivate *priv;
 306
 307         g_return_if_fail (MODEST_IS_WINDOW (self));
 308         priv = MODEST_WINDOW_GET_PRIVATE(self);
 309
 310         if (priv->ui_dimming_enabled)
 311                 modest_ui_dimming_manager_process_dimming_rules (priv->ui_dimming_manager);
 312 }
 313
 314 void
 315 modest_window_check_dimming_rules_group (ModestWindow *self,
 316                                          const gchar *group_name)
 317 {
 318         ModestWindowPrivate *priv;
 319
 320         g_return_if_fail (MODEST_IS_WINDOW (self));
 321         priv = MODEST_WINDOW_GET_PRIVATE(self);
 322
 323         if (priv->ui_dimming_enabled)
 324                 modest_ui_dimming_manager_process_dimming_rules_group (priv->ui_dimming_manager, group_name);
 325 }
 326
 327 void
 328 modest_window_set_dimming_state (ModestWindow *window,
 329                                  DimmedState *state)
 330 {
 331         ModestWindowPrivate *priv;
 332
 333         g_return_if_fail (MODEST_IS_WINDOW (window));
 334         priv = MODEST_WINDOW_GET_PRIVATE(window);
 335
 336         /* Free previous */
 337         if (priv->dimming_state != NULL)
 338                 g_slice_free (DimmedState, priv->dimming_state);
 339
 340         /* Set new state */
 341         priv->dimming_state = state;
 342 }
 343
 344 const DimmedState *
 345 modest_window_get_dimming_state (ModestWindow *window)
 346 {
 347         ModestWindowPrivate *priv;
 348
 349         g_return_val_if_fail (MODEST_IS_WINDOW (window), NULL);
 350         priv = MODEST_WINDOW_GET_PRIVATE(window);
 351
 352         return priv->dimming_state;
 353 }
 354
 355 void
 356 modest_window_disable_dimming (ModestWindow *self)
 357 {
 358         ModestWindowPrivate *priv;
 359
 360         g_return_if_fail (MODEST_IS_WINDOW (self));
 361         priv = MODEST_WINDOW_GET_PRIVATE(self);
 362
 363         priv->ui_dimming_enabled = FALSE;
 364 }
 365
 366 void
 367 modest_window_enable_dimming (ModestWindow *self)
 368 {
 369         ModestWindowPrivate *priv;
 370
 371         g_return_if_fail (MODEST_IS_WINDOW (self));
 372         priv = MODEST_WINDOW_GET_PRIVATE(self);
 373
 374         priv->ui_dimming_enabled = TRUE;
 375 }
 376
 377 GtkAction *
 378 modest_window_get_action (ModestWindow *window,
 379                           const gchar *action_path)
 380 {
 381         GtkAction *action = NULL;
 382         ModestWindowPrivate *priv;
 383
 384         g_return_val_if_fail (MODEST_IS_WINDOW (window), NULL);
 385         priv = MODEST_WINDOW_GET_PRIVATE(window);
 386
 387         action = gtk_ui_manager_get_action (priv->ui_manager, action_path);
 388
 389         return action;
 390 }
 391
 392 GtkWidget *
 393 modest_window_get_action_widget (ModestWindow *window,
 394                                  const gchar *action_path)
 395 {
 396         GtkWidget *widget = NULL;
 397         ModestWindowPrivate *priv;
 398
 399         g_return_val_if_fail (MODEST_IS_WINDOW (window), NULL);
 400         priv = MODEST_WINDOW_GET_PRIVATE(window);
 401
 402         widget = gtk_ui_manager_get_widget (priv->ui_manager, action_path);
 403
 404         return widget;
 405 }
 406
 407 void
 408 modest_window_set_zoom (ModestWindow *window,
 409                         gdouble zoom)
 410 {
 411         MODEST_WINDOW_GET_CLASS (window)->set_zoom_func (window, zoom);
 412         return;
 413 }
 414
 415 gdouble
 416 modest_window_get_zoom (ModestWindow *window)
 417 {
 418         return MODEST_WINDOW_GET_CLASS (window)->get_zoom_func (window);
 419 }
 420
 421 gboolean
 422 modest_window_zoom_plus (ModestWindow *window)
 423 {
 424         return MODEST_WINDOW_GET_CLASS (window)->zoom_plus_func (window);
 425 }
 426
 427 gboolean
 428 modest_window_zoom_minus (ModestWindow *window)
 429 {
 430         return MODEST_WINDOW_GET_CLASS (window)->zoom_minus_func (window);
 431 }
 432
 433 void
 434 modest_window_show_toolbar (ModestWindow *window,
 435                             gboolean show_toolbar)
 436 {
 437         MODEST_WINDOW_GET_CLASS (window)->show_toolbar_func (window,
 438                                                              show_toolbar);
 439 }
 440
 441 void
 442 modest_window_add_toolbar (ModestWindow *window,
 443                            GtkToolbar *toolbar)
 444 {
 445         MODEST_WINDOW_GET_CLASS (window)->add_toolbar_func (window,
 446                                                             toolbar);
 447 }
 448
 449 void
 450 modest_window_add_to_menu (ModestWindow *window,
 451                            const gchar *label,
 452                            const gchar *accelerator,
 453                            ModestWindowMenuCallback callback,
 454                            ModestDimmingCallback dimming_callback)
 455 {
 456         MODEST_WINDOW_GET_CLASS (window)->add_to_menu_func (window,
 457                                                             label,
 458                                                             accelerator,
 459                                                             callback,
 460                                                             dimming_callback);
 461 }
 462
 463 void
 464 modest_window_add_item_to_menu (ModestWindow *window,
 465                                 GtkWidget *item,
 466                                 ModestDimmingCallback dimming_callback)
 467 {
 468         MODEST_WINDOW_GET_CLASS (window)->add_item_to_menu_func (window,
 469                                                                  item,
 470                                                                  dimming_callback);
 471 }
 472
 473 void
 474 modest_window_set_title (ModestWindow *window,
 475                          const gchar *title)
 476 {
 477         MODEST_WINDOW_GET_CLASS (window)->set_title_func (window,
 478                                                           title);
 479 }
 480
 481 void
 482 modest_window_disconnect_signals (ModestWindow *window)
 483 {
 484         MODEST_WINDOW_GET_CLASS (window)->disconnect_signals_func (window);
 485 }
 486
 487 void
 488 modest_window_show_progress (ModestWindow *window, gboolean show)
 489 {
 490         MODEST_WINDOW_GET_CLASS (window)->show_progress_func (window, show);
 491 }
 492
 493
 494 /* Default implementations */
 495
 496 static void
 497 modest_window_set_zoom_default (ModestWindow *window,
 498                                 gdouble zoom)
 499 {
 500         g_warning ("modest: You should implement %s", __FUNCTION__);
 501
 502 }
 503
 504 static gdouble
 505 modest_window_get_zoom_default (ModestWindow *window)
 506 {
 507         g_warning ("modest: You should implement %s", __FUNCTION__);
 508         return 1.0;
 509 }
 510
 511 static gboolean
 512 modest_window_zoom_plus_default (ModestWindow *window)
 513 {
 514         g_warning ("modest: You should implement %s", __FUNCTION__);
 515         return FALSE;
 516 }
 517
 518 static gboolean
 519 modest_window_zoom_minus_default (ModestWindow *window)
 520 {
 521         g_warning ("modest: You should implement %s", __FUNCTION__);
 522         return FALSE;
 523 }
 524
 525 static void
 526 modest_window_show_toolbar_default (ModestWindow *window,
 527                                     gboolean show_toolbar)
 528 {
 529         g_warning ("modest: You should implement %s", __FUNCTION__);
 530 }
 531
 532 static void
 533 modest_window_add_toolbar_default (ModestWindow *window,
 534                                    GtkToolbar *toolbar)
 535 {
 536         g_warning ("modest: You should implement %s", __FUNCTION__);
 537 }
 538
 539 static void
 540 modest_window_add_to_menu_default (ModestWindow *window,
 541                                    const gchar *label,
 542                                    const gchar *accelerator,
 543                                    ModestWindowMenuCallback callback,
 544                                    ModestDimmingCallback dimming_callback)
 545 {
 546         g_warning ("modest: You should implement %s", __FUNCTION__);
 547 }
 548
 549 static void
 550 modest_window_add_item_to_menu_default (ModestWindow *window,
 551                                         GtkWidget *item,
 552                                         ModestDimmingCallback dimming_callback)
 553 {
 554         g_warning ("modest: You should implement %s", __FUNCTION__);
 555 }
 556
 557 static void
 558 modest_window_set_title_default (ModestWindow *window,
 559                                  const gchar *title)
 560 {
 561         g_warning ("modest: You should implement %s", __FUNCTION__);
 562 }
 563
 564 static void
 565 modest_window_disconnect_signals_default (ModestWindow *self)
 566 {
 567         g_warning ("modest: You should implement %s", __FUNCTION__);
 568 }
 569
 570 static void
 571 modest_window_show_progress_default (ModestWindow *self, gboolean show)
 572 {
 573         g_warning ("modest: You should implement %s", __FUNCTION__);
 574 }
 575
 576 void
 577 modest_window_save_state (ModestWindow *window)
 578 {
 579         ModestWindowClass *klass = MODEST_WINDOW_GET_CLASS (window);
 580         if (klass->save_state_func)
 581                 klass->save_state_func (window);
 582 }
 583
 584 static gboolean
 585 on_key_pressed (GtkWidget *self,
 586                 GdkEventKey *event,
 587                 gpointer user_data)
 588 {
 589         ModestWindowMgr *mgr = NULL;
 590
 591         mgr = modest_runtime_get_window_mgr ();
 592
 593         switch (event->keyval) {
 594         case GDK_F6:
 595                 modest_ui_actions_on_change_fullscreen (NULL, MODEST_WINDOW(self));
 596                 return TRUE;
 597 #ifdef MODEST_TOOLKIT_HILDON2
 598         case HILDON_HARDKEY_INCREASE:
 599                 modest_ui_actions_on_zoom_plus (NULL, MODEST_WINDOW(self));
 600                 return TRUE;
 601         case HILDON_HARDKEY_DECREASE:
 602                 modest_ui_actions_on_zoom_minus (NULL, MODEST_WINDOW(self));
 603                 return TRUE;
 604 #else
 605         case GDK_F7:
 606                 modest_ui_actions_on_zoom_plus (NULL, MODEST_WINDOW(self));
 607                 return TRUE;
 608         case GDK_F8:
 609                 modest_ui_actions_on_zoom_minus (NULL, MODEST_WINDOW(self));
 610                 return TRUE;
 611 #endif
 612         case GDK_Escape:
 613                 if (modest_window_mgr_get_fullscreen_mode (mgr))
 614                         modest_ui_actions_on_change_fullscreen (NULL, MODEST_WINDOW(self));
 615                 else if (MODEST_IS_MSG_VIEW_WINDOW (self))
 616                         modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (self));
 617                 break;
 618         }
 619
 620         return FALSE;
 621 }
 622
 623 static gboolean
 624 _modest_window_map_event (GtkWidget *widget,
 625                           GdkEvent *event,
 626                           gpointer userdata)
 627 {
 628         _make_zoom_buttons_grabeable (GTK_WIDGET (widget));
 629         return FALSE;
 630 }
 631
 632 static void
 633 _make_zoom_buttons_grabeable (GtkWidget* widget)
 634 {
 635     GdkDisplay *display;
 636     Atom atom;
 637     unsigned long val = 1;
 638
 639     display = gdk_drawable_get_display (widget->window);
 640     atom = gdk_x11_get_xatom_by_name_for_display (display, "_HILDON_ZOOM_KEY_ATOM");
 641     XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
 642                      GDK_WINDOW_XID (widget->window), atom,
 643                      XA_INTEGER, 32, PropModeReplace,
 644                      (unsigned char *) &val, 1);
 645 }
 646
 647 static void
 648 modest_window_pack_toolbar_not_implemented (ModestWindow *self,
 649                                             GtkPackType pack_type,
 650                                             GtkWidget *toolbar)
 651 {
 652         g_return_if_fail (MODEST_IS_WINDOW (self));
 653
 654         g_debug ("%s not implemented", __FUNCTION__);
 655 }
 656
 657 void
 658 modest_window_pack_toolbar (ModestWindow *self,
 659                             GtkPackType pack_type,
 660                             GtkWidget *toolbar)
 661 {
 662         g_return_if_fail (MODEST_IS_WINDOW (self));
 663
 664         MODEST_WINDOW_GET_CLASS (self)->pack_toolbar_func (self, pack_type, toolbar);
 665 }
 666