path: root/e-util/e-proxy-link-selector.c

/*
 * e-proxy-link-selector.c
 *
 * 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.
 *
 * 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 General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 */

/**
 * SECTION: e-proxy-link-selector
 * @include: e-util/e-util.h
 * @short_description: Link accounts to a proxy profile
 *
 * #EProxyLinkSelector shows all network-based accounts in a tree view,
 * with a checkbox next to each account.  The checkbox allows users to
 * choose between linking the account to a pre-determined user-defined
 * proxy profile, or to the built-in default proxy profile.
 **/

#include "e-proxy-link-selector.h"

#define E_PROXY_LINK_SELECTOR_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), E_TYPE_PROXY_LINK_SELECTOR, EProxyLinkSelectorPrivate))

struct _EProxyLinkSelectorPrivate {
    ESource *target_source;
    ESource *fallback_source;
};

enum {
    PROP_0,
    PROP_TARGET_SOURCE
};

G_DEFINE_TYPE (
    EProxyLinkSelector,
    e_proxy_link_selector,
    E_TYPE_SOURCE_SELECTOR)

static gboolean
proxy_link_selector_target_source_to_show_toggles (GBinding *binding,
                                                   const GValue *source_value,
                                                   GValue *target_value,
                                                   gpointer user_data)
{
    ESource *target_source;
    ESource *fallback_source;
    gboolean show_toggles;

    fallback_source = E_SOURCE (user_data);
    target_source = g_value_get_object (source_value);
    show_toggles = !e_source_equal (target_source, fallback_source);
    g_value_set_boolean (target_value, show_toggles);

    return TRUE;
}

static void
proxy_link_selector_set_property (GObject *object,
                                  guint property_id,
                                  const GValue *value,
                                  GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_TARGET_SOURCE:
            e_proxy_link_selector_set_target_source (
                E_PROXY_LINK_SELECTOR (object),
                g_value_get_object (value));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
proxy_link_selector_get_property (GObject *object,
                                  guint property_id,
                                  GValue *value,
                                  GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_TARGET_SOURCE:
            g_value_take_object (
                value,
                e_proxy_link_selector_ref_target_source (
                E_PROXY_LINK_SELECTOR (object)));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
proxy_link_selector_dispose (GObject *object)
{
    EProxyLinkSelectorPrivate *priv;

    priv = E_PROXY_LINK_SELECTOR_GET_PRIVATE (object);

    g_clear_object (&priv->target_source);

    /* Chain up to parent's dispose() method. */
    G_OBJECT_CLASS (e_proxy_link_selector_parent_class)->dispose (object);
}

static void
proxy_link_selector_constructed (GObject *object)
{
    EProxyLinkSelectorPrivate *priv;
    ESourceSelector *selector;
    ESourceRegistry *registry;
    ESource *builtin_proxy;

    priv = E_PROXY_LINK_SELECTOR_GET_PRIVATE (object);

    selector = E_SOURCE_SELECTOR (object);
    registry = e_source_selector_get_registry (selector);

    /* Set the target and fallback sources before chaining up. */

    builtin_proxy = e_source_registry_ref_builtin_proxy (registry);
    g_return_if_fail (builtin_proxy != NULL);

    priv->target_source = g_object_ref (builtin_proxy);
    priv->fallback_source = g_object_ref (builtin_proxy);

    g_object_unref (builtin_proxy);

    /* Hide toggle buttons when the target source is the same as
     * the fallback source since toggling the buttons would have
     * no effect in that particular case. */
    g_object_bind_property_full (
        selector, "target-source",
        selector, "show-toggles",
        G_BINDING_SYNC_CREATE,
        proxy_link_selector_target_source_to_show_toggles,
        NULL,
        g_object_ref (priv->fallback_source),
        (GDestroyNotify) g_object_unref);

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

    /* This triggers a model rebuild, so chain up first. */
    e_source_selector_set_show_icons (selector, TRUE);
}

static gboolean
proxy_link_selector_get_source_selected (ESourceSelector *selector,
                                         ESource *source)
{
    EProxyLinkSelector *link_selector;
    ESourceAuthentication *extension;
    const gchar *extension_name;
    const gchar *target_uid;
    gboolean selected = FALSE;
    gchar *uid;

    link_selector = E_PROXY_LINK_SELECTOR (selector);

    /* Make sure this source has an Authentication extension. */
    extension_name = e_source_selector_get_extension_name (selector);
    if (!e_source_has_extension (source, extension_name))
        return FALSE;

    extension = e_source_get_extension (source, extension_name);
    g_return_val_if_fail (E_IS_SOURCE_AUTHENTICATION (extension), FALSE);

    uid = e_source_authentication_dup_proxy_uid (extension);
    target_uid = e_source_get_uid (link_selector->priv->target_source);
    selected = (g_strcmp0 (uid, target_uid) == 0);
    g_free (uid);

    return selected;
}

static void
proxy_link_selector_set_source_selected (ESourceSelector *selector,
                                         ESource *source,
                                         gboolean selected)
{
    EProxyLinkSelector *link_selector;
    ESourceAuthentication *extension;
    ESource *target_source;
    const gchar *extension_name;
    const gchar *new_target_uid;
    const gchar *old_target_uid;

    link_selector = E_PROXY_LINK_SELECTOR (selector);

    /* Make sure this source has an Authentication extension. */
    extension_name = e_source_selector_get_extension_name (selector);
    if (!e_source_has_extension (source, extension_name))
        return;

    extension = e_source_get_extension (source, extension_name);
    g_return_if_fail (E_IS_SOURCE_AUTHENTICATION (extension));

    if (selected)
        target_source = link_selector->priv->target_source;
    else
        target_source = link_selector->priv->fallback_source;

    new_target_uid = e_source_get_uid (target_source);
    old_target_uid = e_source_authentication_get_proxy_uid (extension);

    if (g_strcmp0 (new_target_uid, old_target_uid) != 0) {
        e_source_authentication_set_proxy_uid (
            extension, new_target_uid);
        e_source_selector_queue_write (selector, source);
    }
}

static void
e_proxy_link_selector_class_init (EProxyLinkSelectorClass *class)
{
    GObjectClass *object_class;
    ESourceSelectorClass *source_selector_class;

    g_type_class_add_private (class, sizeof (EProxyLinkSelectorPrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->set_property = proxy_link_selector_set_property;
    object_class->get_property = proxy_link_selector_get_property;
    object_class->dispose = proxy_link_selector_dispose;
    object_class->constructed = proxy_link_selector_constructed;

    source_selector_class = E_SOURCE_SELECTOR_CLASS (class);
    source_selector_class->get_source_selected =
                proxy_link_selector_get_source_selected;
    source_selector_class->set_source_selected =
                proxy_link_selector_set_source_selected;

    g_object_class_install_property (
        object_class,
        PROP_TARGET_SOURCE,
        g_param_spec_object (
            "target-source",
            "Target Source",
            "The data source to link to "
            "when the checkbox is active",
            E_TYPE_SOURCE,
            G_PARAM_READWRITE |
            G_PARAM_STATIC_STRINGS));
}

static void
e_proxy_link_selector_init (EProxyLinkSelector *selector)
{
    selector->priv = E_PROXY_LINK_SELECTOR_GET_PRIVATE (selector);
}

/**
 * e_proxy_link_selector_new:
 * @registry: an #ESourceRegistry
 *
 * Creates a new #EProxyLinkSelector using #ESource instances in @registry.
 *
 * Returns: a new #EProxyLinkSelector
 **/
GtkWidget *
e_proxy_link_selector_new (ESourceRegistry *registry)
{
    g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);

    return g_object_new (
        E_TYPE_PROXY_LINK_SELECTOR,
        "extension-name", E_SOURCE_EXTENSION_AUTHENTICATION,
        "registry", registry, NULL);
}

/**
 * e_proxy_link_selector_ref_target_source:
 * @selector: an #EProxyLinkSelector
 *
 * Returns the target network proxy profile #ESource.
 *
 * See e_proxy_link_selector_set_target_source() for further details.
 *
 * The returned #ESource is referenced for thread-safety and must be
 * unreferenced with g_object_unref() when finished with it.
 *
 * Returns: an #ESource
 **/
ESource *
e_proxy_link_selector_ref_target_source (EProxyLinkSelector *selector)
{
    g_return_val_if_fail (E_IS_PROXY_LINK_SELECTOR (selector), NULL);

    return g_object_ref (selector->priv->target_source);
}

/**
 * e_proxy_link_selector_set_target_source:
 * @selector: an #EProxyLinkSelector
 * @target_source: an #ESource
 *
 * Sets the target network proxy profile #ESource.
 *
 * Checking the box next to an account name in @selector will link the
 * account to @target_source.  The account will then use @target_source
 * as its #GProxyResolver when connecting to a remote host.
 *
 * As a special case, if @target_source refers to the built-in network
 * proxy profile, then @selector will hide its checkboxes since they would
 * otherwise link accounts to the same #ESource when checked or unchecked.
 **/
void
e_proxy_link_selector_set_target_source (EProxyLinkSelector *selector,
                                         ESource *target_source)
{
    g_return_if_fail (E_IS_PROXY_LINK_SELECTOR (selector));
    g_return_if_fail (E_IS_SOURCE (target_source));

    if (target_source == selector->priv->target_source)
        return;

    g_clear_object (&selector->priv->target_source);
    selector->priv->target_source = g_object_ref (target_source);

    g_object_notify (G_OBJECT (selector), "target-source");

    e_source_selector_update_all_rows (E_SOURCE_SELECTOR (selector));
}