git.maemo.org Git - modest/blob - src/modest-window-mgr.c

   1 /* modest-window-mgr.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include "modest-window-mgr.h"
   6 /* include other impl specific header files */
   7
   8 /* 'private'/'protected' functions */
   9 static void                   modest_window_mgr_class_init    (ModestWindowMgrClass *klass);
  10 static void                   modest_window_mgr_init          (ModestWindowMgr *obj);
  11 static void                   modest_window_mgr_finalize      (GObject *obj);
  12
  13 /* list my signals */
  14 enum {
  15         /* MY_SIGNAL_1, */
  16         /* MY_SIGNAL_2, */
  17         LAST_WINDOW_CLOSED_SIGNAL,
  18         LAST_SIGNAL
  19 };
  20
  21 typedef struct _ModestWindowMgrPrivate ModestWindowMgrPrivate;
  22 struct _ModestWindowMgrPrivate {
  23         GSList *open_windows;
  24
  25 };
  26 #define MODEST_WINDOW_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  27                                                MODEST_TYPE_WINDOW_MGR, \
  28                                                ModestWindowMgrPrivate))
  29 /* globals */
  30 static GObjectClass *parent_class = NULL;
  31
  32 static guint signals[LAST_SIGNAL] = {0};
  33
  34 GType
  35 modest_window_mgr_get_type (void)
  36 {
  37         static GType my_type = 0;
  38         if (!my_type) {
  39                 static const GTypeInfo my_info = {
  40                         sizeof(ModestWindowMgrClass),
  41                         NULL,           /* base init */
  42                         NULL,           /* base finalize */
  43                         (GClassInitFunc) modest_window_mgr_class_init,
  44                         NULL,           /* class finalize */
  45                         NULL,           /* class data */
  46                         sizeof(ModestWindowMgr),
  47                         1,              /* n_preallocs */
  48                         (GInstanceInitFunc) modest_window_mgr_init,
  49                 };
  50                 my_type = g_type_register_static (G_TYPE_OBJECT,
  51                                                   "ModestWindowMgr",
  52                                                   &my_info, 0);
  53         }
  54         return my_type;
  55 }
  56
  57 static void
  58 modest_window_mgr_class_init (ModestWindowMgrClass *klass)
  59 {
  60         GObjectClass *gobject_class;
  61         gobject_class = (GObjectClass*) klass;
  62
  63         parent_class            = g_type_class_peek_parent (klass);
  64         gobject_class->finalize = modest_window_mgr_finalize;
  65
  66         g_type_class_add_private (gobject_class, sizeof(ModestWindowMgrPrivate));
  67
  68         signals[LAST_WINDOW_CLOSED_SIGNAL] =
  69                 g_signal_new ("last_window_closed",
  70                               G_TYPE_FROM_CLASS(gobject_class),
  71                               G_SIGNAL_RUN_FIRST,
  72                               G_STRUCT_OFFSET(ModestWindowMgrClass, last_window_closed),
  73                               NULL, NULL,
  74                               g_cclosure_marshal_VOID__VOID,
  75                               G_TYPE_NONE, 0);
  76 }
  77
  78 static void
  79 modest_window_mgr_init (ModestWindowMgr *obj)
  80 {
  81         ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj);
  82         priv->open_windows = NULL;
  83 }
  84
  85 static void
  86 modest_window_mgr_finalize (GObject *obj)
  87 {
  88         ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj);
  89         g_slist_free (priv->open_windows);
  90         priv->open_windows = NULL;
  91 }
  92
  93 GObject*
  94 modest_window_mgr_new (void)
  95 {
  96         return G_OBJECT(g_object_new(MODEST_TYPE_WINDOW_MGR, NULL));
  97 }
  98
  99 /* insert many other interesting function implementations */
 100 /* such as modest_window_mgr_do_something, or modest_window_mgr_has_foo */
 101
 102 gboolean
 103 modest_window_mgr_register (ModestWindowMgr *self, GObject *win,
 104                             ModestWindowType type,
 105                             guint window_id)
 106 {
 107         ModestOpenWindow *openwin = NULL;
 108         ModestWindowMgrPrivate *priv;
 109
 110         g_return_val_if_fail (self, FALSE);
 111         g_return_val_if_fail (type==MODEST_MAIN_WINDOW||type==MODEST_EDIT_WINDOW,
 112                               FALSE);
 113
 114         priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
 115
 116         openwin = g_new (ModestOpenWindow, 1);
 117         openwin->win  = win;
 118         openwin->type = type;
 119         openwin->id   = window_id;
 120
 121         priv->open_windows = g_slist_prepend (priv->open_windows, openwin);
 122
 123         return TRUE;
 124 }
 125
 126
 127
 128 gboolean
 129 modest_window_mgr_unregister (ModestWindowMgr *self, GObject *win)
 130 {
 131         ModestWindowMgrPrivate *priv;
 132         GSList *cursor;
 133         gboolean found = FALSE;
 134
 135         g_return_val_if_fail (self, FALSE);
 136         g_return_val_if_fail (win, FALSE);
 137
 138         priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
 139
 140         cursor = priv->open_windows;
 141         while (cursor) {
 142                 if (((ModestOpenWindow*)cursor->data)->win == win) {
 143                         priv->open_windows = g_slist_delete_link (priv->open_windows,
 144                                                                   cursor);
 145                         found = TRUE;
 146                         break;
 147                 }
 148                 cursor = cursor->next;
 149         }
 150         if (found) {
 151                 guint win_num = g_slist_length (priv->open_windows);
 152                 if (win_num == 0)
 153                         g_signal_emit (self, signals[LAST_WINDOW_CLOSED_SIGNAL],
 154                                        0);
 155         }
 156
 157         return found;
 158 }
 159
 160
 161 GObject *
 162 modest_window_mgr_find_by_type (ModestWindowMgr *self, ModestWindowType type)
 163 {
 164         ModestWindowMgrPrivate *priv;
 165         GSList *cursor;
 166
 167         g_return_val_if_fail (self, NULL);
 168
 169         priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
 170         cursor = priv->open_windows;
 171         while (cursor) {
 172                 ModestOpenWindow *openwin = (ModestOpenWindow*)cursor->data;
 173                 if (openwin->type == type)
 174                         return openwin->win;
 175                 cursor = cursor->next;
 176         }
 177
 178         return NULL;
 179 }
 180
 181
 182 GObject *
 183 modest_window_mgr_find_by_id (ModestWindowMgr *self, gint window_id)
 184 {
 185         ModestWindowMgrPrivate *priv;
 186         GSList *cursor;
 187
 188         g_return_val_if_fail (self, NULL);
 189
 190         priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
 191         cursor = priv->open_windows;
 192         while (cursor) {
 193                 ModestOpenWindow *openwin = (ModestOpenWindow*)cursor->data;
 194                 if (openwin->id == window_id)
 195                         return openwin->win;
 196                 cursor = cursor->next;
 197         }
 198         return NULL;
 199 }
 200