Skip to content
This repository has been archived by the owner on Jun 8, 2021. It is now read-only.

Remove xx_sys to xx_ffi renaming #284

Merged
merged 1 commit into from
Mar 10, 2019
Merged

Remove xx_sys to xx_ffi renaming #284

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion gir
Open in desktop
Submodule gir updated 49 files
+1 −1 .travis.yml
+2 −0 README.md
+4 −9 src/analysis/ffi_type.rs
+7 −7 src/analysis/functions.rs
+1 −1 src/analysis/mod.rs
+5 −16 src/analysis/namespaces.rs
+2 −2 src/analysis/object.rs
+3 −3 src/analysis/properties.rs
+3 −3 src/analysis/record.rs
+2 −2 src/analysis/ref_mode.rs
+7 −1 src/analysis/return_value.rs
+2 −2 src/analysis/signals.rs
+4 −2 src/chunk/mod.rs
+4 −2 src/codegen/constants.rs
+1 −1 src/codegen/doc/format.rs
+1 −1 src/codegen/doc/mod.rs
+17 −11 src/codegen/enums.rs
+13 −9 src/codegen/flags.rs
+2 −2 src/codegen/function.rs
+22 −27 src/codegen/function_body_chunk.rs
+34 −32 src/codegen/general.rs
+14 −6 src/codegen/property_body.rs
+4 −0 src/codegen/record.rs
+1 −1 src/codegen/signal.rs
+2 −2 src/codegen/signal_body.rs
+1 −1 src/codegen/sys/cargo_toml.rs
+2 −2 src/codegen/sys/ffi_type.rs
+23 −8 src/codegen/sys/lib_.rs
+1 −1 src/codegen/sys/mod.rs
+1 −1 src/codegen/sys/tests.rs
+3 −3 src/codegen/trampoline.rs
+10 −10 src/config/child_properties.rs
+4 −4 src/config/constants.rs
+3 −3 src/config/derives.rs
+1 −1 src/config/external_libraries.rs
+33 −20 src/config/functions.rs
+32 −17 src/config/gobjects.rs
+2 −2 src/config/ident.rs
+4 −4 src/config/members.rs
+1 −1 src/config/parsable.rs
+2 −2 src/config/properties.rs
+10 −10 src/config/signals.rs
+1 −1 src/config/work_mode.rs
+4 −0 src/env.rs
+2 −2 src/library.rs
+6 −12 src/nameutil.rs
+3 −3 src/parser.rs
+1 −1 src/version.rs
+2 −6 src/writer/to_code.rs
86 changes: 43 additions & 43 deletions src/atom.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,15 +2,15 @@
// See the COPYRIGHT file at the top-level directory of this distribution.
// Licensed under the MIT license, see the LICENSE file or <http://opensource.org/licenses/MIT>

use ffi;
use gdk_sys;
use glib::translate::*;
use glib::GString;
use glib_ffi;
use std::ptr;
use glib_sys;
use std::mem;
use glib::translate::*;
use std::ptr;

#[derive(Copy, Clone, PartialEq, Eq)]
pub struct Atom(ffi::GdkAtom);
pub struct Atom(gdk_sys::GdkAtom);

pub const NONE: Atom = Atom(0 as *mut _);
pub const SELECTION_PRIMARY: Atom = Atom(1 as *mut _);
Expand All @@ -33,11 +33,11 @@ pub const SELECTION_TYPE_STRING: Atom = Atom(31 as *mut _);
impl Atom {
pub fn intern(atom_name: &str) -> Atom {
assert_initialized_main_thread!();
unsafe { Atom(ffi::gdk_atom_intern(atom_name.to_glib_none().0, false.to_glib())) }
unsafe { Atom(gdk_sys::gdk_atom_intern(atom_name.to_glib_none().0, false.to_glib())) }
}

pub fn name(self) -> GString {
unsafe { from_glib_full(ffi::gdk_atom_name(self.0)) }
unsafe { from_glib_full(gdk_sys::gdk_atom_name(self.0)) }
}

pub unsafe fn value(self) -> usize {
Expand All @@ -46,7 +46,7 @@ impl Atom {
}

impl GlibPtrDefault for Atom {
type GlibType = ffi::GdkAtom;
type GlibType = gdk_sys::GdkAtom;
}

#[doc(hidden)]
Expand All @@ -57,44 +57,44 @@ impl Uninitialized for Atom {
}
}

impl<'a> ToGlibPtr<'a, ffi::GdkAtom> for Atom {
impl<'a> ToGlibPtr<'a, gdk_sys::GdkAtom> for Atom {
type Storage = ();

#[inline]
fn to_glib_none(&self) -> Stash<'a, ffi::GdkAtom, Atom> {
fn to_glib_none(&self) -> Stash<'a, gdk_sys::GdkAtom, Atom> {
Stash(self.0, ())
}
}

impl<'a> ToGlibPtrMut<'a, *mut ffi::GdkAtom> for Atom {
impl<'a> ToGlibPtrMut<'a, *mut gdk_sys::GdkAtom> for Atom {
type Storage = ();

#[inline]
fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::GdkAtom, Atom> {
fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut gdk_sys::GdkAtom, Atom> {
StashMut(&mut self.0, ())
}
}

impl<'a> ToGlibContainerFromSlice<'a, *mut ffi::GdkAtom> for &'a Atom {
type Storage = (Vec<Stash<'a, ffi::GdkAtom, &'a Atom>>, Option<Vec<ffi::GdkAtom>>);
impl<'a> ToGlibContainerFromSlice<'a, *mut gdk_sys::GdkAtom> for &'a Atom {
type Storage = (Vec<Stash<'a, gdk_sys::GdkAtom, &'a Atom>>, Option<Vec<gdk_sys::GdkAtom>>);

fn to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*mut ffi::GdkAtom, Self::Storage) {
fn to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*mut gdk_sys::GdkAtom, Self::Storage) {
skip_assert_initialized!();

let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();
let mut v_ptr: Vec<_> = v.iter().map(|s| s.0).collect();
v_ptr.push(ptr::null_mut());

(v_ptr.as_ptr() as *mut ffi::GdkAtom, (v, Some(v_ptr)))
(v_ptr.as_ptr() as *mut gdk_sys::GdkAtom, (v, Some(v_ptr)))
}

fn to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*mut ffi::GdkAtom, Self::Storage) {
fn to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*mut gdk_sys::GdkAtom, Self::Storage) {
skip_assert_initialized!();

let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();

let v_ptr = unsafe {
let v_ptr = glib_ffi::g_malloc0(mem::size_of::<ffi::GdkAtom>() * (t.len() + 1)) as *mut ffi::GdkAtom;
let v_ptr = glib_sys::g_malloc0(mem::size_of::<gdk_sys::GdkAtom>() * (t.len() + 1)) as *mut gdk_sys::GdkAtom;

for (i, s) in v.iter().enumerate() {
ptr::write(v_ptr.offset(i as isize), s.0);
Expand All @@ -106,68 +106,68 @@ impl<'a> ToGlibContainerFromSlice<'a, *mut ffi::GdkAtom> for &'a Atom {
(v_ptr, (v, None))
}

fn to_glib_full_from_slice(_: &[&'a Atom]) -> *mut ffi::GdkAtom {
fn to_glib_full_from_slice(_: &[&'a Atom]) -> *mut gdk_sys::GdkAtom {
skip_assert_initialized!();

unimplemented!()
}
}

impl<'a> ToGlibContainerFromSlice<'a, *const ffi::GdkAtom> for &'a Atom {
type Storage = (Vec<Stash<'a, ffi::GdkAtom, &'a Atom>>, Option<Vec<ffi::GdkAtom>>);
impl<'a> ToGlibContainerFromSlice<'a, *const gdk_sys::GdkAtom> for &'a Atom {
type Storage = (Vec<Stash<'a, gdk_sys::GdkAtom, &'a Atom>>, Option<Vec<gdk_sys::GdkAtom>>);

fn to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*const ffi::GdkAtom, Self::Storage) {
fn to_glib_none_from_slice(t: &'a [&'a Atom]) -> (*const gdk_sys::GdkAtom, Self::Storage) {
skip_assert_initialized!();

let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();
let mut v_ptr: Vec<_> = v.iter().map(|s| s.0).collect();
v_ptr.push(ptr::null_mut());

(v_ptr.as_ptr() as *const ffi::GdkAtom, (v, Some(v_ptr)))
(v_ptr.as_ptr() as *const gdk_sys::GdkAtom, (v, Some(v_ptr)))
}

fn to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*const ffi::GdkAtom, Self::Storage) {
fn to_glib_container_from_slice(t: &'a [&'a Atom]) -> (*const gdk_sys::GdkAtom, Self::Storage) {
skip_assert_initialized!();

let v: Vec<_> = t.iter().map(|s| s.to_glib_none()).collect();

let v_ptr = unsafe {
let v_ptr = glib_ffi::g_malloc0(mem::size_of::<ffi::GdkAtom>() * (t.len() + 1)) as *mut ffi::GdkAtom;
let v_ptr = glib_sys::g_malloc0(mem::size_of::<gdk_sys::GdkAtom>() * (t.len() + 1)) as *mut gdk_sys::GdkAtom;

for (i, s) in v.iter().enumerate() {
ptr::write(v_ptr.offset(i as isize), s.0);
}

v_ptr as *const ffi::GdkAtom
v_ptr as *const gdk_sys::GdkAtom
};

(v_ptr, (v, None))
}

fn to_glib_full_from_slice(_: &[&'a Atom]) -> *const ffi::GdkAtom {
fn to_glib_full_from_slice(_: &[&'a Atom]) -> *const gdk_sys::GdkAtom {
skip_assert_initialized!();

unimplemented!()
}
}

impl FromGlibPtrNone<ffi::GdkAtom> for Atom {
impl FromGlibPtrNone<gdk_sys::GdkAtom> for Atom {
#[inline]
unsafe fn from_glib_none(ptr: ffi::GdkAtom) -> Atom { Atom(ptr) }
unsafe fn from_glib_none(ptr: gdk_sys::GdkAtom) -> Atom { Atom(ptr) }
}

impl FromGlibPtrBorrow<ffi::GdkAtom> for Atom {
impl FromGlibPtrBorrow<gdk_sys::GdkAtom> for Atom {
#[inline]
unsafe fn from_glib_borrow(ptr: ffi::GdkAtom) -> Atom { Atom(ptr) }
unsafe fn from_glib_borrow(ptr: gdk_sys::GdkAtom) -> Atom { Atom(ptr) }
}

impl FromGlibPtrFull<ffi::GdkAtom> for Atom {
impl FromGlibPtrFull<gdk_sys::GdkAtom> for Atom {
#[inline]
unsafe fn from_glib_full(_: ffi::GdkAtom) -> Atom { unimplemented!() }
unsafe fn from_glib_full(_: gdk_sys::GdkAtom) -> Atom { unimplemented!() }
}

impl FromGlibContainerAsVec<ffi::GdkAtom, *mut ffi::GdkAtom> for Atom {
unsafe fn from_glib_none_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self> {
impl FromGlibContainerAsVec<gdk_sys::GdkAtom, *mut gdk_sys::GdkAtom> for Atom {
unsafe fn from_glib_none_num_as_vec(ptr: *mut gdk_sys::GdkAtom, num: usize) -> Vec<Self> {
if num == 0 || ptr.is_null() {
return Vec::new();
}
Expand All @@ -179,13 +179,13 @@ impl FromGlibContainerAsVec<ffi::GdkAtom, *mut ffi::GdkAtom> for Atom {
res
}

unsafe fn from_glib_container_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self> {
unsafe fn from_glib_container_num_as_vec(ptr: *mut gdk_sys::GdkAtom, num: usize) -> Vec<Self> {
let res = FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, num);
glib_ffi::g_free(ptr as *mut _);
glib_sys::g_free(ptr as *mut _);
res
}

unsafe fn from_glib_full_num_as_vec(ptr: *mut ffi::GdkAtom, num: usize) -> Vec<Self> {
unsafe fn from_glib_full_num_as_vec(ptr: *mut gdk_sys::GdkAtom, num: usize) -> Vec<Self> {
if num == 0 || ptr.is_null() {
return Vec::new();
}
Expand All @@ -194,21 +194,21 @@ impl FromGlibContainerAsVec<ffi::GdkAtom, *mut ffi::GdkAtom> for Atom {
for i in 0..num {
res.push(from_glib_full(ptr::read(ptr.offset(i as isize))));
}
glib_ffi::g_free(ptr as *mut _);
glib_sys::g_free(ptr as *mut _);
res
}
}

impl FromGlibPtrArrayContainerAsVec<ffi::GdkAtom, *mut ffi::GdkAtom> for Atom {
unsafe fn from_glib_none_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self> {
impl FromGlibPtrArrayContainerAsVec<gdk_sys::GdkAtom, *mut gdk_sys::GdkAtom> for Atom {
unsafe fn from_glib_none_as_vec(ptr: *mut gdk_sys::GdkAtom) -> Vec<Self> {
FromGlibContainerAsVec::from_glib_none_num_as_vec(ptr, c_ptr_array_len(ptr))
}

unsafe fn from_glib_container_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self> {
unsafe fn from_glib_container_as_vec(ptr: *mut gdk_sys::GdkAtom) -> Vec<Self> {
FromGlibContainerAsVec::from_glib_container_num_as_vec(ptr, c_ptr_array_len(ptr))
}

unsafe fn from_glib_full_as_vec(ptr: *mut ffi::GdkAtom) -> Vec<Self> {
unsafe fn from_glib_full_as_vec(ptr: *mut gdk_sys::GdkAtom) -> Vec<Self> {
FromGlibContainerAsVec::from_glib_full_num_as_vec(ptr, c_ptr_array_len(ptr))
}
}
Expand Down
20 changes: 10 additions & 10 deletions src/auto/app_launch_context.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,59 +4,59 @@

use Display;
use Screen;
use ffi;
use gdk_sys;
use gio;
use glib::StaticType;
use glib::Value;
use glib::object::IsA;
use glib::object::ObjectType;
use glib::translate::*;
use gobject_ffi;
use gobject_sys;
use std::fmt;

glib_wrapper! {
pub struct AppLaunchContext(Object<ffi::GdkAppLaunchContext, AppLaunchContextClass>) @extends gio::AppLaunchContext;
pub struct AppLaunchContext(Object<gdk_sys::GdkAppLaunchContext, AppLaunchContextClass>) @extends gio::AppLaunchContext;

match fn {
get_type => || ffi::gdk_app_launch_context_get_type(),
get_type => || gdk_sys::gdk_app_launch_context_get_type(),
}
}

impl AppLaunchContext {
pub fn set_desktop(&self, desktop: i32) {
unsafe {
ffi::gdk_app_launch_context_set_desktop(self.to_glib_none().0, desktop);
gdk_sys::gdk_app_launch_context_set_desktop(self.to_glib_none().0, desktop);
}
}

pub fn set_icon<P: IsA<gio::Icon>>(&self, icon: Option<&P>) {
unsafe {
ffi::gdk_app_launch_context_set_icon(self.to_glib_none().0, icon.map(|p| p.as_ref()).to_glib_none().0);
gdk_sys::gdk_app_launch_context_set_icon(self.to_glib_none().0, icon.map(|p| p.as_ref()).to_glib_none().0);
}
}

pub fn set_icon_name(&self, icon_name: Option<&str>) {
unsafe {
ffi::gdk_app_launch_context_set_icon_name(self.to_glib_none().0, icon_name.to_glib_none().0);
gdk_sys::gdk_app_launch_context_set_icon_name(self.to_glib_none().0, icon_name.to_glib_none().0);
}
}

pub fn set_screen(&self, screen: &Screen) {
unsafe {
ffi::gdk_app_launch_context_set_screen(self.to_glib_none().0, screen.to_glib_none().0);
gdk_sys::gdk_app_launch_context_set_screen(self.to_glib_none().0, screen.to_glib_none().0);
}
}

pub fn set_timestamp(&self, timestamp: u32) {
unsafe {
ffi::gdk_app_launch_context_set_timestamp(self.to_glib_none().0, timestamp);
gdk_sys::gdk_app_launch_context_set_timestamp(self.to_glib_none().0, timestamp);
}
}

pub fn get_property_display(&self) -> Option<Display> {
unsafe {
let mut value = Value::from_type(<Display as StaticType>::static_type());
gobject_ffi::g_object_get_property(self.as_ptr() as *mut gobject_ffi::GObject, b"display\0".as_ptr() as *const _, value.to_glib_none_mut().0);
gobject_sys::g_object_get_property(self.as_ptr() as *mut gobject_sys::GObject, b"display\0".as_ptr() as *const _, value.to_glib_none_mut().0);
value.get()
}
}
Expand Down
24 changes: 12 additions & 12 deletions src/auto/cursor.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,17 +5,17 @@
use CursorType;
use Display;
use cairo;
use ffi;
use gdk_pixbuf;
use gdk_sys;
use glib::translate::*;
use std::fmt;
use std::mem;

glib_wrapper! {
pub struct Cursor(Object<ffi::GdkCursor, CursorClass>);
pub struct Cursor(Object<gdk_sys::GdkCursor, CursorClass>);

match fn {
get_type => || ffi::gdk_cursor_get_type(),
get_type => || gdk_sys::gdk_cursor_get_type(),
}
}

Expand All @@ -24,61 +24,61 @@ impl Cursor {
pub fn new(cursor_type: CursorType) -> Cursor {
assert_initialized_main_thread!();
unsafe {
from_glib_full(ffi::gdk_cursor_new(cursor_type.to_glib()))
from_glib_full(gdk_sys::gdk_cursor_new(cursor_type.to_glib()))
}
}

pub fn new_for_display(display: &Display, cursor_type: CursorType) -> Cursor {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gdk_cursor_new_for_display(display.to_glib_none().0, cursor_type.to_glib()))
from_glib_full(gdk_sys::gdk_cursor_new_for_display(display.to_glib_none().0, cursor_type.to_glib()))
}
}

pub fn new_from_name(display: &Display, name: &str) -> Option<Cursor> {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gdk_cursor_new_from_name(display.to_glib_none().0, name.to_glib_none().0))
from_glib_full(gdk_sys::gdk_cursor_new_from_name(display.to_glib_none().0, name.to_glib_none().0))
}
}

pub fn new_from_pixbuf(display: &Display, pixbuf: &gdk_pixbuf::Pixbuf, x: i32, y: i32) -> Cursor {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gdk_cursor_new_from_pixbuf(display.to_glib_none().0, pixbuf.to_glib_none().0, x, y))
from_glib_full(gdk_sys::gdk_cursor_new_from_pixbuf(display.to_glib_none().0, pixbuf.to_glib_none().0, x, y))
}
}

pub fn new_from_surface(display: &Display, surface: &cairo::Surface, x: f64, y: f64) -> Cursor {
skip_assert_initialized!();
unsafe {
from_glib_full(ffi::gdk_cursor_new_from_surface(display.to_glib_none().0, mut_override(surface.to_glib_none().0), x, y))
from_glib_full(gdk_sys::gdk_cursor_new_from_surface(display.to_glib_none().0, mut_override(surface.to_glib_none().0), x, y))
}
}

pub fn get_cursor_type(&self) -> CursorType {
unsafe {
from_glib(ffi::gdk_cursor_get_cursor_type(self.to_glib_none().0))
from_glib(gdk_sys::gdk_cursor_get_cursor_type(self.to_glib_none().0))
}
}

pub fn get_display(&self) -> Display {
unsafe {
from_glib_none(ffi::gdk_cursor_get_display(self.to_glib_none().0))
from_glib_none(gdk_sys::gdk_cursor_get_display(self.to_glib_none().0))
}
}

pub fn get_image(&self) -> Option<gdk_pixbuf::Pixbuf> {
unsafe {
from_glib_full(ffi::gdk_cursor_get_image(self.to_glib_none().0))
from_glib_full(gdk_sys::gdk_cursor_get_image(self.to_glib_none().0))
}
}

pub fn get_surface(&self) -> (Option<cairo::Surface>, f64, f64) {
unsafe {
let mut x_hot = mem::uninitialized();
let mut y_hot = mem::uninitialized();
let ret = from_glib_full(ffi::gdk_cursor_get_surface(self.to_glib_none().0, &mut x_hot, &mut y_hot));
let ret = from_glib_full(gdk_sys::gdk_cursor_get_surface(self.to_glib_none().0, &mut x_hot, &mut y_hot));
(ret, x_hot, y_hot)
}
}
Expand Down
Loading