src/give_drag_and_drop.c

Go to the documentation of this file.

/* Give - Statusbar plugin for easy drag & drop data sending via Bluetooth.
 * Copyright (C) 2008 Dénes Mátételki
 *
 * 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 this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "give_drag_and_drop.h"
#include "give_bluetooth.h"
#include "give_ebook.h"

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>

// #include <glib/gprintf.h>
#include <dbus/dbus-glib.h>

// localization
#include <locale.h>
#include <libintl.h>
#define _(String) gettext(String)

typedef struct _give_drag_and_drop_private give_drag_and_drop_private;

#define GIVE_DRAG_AND_DROP_GET_PRIVATE(obj) \
                        (G_TYPE_INSTANCE_GET_PRIVATE ((obj),\
                        GIVE_DRAG_AND_DROP_TYPE, \
                        give_drag_and_drop_private));

struct _give_drag_and_drop_private
{
        gboolean bt_is_on;
        GtkWidget *destination;
        gulong handler_id;
        DBusGProxy *dbus_proxy;
        give_bluetooth* give_bt_object;
        give_ebook *give_ebook_object;
};

#define TEMP_DIR        "/tmp"

#define BLUEZ_DBUS_SERVICE      "org.bluez"
#define BLUEZ_DBUS_PATH         "/org/bluez/hci0"
#define BLUEZ_DBUS_INTERFACE    "org.bluez.Adapter"
#define BLUEZ_DBUS_SET_MODE     "SetMode"
#define BLUEZ_DBUS_MESSAGE      "connectable"

#define PLAIN_TEXT_TYPE         "text/plain"
#define URI_LIST_TYPE           "text/uri-list"
#define CALENDAR_EVENT_TYPE     "application/x-e-calendar-event"
#define CONTACT_LIST_TYPE       "x-osso-contact-list"

#define TREE_ROW_TYPE           "GTK_TREE_MODEL_ROW"
#define TREE_AS_STRING_TYPE     "text/tree-path-as-string-list"
#define MODEST_EMAIL_TYPE       "text/modest-email"

enum {
        PLAIN_TEXT,
        URI_LIST,
        CALENDAR_EVENT,
        CONTACT_LIST,
        TREE_ROW,
        TREE_AS_STRING,
        MODEST_EMAIL
};

const GtkTargetEntry drop_types[] =
{
        { PLAIN_TEXT_TYPE,      0, PLAIN_TEXT },
        { URI_LIST_TYPE,        0, URI_LIST },
        { CALENDAR_EVENT_TYPE,  0, CALENDAR_EVENT },
        { CONTACT_LIST_TYPE,    0, CONTACT_LIST },
        { TREE_ROW_TYPE,        0, TREE_ROW },
        { TREE_AS_STRING_TYPE,  0, TREE_AS_STRING },
        { MODEST_EMAIL_TYPE,    0, MODEST_EMAIL }
};



// Private funcions
GType give_drag_and_drop_get_type (void);
static void give_drag_and_drop_class_init (give_drag_and_dropClass *klass);
static void give_drag_and_drop_init (give_drag_and_drop *self);
static void give_drag_and_drop_finalize (GObject* self);

give_drag_and_drop *give_drag_and_drop_new (GtkWidget *widget);
static void give_drag_and_drop_set_dest(give_drag_and_drop *self,
                GtkWidget *widget);
void give_drag_and_drop_have_bt (give_drag_and_drop *self, gboolean setting);
gboolean give_drag_and_drop_turn_bt_on_dialog(give_drag_and_drop *self);

// Public functions
static GtkWidget *give_drag_and_drop_create_dialog(give_drag_and_drop *self,
                const guint info, const gchar *text, guint *file_count,
                GtkWidget **entry);
static int give_drag_and_drop_run_dialog (give_drag_and_drop *self,
                GtkWidget *dialog, const guint info, const gchar *text,
                const guint file_count, gchar ***files, const GtkWidget *entry);
static void give_drag_and_drop_send(give_drag_and_drop *self, const guint info,
                const gchar *text);
static void give_drag_and_drop_drag_recieved (GtkWidget *widget, 
                GdkDragContext *context, gint x, gint y,
                GtkSelectionData *selection_data, guint info, guint32 time, 
                gpointer user_data);

GType
give_drag_and_drop_get_type (void)
{
        g_message(__PRETTY_FUNCTION__);

        static GType type = 0;
        type = g_type_from_name ("give_drag_and_drop");

        if (type == 0){
                static const GTypeInfo info = {
                        sizeof (give_drag_and_dropClass),
                        (GBaseInitFunc) NULL,
                        (GBaseFinalizeFunc) NULL,
                        (GClassInitFunc) give_drag_and_drop_class_init,
                        NULL,
                        NULL,
                        sizeof (give_drag_and_drop),
                        0,
                        (GInstanceInitFunc) give_drag_and_drop_init
                };

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

        }

        return type;
}

static void
give_drag_and_drop_class_init (give_drag_and_dropClass *klass)
{
        g_message(__PRETTY_FUNCTION__);

        GObjectClass *object_class;
        object_class = (GObjectClass*) klass;

        object_class->finalize  = give_drag_and_drop_finalize;

        g_type_class_add_private (klass, sizeof (give_drag_and_drop_private));
}

static void
give_drag_and_drop_init (give_drag_and_drop *self)
{
        g_message(__PRETTY_FUNCTION__);

        give_drag_and_drop_private *priv;
        DBusGConnection *dbus_connection = NULL;
        GError *error = NULL;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        dbus_connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
        if (error){
                g_critical ("%s: Error getting system dbus: %s",
                        __PRETTY_FUNCTION__,error->message);
                g_error_free(error);
                g_assert(dbus_connection);
        }

        priv->dbus_proxy = dbus_g_proxy_new_for_name(dbus_connection,
                                        BLUEZ_DBUS_SERVICE,
                                        BLUEZ_DBUS_PATH,
                                        BLUEZ_DBUS_INTERFACE);
        if (!priv->dbus_proxy){
                g_critical ("%s: Error getting system dbus: %s",
                        __PRETTY_FUNCTION__,error->message);
                g_error_free(error);
                g_assert(priv->dbus_proxy);
        }

        give_drag_and_drop_have_bt (self, TRUE);

        priv->give_bt_object = give_bluetooth_new();
        priv->give_ebook_object = give_ebook_new();
}

static void
give_drag_and_drop_finalize (GObject* self)
{
        g_message(__PRETTY_FUNCTION__);

        give_drag_and_drop_private *priv;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        // free stuff
        g_object_unref(G_OBJECT(priv->dbus_proxy));
        gtk_drag_dest_unset (priv->destination);

        g_signal_handler_disconnect (priv->destination,
                                        priv->handler_id);

        g_object_unref(priv->give_bt_object);
        g_object_unref(priv->give_ebook_object);
}

give_drag_and_drop *
give_drag_and_drop_new (GtkWidget *widget)
{
        g_message(__PRETTY_FUNCTION__);

        give_drag_and_drop *give_dnd_object;

        g_assert(widget);

        give_dnd_object = g_object_new(GIVE_DRAG_AND_DROP_TYPE,NULL);
        g_assert(give_dnd_object);

        give_drag_and_drop_set_dest(give_dnd_object, widget);

        return give_dnd_object;
}

static void
give_drag_and_drop_set_dest(give_drag_and_drop *self, GtkWidget *widget)
{
        g_message(__PRETTY_FUNCTION__);

        give_drag_and_drop_private *priv;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        g_assert(widget);
        priv->destination = widget;

        gtk_drag_dest_set ( priv->destination, GTK_DEST_DEFAULT_ALL,
                        drop_types, G_N_ELEMENTS (drop_types),
                        GDK_ACTION_COPY);

        priv->handler_id = g_signal_connect(GTK_OBJECT(priv->destination),
                        "drag_data_received",
                        GTK_SIGNAL_FUNC(give_drag_and_drop_drag_recieved),
                        self);
}


void
give_drag_and_drop_have_bt (give_drag_and_drop *self, gboolean setting)
{
        g_message(__PRETTY_FUNCTION__);

        give_drag_and_drop_private *priv;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        priv->bt_is_on = setting;
}

static GtkWidget *
give_drag_and_drop_create_dialog(give_drag_and_drop *self, const guint info,
                        const gchar *text, guint *file_count, GtkWidget **entry)
{
        g_message(__PRETTY_FUNCTION__);

        GtkWidget *dialog;
        gchar dialog_label[20];
        GtkWidget *dialog_message;
        GtkWidget *vbox;

        gchar *s;       // temp string to iterate the filenames in 'text'

        gchar *file;    // one full-path file item of 'text'
        gchar *filenames = NULL;        // list of filenames (without path) 
                                        // seperated with '\n'

        gchar *contact;         // id of a conatact in EDS
        gchar *contacts;        // full names of selected contacts

        struct stat st;
        gboolean dir_selected = FALSE;
        gchar *summary;

        give_drag_and_drop_private *priv;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        g_assert(text);

        switch ( info ){
                case PLAIN_TEXT:
                        sprintf(dialog_label,_("Give text as:"));
                        dialog_message = gtk_entry_new ();
                        *entry = dialog_message;
                        gtk_entry_set_text ( GTK_ENTRY(dialog_message),
                                                "note.txt");
                        break;

                case CALENDAR_EVENT:
                        sprintf(dialog_label,_("Give event as:"));
                        dialog_message = gtk_entry_new ();
                        *entry = dialog_message;

                        summary = (gchar *) calloc (
                                        strlen ( strstr ( text, "SUMMARY:" ))
                                        - strlen ( strstr( text, "UID" )) - 4,
                                        sizeof( gchar));

                        strncpy ( summary, strstr ( text, "SUMMARY:" )+8,
                                        strlen ( strstr ( text, "SUMMARY:" ))
                                        - strlen ( strstr( text, "UID" )) - 9);

                        strcat ( summary, ".vcs");

                        gtk_entry_set_text ( GTK_ENTRY(dialog_message),
                                                summary);

                        break;

                case URI_LIST:

                        sprintf(dialog_label,_("Give file(s):"));
                        filenames = NULL;
                        *file_count = 0;
                        // since text contains full paths, filenames can be
                        // just shorter
                        filenames = (gchar *) calloc ( strlen (text),
                                                        sizeof (gchar ));

                        for (   s = (gchar *)text;
                                s != NULL && strlen(s) != 0;
                                s = strstr( s, "\n") != NULL  ? s + strlen (s) -
                                        strlen ( strstr( s, "\n")) + 1: NULL)
                        {
                                file = g_strndup ( s, strlen ( s ) -
                                                (strstr( s, "\n") == NULL ? 0 :
                                                strlen ( strstr( s, "\n"))+1) );

                                stat (file+7, &st);
                                if ( S_ISDIR( st.st_mode) ) {
                                        dir_selected = TRUE;
                                        break;
                                }

                                strcat (filenames, "\n");
                                strcat (filenames, g_strrstr( file, "/")+1 );


                                (*file_count)++;
                                g_free(file);
                        }

                        dialog_message = gtk_label_new (filenames+1);
                        break;

                case CONTACT_LIST:

                        sprintf(dialog_label,_("Give contact(s):"));
                        contacts = (gchar *) calloc ( 1000,
                                                        sizeof (gchar ));
                        *file_count = 0; // contact count this time


                        for (   s = (gchar *)text;
                                s != NULL && strlen(s) != 0;
                                s = strstr( s, "\n") != NULL  ? s + strlen (s) -
                                        strlen ( strstr( s, "\n")) + 1: NULL)
                        {
                                contact = g_strndup ( s, strlen ( s ) -
                                                (strstr( s, "\n") == NULL ? 0 :
                                                strlen ( strstr( s, "\n"))) );

                                strcat (contacts, "\n");
                                strcat (contacts, give_ebook_get_contact_name(
                                                        priv->give_ebook_object,
                                                        contact));
                                strcat (contacts, ".vcf");

                                (*file_count)++;
                        }

                        dialog_message = gtk_label_new (contacts+1);
                        break;

                default:
                        dialog_message = NULL;
                        g_assert(0);
                        break;
        }


        if ( dir_selected ){

                dialog = gtk_dialog_new_with_buttons (
                                        _("Give directory"),
                                        NULL,
                                        GTK_DIALOG_MODAL,
                                        GTK_STOCK_OK, GTK_RESPONSE_REJECT,
                                        NULL);

                dialog_message = gtk_label_new
                                        (_("Directories cannot be selected"));

        } else {

                dialog = gtk_dialog_new_with_buttons (
                                        dialog_label,
                                        NULL,
                                        GTK_DIALOG_MODAL,
                                        GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
                                        GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
                                        NULL);
        }

        gtk_label_set_justify(GTK_LABEL(dialog_message), GTK_JUSTIFY_CENTER );

        vbox = gtk_vbox_new(FALSE, 5);
        gtk_container_add (GTK_CONTAINER (vbox), dialog_message);
        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), vbox);

        return dialog;
}

static gint
give_drag_and_drop_run_dialog ( give_drag_and_drop      *self,
                                GtkWidget               *dialog,
                                const guint             info,
                                const gchar             *text,
                                const guint             file_count,
                                gchar                   ***files,
                                const GtkWidget         *entry)
{
        g_message(__PRETTY_FUNCTION__);

        guint result;
        gchar *s;       // temp string to iterate the filenames in 'text'
        gchar *file;    // one full-path file item of 'text'
        gchar *filenames;// list of filenames (without path) seperated with '\n'
        gchar *contact;
        FILE *fp;
        gint retval;
        gint i;
        give_drag_and_drop_private *priv;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        g_assert (dialog);
        g_assert (text);

        gtk_widget_show_all ( dialog);
        result = gtk_dialog_run ( GTK_DIALOG ( dialog));

        if ( result == GTK_RESPONSE_REJECT){
                retval = 0;
                gtk_widget_destroy (dialog);
                return retval;
        }

        // else result is GTK_RESPONSE_ACCEPT
        switch ( info ) {

                case PLAIN_TEXT: 
                case CALENDAR_EVENT:

                        g_assert (entry);

                        filenames = g_strdup_printf( "%s/%s",TEMP_DIR,
                                        gtk_entry_get_text( GTK_ENTRY(entry)));

                        fp = fopen(filenames,"w");
                        g_assert(fp);

                        if ( info == PLAIN_TEXT)
                                fprintf(fp,"%s",text);
                        else 
                                fprintf(fp,"BEGIN:VCALENDAR\nVERSION:2.0\n"
                                        "%s\nEND:VCALENDAR",text);
                        
                        fclose(fp);

                        *files = g_new0(gchar*, 2);
                        (*files)[0] = filenames;
                        (*files)[1] = NULL;

                        g_debug("%s - filenames: '%s'",__PRETTY_FUNCTION__,
                                                                (*files)[0]);


                        break;

                case URI_LIST:

                        g_assert (file_count > 0);

                        *files = g_new0(gchar*, file_count);
                        i = 0;

                        for (   s = (gchar *)text;
                                s != NULL && strlen(s) != 0;
                                s = strstr( s, "\n") != NULL  ? s + strlen (s) -
                                        strlen ( strstr( s, "\n")) + 1: NULL)
                        {
                                file = g_strndup ( s, strlen ( s ) -
                                                (strstr( s, "\n") == NULL ? 0 :
                                                strlen ( strstr( s, "\n"))+1) );

                                (*files)[i++] = file;
                        }
                        (*files)[file_count] = NULL;

                        break;


                case CONTACT_LIST:

                        g_assert (file_count > 0);

                        *files = g_new0(gchar*, file_count);
                        i = 0;

                        for (   s = (gchar *)text;
                                s != NULL && strlen(s) != 0;
                                s = strstr( s, "\n") != NULL  ? s + strlen (s) -
                                        strlen ( strstr( s, "\n")) + 1: NULL)
                        {
                                contact = g_strndup ( s, strlen ( s ) -
                                                (strstr( s, "\n") == NULL ? 0 :
                                                strlen ( strstr( s, "\n"))) );

                                filenames = g_strdup_printf( "%s/%s.vcf",
                                        TEMP_DIR, give_ebook_get_contact_name(
                                                        priv->give_ebook_object,
                                                        contact));

                                fp = fopen(filenames,"w");
                                g_assert(fp);

                                fprintf(fp,"%s",give_ebook_get_contact_vcard(
                                                        priv->give_ebook_object,
                                                        contact));
                                fclose(fp);

                                (*files)[i++] = filenames;

                        }
                        (*files)[file_count] = NULL;

                        break;

                default:
                        *files = NULL;
                        g_assert(0);
                        break;
        }

        gtk_widget_destroy (dialog);
        return 1;
}

static void
give_drag_and_drop_send(give_drag_and_drop *self, const guint info, 
                        const gchar *text)
{
        g_message(__PRETTY_FUNCTION__);

        give_drag_and_drop_private *priv;
        GtkWidget *dialog;
        GtkWidget *entry;
        gchar **files;
        guint file_count;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        g_assert(text);

        dialog = give_drag_and_drop_create_dialog(self, info, text, &file_count, 
                                                        &entry);
        if ( give_drag_and_drop_run_dialog(self, dialog, info, text, file_count, 
                                                &files, entry) == 1){

                give_bluetooth_send_file(priv->give_bt_object, files);

                g_strfreev (files);
        }
}


gboolean
give_drag_and_drop_turn_bt_on_dialog(give_drag_and_drop *self)
{
        g_message(__PRETTY_FUNCTION__);

        GtkWidget *dialog;
        GtkWidget *label;
        gint result;
        gboolean turned_on;
        give_drag_and_drop_private *priv;
        GError *error = NULL;

        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        dialog = gtk_dialog_new_with_buttons (
                                        "Give",
                                        NULL,
                                        GTK_DIALOG_MODAL,
                                        GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
                                        GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
                                        NULL);


        label = gtk_label_new (_("Bluetooth is off.\nTurn it on?"));

        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
        gtk_widget_show_all (dialog);

        result = gtk_dialog_run (GTK_DIALOG (dialog));
        switch (result){
                case GTK_RESPONSE_ACCEPT:

                        if (!dbus_g_proxy_call(priv->dbus_proxy,
                                BLUEZ_DBUS_SET_MODE, &error,
                                G_TYPE_STRING, BLUEZ_DBUS_MESSAGE,
                                G_TYPE_INVALID, G_TYPE_INVALID))
                        {
                                g_warning("%s: Error sending %s request "
                                                "to bluez: %s",
                                        __PRETTY_FUNCTION__,BLUEZ_DBUS_SET_MODE,
                                        error->message);
                                g_error_free(error);
                                turned_on = FALSE;
                        } else {
                                turned_on = TRUE;
                        }

                        break;
                case GTK_RESPONSE_REJECT:
                        // do nothing
                        turned_on = FALSE;
                        break;
                default:
                        g_assert(0);
        }

        gtk_widget_destroy (dialog);
        return turned_on;       
}

static void
give_drag_and_drop_drag_recieved
                        (GtkWidget              *widget,
                        GdkDragContext          *context,
                        gint                    x,
                        gint                    y,
                        GtkSelectionData        *selection_data,
                        guint                   info,
                        guint32                 time,
                        gpointer                user_data)
{
        g_message(__PRETTY_FUNCTION__);

        g_assert(widget);
        g_assert(context);
        g_assert(selection_data);
        g_assert(user_data);

        give_drag_and_drop *self;
        give_drag_and_drop_private *priv;

        self = (give_drag_and_drop *) user_data;
        g_assert(self);
        g_assert(GIVE_DRAG_AND_DROP_IS_OBJECT(self));

        priv = GIVE_DRAG_AND_DROP_GET_PRIVATE (self);
        g_assert (priv);

        // otherwise the function will be invoked multiple times
        g_signal_stop_emission_by_name (widget, "drag_data_received");

        // if BT is off, then invoke 'turn-on BT' dialog
        if ( !priv->bt_is_on  )         
                if ( !give_drag_and_drop_turn_bt_on_dialog(self) ) 
                        return;

        g_debug("%s: got data. info: %d, data: '%s'",__PRETTY_FUNCTION__,
                info, selection_data->data);

        // modest-patch  is under development, ignore data from modest.
        if (    info == MODEST_EMAIL)
                        g_message("%s: my modest :)",__PRETTY_FUNCTION__);
        if (    info == TREE_ROW ||
                info == TREE_AS_STRING ||
                info == MODEST_EMAIL
                ) return;

        give_drag_and_drop_send(self, info, selection_data->data);

//      g_free(selection_data);
}

---