~ubuntu-branches/ubuntu/raring/rygel/raring

 * generated from rygel-dbus-thumbnailer.vala, do not modify */

 

/*

static const GDBusInterfaceVTable _tumbler_dbus_interface_vtable = {tumbler_dbus_interface_method_call, tumbler_dbus_interface_get_property, tumbler_dbus_interface_set_property};

 

void tumbler_Queue (Tumbler* self, gchar** uris, int uris_length1, gchar** mime_types, int mime_types_length1, const gchar* flavor, const gchar* sheduler, guint handle, GAsyncReadyCallback _callback_, gpointer _user_data_) {

        TUMBLER_GET_INTERFACE (self)->Queue (self, uris, uris_length1, mime_types, mime_types_length1, flavor, sheduler, handle, _callback_, _user_data_);

}

 

 

guint tumbler_Queue_finish (Tumbler* self, GAsyncResult* _res_, GError** error) {

        return TUMBLER_GET_INTERFACE (self)->Queue_finish (self, _res_, error);

}

 

 

static void tumbler_base_init (TumblerIface * iface) {

        static gboolean initialized = FALSE;

        if (!initialized) {

                initialized = TRUE;

        }

}

 

 

 

static void _rygel_dbus_thumbnailer_on_activatable_names_gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {

        rygel_dbus_thumbnailer_on_activatable_names (self, source_object, res);

        g_object_unref (self);

}

 

 

        FreeDesktopDBusObject* _tmp5_;

        FreeDesktopDBusObject* _tmp6_;

        GError * _inner_error_ = NULL;

        g_return_val_if_fail (flavor != NULL, NULL);

        self = (RygelDbusThumbnailer*) g_object_new (object_type, NULL);

        _tmp0_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL);

        _g_object_unref0 (self->priv->uris);

        self->priv->uris = _tmp0_;

        _tmp1_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL);

        _g_object_unref0 (self->priv->mimes);

        self->priv->mimes = _tmp1_;

        self->priv->timeout_id = (guint) 0;

        _tmp2_ = flavor;

        _tmp3_ = g_strdup (_tmp2_);

        _g_free0 (self->priv->flavor);

        self->priv->flavor = _tmp3_;

        _tmp4_ = g_initable_new (FREE_DESKTOP_TYPE_DBUS_OBJECT_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", FREE_DESKTOP_DBUS_SERVICE, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", FREE_DESKTOP_DBUS_OBJECT_PATH, "g-interface-name", "org.freedesktop.DBus", NULL);

        _tmp5_ = (FreeDesktopDBusObject*) _tmp4_;

        if (_inner_error_ != NULL) {

                if ((_inner_error_->domain == G_IO_ERROR) || (_inner_error_->domain == G_DBUS_ERROR)) {

                        g_propagate_error (error, _inner_error_);

                        _g_object_unref0 (self);

                        return NULL;

                } else {

                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                        g_clear_error (&_inner_error_);

                        return NULL;

                }

        }

        _g_object_unref0 (self->priv->fdo);

        self->priv->fdo = _tmp5_;

        _tmp6_ = self->priv->fdo;

        free_desktop_dbus_object_list_activatable_names (_tmp6_, _rygel_dbus_thumbnailer_on_activatable_names_gasync_ready_callback, g_object_ref (self));

        return self;

}

 

 

RygelDbusThumbnailer* rygel_dbus_thumbnailer_new (const gchar* flavor, GError** error) {

        return rygel_dbus_thumbnailer_construct (RYGEL_TYPE_DBUS_THUMBNAILER, flavor, error);

}

 

 

static gboolean _rygel_dbus_thumbnailer_on_timeout_gsource_func (gpointer self) {

        gboolean result;

        result = rygel_dbus_thumbnailer_on_timeout (self);

        return result;

}

 

 

        GeeArrayList* _tmp10_;

        gint _tmp11_;

        gint _tmp12_;

        g_return_if_fail (self != NULL);

        g_return_if_fail (uri != NULL);

        g_return_if_fail (mime != NULL);

        _tmp0_ = uri;

        _tmp1_ = g_file_new_for_uri (_tmp0_);

        file = _tmp1_;

        _tmp2_ = file;

        _tmp3_ = g_file_is_native (_tmp2_);

        if (!_tmp3_) {

                _g_object_unref0 (file);

                return;

        }

        _tmp4_ = self->priv->uris;

        _tmp5_ = uri;

        gee_abstract_collection_add ((GeeAbstractCollection*) _tmp4_, _tmp5_);

        _tmp6_ = self->priv->mimes;

        _tmp7_ = mime;

        gee_abstract_collection_add ((GeeAbstractCollection*) _tmp6_, _tmp7_);

        _tmp8_ = self->priv->timeout_id;

        if (_tmp8_ != ((guint) 0)) {

                guint _tmp9_;

                _tmp9_ = self->priv->timeout_id;

                g_source_remove (_tmp9_);

        }

        _tmp10_ = self->priv->uris;

        _tmp11_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp10_);

        _tmp12_ = _tmp11_;

        if (((guint) _tmp12_) < RYGEL_DBUS_THUMBNAILER_THUMBNAIL_MAX_QUEUE_SIZE) {

                guint _tmp13_ = 0U;

                _tmp13_ = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) 100, _rygel_dbus_thumbnailer_on_timeout_gsource_func, g_object_ref (self), g_object_unref);

                self->priv->timeout_id = _tmp13_;

        } else {

                rygel_dbus_thumbnailer_on_timeout (self);

        }

        _g_object_unref0 (file);

}

 

 

        const gchar* _tmp13_;

        GeeArrayList* _tmp14_;

        GeeArrayList* _tmp15_;

        g_return_val_if_fail (self != NULL, FALSE);

        _tmp0_ = self->priv->tumbler;

        if (_tmp0_ == NULL) {

                result = TRUE;

                return result;

        }

        _tmp1_ = self->priv->uris;

        _tmp2_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp1_);

        _tmp3_ = _tmp2_;

        g_debug ("rygel-dbus-thumbnailer.vala:92: Queueing thumbnail creation for %d fil" \

"es", _tmp3_);

        _tmp4_ = self->priv->tumbler;

        _tmp5_ = self->priv->uris;

        _tmp7_ = gee_abstract_collection_to_array ((GeeAbstractCollection*) _tmp5_, &_tmp6_);

        _tmp8_ = _tmp7_;

        _tmp8__length1 = _tmp6_;

        _tmp9_ = self->priv->mimes;

        _tmp11_ = gee_abstract_collection_to_array ((GeeAbstractCollection*) _tmp9_, &_tmp10_);

        _tmp12_ = _tmp11_;

        _tmp12__length1 = _tmp10_;

        _tmp13_ = self->priv->flavor;

        tumbler_Queue (_tmp4_, _tmp8_, _tmp6_, _tmp12_, _tmp10_, _tmp13_, "default", (guint) 0, NULL, NULL);

        _tmp12_ = (_vala_array_free (_tmp12_, _tmp12__length1, (GDestroyNotify) g_free), NULL);

        _tmp8_ = (_vala_array_free (_tmp8_, _tmp8__length1, (GDestroyNotify) g_free), NULL);

        _tmp14_ = self->priv->uris;

        gee_abstract_collection_clear ((GeeAbstractCollection*) _tmp14_);

        _tmp15_ = self->priv->mimes;

        gee_abstract_collection_clear ((GeeAbstractCollection*) _tmp15_);

        self->priv->timeout_id = (guint) 0;

        result = FALSE;

        return result;

}

 

 

static gboolean _vala_string_array_contains (gchar** stack, int stack_length, gchar* needle) {

        int i;

        for (i = 0; i < stack_length; i++) {

                if (g_strcmp0 (stack[i], needle) == 0) {

                        return TRUE;

                }

        }

        return FALSE;

}

 

 

static void rygel_dbus_thumbnailer_on_activatable_names (RygelDbusThumbnailer* self, GObject* source, GAsyncResult* res) {

        Tumbler* _tmp8_;

        GError * _inner_error_ = NULL;

        g_return_if_fail (self != NULL);

        g_return_if_fail (res != NULL);

        {

                FreeDesktopDBusObject* _tmp0_;

                GAsyncResult* _tmp1_;

                gint _names_size_;

                gchar** _tmp4_;

                gint _tmp4__length1;

                _tmp0_ = self->priv->fdo;

                _tmp1_ = res;

                _tmp3_ = free_desktop_dbus_object_list_activatable_names_finish (_tmp0_, _tmp1_, &_tmp2_, &_inner_error_);

                names = _tmp3_;

                names_length1 = _tmp2_;

                _names_size_ = names_length1;

                if (_inner_error_ != NULL) {

                        if (_inner_error_->domain == G_DBUS_ERROR) {

                                goto __catch18_g_dbus_error;

                        }

                        if (_inner_error_->domain == G_IO_ERROR) {

                                goto __catch18_g_io_error;

                        }

                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                        g_clear_error (&_inner_error_);

                        return;

                }

                _tmp4_ = names;

                _tmp4__length1 = names_length1;

                if (_vala_string_array_contains (_tmp4_, _tmp4__length1, RYGEL_DBUS_THUMBNAILER_THUMBNAILER_IFACE)) {

                        Tumbler* _tmp5_ = NULL;

                        Tumbler* _tmp6_;

                        _tmp5_ = g_initable_new (TYPE_TUMBLER_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", RYGEL_DBUS_THUMBNAILER_THUMBNAILER_IFACE, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", RYGEL_DBUS_THUMBNAILER_THUMBNAILER_SERVICE, "g-interface-name", "org.freedesktop.thumbnails.Thumbnailer1", NULL);

                        _tmp6_ = (Tumbler*) _tmp5_;

                        if (_inner_error_ != NULL) {

                                names = (_vala_array_free (names, names_length1, (GDestroyNotify) g_free), NULL);

                                if (_inner_error_->domain == G_DBUS_ERROR) {

                                        goto __catch18_g_dbus_error;

                                }

                                if (_inner_error_->domain == G_IO_ERROR) {

                                        goto __catch18_g_io_error;

                                }

                                names = (_vala_array_free (names, names_length1, (GDestroyNotify) g_free), NULL);

                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                                g_clear_error (&_inner_error_);

                                return;

                        }

                        _g_object_unref0 (self->priv->tumbler);

                        self->priv->tumbler = _tmp6_;

                } else {

                        const gchar* _tmp7_ = NULL;

                        _tmp7_ = _ ("No D-Bus thumbnailer service available");

                        g_debug ("rygel-dbus-thumbnailer.vala:116: %s", _tmp7_);

                }

                names = (_vala_array_free (names, names_length1, (GDestroyNotify) g_free), NULL);

        }

        goto __finally18;

        __catch18_g_dbus_error:

        {

                GError* _error_ = NULL;

                _error_ = _inner_error_;

                _inner_error_ = NULL;

                _g_error_free0 (_error_);

        }

        goto __finally18;

        __catch18_g_io_error:

        {

                GError* io_error = NULL;

                io_error = _inner_error_;

                _inner_error_ = NULL;

                _g_error_free0 (io_error);

        }

        __finally18:

        if (_inner_error_ != NULL) {

                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                g_clear_error (&_inner_error_);

                return;

        }

        _tmp8_ = self->priv->tumbler;

        g_signal_emit_by_name (self, "ready", _tmp8_ != NULL);

}

 

 

static void rygel_dbus_thumbnailer_class_init (RygelDbusThumbnailerClass * klass) {

        rygel_dbus_thumbnailer_parent_class = g_type_class_peek_parent (klass);

        g_type_class_add_private (klass, sizeof (RygelDbusThumbnailerPrivate));

        G_OBJECT_CLASS (klass)->finalize = rygel_dbus_thumbnailer_finalize;

        g_signal_new ("ready", RYGEL_TYPE_DBUS_THUMBNAILER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

}

 

 

static void rygel_dbus_thumbnailer_instance_init (RygelDbusThumbnailer * self) {

        self->priv = RYGEL_DBUS_THUMBNAILER_GET_PRIVATE (self);

}

 

 

static void rygel_dbus_thumbnailer_finalize (GObject* obj) {

        RygelDbusThumbnailer * self;

        _g_object_unref0 (self->priv->tumbler);

        _g_object_unref0 (self->priv->uris);

        _g_object_unref0 (self->priv->mimes);

        _g_free0 (self->priv->flavor);

        _g_object_unref0 (self->priv->fdo);

        G_OBJECT_CLASS (rygel_dbus_thumbnailer_parent_class)->finalize (obj);

}