use Cancellable;
use Error;
use File;
use IOErrorEnum;
use IOStream;
use Icon;
use InputStream;
use Resource;
use ResourceLookupFlags;
use SettingsBackend;
use ffi;
#[cfg(feature = "futures")]
use futures_core;
use glib;
use glib::object::IsA;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std;
#[cfg(feature = "futures")]
use std::boxed::Box as Box_;
use std::mem;
use std::ptr;
pub fn bus_unown_name(owner_id: u32) {
unsafe {
ffi::g_bus_unown_name(owner_id);
}
}
pub fn bus_unwatch_name(watcher_id: u32) {
unsafe {
ffi::g_bus_unwatch_name(watcher_id);
}
}
pub fn content_type_can_be_executable(type_: &str) -> bool {
unsafe {
from_glib(ffi::g_content_type_can_be_executable(type_.to_glib_none().0))
}
}
pub fn content_type_equals(type1: &str, type2: &str) -> bool {
unsafe {
from_glib(ffi::g_content_type_equals(type1.to_glib_none().0, type2.to_glib_none().0))
}
}
pub fn content_type_from_mime_type(mime_type: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_content_type_from_mime_type(mime_type.to_glib_none().0))
}
}
pub fn content_type_get_description(type_: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_content_type_get_description(type_.to_glib_none().0))
}
}
#[cfg(any(feature = "v2_34", feature = "dox"))]
pub fn content_type_get_generic_icon_name(type_: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_content_type_get_generic_icon_name(type_.to_glib_none().0))
}
}
pub fn content_type_get_icon(type_: &str) -> Option<Icon> {
unsafe {
from_glib_full(ffi::g_content_type_get_icon(type_.to_glib_none().0))
}
}
pub fn content_type_get_mime_type(type_: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_content_type_get_mime_type(type_.to_glib_none().0))
}
}
#[cfg(any(feature = "v2_34", feature = "dox"))]
pub fn content_type_get_symbolic_icon(type_: &str) -> Option<Icon> {
unsafe {
from_glib_full(ffi::g_content_type_get_symbolic_icon(type_.to_glib_none().0))
}
}
pub fn content_type_guess<'a, P: Into<Option<&'a str>>>(filename: P, data: &[u8]) -> (String, bool) {
let filename = filename.into();
let filename = filename.to_glib_none();
let data_size = data.len() as usize;
unsafe {
let mut result_uncertain = mem::uninitialized();
let ret = from_glib_full(ffi::g_content_type_guess(filename.0, data.to_glib_none().0, data_size, &mut result_uncertain));
(ret, from_glib(result_uncertain))
}
}
pub fn content_type_guess_for_tree<P: IsA<File>>(root: &P) -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_content_type_guess_for_tree(root.to_glib_none().0))
}
}
pub fn content_type_is_a(type_: &str, supertype: &str) -> bool {
unsafe {
from_glib(ffi::g_content_type_is_a(type_.to_glib_none().0, supertype.to_glib_none().0))
}
}
#[cfg(any(feature = "v2_52", feature = "dox"))]
pub fn content_type_is_mime_type(type_: &str, mime_type: &str) -> bool {
unsafe {
from_glib(ffi::g_content_type_is_mime_type(type_.to_glib_none().0, mime_type.to_glib_none().0))
}
}
pub fn content_type_is_unknown(type_: &str) -> bool {
unsafe {
from_glib(ffi::g_content_type_is_unknown(type_.to_glib_none().0))
}
}
pub fn content_types_get_registered() -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_content_types_get_registered())
}
}
#[cfg(any(feature = "v2_36", feature = "dox"))]
pub fn dbus_address_escape_value(string: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_dbus_address_escape_value(string.to_glib_none().0))
}
}
pub fn dbus_address_get_stream<'a, P: Into<Option<&'a Cancellable>>, Q: FnOnce(Result<(IOStream, String), Error>) + Send + 'static>(address: &str, cancellable: P, callback: Q) {
let cancellable = cancellable.into();
let cancellable = cancellable.to_glib_none();
let user_data: Box<Box<Q>> = Box::new(Box::new(callback));
unsafe extern "C" fn dbus_address_get_stream_trampoline<Q: FnOnce(Result<(IOStream, String), Error>) + Send + 'static>(_source_object: *mut gobject_ffi::GObject, res: *mut ffi::GAsyncResult, user_data: glib_ffi::gpointer)
{
let mut error = ptr::null_mut();
let mut out_guid = ptr::null_mut();
let ret = ffi::g_dbus_address_get_stream_finish(res, &mut out_guid, &mut error);
let result = if error.is_null() { Ok((from_glib_full(ret), from_glib_full(out_guid))) } else { Err(from_glib_full(error)) };
let callback: Box<Box<Q>> = Box::from_raw(user_data as *mut _);
callback(result);
}
let callback = dbus_address_get_stream_trampoline::<Q>;
unsafe {
ffi::g_dbus_address_get_stream(address.to_glib_none().0, cancellable.0, Some(callback), Box::into_raw(user_data) as *mut _);
}
}
#[cfg(feature = "futures")]
pub fn dbus_address_get_stream_future(address: &str) -> Box_<futures_core::Future<Item = (IOStream, String), Error = Error>> {
use GioFuture;
use fragile::Fragile;
let address = String::from(address);
GioFuture::new(&(), move |_obj, send| {
let cancellable = Cancellable::new();
let send = Fragile::new(send);
dbus_address_get_stream(
&address,
Some(&cancellable),
move |res| {
let _ = send.into_inner().send(res);
},
);
cancellable
})
}
pub fn dbus_address_get_stream_sync<'a, P: Into<Option<&'a Cancellable>>>(address: &str, cancellable: P) -> Result<(IOStream, String), Error> {
let cancellable = cancellable.into();
let cancellable = cancellable.to_glib_none();
unsafe {
let mut out_guid = ptr::null_mut();
let mut error = ptr::null_mut();
let ret = ffi::g_dbus_address_get_stream_sync(address.to_glib_none().0, &mut out_guid, cancellable.0, &mut error);
if error.is_null() { Ok((from_glib_full(ret), from_glib_full(out_guid))) } else { Err(from_glib_full(error)) }
}
}
pub fn dbus_generate_guid() -> Option<String> {
unsafe {
from_glib_full(ffi::g_dbus_generate_guid())
}
}
pub fn dbus_is_address(string: &str) -> bool {
unsafe {
from_glib(ffi::g_dbus_is_address(string.to_glib_none().0))
}
}
pub fn dbus_is_guid(string: &str) -> bool {
unsafe {
from_glib(ffi::g_dbus_is_guid(string.to_glib_none().0))
}
}
pub fn dbus_is_interface_name(string: &str) -> bool {
unsafe {
from_glib(ffi::g_dbus_is_interface_name(string.to_glib_none().0))
}
}
pub fn dbus_is_member_name(string: &str) -> bool {
unsafe {
from_glib(ffi::g_dbus_is_member_name(string.to_glib_none().0))
}
}
pub fn dbus_is_name(string: &str) -> bool {
unsafe {
from_glib(ffi::g_dbus_is_name(string.to_glib_none().0))
}
}
pub fn dbus_is_supported_address(string: &str) -> Result<(), Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_dbus_is_supported_address(string.to_glib_none().0, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn dbus_is_unique_name(string: &str) -> bool {
unsafe {
from_glib(ffi::g_dbus_is_unique_name(string.to_glib_none().0))
}
}
pub fn io_error_from_errno(err_no: i32) -> IOErrorEnum {
unsafe {
from_glib(ffi::g_io_error_from_errno(err_no))
}
}
pub fn io_modules_scan_all_in_directory<P: AsRef<std::path::Path>>(dirname: P) {
unsafe {
ffi::g_io_modules_scan_all_in_directory(dirname.as_ref().to_glib_none().0);
}
}
pub fn io_scheduler_cancel_all_jobs() {
unsafe {
ffi::g_io_scheduler_cancel_all_jobs();
}
}
pub fn keyfile_settings_backend_new<'a, P: Into<Option<&'a str>>>(filename: &str, root_path: &str, root_group: P) -> Option<SettingsBackend> {
let root_group = root_group.into();
let root_group = root_group.to_glib_none();
unsafe {
from_glib_full(ffi::g_keyfile_settings_backend_new(filename.to_glib_none().0, root_path.to_glib_none().0, root_group.0))
}
}
pub fn memory_settings_backend_new() -> Option<SettingsBackend> {
unsafe {
from_glib_full(ffi::g_memory_settings_backend_new())
}
}
#[cfg(any(feature = "v2_36", feature = "dox"))]
pub fn networking_init() {
unsafe {
ffi::g_networking_init();
}
}
pub fn null_settings_backend_new() -> Option<SettingsBackend> {
unsafe {
from_glib_full(ffi::g_null_settings_backend_new())
}
}
pub fn resources_enumerate_children(path: &str, lookup_flags: ResourceLookupFlags) -> Result<Vec<String>, Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::g_resources_enumerate_children(path.to_glib_none().0, lookup_flags.to_glib(), &mut error);
if error.is_null() { Ok(FromGlibPtrContainer::from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
pub fn resources_get_info(path: &str, lookup_flags: ResourceLookupFlags) -> Result<(usize, u32), Error> {
unsafe {
let mut size = mem::uninitialized();
let mut flags = mem::uninitialized();
let mut error = ptr::null_mut();
let _ = ffi::g_resources_get_info(path.to_glib_none().0, lookup_flags.to_glib(), &mut size, &mut flags, &mut error);
if error.is_null() { Ok((size, flags)) } else { Err(from_glib_full(error)) }
}
}
pub fn resources_lookup_data(path: &str, lookup_flags: ResourceLookupFlags) -> Result<glib::Bytes, Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::g_resources_lookup_data(path.to_glib_none().0, lookup_flags.to_glib(), &mut error);
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
pub fn resources_open_stream(path: &str, lookup_flags: ResourceLookupFlags) -> Result<InputStream, Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::g_resources_open_stream(path.to_glib_none().0, lookup_flags.to_glib(), &mut error);
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
pub fn resources_register(resource: &Resource) {
unsafe {
ffi::g_resources_register(resource.to_glib_none().0);
}
}
pub fn resources_unregister(resource: &Resource) {
unsafe {
ffi::g_resources_unregister(resource.to_glib_none().0);
}
}
#[cfg(any(unix, feature = "dox"))]
pub fn unix_is_mount_path_system_internal<P: AsRef<std::path::Path>>(mount_path: P) -> bool {
unsafe {
from_glib(ffi::g_unix_is_mount_path_system_internal(mount_path.as_ref().to_glib_none().0))
}
}
#[cfg(any(unix, feature = "dox"))]
#[cfg(any(feature = "v2_56", feature = "dox"))]
pub fn unix_is_system_device_path<P: AsRef<std::path::Path>>(device_path: P) -> bool {
unsafe {
from_glib(ffi::g_unix_is_system_device_path(device_path.as_ref().to_glib_none().0))
}
}
#[cfg(any(unix, feature = "dox"))]
#[cfg(any(feature = "v2_56", feature = "dox"))]
pub fn unix_is_system_fs_type(fs_type: &str) -> bool {
unsafe {
from_glib(ffi::g_unix_is_system_fs_type(fs_type.to_glib_none().0))
}
}
#[cfg(any(unix, feature = "dox"))]
pub fn unix_mount_points_changed_since(time: u64) -> bool {
unsafe {
from_glib(ffi::g_unix_mount_points_changed_since(time))
}
}
#[cfg(any(unix, feature = "dox"))]
pub fn unix_mounts_changed_since(time: u64) -> bool {
unsafe {
from_glib(ffi::g_unix_mounts_changed_since(time))
}
}