git.maemo.org Git - modest/blob - src/gtk/modest-transport-widget.c

   1 /* modest-transport-widget.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include <glib/gi18n.h>
   6 #include "modest-transport-widget.h"
   7 #include <string.h>
   8
   9 /* 'private'/'protected' functions */
  10 static void modest_transport_widget_class_init (ModestTransportWidgetClass *klass);
  11 static void modest_transport_widget_init       (ModestTransportWidget *obj);
  12 static void modest_transport_widget_finalize   (GObject *obj);
  13 /* list my signals  */
  14 enum {
  15         /* MY_SIGNAL_1, */
  16         /* MY_SIGNAL_2, */
  17         LAST_SIGNAL
  18 };
  19
  20 typedef struct _ModestTransportWidgetPrivate ModestTransportWidgetPrivate;
  21 struct _ModestTransportWidgetPrivate {
  22         ModestProtocol proto;
  23         ModestWidgetFactory *factory;
  24
  25         GtkWidget *servername;
  26         GtkWidget *username;
  27         GtkWidget *auth;
  28         GtkWidget *remember_pwd;
  29 };
  30 #define MODEST_TRANSPORT_WIDGET_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  31                                                      MODEST_TYPE_TRANSPORT_WIDGET, \
  32                                                      ModestTransportWidgetPrivate))
  33 /* globals */
  34 static GtkContainerClass *parent_class = NULL;
  35
  36 /* uncomment the following if you have defined any signals */
  37 /* static guint signals[LAST_SIGNAL] = {0}; */
  38
  39 GType
  40 modest_transport_widget_get_type (void)
  41 {
  42         static GType my_type = 0;
  43         if (!my_type) {
  44                 static const GTypeInfo my_info = {
  45                         sizeof(ModestTransportWidgetClass),
  46                         NULL,           /* base init */
  47                         NULL,           /* base finalize */
  48                         (GClassInitFunc) modest_transport_widget_class_init,
  49                         NULL,           /* class finalize */
  50                         NULL,           /* class data */
  51                         sizeof(ModestTransportWidget),
  52                         1,              /* n_preallocs */
  53                         (GInstanceInitFunc) modest_transport_widget_init,
  54                         NULL
  55                 };
  56                 my_type = g_type_register_static (GTK_TYPE_VBOX,
  57                                                   "ModestTransportWidget",
  58                                                   &my_info, 0);
  59         }
  60         return my_type;
  61 }
  62
  63 static void
  64 modest_transport_widget_class_init (ModestTransportWidgetClass *klass)
  65 {
  66         GObjectClass *gobject_class;
  67         gobject_class = (GObjectClass*) klass;
  68
  69         parent_class            = g_type_class_peek_parent (klass);
  70         gobject_class->finalize = modest_transport_widget_finalize;
  71
  72         g_type_class_add_private (gobject_class, sizeof(ModestTransportWidgetPrivate));
  73
  74         /* signal definitions go here, e.g.: */
  75 /*      signals[MY_SIGNAL_1] = */
  76 /*              g_signal_new ("my_signal_1",....); */
  77 /*      signals[MY_SIGNAL_2] = */
  78 /*              g_signal_new ("my_signal_2",....); */
  79 /*      etc. */
  80 }
  81
  82 static void
  83 modest_transport_widget_init (ModestTransportWidget *obj)
  84 {
  85         ModestTransportWidgetPrivate *priv;
  86         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(obj);
  87
  88         priv->proto = MODEST_PROTOCOL_UNKNOWN;
  89 }
  90
  91 static void
  92 modest_transport_widget_finalize (GObject *obj)
  93 {
  94         ModestTransportWidgetPrivate *priv;
  95         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(obj);
  96
  97         if (priv->factory) {
  98                 g_object_unref (priv->factory);
  99                 priv->factory = NULL;
 100         }
 101
 102         G_OBJECT_CLASS(parent_class)->finalize (obj);
 103 }
 104
 105 static void
 106 on_button_toggled (GtkToggleButton *button, gpointer user_data)
 107 {
 108         ModestTransportWidgetPrivate *priv;
 109
 110         priv = (ModestTransportWidgetPrivate *) user_data;
 111
 112         if (gtk_toggle_button_get_active (button))
 113                 gtk_widget_set_sensitive (gtk_widget_get_parent (priv->username), TRUE);
 114         else
 115                 gtk_widget_set_sensitive (gtk_widget_get_parent (priv->username), FALSE);
 116 }
 117
 118
 119 static GtkWidget*
 120 smtp_configuration (ModestTransportWidget *self)
 121 {
 122         ModestTransportWidgetPrivate *priv;
 123         GtkWidget *label, *box, *hbox;
 124
 125         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(self);
 126         box = gtk_vbox_new (FALSE, 6);
 127
 128         label = gtk_label_new (NULL);
 129         gtk_label_set_markup (GTK_LABEL(label),
 130                               _("<b>SMTP configuration</b>"));
 131         gtk_box_pack_start (GTK_BOX(box), label, FALSE, FALSE, 6);
 132
 133         priv->servername = gtk_entry_new_with_max_length (40);
 134         priv->username = gtk_entry_new_with_max_length (40);
 135
 136         /* Servername */
 137         hbox = gtk_hbox_new (FALSE, 6);
 138         gtk_box_pack_start (GTK_BOX(hbox), gtk_label_new (_("Servername: ")),
 139                             FALSE, FALSE, 6);
 140         gtk_box_pack_start (GTK_BOX(hbox), priv->servername, TRUE, TRUE, 6);
 141         gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 6);
 142
 143         /* Auth */
 144         priv->auth = gtk_check_button_new_with_label (_("Requires authentication"));
 145         gtk_box_pack_start (GTK_BOX(box), priv->auth, TRUE, FALSE, 6);
 146
 147         g_signal_connect (priv->auth, "toggled", G_CALLBACK (on_button_toggled), priv);
 148
 149         /* Username */
 150         hbox = gtk_hbox_new (FALSE, 6);
 151         gtk_box_pack_start (GTK_BOX(hbox), gtk_label_new (_("Username: ")),
 152                             FALSE, FALSE, 6);
 153         gtk_box_pack_start (GTK_BOX(hbox), priv->username, TRUE, TRUE, 6);
 154         gtk_widget_set_sensitive (hbox, FALSE);
 155         gtk_box_pack_start (GTK_BOX(box), hbox, TRUE, TRUE, 6);
 156
 157         /* Security */
 158         label = gtk_label_new(NULL);
 159         gtk_label_set_markup (GTK_LABEL(label),_("<b>Security</b>"));
 160         gtk_box_pack_start (GTK_BOX(box), label, FALSE, FALSE, 0);
 161
 162         hbox = gtk_hbox_new (FALSE, 6);
 163         label = gtk_label_new(NULL);
 164         gtk_label_set_text (GTK_LABEL(label),_("Connection type:"));
 165         gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
 166         gtk_box_pack_start (GTK_BOX(hbox),  modest_widget_factory_get_combo_box
 167                             (priv->factory, MODEST_COMBO_BOX_TYPE_SECURITY_PROTOS),
 168                             FALSE, FALSE,0);
 169         gtk_box_pack_start (GTK_BOX(box), hbox, FALSE, FALSE, 0);
 170
 171
 172         hbox = gtk_hbox_new (FALSE, 6);
 173         label = gtk_label_new(NULL);
 174
 175         gtk_label_set_text (GTK_LABEL(label),_("Authentication:"));
 176         gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 6);
 177         gtk_box_pack_start (GTK_BOX(hbox),   modest_widget_factory_get_combo_box
 178                             (priv->factory, MODEST_COMBO_BOX_TYPE_AUTH_PROTOS),
 179                             FALSE, FALSE, 0);
 180         priv->remember_pwd =
 181                 gtk_check_button_new_with_label (_("Remember password"));
 182         gtk_box_pack_start (GTK_BOX(hbox),priv->remember_pwd,
 183                             FALSE, FALSE, 0);
 184         return box;
 185 }
 186
 187
 188 GtkWidget*
 189 modest_transport_widget_new (ModestWidgetFactory *factory, ModestProtocol proto)
 190 {
 191         GObject *obj;
 192         GtkWidget *w;
 193         ModestTransportWidget *self;
 194         ModestTransportWidgetPrivate *priv;
 195
 196         g_return_val_if_fail (proto, NULL);
 197         g_return_val_if_fail (factory, NULL);
 198
 199         obj = g_object_new(MODEST_TYPE_TRANSPORT_WIDGET, NULL);
 200         self = MODEST_TRANSPORT_WIDGET(obj);
 201         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(self);
 202
 203         g_object_ref (factory);
 204         priv->factory = factory;
 205
 206         priv->proto = proto;
 207
 208         if (proto == MODEST_PROTOCOL_TRANSPORT_SMTP)
 209                 w = smtp_configuration (self);
 210         else
 211                 w = gtk_label_new ("");
 212
 213         gtk_widget_show_all (w);
 214         gtk_box_pack_start (GTK_BOX(self), w, FALSE, FALSE, 2);
 215
 216         return GTK_WIDGET(self);
 217 }
 218
 219
 220 gboolean
 221 modest_transport_widget_get_remember_password (ModestTransportWidget *self)
 222 {
 223         ModestTransportWidgetPrivate *priv;
 224
 225         g_return_val_if_fail (self, FALSE);
 226         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(self);
 227
 228         return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(priv->remember_pwd));
 229 }
 230
 231 gboolean
 232 modest_transport_widget_get_requires_auth (ModestTransportWidget *self)
 233 {
 234         ModestTransportWidgetPrivate *priv;
 235
 236         g_return_val_if_fail (self, FALSE);
 237         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(self);
 238
 239         return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(priv->auth));
 240 }
 241
 242 const gchar*
 243 modest_transport_widget_get_username (ModestTransportWidget *self)
 244 {
 245         ModestTransportWidgetPrivate *priv;
 246
 247         g_return_val_if_fail (self, NULL);
 248         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(self);
 249
 250         return gtk_entry_get_text (GTK_ENTRY(priv->username));
 251 }
 252
 253 const gchar*
 254 modest_transport_widget_get_servername (ModestTransportWidget *self)
 255 {
 256         ModestTransportWidgetPrivate *priv;
 257
 258         g_return_val_if_fail (self, NULL);
 259         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(self);
 260
 261         return gtk_entry_get_text (GTK_ENTRY(priv->servername));
 262 }
 263
 264
 265 ModestProtocol
 266 modest_transport_widget_get_proto (ModestTransportWidget *self)
 267 {
 268         ModestTransportWidgetPrivate *priv;
 269
 270         g_return_val_if_fail (self, MODEST_PROTOCOL_UNKNOWN);
 271         priv = MODEST_TRANSPORT_WIDGET_GET_PRIVATE(self);
 272
 273         return priv->proto;
 274 }
 275