git.maemo.org Git - modest/blob - src/gtk2/modest-main-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-widget-memory.h>
  31
  32 #include "modest-main-window.h"
  33 #include "modest-account-view-window.h"
  34 #include "modest-msg-window.h"
  35
  36 /* 'private'/'protected' functions */
  37 static void modest_main_window_class_init    (ModestMainWindowClass *klass);
  38 static void modest_main_window_init          (ModestMainWindow *obj);
  39 static void modest_main_window_finalize      (GObject *obj);
  40
  41 static void restore_sizes (ModestMainWindow *self);
  42 static void save_sizes (ModestMainWindow *self);
  43
  44 /* list my signals */
  45 enum {
  46         /* MY_SIGNAL_1, */
  47         /* MY_SIGNAL_2, */
  48         LAST_SIGNAL
  49 };
  50
  51 typedef struct _ModestMainWindowPrivate ModestMainWindowPrivate;
  52 struct _ModestMainWindowPrivate {
  53         GtkWidget *toolbar;
  54         GtkWidget *menubar;
  55
  56         GtkWidget *folder_paned;
  57         GtkWidget *msg_paned;
  58         GtkWidget *main_paned;
  59
  60         ModestWidgetFactory *widget_factory;
  61         ModestConf *conf;
  62
  63         ModestHeaderView *header_view;
  64         ModestFolderView *folder_view;
  65         ModestMsgView    *msg_preview;
  66 };
  67
  68
  69 #define MODEST_MAIN_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  70                                                 MODEST_TYPE_MAIN_WINDOW, \
  71                                                 ModestMainWindowPrivate))
  72 /* globals */
  73 static GtkWindowClass *parent_class = NULL;
  74
  75 /* uncomment the following if you have defined any signals */
  76 /* static guint signals[LAST_SIGNAL] = {0}; */
  77
  78 GType
  79 modest_main_window_get_type (void)
  80 {
  81         static GType my_type = 0;
  82         if (!my_type) {
  83                 static const GTypeInfo my_info = {
  84                         sizeof(ModestMainWindowClass),
  85                         NULL,           /* base init */
  86                         NULL,           /* base finalize */
  87                         (GClassInitFunc) modest_main_window_class_init,
  88                         NULL,           /* class finalize */
  89                         NULL,           /* class data */
  90                         sizeof(ModestMainWindow),
  91                         1,              /* n_preallocs */
  92                         (GInstanceInitFunc) modest_main_window_init,
  93                 };
  94                 my_type = g_type_register_static (GTK_TYPE_WINDOW,
  95                                                   "ModestMainWindow",
  96                                                   &my_info, 0);
  97         }
  98         return my_type;
  99 }
 100
 101 static void
 102 modest_main_window_class_init (ModestMainWindowClass *klass)
 103 {
 104         GObjectClass *gobject_class;
 105         gobject_class = (GObjectClass*) klass;
 106
 107         parent_class            = g_type_class_peek_parent (klass);
 108         gobject_class->finalize = modest_main_window_finalize;
 109
 110         g_type_class_add_private (gobject_class, sizeof(ModestMainWindowPrivate));
 111
 112         /* signal definitions go here, e.g.: */
 113 /*      signals[MY_SIGNAL_1] = */
 114 /*              g_signal_new ("my_signal_1",....); */
 115 /*      signals[MY_SIGNAL_2] = */
 116 /*              g_signal_new ("my_signal_2",....); */
 117 /*      etc. */
 118 }
 119
 120 static void
 121 modest_main_window_init (ModestMainWindow *obj)
 122 {
 123         ModestMainWindowPrivate *priv;
 124
 125         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 126
 127         priv->widget_factory = NULL;
 128 }
 129
 130 static void
 131 modest_main_window_finalize (GObject *obj)
 132 {
 133         ModestMainWindowPrivate *priv;
 134
 135         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 136
 137         if (priv->widget_factory) {
 138                 g_object_unref (G_OBJECT(priv->widget_factory));
 139                 priv->widget_factory = NULL;
 140         }
 141
 142         if (priv->conf) {
 143                 g_object_unref (G_OBJECT(priv->conf));
 144                 priv->conf = NULL;
 145         }
 146         G_OBJECT_CLASS(parent_class)->finalize (obj);
 147 }
 148
 149
 150 static void
 151 on_menu_about (GtkWidget *widget, gpointer data)
 152 {
 153         GtkWidget *about;
 154
 155         about = gtk_about_dialog_new ();
 156         gtk_about_dialog_set_name (GTK_ABOUT_DIALOG(about), PACKAGE_NAME);
 157         gtk_about_dialog_set_version (GTK_ABOUT_DIALOG(about),PACKAGE_VERSION);
 158         gtk_about_dialog_set_copyright (
 159                 GTK_ABOUT_DIALOG(about),
 160                 _("Copyright (c) 2006, Nokia Corporation\n"
 161                   "All rights reserved."));
 162         gtk_about_dialog_set_comments ( GTK_ABOUT_DIALOG(about),
 163                 _("a modest e-mail client"));
 164         gtk_dialog_run (GTK_DIALOG (about));
 165         gtk_widget_destroy(about);
 166 }
 167
 168
 169 static void
 170 on_menu_accounts (ModestMainWindow *self, guint action, GtkWidget *widget)
 171 {
 172         GtkWidget *account_win;
 173         ModestMainWindowPrivate *priv;
 174
 175         g_return_if_fail (widget);
 176         g_return_if_fail (self);
 177
 178         priv        = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 179         account_win = modest_account_view_window_new (priv->conf,
 180                                                       priv->widget_factory);
 181
 182         gtk_window_set_transient_for (GTK_WINDOW(account_win),
 183                                       GTK_WINDOW(self));
 184
 185         gtk_widget_show (account_win);
 186 }
 187
 188
 189 static void
 190 on_menu_new_message (ModestMainWindow *self, guint action, GtkWidget *widget)
 191 {
 192         GtkWidget *msg_win;
 193
 194         msg_win = modest_msg_window_new (MODEST_MSG_WINDOW_TYPE_NEW,
 195                                          NULL);
 196
 197         gtk_widget_show (msg_win);
 198 }
 199
 200 static void
 201 on_menu_quit (ModestMainWindow *self, guint action, GtkWidget *widget)
 202 {
 203         save_sizes (self);
 204         gtk_main_quit ();
 205 }
 206
 207
 208
 209 /* Our menu, an array of GtkItemFactoryEntry structures that defines each menu item */
 210 static GtkItemFactoryEntry menu_items[] = {
 211         { "/_File",             NULL,                   NULL,           0, "<Branch>" },
 212         { "/File/_New",         "<control>N",           NULL,           0, "<StockItem>", GTK_STOCK_NEW },
 213         { "/File/_Open",        "<control>O",           NULL,           0, "<StockItem>", GTK_STOCK_OPEN },
 214         { "/File/_Save",        "<control>S",           NULL,           0, "<StockItem>", GTK_STOCK_SAVE },
 215         { "/File/Save _As",     NULL,                   NULL,           0, "<Item>" },
 216         { "/File/sep1",         NULL,                   NULL,           0, "<Separator>" },
 217         { "/File/_Quit",        "<CTRL>Q",              on_menu_quit,  0, "<StockItem>", GTK_STOCK_QUIT },
 218
 219         { "/_Edit",             NULL,                   NULL,           0, "<Branch>" },
 220         { "/Edit/_Undo",        "<CTRL>Z",              NULL,           0, "<StockItem>", GTK_STOCK_UNDO },
 221         { "/Edit/_Redo",        "<shift><CTRL>Z",       NULL,           0, "<StockItem>", GTK_STOCK_REDO },
 222         { "/File/sep1",         NULL,                   NULL,           0, "<Separator>" },
 223         { "/Edit/Cut",          "<control>X",           NULL,           0, "<StockItem>", GTK_STOCK_CUT  },
 224         { "/Edit/Copy",         "<CTRL>C",              NULL,           0, "<StockItem>", GTK_STOCK_COPY },
 225         { "/Edit/Paste",        NULL,                   NULL,           0, "<StockItem>", GTK_STOCK_PASTE},
 226         { "/Edit/sep1",         NULL,                   NULL,           0, "<Separator>" },
 227         { "/Edit/Delete",       "<CTRL>Q",              NULL,           0, "<Item>" },
 228         { "/Edit/Select all",   "<CTRL>A",              NULL,           0, "<Item>" },
 229         { "/Edit/Deelect all",  "<Shift><CTRL>A",       NULL,           0, "<Item>" },
 230
 231         { "/_Actions",                NULL,             NULL,           0, "<Branch>" },
 232         { "/Actions/_New Message",    NULL,             on_menu_new_message,            0, "<Item>" },
 233         { "/Actions/_Reply",    NULL,                   NULL,           0, "<Item>" },
 234         { "/Actions/_Forward",  NULL,                   NULL,           0, "<Item>" },
 235         { "/Actions/_Bounce",   NULL,                   NULL,           0, "<Item>" },
 236
 237         { "/_Options",           NULL,                  NULL,           0, "<Branch>" },
 238         { "/Options/_Accounts",  NULL,                  on_menu_accounts,0, "<Item>" },
 239         { "/Options/_Contacts",  NULL,                  NULL,           0, "<Item>" },
 240
 241
 242         { "/_Help",         NULL,                       NULL,           0, "<Branch>" },
 243         { "/_Help/About",   NULL,                       on_menu_about,  0, "<StockItem>", GTK_STOCK_ABOUT},
 244 };
 245
 246 static gint nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
 247
 248
 249 static GtkWidget *
 250 menubar_new (ModestMainWindow *self)
 251 {
 252         GtkItemFactory *item_factory;
 253         GtkAccelGroup *accel_group;
 254
 255         /* Make an accelerator group (shortcut keys) */
 256         accel_group = gtk_accel_group_new ();
 257
 258         /* Make an ItemFactory (that makes a menubar) */
 259         item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>",
 260                                              accel_group);
 261
 262         /* This function generates the menu items. Pass the item factory,
 263            the number of items in the array, the array itself, and any
 264            callback data for the the menu items. */
 265         gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, self);
 266
 267         ///* Attach the new accelerator group to the window. */
 268         gtk_window_add_accel_group (GTK_WINDOW (self), accel_group);
 269
 270         /* Finally, return the actual menu bar created by the item factory. */
 271         return gtk_item_factory_get_widget (item_factory, "<main>");
 272 }
 273
 274
 275
 276
 277 static ModestHeaderView*
 278 header_view_new (ModestMainWindow *self)
 279 {
 280         int i;
 281         GSList *columns = NULL;
 282         ModestHeaderView *header_view;
 283         ModestMainWindowPrivate *priv;
 284         ModestHeaderViewColumn cols[] = {
 285                 MODEST_HEADER_VIEW_COLUMN_MSGTYPE,
 286                 MODEST_HEADER_VIEW_COLUMN_ATTACH,
 287                 MODEST_HEADER_VIEW_COLUMN_FROM,
 288                 MODEST_HEADER_VIEW_COLUMN_SUBJECT,
 289                 MODEST_HEADER_VIEW_COLUMN_RECEIVED_DATE
 290         };
 291
 292         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 293
 294         for (i = 0 ; i != sizeof(cols) / sizeof(ModestHeaderViewColumn); ++i)
 295                 columns = g_slist_append (columns, GINT_TO_POINTER(cols[i]));
 296
 297         header_view = modest_widget_factory_get_header_view (priv->widget_factory);
 298         modest_header_view_set_columns (header_view, columns);
 299         g_slist_free (columns);
 300
 301         return header_view;
 302 }
 303
 304
 305 static void
 306 restore_sizes (ModestMainWindow *self)
 307 {
 308         ModestMainWindowPrivate *priv;
 309
 310         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 311
 312         modest_widget_memory_restore_settings (priv->conf,GTK_WIDGET(self),
 313                                                "modest-main-window");
 314         modest_widget_memory_restore_settings (priv->conf, GTK_WIDGET(priv->folder_paned),
 315                                                "modest-folder-paned");
 316         modest_widget_memory_restore_settings (priv->conf, GTK_WIDGET(priv->msg_paned),
 317                                                "modest-msg-paned");
 318         modest_widget_memory_restore_settings (priv->conf, GTK_WIDGET(priv->main_paned),
 319                                                "modest-main-paned");
 320
 321 }
 322
 323
 324 static void
 325 save_sizes (ModestMainWindow *self)
 326 {
 327         ModestMainWindowPrivate *priv;
 328
 329         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 330
 331         modest_widget_memory_save_settings (priv->conf,GTK_WIDGET(self),
 332                                             "modest-main-window");
 333         modest_widget_memory_save_settings (priv->conf, GTK_WIDGET(priv->folder_paned),
 334                                             "modest-folder-paned");
 335         modest_widget_memory_save_settings (priv->conf, GTK_WIDGET(priv->msg_paned),
 336                                             "modest-msg-paned");
 337         modest_widget_memory_save_settings (priv->conf, GTK_WIDGET(priv->main_paned),
 338                                             "modest-main-paned");
 339
 340
 341
 342 }
 343
 344
 345 static GtkWidget*
 346 wrapped_in_scrolled_window (GtkWidget *widget, gboolean needs_viewport)
 347 {
 348         GtkWidget *win;
 349
 350         win = gtk_scrolled_window_new (NULL, NULL);
 351         gtk_scrolled_window_set_policy
 352                 (GTK_SCROLLED_WINDOW (win),GTK_POLICY_NEVER,
 353                  GTK_POLICY_AUTOMATIC);
 354
 355         if (needs_viewport)
 356                 gtk_scrolled_window_add_with_viewport
 357                         (GTK_SCROLLED_WINDOW(win), widget);
 358         else
 359                 gtk_container_add (GTK_CONTAINER(win),
 360                                    widget);
 361
 362         return win;
 363 }
 364
 365 GtkWidget*
 366 modest_main_window_new (ModestWidgetFactory *factory, ModestConf *conf)
 367 {
 368         GObject *obj;
 369         ModestMainWindowPrivate *priv;
 370
 371         GtkWidget *main_vbox;
 372         GtkWidget *status_hbox;
 373         GtkWidget *header_win, *folder_win;
 374
 375         g_return_val_if_fail (factory, NULL);
 376         g_return_val_if_fail (conf, NULL);
 377
 378         obj  = g_object_new(MODEST_TYPE_MAIN_WINDOW, NULL);
 379         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 380
 381         g_object_ref (factory);
 382         priv->widget_factory = factory;
 383
 384         g_object_ref (conf);
 385         priv->conf = conf;
 386
 387         /* widgets from factory */
 388         priv->folder_view = modest_widget_factory_get_folder_view (factory);
 389         priv->header_view = header_view_new (MODEST_MAIN_WINDOW(obj));
 390         priv->msg_preview = modest_widget_factory_get_msg_preview (factory);
 391
 392         folder_win = wrapped_in_scrolled_window (GTK_WIDGET(priv->folder_view),
 393                                                  FALSE);
 394         header_win = wrapped_in_scrolled_window (GTK_WIDGET(priv->header_view),
 395                                                  FALSE);
 396         /* tool/menubar */
 397         priv->menubar = menubar_new (MODEST_MAIN_WINDOW(obj));
 398         priv->toolbar = gtk_toolbar_new ();
 399
 400         /* paned */
 401         priv->folder_paned = gtk_vpaned_new ();
 402         priv->msg_paned = gtk_vpaned_new ();
 403         priv->main_paned = gtk_hpaned_new ();
 404         gtk_paned_add1 (GTK_PANED(priv->main_paned), priv->folder_paned);
 405         gtk_paned_add2 (GTK_PANED(priv->main_paned), priv->msg_paned);
 406         gtk_paned_add1 (GTK_PANED(priv->folder_paned),
 407                         gtk_label_new (_("Favorites")));
 408         gtk_paned_add2 (GTK_PANED(priv->folder_paned), folder_win);
 409         gtk_paned_add1 (GTK_PANED(priv->msg_paned), header_win);
 410         gtk_paned_add2 (GTK_PANED(priv->msg_paned), GTK_WIDGET(priv->msg_preview));
 411
 412         gtk_widget_show (GTK_WIDGET(priv->header_view));
 413
 414         /* status bar / progress */
 415         status_hbox = gtk_hbox_new (TRUE, 5);
 416         gtk_box_pack_start (GTK_BOX(status_hbox),
 417                             modest_widget_factory_get_status_bar(factory),
 418                             FALSE, TRUE, 5);
 419         gtk_box_pack_start (GTK_BOX(status_hbox),
 420                             modest_widget_factory_get_progress_bar(factory),
 421                             FALSE, TRUE, 5);
 422
 423         /* putting it all together... */
 424         main_vbox = gtk_vbox_new (FALSE, 2);
 425         gtk_box_pack_start (GTK_BOX(main_vbox), priv->menubar, FALSE, FALSE, 2);
 426         gtk_box_pack_start (GTK_BOX(main_vbox), priv->toolbar, FALSE, TRUE, 5);
 427         gtk_box_pack_start (GTK_BOX(main_vbox), priv->main_paned, TRUE, TRUE, 2);
 428         gtk_box_pack_start (GTK_BOX(main_vbox), status_hbox, FALSE, FALSE, 5);
 429
 430         gtk_container_add (GTK_CONTAINER(obj), main_vbox);
 431         gtk_widget_show_all (main_vbox);
 432
 433         gtk_window_set_title (GTK_WINDOW(obj), "Modest");
 434
 435         restore_sizes (MODEST_MAIN_WINDOW(obj));
 436
 437         return GTK_WIDGET(obj);
 438 }