aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--libempathy/empathy-ft-factory.c147
-rw-r--r--libempathy/empathy-ft-factory.h64
-rw-r--r--libempathy/empathy-ft-handler.c216
-rw-r--r--libempathy/empathy-ft-handler.h62
4 files changed, 489 insertions, 0 deletions
diff --git a/libempathy/empathy-ft-factory.c b/libempathy/empathy-ft-factory.c
new file mode 100644
index 000000000..0356c32b6
--- /dev/null
+++ b/libempathy/empathy-ft-factory.c
@@ -0,0 +1,147 @@
+/*
+ * empathy-ft-factory.c - Source for EmpathyFTFactory
+ * Copyright (C) 2009 Collabora Ltd.
+ *
+ * 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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
+ */
+
+/* empathy-ft-factory.c */
+
+#include "empathy-ft-factory.h"
+#include "empathy-marshal.h"
+#include "empathy-utils.h"
+
+G_DEFINE_TYPE (EmpathyFTFactory, empathy_ft_factory, G_TYPE_OBJECT);
+
+#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyFTFactoryPriv)
+
+enum {
+ NEW_FT_HANDLER,
+ LAST_SIGNAL
+}
+
+typedef struct {
+ gboolean dispose_run;
+} EmpathyFTFactoryPriv;
+
+static EmpathyFTFactory *factory_singleton = NULL;
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static void
+do_dispose (GObject *object)
+{
+ EmpathyFTFactoryPriv *priv = GET_PRIV (object);
+
+ if (priv->dispose_run)
+ return;
+
+ priv->dispose_run = TRUE;
+
+ G_OBJECT_CLASS (empathy_ft_factory_parent_class)->dispose (object);
+}
+
+static void
+do_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (empathy_ft_factory_parent_class)->finalize (object);
+}
+
+static GObject *
+do_constructor (GType type,
+ guint n_props,
+ GObjectConstructParam *props)
+{
+ GObject *retval;
+
+ if (factory_singleton) {
+ retval = g_object_ref (factory_singleton);
+ } else {
+ retval = G_OBJECT_CLASS (empathy_ft_factory_parent_class)->constructor
+ (type, n_props, props);
+
+ factory_singleton = EMPATHY_FT_FACTORY (retval);
+ g_object_add_weak_pointer (retval, (gpointer *) &factory_singleton);
+ }
+
+ return retval;
+}
+
+static void
+empathy_ft_factory_class_init (EmpathyFTFactoryClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ g_type_class_add_private (klass, sizeof (EmpathyFTFactoryPriv));
+
+ object_class->dispose = do_dispose;
+ object_class->finalize = do_finalize;
+ object_class->constructor = do_constructor;
+
+ signals[NEW_FT_HANDLER] =
+ g_signal_new ("new-ft-handler",
+ G_TYPE_FROM_CLASS (empathy_call_factory_class),
+ G_SIGNAL_RUN_LAST, 0,
+ NULL, NULL,
+ _empathy_marshal_VOID__OBJECT_BOOLEAN,
+ G_TYPE_NONE,
+ 2, EMPATHY_TYPE_FT_HANDLER, G_TYPE_BOOLEAN);
+}
+
+static void
+empathy_ft_factory_init (EmpathyFTFactory *self)
+{
+ EmpathyFTFactoryPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ EMPATHY_TYPE_FT_FACTORY, EmpathyFTFactoryPriv);
+
+ self->priv = priv;
+}
+
+/* public methods */
+
+EmpathyFTFactory*
+empathy_ft_factory_dup_singleton (void)
+{
+ return g_object_new (EMPATHY_TYPE_FT_FACTORY, NULL);
+}
+
+void
+empathy_ft_factory_new_transfer (EmpathyFTFactory *factory,
+ EmpathyContact *contact,
+ GFile *file)
+{
+ EmpathyFTHandler *handler;
+
+ g_return_if_fail (EMPATHY_IS_FT_FACTORY (factory));
+ g_return_if_fail (EMPATHY_IS_CONTACT (contact));
+ g_return_if_fail (G_IS_FILE (file));
+
+ handler = empathy_ft_handler_new (contact, file);
+ g_signal_emit (factory, signals[NEW_FT_HANDLER], 0, handler, TRUE);
+
+ g_object_unref (handler);
+}
+
+void
+empathy_ft_factory_claim_channel (EmpathyFTFactory *factory,
+ EmpathyDispatchOperation *operation)
+{
+ g_return_val_if_fail (EMPATHY_IS_FACTORY (factory));
+ g_return_val_if_fail (EMPATHY_IS_DISPATCH_OPERATION (operation));
+
+ /* TODO */
+}
+
diff --git a/libempathy/empathy-ft-factory.h b/libempathy/empathy-ft-factory.h
new file mode 100644
index 000000000..3f4f6b2b9
--- /dev/null
+++ b/libempathy/empathy-ft-factory.h
@@ -0,0 +1,64 @@
+/*
+ * empathy-ft-factory.h - Header for EmpathyFTFactory
+ * Copyright (C) 2009 Collabora Ltd.
+ *
+ * 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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
+ */
+
+/* empathy-ft-factory.h */
+
+#ifndef __EMPATHY_FT_FACTORY_H__
+#define __EMPATHY_FT_FACTORY_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define EMPATHY_TYPE_FT_FACTORY empathy_ft_factory_get_type()
+#define EMPATHY_FT_FACTORY(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), EMPATHY_TYPE_FT_FACTORY, EmpathyFTFactory))
+#define EMPATHY_FT_FACTORY_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), EMPATHY_TYPE_FT_FACTORY, EmpathyFTFactoryClass))
+#define EMPATHY_IS_FT_FACTORY(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EMPATHY_TYPE_FT_FACTORY))
+#define EMPATHY_IS_FT_FACTORY_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), EMPATHY_TYPE_FT_FACTORY))
+#define EMPATHY_FT_FACTORY_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_FT_FACTORY, EmpathyFTFactoryClass))
+
+typedef struct {
+ GObject parent;
+ gpointer priv;
+} EmpathyFTFactory;
+
+typedef struct {
+ GObjectClass parent_class;
+} EmpathyFTFactoryClass;
+
+GType empathy_ft_factory_get_type (void);
+
+/* public methods */
+EmpathyFTFactory* empathy_ft_factory_dup_singleton (void);
+void empathy_ft_factory_new_transfer (EmpathyFTFactory *factory,
+ EmpathyContact *contact, GFile *file);
+void empathy_ft_factory_claim_channel (EmpathyFTFactory *factory,
+ EmpathyDispatchOperation *operation);
+
+G_END_DECLS
+
+#endif /* __EMPATHY_FT_FACTORY_H__ */
+
diff --git a/libempathy/empathy-ft-handler.c b/libempathy/empathy-ft-handler.c
new file mode 100644
index 000000000..ade8693b3
--- /dev/null
+++ b/libempathy/empathy-ft-handler.c
@@ -0,0 +1,216 @@
+/*
+ * empathy-ft-handler.c - Source for EmpathyFTHandler
+ * Copyright (C) 2009 Collabora Ltd.
+ *
+ * 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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
+ */
+
+/* empathy-ft-handler.c */
+
+#include "empathy-ft-handler.h"
+
+G_DEFINE_TYPE (EmpathyFTHandler, empathy_ft_handler, G_TYPE_OBJECT)
+
+#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyFTHandlerPriv)
+
+enum {
+ PROP_TP_FILE = 1,
+ PROP_G_FILE,
+ PROP_CONTACT
+};
+
+typedef struct EmpathyFTHandlerPriv {
+ gboolean dispose_run;
+ EmpathyContact *contact;
+ GFile *gfile;
+ EmpathyTpFile *tpfile;
+};
+
+static void
+do_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ EmpathyFTHandlerPriv *priv = GET_PRIV (object);
+
+ switch (property_id)
+ {
+ case PROP_CONTACT:
+ g_value_set_object (value, priv->contact);
+ break;
+ case PROP_G_FILE:
+ g_value_set_object (value, priv->gfile);
+ break;
+ case PROP_TP_FILE:
+ g_value_set_object (value, priv->tpfile);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ }
+}
+
+static void
+do_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ EmpathyCallHandlerPriv *priv = GET_PRIV (object);
+
+ switch (property_id)
+ {
+ case PROP_CONTACT:
+ priv->contact = g_value_dup_object (value);
+ break;
+ case PROP_G_FILE:
+ priv->gfile = g_value_dup_object (value);
+ break;
+ case PROP_TP_FILE:
+ priv->tpfile = g_value_dup_object (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ }
+}
+
+static void
+do_dispose (GObject *object)
+{
+ EmpathyFTHandlerPriv *priv = GET_PRIV (object);
+
+ if (priv->dispose_run)
+ return;
+
+ priv->dispose_run = TRUE;
+
+ if (priv->contact) {
+ g_object_unref (priv->contact);
+ priv->contact = NULL;
+ }
+
+ if (priv->gfile) {
+ g_object_unref (priv->gfile);
+ priv->gfile = NULL;
+ }
+
+ if (priv->tpfile) {
+ empathy_tp_file_close (priv->tpfile);
+ g_object_unref (priv->tpfile);
+ priv->tpfile = NULL;
+ }
+
+ G_OBJECT_CLASS (empathy_ft_handler_parent_class)->dispose (object);
+}
+
+static void
+do_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (empathy_ft_handler_parent_class)->finalize (object);
+}
+
+static void
+empathy_ft_handler_class_init (EmpathyFTHandlerClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GParamSpec *param_spec;
+
+ g_type_class_add_private (klass, sizeof (EmpathyFTHandlerPrivate));
+
+ object_class->get_property = do_get_property;
+ object_class->set_property = do_set_property;
+ object_class->dispose = do_dispose;
+ object_class->finalize = do_finalize;
+
+ param_spec = g_param_spec_object ("contact",
+ "contact", "The remote contact",
+ EMPATHY_TYPE_CONTACT,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+ g_object_class_install_property (object_class, PROP_CONTACT, param_spec);
+
+ param_spec = g_param_spec_object ("gfile",
+ "gfile", "The GFile we're handling",
+ G_TYPE_FILE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+ g_object_class_install_property (object_class, PROP_G_FILE, param_spec);
+
+ param_spec = g_param_spec_object ("tp-file",
+ "tp-file", "The file's channel wrapper",
+ EMPATHY_TYPE_TP_FILE,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+ g_object_class_install_property (object_class, PROP_TP_FILE, param_spec);
+}
+
+static void
+empathy_ft_handler_init (EmpathyFTHandler *self)
+{
+ EmpathyFTHandlerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ EMPATHY_TYPE_FT_HANDLER, EmpathyFTHandlerPriv);
+
+ self->priv = priv;
+}
+
+static void
+empathy_ft_handler_contact_ready_cb (EmpathyContact *contact,
+ const GError *error,
+ gpointer user_data,
+ GObject *weak_object);
+{
+ EmpathyFTHandler *handler = EMPATHY_FT_HANDLER (weak_object);
+ EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
+ GHashTable *request;
+ GValue *value;
+}
+
+/* public methods */
+
+EmpathyFTHandler*
+empathy_ft_handler_new (EmpathyContact *contact,
+ GFile *file)
+{
+ g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
+ g_return_val_if_fail (G_IS_FILE (file), NULL);
+
+ return g_object_new (EMPATHY_TYPE_FT_HANDLER,
+ "contact", contact, "gfile", file, NULL);
+}
+
+EmpathyFTHandler *
+empathy_ft_handler_new_for_channel (EmpathyTpFile *file)
+{
+ g_return_val_if_fail (EMPATHY_IS_TP_FILE (file), NULL);
+
+ return g_object_new (EMPATHY_TYPE_FT_HANDLER,
+ "tp-file", file, NULL);
+}
+
+void
+empathy_ft_handler_start_transfer (EmpathyFTHandler *handler)
+{
+ g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
+
+ if (priv->tpfile == NULL)
+ {
+ empathy_contact_call_when_ready (priv->contact,
+ EMPATHY_CONTACT_READY_ID,
+ empathy_ft_handler_contact_ready_cb, NULL, NULL, G_OBJECT (handler));
+ }
+ else
+ {
+ /* TODO: */
+ }
+}
diff --git a/libempathy/empathy-ft-handler.h b/libempathy/empathy-ft-handler.h
new file mode 100644
index 000000000..5a5ec61df
--- /dev/null
+++ b/libempathy/empathy-ft-handler.h
@@ -0,0 +1,62 @@
+/*
+ * empathy-ft-handler.h - Header for EmpathyFTHandler
+ * Copyright (C) 2009 Collabora Ltd.
+ *
+ * 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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Author: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
+ */
+
+/* empathy-ft-handler.h */
+
+#ifndef __EMPATHY_FT_HANDLER_H__
+#define __EMPATHY_FT_HANDLER_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define EMPATHY_TYPE_FT_HANDLER empathy_ft_handler_get_type()
+#define EMPATHY_FT_HANDLER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), EMPATHY_TYPE_FT_HANDLER, EmpathyFTHandler))
+#define EMPATHY_FT_HANDLER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), EMPATHY_TYPE_FT_HANDLER, EmpathyFTHandlerClass))
+#define EMPATHY_IS_FT_HANDLER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EMPATHY_TYPE_FT_HANDLER))
+#define EMPATHY_IS_FT_HANDLER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), EMPATHY_TYPE_FT_HANDLER))
+#define EMPATHY_FT_HANDLER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_FT_HANDLER, EmpathyFTHandlerClass))
+
+typedef struct {
+ GObject parent;
+ gpointer priv;
+} EmpathyFTHandler;
+
+typedef struct {
+ GObjectClass parent_class;
+} EmpathyFTHandlerClass;
+
+GType empathy_ft_handler_get_type (void);
+
+/* public methods */
+EmpathyFTHandler * empathy_ft_handler_new (EmpathyContact *contact,
+ GFile *file);
+EmpathyFTHandler * empathy_ft_handler_new_for_channel (EmpathyTpFile *file);
+void empathy_ft_handler_start_transfer (EmpathyFTHandler *handler);
+
+G_END_DECLS
+
+#endif /* __EMPATHY_FT_HANDLER_H__ */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 13:27:50 +0800