path: root/widgets/misc/e-send-options.c

/*
 * Evolution calendar - Main page of the Groupwise send options Dialog
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Chenthill Palanisamy <pchenthill@novell.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>
#include <glib/gi18n.h>
#include <time.h>

#include "e-util/e-util.h"
#include "e-util/e-util-private.h"

#include "e-dateedit.h"
#include "e-send-options.h"

struct _ESendOptionsDialogPrivate {
    GtkBuilder *builder;

    gboolean gopts_needed;
    gboolean global;

    /* Widgets */

    GtkWidget *main;

    /* Noteboook to add options page and status tracking page*/
    GtkNotebook *notebook;

    GtkWidget *status;

    /* priority */
    GtkWidget *priority;

    /* Security */
    GtkWidget *security;

    /* Widgets for Reply Requestion options */
    GtkWidget *reply_request;
    GtkWidget *reply_convenient;
    GtkWidget *reply_within;
    GtkWidget *within_days;

    /* Widgets for delay delivery Option */
    GtkWidget *delay_delivery;
    GtkWidget *delay_until;

    /* Widgets for Choosing expiration date */
    GtkWidget *expiration;
    GtkWidget *expire_after;

    /* Widgets to for tracking information through sent Item */
    GtkWidget *create_sent;
    GtkWidget *delivered;
    GtkWidget *delivered_opened;
    GtkWidget *all_info;
    GtkWidget *autodelete;

    /* Widgets for setting the Return Notification */
    GtkWidget *when_opened;
    GtkWidget *when_declined;
    GtkWidget *when_accepted;
    GtkWidget *when_completed;

    /* label widgets */
    GtkWidget *security_label;
    GtkWidget *priority_label;
    GtkWidget *gopts_label;
    GtkWidget *opened_label;
    GtkWidget *declined_label;
    GtkWidget *accepted_label;
    GtkWidget *completed_label;
    GtkWidget *until_label;
        gchar *help_section;
};

static void e_send_options_dialog_finalize (GObject *object);
static void e_send_options_cb (GtkDialog *dialog, gint state, gpointer func_data);

enum {
    SOD_RESPONSE,
    LAST_SIGNAL
};

static guint signals[LAST_SIGNAL] = {0};

G_DEFINE_TYPE (
    ESendOptionsDialog,
    e_send_options_dialog,
    G_TYPE_OBJECT)

static void
e_send_options_get_widgets_data (ESendOptionsDialog *sod)
{
    ESendOptionsDialogPrivate *priv;
    ESendOptionsGeneral *gopts;
    ESendOptionsStatusTracking *sopts;

    priv = sod->priv;
    gopts = sod->data->gopts;
    sopts = sod->data->sopts;

    gopts->priority = gtk_combo_box_get_active ((GtkComboBox *) priv->priority);
    gopts->security = gtk_combo_box_get_active ((GtkComboBox *) priv->security);

    gopts->reply_enabled = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->reply_request));
    gopts->reply_convenient = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->reply_convenient));
    gopts->reply_within = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (priv->within_days));

    gopts->expiration_enabled = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->expiration));
    gopts->expire_after = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (priv->expire_after));
    gopts->delay_enabled = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->delay_delivery));

    if (e_date_edit_date_is_valid (E_DATE_EDIT (priv->delay_until)) &&
                                e_date_edit_time_is_valid (E_DATE_EDIT (priv->delay_until)))
        gopts->delay_until = e_date_edit_get_time (E_DATE_EDIT (priv->delay_until));

    sopts->tracking_enabled = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->create_sent));

    sopts->autodelete = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->autodelete));

    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->delivered)))
        sopts->track_when = E_DELIVERED;
    else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->delivered_opened)))
        sopts->track_when = E_DELIVERED_OPENED;
    else
        sopts->track_when = E_ALL;

    sopts->opened = gtk_combo_box_get_active ((GtkComboBox *) priv->when_opened);
    sopts->accepted = gtk_combo_box_get_active ((GtkComboBox *) priv->when_accepted);
    sopts->declined = gtk_combo_box_get_active ((GtkComboBox *) priv->when_declined);
    sopts->completed = gtk_combo_box_get_active ((GtkComboBox *) priv->when_completed);
}

static void
e_send_options_fill_widgets_with_data (ESendOptionsDialog *sod)
{
    ESendOptionsDialogPrivate *priv;
    ESendOptionsGeneral *gopts;
    ESendOptionsStatusTracking *sopts;
    time_t tmp;

    priv = sod->priv;
    gopts = sod->data->gopts;
    sopts = sod->data->sopts;
    tmp = time (NULL);

    gtk_combo_box_set_active ((GtkComboBox *) priv->priority, gopts->priority);
    gtk_combo_box_set_active ((GtkComboBox *) priv->security, gopts->security);

    if (gopts->reply_enabled)
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->reply_request), TRUE);
    else
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->reply_request), FALSE);

    if (gopts->reply_convenient)
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->reply_convenient), TRUE);
    else
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->reply_within), TRUE);

    gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->within_days), (gdouble) gopts->reply_within);

    if (gopts->expiration_enabled)
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->expiration), TRUE);
    else
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->expiration), FALSE);

    gtk_spin_button_set_value (GTK_SPIN_BUTTON (priv->expire_after), (gdouble) gopts->expire_after);

    if (gopts->delay_enabled)
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->delay_delivery), TRUE);
    else
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->delay_delivery), FALSE);

    if (!gopts->delay_until || (!difftime (gopts->delay_until, tmp) < 0))
        e_date_edit_set_time (E_DATE_EDIT (priv->delay_until), 0);
    else
        e_date_edit_set_time (E_DATE_EDIT (priv->delay_until), gopts->delay_until);

    if (sopts->tracking_enabled)
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->create_sent), TRUE);
    else
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->create_sent), FALSE);

    if (sopts->autodelete)
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->autodelete), TRUE);
    else
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->autodelete), FALSE);

    switch (sopts->track_when) {
        case E_DELIVERED:
            gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->delivered), TRUE);
            break;
        case E_DELIVERED_OPENED:
            gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->delivered_opened), TRUE);
            break;
        case E_ALL:
            gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_info), TRUE);
    }

    gtk_combo_box_set_active ((GtkComboBox *) priv->when_opened, sopts->opened);
    gtk_combo_box_set_active ((GtkComboBox *) priv->when_declined, sopts->declined);
    gtk_combo_box_set_active ((GtkComboBox *) priv->when_accepted, sopts->accepted);
    gtk_combo_box_set_active ((GtkComboBox *) priv->when_completed, sopts->completed);
}

static void
sensitize_widgets (ESendOptionsDialog *sod)
{
    ESendOptionsDialogPrivate *priv;
    ESendOptionsGeneral *gopts;
    ESendOptionsStatusTracking *sopts;

    priv = sod->priv;
    gopts = sod->data->gopts;
    sopts = sod->data->sopts;

    if (!gopts->reply_enabled) {
        gtk_widget_set_sensitive (priv->reply_convenient, FALSE);
        gtk_widget_set_sensitive (priv->reply_within, FALSE);
        gtk_widget_set_sensitive (priv->within_days, FALSE);
    }

    if (!gopts->expiration_enabled)
        gtk_widget_set_sensitive (priv->expire_after, FALSE);

    if (!gopts->delay_enabled) {
        gtk_widget_set_sensitive (priv->delay_until, FALSE);
    }

    if (!sopts->tracking_enabled) {
        gtk_widget_set_sensitive (priv->delivered, FALSE);
        gtk_widget_set_sensitive (priv->delivered_opened, FALSE);
        gtk_widget_set_sensitive (priv->all_info, FALSE);
        gtk_widget_set_sensitive (priv->autodelete, FALSE);
    }
}

static void
expiration_toggled_cb (GtkToggleButton *toggle,
                       gpointer data)
{
    gboolean active;
    ESendOptionsDialog *sod;
    ESendOptionsDialogPrivate *priv;

    sod = data;
    priv = sod->priv;

    active = gtk_toggle_button_get_active (toggle);

    gtk_widget_set_sensitive (priv->expire_after, active);
}

static void
reply_request_toggled_cb (GtkToggleButton *toggle,
                          gpointer data)
{
    gboolean active;
    ESendOptionsDialog *sod;
    ESendOptionsDialogPrivate *priv;

    sod = data;
    priv = sod->priv;
    active = gtk_toggle_button_get_active (toggle);

    gtk_widget_set_sensitive (priv->reply_convenient, active);
    gtk_widget_set_sensitive (priv->reply_within, active);
    gtk_widget_set_sensitive (priv->within_days, active);

}

static void
delay_delivery_toggled_cb (GtkToggleButton *toggle,
                           gpointer data)
{
    gboolean active;
    ESendOptionsDialog *sod;
    ESendOptionsDialogPrivate *priv;

    sod = data;
    priv = sod->priv;
    active = gtk_toggle_button_get_active (toggle);

    gtk_widget_set_sensitive (priv->delay_until, active);
}

static void
sent_item_toggled_cb (GtkToggleButton *toggle,
                      gpointer data)
{
    gboolean active;
    ESendOptionsDialog *sod;
    ESendOptionsDialogPrivate *priv;

    sod = data;
    priv = sod->priv;
    active = gtk_toggle_button_get_active (toggle);

    gtk_widget_set_sensitive (priv->delivered, active);
    gtk_widget_set_sensitive (priv->delivered_opened, active);
    gtk_widget_set_sensitive (priv->all_info, active);
    gtk_widget_set_sensitive (priv->autodelete, active);
}

static void
delay_until_date_changed_cb (GtkWidget *dedit,
                             gpointer data)
{
    ESendOptionsDialog *sod;
    ESendOptionsDialogPrivate *priv;
    time_t tmp, current;

    sod = data;
    priv = sod->priv;

    current = time (NULL);
    tmp = e_date_edit_get_time (E_DATE_EDIT (priv->delay_until));

    if ((difftime (tmp, current) < 0) || !e_date_edit_time_is_valid (E_DATE_EDIT (priv->delay_until))
                      || !e_date_edit_date_is_valid (E_DATE_EDIT (priv->delay_until)))
        e_date_edit_set_time (E_DATE_EDIT (priv->delay_until), 0);

}
static void
page_changed_cb (GtkNotebook *notebook,
                 GtkWidget *page,
                 gint num,
                 gpointer data)
{
    ESendOptionsDialog *sod = data;
    ESendOptionsDialogPrivate *priv = sod->priv;

    e_send_options_get_widgets_data (sod);
    if (num > 0) {
        GtkWidget *child;

        if (num == 1) {
            gtk_widget_hide (priv->accepted_label);
            gtk_widget_hide (priv->when_accepted);
            gtk_widget_hide (priv->completed_label);
            gtk_widget_hide (priv->when_completed);
            gtk_widget_set_sensitive (priv->autodelete, TRUE);
            sod->data->sopts = sod->data->mopts;

            child = gtk_notebook_get_nth_page (notebook, 1);
            if (child != priv->status && (!GTK_IS_BIN (child) || gtk_bin_get_child (GTK_BIN (child)) != priv->status))
                gtk_widget_reparent (priv->status, child);
        } else if (num == 2) {
            gtk_widget_hide (priv->completed_label);
            gtk_widget_hide (priv->when_completed);
            gtk_widget_set_sensitive (priv->autodelete, FALSE);

            gtk_widget_show (priv->accepted_label);
            gtk_widget_show (priv->when_accepted);
            sod->data->sopts = sod->data->copts;

            child = gtk_notebook_get_nth_page (notebook, 2);
            if (gtk_bin_get_child (GTK_BIN (child)) != priv->status)
                gtk_widget_reparent (priv->status, child);
        } else {
            gtk_widget_set_sensitive (priv->autodelete, FALSE);

            gtk_widget_show (priv->completed_label);
            gtk_widget_show (priv->when_completed);
            gtk_widget_show (priv->accepted_label);
            gtk_widget_show (priv->when_accepted);
            sod->data->sopts = sod->data->topts;

            child = gtk_notebook_get_nth_page (notebook, 3);
            if (gtk_bin_get_child (GTK_BIN (child)) != priv->status)
                gtk_widget_reparent (priv->status, child);
        }
    }
    e_send_options_fill_widgets_with_data (sod);
}

static void
init_widgets (ESendOptionsDialog *sod)
{
    ESendOptionsDialogPrivate *priv;

    priv = sod->priv;

    g_signal_connect (priv->expiration, "toggled", G_CALLBACK (expiration_toggled_cb), sod);
    g_signal_connect (priv->reply_request, "toggled", G_CALLBACK (reply_request_toggled_cb), sod);
    g_signal_connect (priv->delay_delivery, "toggled", G_CALLBACK (delay_delivery_toggled_cb), sod);
    g_signal_connect (priv->create_sent, "toggled", G_CALLBACK (sent_item_toggled_cb), sod);

    g_signal_connect (GTK_DIALOG (priv->main), "response", G_CALLBACK(e_send_options_cb), sod);
    g_signal_connect (priv->delay_until, "changed", G_CALLBACK (delay_until_date_changed_cb), sod);

    if (priv->global)
        g_signal_connect (priv->notebook, "switch-page", G_CALLBACK (page_changed_cb), sod);

}

static gboolean
get_widgets (ESendOptionsDialog *sod)
{
    ESendOptionsDialogPrivate *priv;
    GtkBuilder *builder;

    priv = sod->priv;
    builder = sod->priv->builder;

    priv->main = e_builder_get_widget (builder, "send-options-dialog");
    if (!priv->main)
        return FALSE;

    priv->priority = e_builder_get_widget (builder, "combo-priority");
    priv->status = e_builder_get_widget (builder, "status-tracking");
    priv->security = e_builder_get_widget (builder, "security-combo");
    priv->notebook = (GtkNotebook *)e_builder_get_widget (builder, "notebook");
    priv->reply_request = e_builder_get_widget (builder, "reply-request-button");
    priv->reply_convenient = e_builder_get_widget (builder, "reply-convinient");
    priv->reply_within = e_builder_get_widget (builder, "reply-within");
    priv->within_days = e_builder_get_widget (builder, "within-days");
    priv->delay_delivery = e_builder_get_widget (builder, "delay-delivery-button");
    priv->delay_until = e_builder_get_widget (builder, "until-date");
    gtk_widget_show (priv->delay_until);
    priv->expiration = e_builder_get_widget (builder, "expiration-button");
    priv->expire_after = e_builder_get_widget (builder, "expire-after");
    priv->create_sent = e_builder_get_widget (builder, "create-sent-button");
    priv->delivered = e_builder_get_widget (builder, "delivered");
    priv->delivered_opened = e_builder_get_widget (builder, "delivered-opened");
    priv->all_info = e_builder_get_widget (builder, "all-info");
    priv->autodelete = e_builder_get_widget (builder, "autodelete");
    priv->when_opened = e_builder_get_widget (builder, "open-combo");
    priv->when_declined = e_builder_get_widget (builder, "delete-combo");
    priv->when_accepted = e_builder_get_widget (builder, "accept-combo");
    priv->when_completed = e_builder_get_widget (builder, "complete-combo");
    priv->security_label = e_builder_get_widget (builder, "security-label");
    priv->gopts_label = e_builder_get_widget (builder, "gopts-label");
    priv->priority_label = e_builder_get_widget (builder, "priority-label");
    priv->until_label = e_builder_get_widget (builder, "until-label");
    priv->opened_label = e_builder_get_widget (builder, "opened-label");
    priv->declined_label = e_builder_get_widget (builder, "declined-label");
    priv->accepted_label = e_builder_get_widget (builder, "accepted-label");
    priv->completed_label = e_builder_get_widget (builder, "completed-label");

    return (priv->priority
        && priv->security
        && priv->status
        && priv->reply_request
        && priv->reply_convenient
        && priv->reply_within
        && priv->within_days
        && priv->delay_delivery
        && priv->delay_until
        && priv->expiration
        && priv->expire_after
        && priv->create_sent
        && priv->delivered
        && priv->delivered_opened
        && priv->autodelete
        && priv->all_info
        && priv->when_opened
        && priv->when_declined
        && priv->when_accepted
        && priv->when_completed
        && priv->security_label
        && priv->priority_label
        && priv->opened_label
        && priv->gopts_label
        && priv->declined_label
        && priv->accepted_label
        && priv->completed_label);

}

static void
setup_widgets (ESendOptionsDialog *sod,
               Item_type type)
{
    ESendOptionsDialogPrivate *priv;

    priv = sod->priv;

    if (!priv->gopts_needed) {
        gtk_notebook_set_show_tabs (priv->notebook, FALSE);
        gtk_notebook_set_current_page (priv->notebook, 1);
        gtk_widget_hide (priv->delay_until);
    } else
        gtk_notebook_set_show_tabs (priv->notebook, TRUE);

    gtk_label_set_mnemonic_widget (GTK_LABEL (priv->priority_label), priv->priority);
    gtk_label_set_mnemonic_widget (GTK_LABEL (priv->security_label), priv->security);
    gtk_label_set_mnemonic_widget (GTK_LABEL (priv->accepted_label), priv->when_accepted);
    gtk_label_set_mnemonic_widget (GTK_LABEL (priv->declined_label), priv->when_declined);
    gtk_label_set_mnemonic_widget (GTK_LABEL (priv->opened_label), priv->when_opened);
    gtk_label_set_mnemonic_widget (GTK_LABEL (priv->completed_label), priv->when_completed);
    gtk_label_set_mnemonic_widget (GTK_LABEL (priv->until_label), priv->delay_until);

    if (priv->global) {
        GtkWidget *widget, *page;

        widget = gtk_label_new (_("Mail"));
        page = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
        gtk_widget_reparent (priv->status, page);
        gtk_notebook_append_page (priv->notebook, page, widget);
        gtk_container_child_set (GTK_CONTAINER (priv->notebook), page, "tab-fill", FALSE, "tab-expand", FALSE, NULL);
        gtk_widget_show (page);
        gtk_widget_show (widget);

        widget = gtk_label_new (_("Calendar"));
        page = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
        gtk_notebook_append_page (priv->notebook, page, widget);
        gtk_container_child_set (GTK_CONTAINER (priv->notebook), page, "tab-fill", FALSE, "tab-expand", FALSE, NULL);
        gtk_widget_show (page);
        gtk_widget_show (widget);

        widget = gtk_label_new (_("Task"));
        page = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
        gtk_notebook_append_page (priv->notebook, page, widget);
        gtk_container_child_set (GTK_CONTAINER (priv->notebook), page, "tab-fill", FALSE, "tab-expand", FALSE, NULL);
        gtk_widget_show (page);
        gtk_widget_show (widget);

        gtk_notebook_set_show_tabs (priv->notebook, TRUE);
    }

    switch (type) {
        case E_ITEM_MAIL:
            priv->help_section = g_strdup ("usage-mail");
            gtk_widget_hide (priv->accepted_label);
            gtk_widget_hide (priv->when_accepted);
            gtk_widget_hide (priv->completed_label);
            gtk_widget_hide (priv->when_completed);
            gtk_label_set_text_with_mnemonic (GTK_LABEL (priv->declined_label), (_("When de_leted:")));
            break;
        case E_ITEM_CALENDAR:
            priv->help_section = g_strdup ("usage-calendar");
            gtk_widget_hide (priv->completed_label);
            gtk_widget_hide (priv->when_completed);
        case E_ITEM_TASK:
            priv->help_section = g_strdup ("usage-calendar-todo");
            gtk_widget_hide (priv->security_label);
            gtk_widget_hide (priv->security);
            gtk_widget_set_sensitive (priv->autodelete, FALSE);
            break;
        default:
            break;
    }
}

ESendOptionsDialog *
e_send_options_dialog_new (void)
{
    ESendOptionsDialog *sod;

    sod = g_object_new (E_TYPE_SENDOPTIONS_DIALOG, NULL);

    return sod;
}

void
e_send_options_set_need_general_options (ESendOptionsDialog *sod,
                                         gboolean needed)
{
    g_return_if_fail (E_IS_SENDOPTIONS_DIALOG (sod));

    sod->priv->gopts_needed = needed;
}

gboolean
e_send_options_get_need_general_options (ESendOptionsDialog *sod)
{
    g_return_val_if_fail (E_IS_SENDOPTIONS_DIALOG (sod), FALSE);

    return sod->priv->gopts_needed;
}

gboolean
e_send_options_set_global (ESendOptionsDialog *sod,
                           gboolean set)
{
    g_return_val_if_fail (E_IS_SENDOPTIONS_DIALOG (sod), FALSE);

    sod->priv->global = set;

    return TRUE;
}

static void
e_send_options_cb (GtkDialog *dialog,
                   gint state,
                   gpointer func_data)
{
    ESendOptionsDialogPrivate *priv;
    ESendOptionsDialog *sod;

    sod = func_data;
    priv = sod->priv;

    switch (state) {
        case GTK_RESPONSE_OK:
            e_send_options_get_widgets_data (sod);
        case GTK_RESPONSE_CANCEL:
            gtk_widget_hide (priv->main);
            gtk_widget_destroy (priv->main);
            g_object_unref (priv->builder);
            break;
        case GTK_RESPONSE_HELP:
            e_display_help (
                GTK_WINDOW (priv->main),
                priv->help_section);
            break;
    }

    g_signal_emit (G_OBJECT (func_data), signals[SOD_RESPONSE], 0, state);
}

gboolean
e_send_options_dialog_run (ESendOptionsDialog *sod,
                           GtkWidget *parent,
                           Item_type type)
{
    ESendOptionsDialogPrivate *priv;
    GtkWidget *toplevel;

    g_return_val_if_fail (sod != NULL || E_IS_SENDOPTIONS_DIALOG (sod), FALSE);

    priv = sod->priv;

    /* Make sure our custom widget classes are registered with
     * GType before we load the GtkBuilder definition file. */
    E_TYPE_DATE_EDIT;

    priv->builder = gtk_builder_new ();
    e_load_ui_builder_definition (priv->builder, "e-send-options.ui");

    if (!get_widgets (sod)) {
        g_object_unref (priv->builder);
        g_message (G_STRLOC ": Could not get the Widgets \n");
        return FALSE;
    }

    if (priv->global) {
        g_free (sod->data->sopts);
        sod->data->sopts = sod->data->mopts;
    }

    setup_widgets (sod, type);

    toplevel =  gtk_widget_get_toplevel (priv->main);
    if (parent)
        gtk_window_set_transient_for (GTK_WINDOW (toplevel),
                      GTK_WINDOW (parent));

    e_send_options_fill_widgets_with_data (sod);
    sensitize_widgets (sod);
    init_widgets (sod);
    gtk_window_set_modal ((GtkWindow *) priv->main, TRUE);

    gtk_widget_show (priv->main);

    return TRUE;
}

static void
e_send_options_dialog_finalize (GObject *object)
{
    ESendOptionsDialog *sod = (ESendOptionsDialog *) object;
    ESendOptionsDialogPrivate *priv;

    g_return_if_fail (E_IS_SENDOPTIONS_DIALOG (sod));
    priv = sod->priv;

    g_free (priv->help_section);

    if (sod->data->gopts) {
        g_free (sod->data->gopts);
        sod->data->gopts = NULL;
    }

    if (!priv->global && sod->data->sopts) {
        g_free (sod->data->sopts);
        sod->data->sopts = NULL;
    }

    if (sod->data->mopts) {
        g_free (sod->data->mopts);
        sod->data->mopts = NULL;
    }

    if (sod->data->copts) {
        g_free (sod->data->copts);
        sod->data->copts = NULL;
    }

    if (sod->data->topts) {
        g_free (sod->data->topts);
        sod->data->topts = NULL;
    }

    if (sod->data) {
        g_free (sod->data);
        sod->data = NULL;
    }

    if (sod->priv) {
        g_free (sod->priv);
        sod->priv = NULL;
    }

    /* Chain up to parent's finalize() method. */
    G_OBJECT_CLASS (e_send_options_dialog_parent_class)->finalize (object);

}

/* Object initialization function for the task page */
static void
e_send_options_dialog_init (ESendOptionsDialog *sod)
{
    ESendOptionsDialogPrivate *priv;
    ESendOptionsData *new;

    new = g_new0 (ESendOptionsData, 1);
    new->gopts = g_new0 (ESendOptionsGeneral, 1);
    new->sopts = g_new0 (ESendOptionsStatusTracking, 1);
    new->mopts = g_new0 (ESendOptionsStatusTracking, 1);
    new->copts = g_new0 (ESendOptionsStatusTracking, 1);
    new->topts = g_new0 (ESendOptionsStatusTracking, 1);
    priv = g_new0 (ESendOptionsDialogPrivate, 1);

    sod->priv = priv;
    sod->data = new;
    sod->data->initialized = FALSE;
    sod->data->gopts->security = 0;

    priv->gopts_needed = TRUE;
    priv->builder = NULL;

    priv->main = NULL;
    priv->notebook = NULL;
    priv->priority = NULL;
    priv->status = NULL;
    priv->security = NULL;
    priv->reply_request = NULL;
    priv->reply_convenient = NULL;
    priv->within_days = NULL;
    priv->delay_delivery = NULL;
    priv->delay_until = NULL;
    priv->expiration = NULL;
    priv->expire_after = NULL;
    priv->create_sent = NULL;
    priv->delivered =NULL;
    priv->delivered_opened = NULL;
    priv->global = FALSE;
    priv->all_info = NULL;
    priv->when_opened = NULL;
    priv->when_declined = NULL;
    priv->when_accepted = NULL;
    priv->when_completed = NULL;
    priv->security_label = NULL;
    priv->priority_label = NULL;
    priv->opened_label = NULL;
    priv->gopts_label = NULL;
    priv-> declined_label = NULL;
    priv->accepted_label = NULL;
    priv->completed_label = NULL;

}

/* Class initialization function for the Send Options */
static void
e_send_options_dialog_class_init (ESendOptionsDialogClass *class)
{
    GObjectClass *object_class;

    object_class = G_OBJECT_CLASS (class);
    object_class->finalize = e_send_options_dialog_finalize;

    signals[SOD_RESPONSE] = g_signal_new ("sod_response",
            G_TYPE_FROM_CLASS (class),
            G_SIGNAL_RUN_FIRST,
            G_STRUCT_OFFSET (ESendOptionsDialogClass, sod_response),
            NULL, NULL,
            g_cclosure_marshal_VOID__INT,
            G_TYPE_NONE, 1,
            G_TYPE_INT);

}