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

 * generated from rygel-writable-user-config.vala, do not modify */

 

/*

        gchar* path;

        gchar* _tmp2_;

        GError * _inner_error_ = NULL;

        _tmp0_ = g_get_user_config_dir ();

        _tmp1_ = g_build_filename (_tmp0_, RYGEL_USER_CONFIG_CONFIG_FILE, NULL);

        path = _tmp1_;

        self = (RygelWritableUserConfig*) rygel_user_config_construct (object_type, path, &_inner_error_);

        if (_inner_error_ != NULL) {

                g_propagate_error (error, _inner_error_);

                _g_free0 (path);

                _g_object_unref0 (self);

                return NULL;

        }

        _tmp2_ = g_strdup (path);

        _g_free0 (self->priv->user_config);

        self->priv->user_config = _tmp2_;

        _g_free0 (path);

        return self;

}

 

 

RygelWritableUserConfig* rygel_writable_user_config_new (GError** error) {

        return rygel_writable_user_config_construct (RYGEL_TYPE_WRITABLE_USER_CONFIG, error);

}

 

 

gboolean rygel_writable_user_config_is_upnp_enabled (RygelWritableUserConfig* self) {

        gboolean result = FALSE;

        GError * _inner_error_ = NULL;

        g_return_val_if_fail (self != NULL, FALSE);

        {

                const gchar* _tmp0_;

                GFile* _tmp1_ = NULL;

                GFile* file;

                GFile* _tmp2_;

                gboolean _tmp3_ = FALSE;

                _tmp0_ = self->priv->user_config;

                _tmp1_ = g_file_new_for_path (_tmp0_);

                file = _tmp1_;

                _tmp2_ = file;

                _tmp3_ = g_file_query_exists (_tmp2_, NULL);

                if (_tmp3_) {

                        gboolean _tmp4_ = FALSE;

                        gboolean _tmp5_;

                        _tmp4_ = rygel_configuration_get_upnp_enabled ((RygelConfiguration*) self, &_inner_error_);

                        _tmp5_ = _tmp4_;

                        if (_inner_error_ != NULL) {

                                _g_object_unref0 (file);

                                goto __catch2_g_error;

                        }

                        result = _tmp5_;

                        _g_object_unref0 (file);

                        return result;

                }

                result = FALSE;

                _g_object_unref0 (file);

                return result;

        }

        goto __finally2;

        __catch2_g_error:

        {

                GError* _error_ = NULL;

                _error_ = _inner_error_;

                _inner_error_ = NULL;

                result = FALSE;

                _g_error_free0 (_error_);

                return result;

        }

        __finally2:

        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 FALSE;

}

 

 

        gboolean _tmp0_ = FALSE;

        gboolean _tmp1_;

        gboolean _tmp2_;

        g_return_if_fail (self != NULL);

        enabled = FALSE;

        _tmp0_ = rygel_writable_user_config_is_upnp_enabled (self);

        enabled = _tmp0_;

        _tmp1_ = value;

        _tmp2_ = enabled;

        if (_tmp1_ != _tmp2_) {

                gboolean _tmp3_;

                _tmp3_ = value;

                rygel_writable_user_config_enable_upnp (self, _tmp3_);

        }

}

 

        gchar* iface = NULL;

        const gchar* _tmp0_;

        const gchar* _tmp4_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        if (_tmp0_ != NULL) {

                const gchar* _tmp1_;

                gchar* _tmp2_;

                _tmp1_ = value;

                _tmp2_ = g_strdup (_tmp1_);

                _g_free0 (iface);

                iface = _tmp2_;

        } else {

                gchar* _tmp3_;

                _tmp3_ = g_strdup ("");

                _g_free0 (iface);

                iface = _tmp3_;

        }

        _tmp4_ = iface;

        rygel_writable_user_config_set_string (self, "general", RYGEL_USER_CONFIG_IFACE_KEY, _tmp4_);

        _g_free0 (iface);

}

 

 

void rygel_writable_user_config_set_port (RygelWritableUserConfig* self, gint value) {

        gint _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_int (self, "general", RYGEL_USER_CONFIG_PORT_KEY, _tmp0_);

}

 

 

void rygel_writable_user_config_set_transcoding (RygelWritableUserConfig* self, gboolean value) {

        gboolean _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_TRANSCODING_KEY, _tmp0_);

}

 

 

void rygel_writable_user_config_set_mp3_transcoder (RygelWritableUserConfig* self, gboolean value) {

        gboolean _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_MP3_TRANSCODER_KEY, _tmp0_);

}

 

 

void rygel_writable_user_config_set_mp2ts_transcoder (RygelWritableUserConfig* self, gboolean value) {

        gboolean _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_MP2TS_TRANSCODER_KEY, _tmp0_);

}

 

 

void rygel_writable_user_config_set_lpcm_transcoder (RygelWritableUserConfig* self, gboolean value) {

        gboolean _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_LPCM_TRANSCODER_KEY, _tmp0_);

}

 

 

void rygel_writable_user_config_set_wmv_transcoder (RygelWritableUserConfig* self, gboolean value) {

        gboolean _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_WMV_TRANSCODER_KEY, _tmp0_);

}

 

 

void rygel_writable_user_config_set_allow_upload (RygelWritableUserConfig* self, gboolean value, GError** error) {

        gboolean _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_ALLOW_UPLOAD_KEY, _tmp0_);

}

 

 

void rygel_writable_user_config_set_allow_deletion (RygelWritableUserConfig* self, gboolean value, GError** error) {

        gboolean _tmp0_;

        g_return_if_fail (self != NULL);

        _tmp0_ = value;

        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_ALLOW_DELETION_KEY, _tmp0_);

}

 

 

        gchar* _tmp4_ = NULL;

        gchar* data;

        GError * _inner_error_ = NULL;

        g_return_if_fail (self != NULL);

        _tmp0_ = g_get_user_config_dir ();

        _tmp1_ = g_build_filename (_tmp0_, RYGEL_USER_CONFIG_CONFIG_FILE, NULL);

        path = _tmp1_;

        _tmp2_ = ((RygelUserConfig*) self)->key_file;

        _tmp4_ = g_key_file_to_data (_tmp2_, &_tmp3_, NULL);

        length = _tmp3_;

        data = _tmp4_;

        {

                g_file_set_contents (path, data, (gssize) ((glong) length), &_inner_error_);

                if (_inner_error_ != NULL) {

                        if (_inner_error_->domain == G_FILE_ERROR) {

                                goto __catch3_g_file_error;

                        }

                        _g_free0 (data);

                        _g_free0 (path);

                        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;

                }

        }

        goto __finally3;

                const gchar* _tmp5_ = NULL;

                GError* _tmp6_;

                const gchar* _tmp7_;

                err = _inner_error_;

                _inner_error_ = NULL;

                _tmp5_ = _ ("Failed to save configuration data to file '%s': %s");

                _tmp6_ = err;

                _tmp7_ = _tmp6_->message;

                g_critical (_tmp5_, path, _tmp7_);

                _g_error_free0 (err);

        }

        __finally3:

        if (_inner_error_ != NULL) {

                _g_free0 (data);

                _g_free0 (path);

                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;

        }

        _g_free0 (data);

        _g_free0 (path);

}

 

 

        const gchar* _tmp1_;

        const gchar* _tmp2_;

        const gchar* _tmp3_;

        g_return_if_fail (self != NULL);

        g_return_if_fail (section != NULL);

        g_return_if_fail (key != NULL);

        g_return_if_fail (value != NULL);

        _tmp0_ = ((RygelUserConfig*) self)->key_file;

        _tmp1_ = section;

        _tmp2_ = key;

        _tmp3_ = value;

        g_key_file_set_string (_tmp0_, _tmp1_, _tmp2_, _tmp3_);

}

 

 

static gpointer _g_object_ref0 (gpointer self) {

        return self ? g_object_ref (self) : NULL;

}

 

 

        const gchar* _tmp23_;

        gchar** _tmp24_;

        gint _tmp24__length1;

        g_return_if_fail (self != NULL);

        g_return_if_fail (section != NULL);

        g_return_if_fail (key != NULL);

        g_return_if_fail (str_list != NULL);

        _tmp0_ = str_list;

        _tmp1_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp0_);

        _tmp2_ = _tmp1_;

        _tmp3_ = g_new0 (gchar*, _tmp2_ + 1);

        strings = _tmp3_;

        strings_length1 = _tmp2_;

        _strings_size_ = strings_length1;

        i = 0;

        {

                GeeArrayList* _tmp4_;

                GeeArrayList* _tmp5_;

                gint _tmp8_;

                gint _str_size;

                gint _str_index;

                _tmp4_ = str_list;

                _tmp5_ = _g_object_ref0 (_tmp4_);

                _str_list = _tmp5_;

                _tmp6_ = _str_list;

                _tmp7_ = gee_abstract_collection_get_size ((GeeCollection*) _tmp6_);

                _tmp8_ = _tmp7_;

                _str_size = _tmp8_;

                _str_index = -1;

                while (TRUE) {

                        gint _tmp9_;

                        gint _tmp10_;

                        gint _tmp11_;

                        gpointer _tmp14_ = NULL;

                        gchar* str;

                        const gchar* _tmp15_;

                        _tmp9_ = _str_index;

                        _str_index = _tmp9_ + 1;

                        _tmp10_ = _str_index;

                        _tmp11_ = _str_size;

                        if (!(_tmp10_ < _tmp11_)) {

                                break;

                        }

                        _tmp12_ = _str_list;

                        _tmp13_ = _str_index;

                        _tmp14_ = gee_abstract_list_get ((GeeAbstractList*) _tmp12_, _tmp13_);

                        str = (gchar*) _tmp14_;

                        _tmp15_ = str;

                        if (g_strcmp0 (_tmp15_, "") != 0) {

                                gchar** _tmp16_;

                                gint _tmp16__length1;

                                gint _tmp17_;

                                const gchar* _tmp18_;

                                gchar* _tmp19_;

                                gchar* _tmp20_;

                                _tmp16_ = strings;

                                _tmp16__length1 = strings_length1;

                                _tmp17_ = i;

                                i = _tmp17_ + 1;

                                _tmp18_ = str;

                                _tmp19_ = g_strdup (_tmp18_);

                                _g_free0 (_tmp16_[_tmp17_]);

                                _tmp16_[_tmp17_] = _tmp19_;

                                _tmp20_ = _tmp16_[_tmp17_];

                        }

                        _g_free0 (str);

                }

                _g_object_unref0 (_str_list);

        }

        _tmp21_ = ((RygelUserConfig*) self)->key_file;

        _tmp22_ = section;

        _tmp23_ = key;

        _tmp24_ = strings;

        _tmp24__length1 = strings_length1;

        g_key_file_set_string_list (_tmp21_, _tmp22_, _tmp23_, (const gchar* const*) _tmp24_, _tmp24__length1);

        strings = (_vala_array_free (strings, strings_length1, (GDestroyNotify) g_free), NULL);

}

 

 

        const gchar* _tmp1_;

        const gchar* _tmp2_;

        gint _tmp3_;

        g_return_if_fail (self != NULL);

        g_return_if_fail (section != NULL);

        g_return_if_fail (key != NULL);

        _tmp0_ = ((RygelUserConfig*) self)->key_file;

        _tmp1_ = section;

        _tmp2_ = key;

        _tmp3_ = value;

        g_key_file_set_integer (_tmp0_, _tmp1_, _tmp2_, _tmp3_);

}

 

 

        const gchar* _tmp1_;

        const gchar* _tmp2_;

        gboolean _tmp3_;

        g_return_if_fail (self != NULL);

        g_return_if_fail (section != NULL);

        g_return_if_fail (key != NULL);

        _tmp0_ = ((RygelUserConfig*) self)->key_file;

        _tmp1_ = section;

        _tmp2_ = key;

        _tmp3_ = value;

        g_key_file_set_boolean (_tmp0_, _tmp1_, _tmp2_, _tmp3_);

}

 

 

static void rygel_writable_user_config_enable_upnp (RygelWritableUserConfig* self, gboolean enable) {

        GError * _inner_error_ = NULL;

        g_return_if_fail (self != NULL);

        {

                const gchar* _tmp0_ = NULL;

                gchar* _tmp1_;

                GFile* _tmp9_ = NULL;

                GFile* dest;

                gboolean _tmp10_;

                _tmp0_ = g_get_user_config_dir ();

                _tmp1_ = g_strdup (_tmp0_);

                config_dir = _tmp1_;

                _tmp2_ = config_dir;

                rygel_writable_user_config_ensure_dir_exists (self, _tmp2_, &_inner_error_);

                if (_inner_error_ != NULL) {

                        _g_free0 (config_dir);

                        goto __catch4_g_error;

                }

                _tmp3_ = config_dir;

                _tmp4_ = g_build_filename (_tmp3_, "autostart", NULL);

                dest_dir = _tmp4_;

                _tmp5_ = dest_dir;

                rygel_writable_user_config_ensure_dir_exists (self, _tmp5_, &_inner_error_);

                if (_inner_error_ != NULL) {

                        _g_free0 (dest_dir);

                        _g_free0 (config_dir);

                        goto __catch4_g_error;

                }

                _tmp6_ = dest_dir;

                _tmp7_ = g_build_filename (_tmp6_, "rygel.desktop", NULL);

                dest_path = _tmp7_;

                _tmp8_ = dest_path;

                _tmp9_ = g_file_new_for_path (_tmp8_);

                dest = _tmp9_;

                _tmp10_ = enable;

                if (_tmp10_) {

                        gchar* _tmp11_ = NULL;

                        gchar* source_path;

                        g_bus_watch_name_with_closures (G_BUS_TYPE_SESSION, RYGEL_DBUS_INTERFACE_SERVICE_NAME, G_BUS_NAME_WATCHER_FLAGS_AUTO_START, (GClosure*) ((NULL == NULL) ? NULL : g_cclosure_new ((GCallback) NULL, NULL, NULL)), (GClosure*) ((NULL == NULL) ? NULL : g_cclosure_new ((GCallback) NULL, NULL, NULL)));

                        _tmp11_ = g_build_filename (DESKTOP_DIR, "rygel.desktop", NULL);

                        source_path = _tmp11_;

                        {

                                GFile* _tmp12_;

                                const gchar* _tmp13_;

                                _tmp12_ = dest;

                                _tmp13_ = source_path;

                                g_file_make_symbolic_link (_tmp12_, _tmp13_, NULL, &_inner_error_);

                                if (_inner_error_ != NULL) {

                                        if (g_error_matches (_inner_error_, G_IO_ERROR, G_IO_ERROR_EXISTS)) {

                                                goto __catch5_g_io_error_exists;

                                        }

                                        goto __finally5;

                        __catch5_g_io_error_exists:

                        {

                                GError* err = NULL;

                                err = _inner_error_;

                                _inner_error_ = NULL;

                                _g_error_free0 (err);

                        }

                        __finally5:

                        if (_inner_error_ != NULL) {

                                _g_free0 (source_path);

                                _g_object_unref0 (dest);

                                _g_free0 (dest_path);

                                _g_free0 (dest_dir);

                                _g_free0 (config_dir);

                                goto __catch4_g_error;

                        }

                        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_UPNP_ENABLED_KEY, TRUE);

                        _g_free0 (source_path);

                } else {

                        gboolean _tmp15_ = FALSE;

                        {

                                GFile* _tmp14_;

                                _tmp14_ = dest;

                                g_file_delete (_tmp14_, NULL, &_inner_error_);

                                if (_inner_error_ != NULL) {

                                        if (g_error_matches (_inner_error_, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {

                                                goto __catch6_g_io_error_not_found;

                                        }

                                        goto __finally6;

                        __catch6_g_io_error_not_found:

                        {

                                GError* err = NULL;

                                err = _inner_error_;

                                _inner_error_ = NULL;

                                _g_error_free0 (err);

                        }

                        __finally6:

                        if (_inner_error_ != NULL) {

                                _g_object_unref0 (dest);

                                _g_free0 (dest_path);

                                _g_free0 (dest_dir);

                                _g_free0 (config_dir);

                                goto __catch4_g_error;

                        }

                        rygel_writable_user_config_set_bool (self, "general", RYGEL_USER_CONFIG_UPNP_ENABLED_KEY, FALSE);

                        _tmp15_ = rygel_writable_user_config_is_upnp_enabled (self);

                        if (_tmp15_) {

                                RygelDBusInterface* _tmp16_ = NULL;

                                RygelDBusInterface* rygel_proxy;

                                RygelDBusInterface* _tmp17_;

                                _tmp16_ = g_initable_new (RYGEL_TYPE_DBUS_INTERFACE_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "g-name", RYGEL_DBUS_INTERFACE_SERVICE_NAME, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", RYGEL_DBUS_INTERFACE_OBJECT_PATH, "g-interface-name", "org.gnome.Rygel1", NULL);

                                rygel_proxy = (RygelDBusInterface*) _tmp16_;

                                if (_inner_error_ != NULL) {

                                        _g_object_unref0 (dest);

                                        _g_free0 (dest_path);

                                        _g_free0 (dest_dir);

                                        _g_free0 (config_dir);

                                        goto __catch4_g_error;

                                }

                                _tmp17_ = rygel_proxy;

                                rygel_dbus_interface_shutdown (_tmp17_, &_inner_error_);

                                if (_inner_error_ != NULL) {

                                        _g_object_unref0 (rygel_proxy);

                                        _g_object_unref0 (dest);

                                        _g_free0 (dest_path);

                                        _g_free0 (dest_dir);

                                        _g_free0 (config_dir);

                                        goto __catch4_g_error;

                                }

                                _g_object_unref0 (rygel_proxy);

                        }

                }

                _g_object_unref0 (dest);

                _g_free0 (dest_path);

                _g_free0 (dest_dir);

                _g_free0 (config_dir);

        }

        goto __finally4;

        __catch4_g_error:

                const gchar* _tmp23_;

                GError* _tmp24_;

                const gchar* _tmp25_;

                err = _inner_error_;

                _inner_error_ = NULL;

                _tmp18_ = enable;

                if (_tmp18_) {

                        const gchar* _tmp19_ = NULL;

                        gchar* _tmp20_;

                        _tmp19_ = _ ("Failed to start Rygel service: %s");

                        _tmp20_ = g_strdup (_tmp19_);

                        _g_free0 (message);

                        message = _tmp20_;

                } else {

                        const gchar* _tmp21_ = NULL;

                        gchar* _tmp22_;

                        _tmp21_ = _ ("Failed to stop Rygel service: %s");

                        _tmp22_ = g_strdup (_tmp21_);

                        _g_free0 (message);

                        message = _tmp22_;

                }

                _tmp23_ = message;

                _tmp24_ = err;

                _tmp25_ = _tmp24_->message;

                g_warning (_tmp23_, _tmp25_);

                _g_free0 (message);

                _g_error_free0 (err);

        }

        __finally4:

        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;

        }

}

 

        GFile* _tmp1_ = NULL;

        GFile* dir;

        GError * _inner_error_ = NULL;

        g_return_if_fail (self != NULL);

        g_return_if_fail (dir_path != NULL);

        _tmp0_ = dir_path;

        _tmp1_ = g_file_new_for_path (_tmp0_);

        dir = _tmp1_;

        {

                g_file_make_directory (dir, NULL, &_inner_error_);

                if (_inner_error_ != NULL) {

                        if (g_error_matches (_inner_error_, G_IO_ERROR, G_IO_ERROR_EXISTS)) {

                                goto __catch7_g_io_error_exists;

                        }

                        goto __finally7;

        __catch7_g_io_error_exists:

        {

                GError* err = NULL;

                err = _inner_error_;

                _inner_error_ = NULL;

                _g_error_free0 (err);

        }

        __finally7:

        if (_inner_error_ != NULL) {

                g_propagate_error (error, _inner_error_);

                _g_object_unref0 (dir);

                return;

        }

        _g_object_unref0 (dir);

}

 

 

static void rygel_writable_user_config_class_init (RygelWritableUserConfigClass * klass) {

        rygel_writable_user_config_parent_class = g_type_class_peek_parent (klass);

        g_type_class_add_private (klass, sizeof (RygelWritableUserConfigPrivate));

        G_OBJECT_CLASS (klass)->finalize = rygel_writable_user_config_finalize;

}

 

 

static void rygel_writable_user_config_instance_init (RygelWritableUserConfig * self) {

        self->priv = RYGEL_WRITABLE_USER_CONFIG_GET_PRIVATE (self);

}

 

 

static void rygel_writable_user_config_finalize (GObject* obj) {

        RygelWritableUserConfig * self;

        _g_free0 (self->priv->user_config);

        G_OBJECT_CLASS (rygel_writable_user_config_parent_class)->finalize (obj);

}