From d2a72338277e0407a0340292ebf6088055b19aa8 Mon Sep 17 00:00:00 2001 From: Jon Emil Jahren Date: Mon, 2 Apr 2018 05:18:05 +0200 Subject: [PATCH] Move SDL_image to sdl2-sys crate Progresses on #647 --- Cargo.toml | 2 +- sdl2-sys/Cargo.toml | 1 + sdl2-sys/build.rs | 23 +++- .../image/ffi.rs => sdl2-sys/src/image.rs | 5 +- sdl2-sys/src/lib.rs | 3 + src/sdl2/image/mod.rs | 107 +++++++----------- 6 files changed, 67 insertions(+), 74 deletions(-) rename src/sdl2/image/ffi.rs => sdl2-sys/src/image.rs (96%) mode change 100755 => 100644 src/sdl2/image/mod.rs diff --git a/Cargo.toml b/Cargo.toml index dc8f3e14..2f37af16 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -38,9 +38,9 @@ optional = true unsafe_textures = [] default = [] ttf = [] -image = [] gfx = ["c_vec"] mixer = ["sdl2-sys/mixer"] +image = ["sdl2-sys/image"] use-bindgen = ["sdl2-sys/use-bindgen"] use-pkgconfig = ["sdl2-sys/use-pkgconfig"] diff --git a/sdl2-sys/Cargo.toml b/sdl2-sys/Cargo.toml index 67ef42d7..3d3b6fae 100644 --- a/sdl2-sys/Cargo.toml +++ b/sdl2-sys/Cargo.toml @@ -51,3 +51,4 @@ static-link = [] use_mac_framework = [] bundled = ["cmake", "reqwest", "tar", "flate2"] mixer = [] +image = [] diff --git a/sdl2-sys/build.rs b/sdl2-sys/build.rs index 8096d76d..2c685535 100644 --- a/sdl2-sys/build.rs +++ b/sdl2-sys/build.rs @@ -204,12 +204,23 @@ fn link_sdl2(target_os: &str) { // leaves it up to the user to make a symlink to the shared object so // -lSDL2_mixer can find it. #[cfg(all(not(feature = "use-pkgconfig"), not(feature = "static-link")))] { - if cfg!(all(any(target_os="linux", target_os="freebsd"), feature = "mixer")) { - println!("cargo:rustc-flags=-l SDL2_mixer"); - } else if cfg!(all(target_os="windows", feature = "mixer")) { - println!("cargo:rustc-flags=-l SDL2_mixer"); - } else if cfg!(all(any(target_os="macos", feature="use_mac_framework"), feature = "mixer")) { - println!("cargo:rustc-flags=-l framework=SDL2_mixer"); + if cfg!(feature = "mixer") { + if cfg!(any(target_os="linux", target_os="freebsd")) { + println!("cargo:rustc-flags=-l SDL2_mixer"); + } else if cfg!(target_os="windows") { + println!("cargo:rustc-flags=-l SDL2_mixer"); + } else if cfg!(any(target_os="macos", feature="use_mac_framework")) { + println!("cargo:rustc-flags=-l framework=SDL2_mixer"); + } + } + if cfg!(feature = "image") { + if cfg!(any(target_os="linux", target_os="freebsd")) { + println!("cargo:rustc-flags=-l SDL2_image"); + } else if cfg!(target_os="windows") { + println!("cargo:rustc-flags=-l SDL2_image"); + } else if cfg!(any(target_os="macos", feature="use_mac_framework")) { + println!("cargo:rustc-flags=-l framework=SDL2_image"); + } } } } diff --git a/src/sdl2/image/ffi.rs b/sdl2-sys/src/image.rs similarity index 96% rename from src/sdl2/image/ffi.rs rename to sdl2-sys/src/image.rs index a934b2bb..d8ac8740 100644 --- a/src/sdl2/image/ffi.rs +++ b/sdl2-sys/src/image.rs @@ -1,6 +1,5 @@ use std::os::raw::{c_int, c_char}; -use sys; -use sys::{SDL_RWops, SDL_Surface, SDL_Renderer, SDL_Texture}; +use ::{SDL_RWops, SDL_Surface, SDL_Renderer, SDL_Texture}; pub type IMG_InitFlags = c_int; pub const IMG_INIT_JPG: IMG_InitFlags = 0x00_00_00_01; @@ -11,7 +10,7 @@ pub const IMG_INIT_WEBP: IMG_InitFlags = 0x00_00_00_08; extern "C" { // This function gets the version of the dynamically linked SDL_image library. -pub fn IMG_Linked_Version() -> *const sys::SDL_version; +pub fn IMG_Linked_Version() -> *const ::SDL_version; // Loads dynamic libraries and prepares them for use. Flags should be // one or more flags from IMG_InitFlags OR'd together. diff --git a/sdl2-sys/src/lib.rs b/sdl2-sys/src/lib.rs index a5e4e9d9..b27f19d6 100644 --- a/sdl2-sys/src/lib.rs +++ b/sdl2-sys/src/lib.rs @@ -12,3 +12,6 @@ include!(concat!(env!("OUT_DIR"), "/bindings.rs")); #[cfg(feature = "mixer")] pub mod mixer; + +#[cfg(feature = "image")] +pub mod image; diff --git a/src/sdl2/image/mod.rs b/src/sdl2/image/mod.rs old mode 100755 new mode 100644 index aa778146..b79c6963 --- a/src/sdl2/image/mod.rs +++ b/src/sdl2/image/mod.rs @@ -30,35 +30,14 @@ use version::Version; use get_error; use sys; -// Setup linking for all targets. -#[cfg(target_os="macos")] -mod mac { - #[cfg(any(mac_framework, feature="use_mac_framework"))] - #[link(kind="framework", name="SDL2_image")] - extern "C" {} - - #[cfg(not(any(mac_framework, feature="use_mac_framework")))] - #[link(name="SDL2_image")] - extern "C" {} -} - -#[cfg(any(target_os="windows", target_os="linux", target_os="freebsd"))] -mod others { - #[link(name="SDL2_image")] - extern "C" {} -} - -#[allow(non_camel_case_types, dead_code)] -mod ffi; - /// InitFlags are passed to init() to control which subsystem /// functionality to load. bitflags! { pub flags InitFlag : u32 { - const INIT_JPG = ffi::IMG_INIT_JPG as u32, - const INIT_PNG = ffi::IMG_INIT_PNG as u32, - const INIT_TIF = ffi::IMG_INIT_TIF as u32, - const INIT_WEBP = ffi::IMG_INIT_WEBP as u32 + const INIT_JPG = sys::image::IMG_INIT_JPG as u32, + const INIT_PNG = sys::image::IMG_INIT_PNG as u32, + const INIT_TIF = sys::image::IMG_INIT_TIF as u32, + const INIT_WEBP = sys::image::IMG_INIT_WEBP as u32 } } @@ -102,7 +81,7 @@ impl<'a> LoadSurface for Surface<'a> { //! Loads an SDL Surface from a file unsafe { let c_filename = CString::new(filename.as_ref().to_str().unwrap()).unwrap(); - let raw = ffi::IMG_Load(c_filename.as_ptr() as *const _); + let raw = sys::image::IMG_Load(c_filename.as_ptr() as *const _); if (raw as *mut ()).is_null() { Err(get_error()) } else { @@ -114,7 +93,7 @@ impl<'a> LoadSurface for Surface<'a> { fn from_xpm_array(xpm: *const *const i8) -> Result, String> { //! Loads an SDL Surface from XPM data unsafe { - let raw = ffi::IMG_ReadXPMFromArray(xpm as *const *const c_char); + let raw = sys::image::IMG_ReadXPMFromArray(xpm as *const *const c_char); if (raw as *mut ()).is_null() { Err(get_error()) } else { @@ -129,7 +108,7 @@ impl<'a> SaveSurface for Surface<'a> { //! Saves an SDL Surface to a file unsafe { let c_filename = CString::new(filename.as_ref().to_str().unwrap()).unwrap(); - let status = ffi::IMG_SavePNG(self.raw(), c_filename.as_ptr() as *const _); + let status = sys::image::IMG_SavePNG(self.raw(), c_filename.as_ptr() as *const _); if status != 0 { Err(get_error()) } else { @@ -141,7 +120,7 @@ impl<'a> SaveSurface for Surface<'a> { fn save_rw(&self, dst: &mut RWops) -> Result<(), String> { //! Saves an SDL Surface to an RWops unsafe { - let status = ffi::IMG_SavePNG_RW(self.raw(), dst.raw(), 0); + let status = sys::image::IMG_SavePNG_RW(self.raw(), dst.raw(), 0); if status != 0 { Err(get_error()) @@ -162,7 +141,7 @@ impl LoadTexture for TextureCreator { //! Loads an SDL Texture from a file unsafe { let c_filename = CString::new(filename.as_ref().to_str().unwrap()).unwrap(); - let raw = ffi::IMG_LoadTexture(self.raw(), c_filename.as_ptr() as *const _); + let raw = sys::image::IMG_LoadTexture(self.raw(), c_filename.as_ptr() as *const _); if (raw as *mut ()).is_null() { Err(get_error()) } else { @@ -179,7 +158,7 @@ pub struct Sdl2ImageContext; impl Drop for Sdl2ImageContext { fn drop(&mut self) { unsafe { - ffi::IMG_Quit(); + sys::image::IMG_Quit(); } } } @@ -188,7 +167,7 @@ impl Drop for Sdl2ImageContext { /// If not every flag is set it returns an error pub fn init(flags: InitFlag) -> Result { let return_flags = unsafe { - let used = ffi::IMG_Init(flags.bits() as c_int); + let used = sys::image::IMG_Init(flags.bits() as c_int); InitFlag::from_bits_truncate(used as u32) }; if !flags.intersects(return_flags) { @@ -207,7 +186,7 @@ pub fn init(flags: InitFlag) -> Result { /// Returns the version of the dynamically linked `SDL_image` library pub fn get_linked_version() -> Version { - unsafe { Version::from_ll(*ffi::IMG_Linked_Version()) } + unsafe { Version::from_ll(*sys::image::IMG_Linked_Version()) } } #[inline] @@ -259,118 +238,118 @@ pub trait ImageRWops { impl<'a> ImageRWops for RWops<'a> { fn load(&self) -> Result { - let raw = unsafe { ffi::IMG_Load_RW(self.raw(), 0) }; + let raw = unsafe { sys::image::IMG_Load_RW(self.raw(), 0) }; to_surface_result(raw) } fn load_typed(&self, _type: &str) -> Result { let raw = unsafe { let c_type = CString::new(_type.as_bytes()).unwrap(); - ffi::IMG_LoadTyped_RW(self.raw(), 0, c_type.as_ptr() as *const _) + sys::image::IMG_LoadTyped_RW(self.raw(), 0, c_type.as_ptr() as *const _) }; to_surface_result(raw) } fn load_cur(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadCUR_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadCUR_RW(self.raw()) }; to_surface_result(raw) } fn load_ico(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadICO_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadICO_RW(self.raw()) }; to_surface_result(raw) } fn load_bmp(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadBMP_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadBMP_RW(self.raw()) }; to_surface_result(raw) } fn load_pnm(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadPNM_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadPNM_RW(self.raw()) }; to_surface_result(raw) } fn load_xpm(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadXPM_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadXPM_RW(self.raw()) }; to_surface_result(raw) } fn load_xcf(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadXCF_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadXCF_RW(self.raw()) }; to_surface_result(raw) } fn load_pcx(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadPCX_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadPCX_RW(self.raw()) }; to_surface_result(raw) } fn load_gif(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadGIF_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadGIF_RW(self.raw()) }; to_surface_result(raw) } fn load_jpg(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadJPG_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadJPG_RW(self.raw()) }; to_surface_result(raw) } fn load_tif(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadTIF_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadTIF_RW(self.raw()) }; to_surface_result(raw) } fn load_png(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadPNG_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadPNG_RW(self.raw()) }; to_surface_result(raw) } fn load_tga(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadTGA_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadTGA_RW(self.raw()) }; to_surface_result(raw) } fn load_lbm(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadLBM_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadLBM_RW(self.raw()) }; to_surface_result(raw) } fn load_xv(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadXV_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadXV_RW(self.raw()) }; to_surface_result(raw) } fn load_webp(&self) -> Result { - let raw = unsafe { ffi::IMG_LoadWEBP_RW(self.raw()) }; + let raw = unsafe { sys::image::IMG_LoadWEBP_RW(self.raw()) }; to_surface_result(raw) } fn is_cur(&self) -> bool { - unsafe { ffi::IMG_isCUR(self.raw()) == 1 } + unsafe { sys::image::IMG_isCUR(self.raw()) == 1 } } fn is_ico(&self) -> bool { - unsafe { ffi::IMG_isICO(self.raw()) == 1 } + unsafe { sys::image::IMG_isICO(self.raw()) == 1 } } fn is_bmp(&self) -> bool { - unsafe { ffi::IMG_isBMP(self.raw()) == 1 } + unsafe { sys::image::IMG_isBMP(self.raw()) == 1 } } fn is_pnm(&self) -> bool { - unsafe { ffi::IMG_isPNM(self.raw()) == 1 } + unsafe { sys::image::IMG_isPNM(self.raw()) == 1 } } fn is_xpm(&self) -> bool { - unsafe { ffi::IMG_isXPM(self.raw()) == 1 } + unsafe { sys::image::IMG_isXPM(self.raw()) == 1 } } fn is_xcf(&self) -> bool { - unsafe { ffi::IMG_isXCF(self.raw()) == 1 } + unsafe { sys::image::IMG_isXCF(self.raw()) == 1 } } fn is_pcx(&self) -> bool { - unsafe { ffi::IMG_isPCX(self.raw()) == 1 } + unsafe { sys::image::IMG_isPCX(self.raw()) == 1 } } fn is_gif(&self) -> bool { - unsafe { ffi::IMG_isGIF(self.raw()) == 1 } + unsafe { sys::image::IMG_isGIF(self.raw()) == 1 } } fn is_jpg(&self) -> bool { - unsafe { ffi::IMG_isJPG(self.raw()) == 1 } + unsafe { sys::image::IMG_isJPG(self.raw()) == 1 } } fn is_tif(&self) -> bool { - unsafe { ffi::IMG_isTIF(self.raw()) == 1 } + unsafe { sys::image::IMG_isTIF(self.raw()) == 1 } } fn is_png(&self) -> bool { - unsafe { ffi::IMG_isPNG(self.raw()) == 1 } + unsafe { sys::image::IMG_isPNG(self.raw()) == 1 } } fn is_lbm(&self) -> bool { - unsafe { ffi::IMG_isLBM(self.raw()) == 1 } + unsafe { sys::image::IMG_isLBM(self.raw()) == 1 } } fn is_xv(&self) -> bool { - unsafe { ffi::IMG_isXV(self.raw()) == 1 } + unsafe { sys::image::IMG_isXV(self.raw()) == 1 } } fn is_webp(&self) -> bool { - unsafe { ffi::IMG_isWEBP(self.raw()) == 1 } + unsafe { sys::image::IMG_isWEBP(self.raw()) == 1 } } }