source: trunk/third/bonobo/bonobo/bonobo-object-directory.c @ 16750

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 c-set-style: linux -*- */
/**
 * bonobo-object-directory.c: abstract the object directory
 *
 * Authors:
 *    Michael Meeks     (michael@helixcode.com)
 *    Havoc Pennington  (hp@redhat.com)
 *    Anders Carlsson   (andersca@gnu.org)
 *    Maciej Stachowiak (mjs@eazel.com)
 *
 * Copyright 1999, 2000 Havoc Pennington, Anders Carlsson,
 *                      Eazel, Inc. Helix Code, Inc.
 */

#include "config.h"
#include <glib.h>
#include <libgnome/gnome-defs.h>
#define GNOME_EXPLICIT_TRANSLATION_DOMAIN PACKAGE
#include <libgnome/gnome-i18n.h>
#include <libgnome/gnome-mime.h>
#include "bonobo-object-directory.h"
#include <liboaf/liboaf.h>

struct _ODServerInfo {
        guint refcount;
        gchar* iid;
        gchar* name;
        gchar* desc;
};

ODServerInfo*
bonobo_directory_new_server_info (const gchar *iid,
                                  const gchar *name,
                                  const gchar *desc)
{
        ODServerInfo *info;

        info = g_new (ODServerInfo, 1);

        info->refcount = 1;
        info->iid = iid ? g_strdup (iid) : NULL;
        info->name = name ? g_strdup (name) : NULL;
        info->desc = desc ? g_strdup (desc) : NULL;

        return info;
}

const gchar*
bonobo_directory_get_server_info_id (ODServerInfo *info)
{
        return info->iid;
}

const gchar*
bonobo_directory_get_server_info_name (ODServerInfo *info)
{
        return info->name;
}
                         
const gchar*
bonobo_directory_get_server_info_description (ODServerInfo *info)
{
        return info->desc;
}

void
bonobo_directory_server_info_ref (ODServerInfo *info)
{
        info->refcount += 1;
}

void
bonobo_directory_server_info_unref (ODServerInfo *info)
{
        g_return_if_fail(info != NULL);
        g_return_if_fail(info->refcount > 0);

        info->refcount -= 1;

        if (info->refcount == 0) {
                g_free (info->iid);
                g_free (info->name);
                g_free (info->desc);
                g_free (info);
        }
}

void
bonobo_directory_free_server_list (GList *list)
{
        GList *l;

        for (l = list; l; l = l->next)
                bonobo_directory_server_info_unref (l->data);

        g_list_free (list);
}


CORBA_ORB
bonobo_directory_get_orb (void)
{
        return oaf_orb_get ();
}

static char *
build_id_query_fragment (const char **required_ids)
{
        const char **required_ids_iter;
        const char **query_components_iter;
        char       **query_components;
        char        *query;
        guint        n_required = 0;

        /* We need to build a query up from the required_ids */
        required_ids_iter = required_ids;

        while (required_ids && *required_ids_iter) {
                ++n_required;
                ++required_ids_iter;
        }

        query_components = g_new0 (gchar*, n_required + 1);

        query_components_iter = (const gchar **) query_components;
        required_ids_iter = required_ids;

        while (*required_ids_iter) {
                *query_components_iter = g_strconcat ("repo_ids.has('",
                                                      *required_ids_iter,
                                                      "')",
                                                      NULL);
                ++query_components_iter;
                ++required_ids_iter;
        }

        query = g_strjoinv (" AND ", query_components);

        g_strfreev (query_components);

        return query;
}

GList *
bonobo_directory_get_server_list (const gchar **required_ids)
{
        GList *retval = NULL;
        gchar *query;
        OAF_ServerInfoList *servers;
        CORBA_Environment ev;
        guint i, j;
        
        g_return_val_if_fail (required_ids != NULL, NULL);
        g_return_val_if_fail (*required_ids != NULL, NULL);

        query = build_id_query_fragment (required_ids);

        CORBA_exception_init (&ev);
        servers = oaf_query (query, NULL, &ev);
        g_free (query);
        CORBA_exception_free (&ev);

        if (servers == NULL)
                return NULL;

        for (i = 0; i < servers->_length; i++) {
                OAF_ServerInfo *oafinfo = &servers->_buffer[i];
                ODServerInfo *info;
                gchar *name = NULL, *desc = NULL;

                for (j = 0; j < oafinfo->props._length; j++) {
                        if (oafinfo->props._buffer[j].v._d != OAF_P_STRING)
                                continue;

                        if (strcmp (oafinfo->props._buffer[j].name, "name") == 0)
                                name = oafinfo->props._buffer[j].v._u.value_string;

                        else if (strcmp (oafinfo->props._buffer[j].name, "description") == 0)
                                desc = oafinfo->props._buffer[j].v._u.value_string;

                        /* FIXME: internationalize here */
                }

                /*
                 * If no name attribute exists, use the description attribute.
                 *  If no description attribute exists, use the name attribute.
                 *  If neither a description attribute nor a name attribute exists, use the oafiid
                 */
                if (!name && !desc)
                        name = desc = oafinfo->iid;

                if (!name)
                        name = desc;

                if (!desc)
                        desc = name;
                
                info = bonobo_directory_new_server_info (oafinfo->iid,
                                           name,
                                           desc);

                retval = g_list_prepend (retval, info);
        }

        CORBA_free (servers);
        
        return g_list_reverse (retval);
}


char *
bonobo_directory_find_for_file (const char  *fname,
                                const char **required_ids,
                                char       **error)
{
        char *query, *interfaces;
        const char *mime_type;
        char *iid;
        CORBA_Environment ev;
        OAF_ServerInfoList *servers;
        OAF_ServerInfo *oafinfo;

        if (!fname) {
                if (error)
                        *error = g_strdup (_("No filename"));
                return NULL;
        }

        if (!(mime_type = gnome_mime_type ((char *) fname))) {
                if (error)
                        *error = g_strdup_printf (_("unknown mime type for '%s'"), fname);
                return CORBA_OBJECT_NIL;
        }

        interfaces = build_id_query_fragment (required_ids);

        if (required_ids && required_ids [0] && interfaces)
                query = g_strdup_printf ("%s AND bonobo:supported_mime_types.has ('%s')",
                                         interfaces, mime_type);
        else
                query = g_strdup_printf ("bonobo:supported_mime_types.has ('%s')",
                                         mime_type);

        g_free (interfaces);

        CORBA_exception_init (&ev);

        servers = oaf_query (query, NULL, &ev);
        g_free (query);

        CORBA_exception_free (&ev);

        if (servers == CORBA_OBJECT_NIL || !servers->_buffer) {
                if (error)
                        *error = g_strdup_printf (
                                _("no handlers for mime type '%s'"), mime_type);
                return NULL;
        }

        /* Just return the first one */
        oafinfo = &servers->_buffer [0];
        iid = g_strdup (oafinfo->iid);

        CORBA_free (servers);

        if (error)
                *error = NULL;
        
        return iid;
}

CORBA_Object
od_server_activate_with_id (const gchar       *iid,
                            gint               flags,
                            CORBA_Environment *ev)
{
        CORBA_Environment *real_ev, tmp_ev;
        CORBA_Object retval;
        
        if (ev)
                real_ev = ev;
        else {
                CORBA_exception_init (&tmp_ev);
                real_ev = &tmp_ev;
        }
                
        retval = oaf_activate_from_id ((gchar *) iid, 0, NULL, real_ev);

        if (!ev)
                CORBA_exception_free (&tmp_ev);
        
        return retval;
}

ODRegistrationResult
bonobo_directory_register_server (CORBA_Object objref,
                                  const gchar *iid)
{
        OAF_RegistrationResult result;
        ODRegistrationResult retval;

        result = oaf_active_server_register (iid, objref);

        switch (result) {
        case OAF_REG_SUCCESS:
                retval = OD_REG_SUCCESS;
                break;
                
        case OAF_REG_NOT_LISTED:
                retval = OD_REG_NOT_LISTED;
                break;

        case OAF_REG_ALREADY_ACTIVE:
                retval = OD_REG_ALREADY_ACTIVE;
                break;

        case OAF_REG_ERROR:
        default:
                retval = OD_REG_ERROR;
                break;
        }

        return retval;
}

ODRegistrationResult
bonobo_directory_unregister_server (CORBA_Object objref,
                                    const gchar *iid)
{
        oaf_active_server_unregister (iid, objref);
        
        return OD_REG_SUCCESS;
}

CORBA_Object
bonobo_directory_get_name_service (CORBA_Environment *ev)
{
        return oaf_name_service_get (ev);
}