root/trunk/src/tmut-platform-factory.c

/* TMut
 * Copyright (C) 2006-2007 Philip Van Hoof <pvanhoof@gnome.org>
 *
 * This library 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) any later version.
 *
 * This library 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 self library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */
#if HAVE_CONFIG_H
#include "config.h"
#endif

#include <glib/gi18n-lib.h>

#include "tmut-platform-factory.h"
#include "tmut-msg-view.h"
#include "tmut-account-store.h"

#ifdef MAEMO
#include <tny-maemo-account-store.h>
#include <tny-maemo-device.h>
#endif

#ifdef GNOMEDESKTOP
#include <tny-gnome-account-store.h>
#include <tny-gnome-device.h>
#endif

#ifdef OLPC
#include <tny-olpc-account-store.h>
#include <tny-olpc-device.h>
#endif

#ifdef GPE
#include <tny-gpe-account-store.h>
#include <tny-gpe-device.h>
#endif

#include <tny-gtk-password-dialog.h>
#include <tny-camel-mime-part.h>
#include <tny-camel-msg.h>

static GObjectClass *parent_class = NULL;

static void
tmut_platform_factory_instance_init (GTypeInstance *instance, gpointer g_class)
{
        return;
}



static TnyMsg*
tmut_platform_factory_new_msg (TnyPlatformFactory *self)
{
        return tny_camel_msg_new ();
}


static TnyMimePart*
tmut_platform_factory_new_mime_part (TnyPlatformFactory *self)
{
        return tny_camel_mime_part_new ();
}


static TnyAccountStore*
tmut_platform_factory_new_account_store (TnyPlatformFactory *self)
{
        TnyAccountStore *decorated;

        return tmut_account_store_new ();
}

static TnyDevice*
tmut_platform_factory_new_device (TnyPlatformFactory *self)
{
#ifdef GNOMEDESKTOP
        return tny_gnome_device_new ();
#endif

#ifdef GPE
        return tny_gpe_device_new ();
#endif

#ifdef MAEMO
        return tny_maemo_device_new ();
#endif

#ifdef OLPC
        return tny_olpc_device_new ();
#endif

}

static TnyMsgView*
tmut_platform_factory_new_msg_view (TnyPlatformFactory *self)
{
        return tmut_msg_view_new (NULL);
}

static TnyPasswordGetter*
tmut_platform_factory_new_password_getter (TnyPlatformFactory *self)
{
        return tny_gtk_password_dialog_new ();
}

/**
 * tmut_platform_factory_get_instance:
 *
 *
 * Return value: The #TMutPlatformFactory singleton instance
 **/
TnyPlatformFactory*
tmut_platform_factory_get_instance (void)
{
        TMutPlatformFactory *self = g_object_new (TMUT_TYPE_PLATFORM_FACTORY, NULL);

        return TNY_PLATFORM_FACTORY (self);
}


static void
tmut_platform_factory_finalize (GObject *object)
{
        (*parent_class->finalize) (object);

        return;
}


static void
tmut_platform_factory_init (gpointer g, gpointer iface_data)
{
        TnyPlatformFactoryIface *klass = (TnyPlatformFactoryIface *)g;

        klass->new_account_store= tmut_platform_factory_new_account_store;
        klass->new_device= tmut_platform_factory_new_device;
        klass->new_msg_view= tmut_platform_factory_new_msg_view;
        klass->new_msg= tmut_platform_factory_new_msg;
        klass->new_mime_part= tmut_platform_factory_new_mime_part;
        klass->new_password_getter= tmut_platform_factory_new_password_getter;

        return;
}


static TnyPlatformFactory *the_singleton = NULL;

static GObject*
tmut_platform_factory_constructor (GType type, guint n_construct_params,
                        GObjectConstructParam *construct_params)
{
        GObject *object;

        if (G_UNLIKELY (!the_singleton)) {
                object = G_OBJECT_CLASS (parent_class)->constructor (type,
                                n_construct_params, construct_params);

                the_singleton = TNY_PLATFORM_FACTORY (object);
        } else {
                object = G_OBJECT (the_singleton);
                g_object_freeze_notify (G_OBJECT(the_singleton));
        }

        return object;
}

static void 
tmut_platform_factory_class_init (TMutPlatformFactoryClass *class)
{
        GObjectClass *object_class;

        parent_class = g_type_class_peek_parent (class);
        object_class = (GObjectClass*) class;

        object_class->finalize = tmut_platform_factory_finalize;
        object_class->constructor = tmut_platform_factory_constructor;

        return;
}

GType 
tmut_platform_factory_get_type (void)
{
        static GType type = 0;

        if (G_UNLIKELY(type == 0))
        {
                static const GTypeInfo info = 
                {
                  sizeof (TMutPlatformFactoryClass),
                  NULL,   /* base_init */
                  NULL,   /* base_finalize */
                  (GClassInitFunc) tmut_platform_factory_class_init,   /* class_init */
                  NULL,   /* class_finalize */
                  NULL,   /* class_data */
                  sizeof (TMutPlatformFactory),
                  0,      /* n_preallocs */
                  tmut_platform_factory_instance_init    /* instance_init */
                };

                static const GInterfaceInfo tmut_platform_factory_info = 
                {
                  (GInterfaceInitFunc) tmut_platform_factory_init, /* interface_init */
                  NULL,         /* interface_finalize */
                  NULL          /* interface_data */
                };

                type = g_type_register_static (G_TYPE_OBJECT,
                        "TMutPlatformFactory",
                        &info, 0);

                g_type_add_interface_static (type, TNY_TYPE_PLATFORM_FACTORY, 
                        &tmut_platform_factory_info);
        }

        return type;
}