From 88e56efc120b3eb104fd2d653e88d4d50ba8e454 Mon Sep 17 00:00:00 2001 From: Andelf Date: Mon, 19 May 2014 22:38:04 +0800 Subject: [PATCH 1/3] fix build error: change from_bits to from_bits_truncate, avoid Option<> wrapper --- src/sdl2_image/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/sdl2_image/lib.rs b/src/sdl2_image/lib.rs index 2a31b1ec..b4805924 100644 --- a/src/sdl2_image/lib.rs +++ b/src/sdl2_image/lib.rs @@ -145,7 +145,7 @@ pub fn init(flags: InitFlag) -> InitFlag { //! InitFlags were actually used. unsafe { let used = ffi::IMG_Init(flags.bits() as c_int); - InitFlag::from_bits(used as u32) + InitFlag::from_bits_truncate(used as u32) } } From f3942e608060ee374c2c7cc93732ab4f99590995 Mon Sep 17 00:00:00 2001 From: Andelf Date: Mon, 26 May 2014 11:35:45 +0800 Subject: [PATCH 2/3] fix compile error: StrBuf change --- src/sdl2_image/lib.rs | 97 ++++++++++++++++++++++--------------------- 1 file changed, 50 insertions(+), 47 deletions(-) diff --git a/src/sdl2_image/lib.rs b/src/sdl2_image/lib.rs index b4805924..81baa46d 100644 --- a/src/sdl2_image/lib.rs +++ b/src/sdl2_image/lib.rs @@ -19,6 +19,9 @@ use sdl2::rwops::RWops; use sdl2::version::Version; use sdl2::get_error; +// FIXME: this should be done in rust-sdl2 +pub type SdlResult = Result; + // Setup linking for all targets. #[cfg(target_os="macos")] mod mac { @@ -55,19 +58,19 @@ bitflags!(flags InitFlag : u32 { pub trait LoadSurface { // Self is only returned here to type hint to the compiler. // The syntax for type hinting in this case is not yet defined. - // The intended return value is Result<~Surface, ~str>. - fn from_file(filename: &Path) -> Result; - fn from_xpm_array(xpm: **i8) -> Result; + // The intended return value is SdlResult<~Surface>. + fn from_file(filename: &Path) -> SdlResult; + fn from_xpm_array(xpm: **i8) -> SdlResult; } /// Method extensions to Surface for saving to disk pub trait SaveSurface { - fn save(&self, filename: &Path) -> Result<(), ~str>; - fn save_rw(&self, dst: &mut RWops) -> Result<(), ~str>; + fn save(&self, filename: &Path) -> SdlResult<()>; + fn save_rw(&self, dst: &mut RWops) -> SdlResult<()>; } impl LoadSurface for Surface { - fn from_file(filename: &Path) -> Result { + fn from_file(filename: &Path) -> SdlResult { //! Loads an SDL Surface from a file unsafe { let raw = ffi::IMG_Load(filename.to_c_str().unwrap()); @@ -79,7 +82,7 @@ impl LoadSurface for Surface { } } - fn from_xpm_array(xpm: **i8) -> Result { + fn from_xpm_array(xpm: **i8) -> SdlResult { //! Loads an SDL Surface from XPM data unsafe { let raw = ffi::IMG_ReadXPMFromArray(xpm as **c_char); @@ -93,7 +96,7 @@ impl LoadSurface for Surface { } impl SaveSurface for Surface { - fn save(&self, filename: &Path) -> Result<(), ~str> { + fn save(&self, filename: &Path) -> SdlResult<()> { //! Saves an SDL Surface to a file unsafe { let status = ffi::IMG_SavePNG(self.raw, @@ -106,7 +109,7 @@ impl SaveSurface for Surface { } } - fn save_rw(&self, dst: &mut RWops) -> Result<(), ~str> { + fn save_rw(&self, dst: &mut RWops) -> SdlResult<()> { //! Saves an SDL Surface to an RWops unsafe { let status = ffi::IMG_SavePNG_RW(self.raw, dst.raw, 0); @@ -122,11 +125,11 @@ impl SaveSurface for Surface { /// Method extensions for creating Textures from a Renderer pub trait LoadTexture { - fn load_texture(&self, filename: &Path) -> Result; + fn load_texture(&self, filename: &Path) -> SdlResult; } -impl LoadTexture for Renderer { - fn load_texture(&self, filename: &Path) -> Result { +impl LoadTexture for Renderer { + fn load_texture(&self, filename: &Path) -> SdlResult { //! Loads an SDL Texture from a file unsafe { let raw = ffi::IMG_LoadTexture(self.raw, @@ -162,7 +165,7 @@ pub fn get_linked_version() -> Version { } #[inline] -fn to_surface_result(raw: *sdl2::surface::ll::SDL_Surface) -> Result { +fn to_surface_result(raw: *sdl2::surface::ll::SDL_Surface) -> SdlResult { if raw == ptr::null() { Err(get_error()) } else { @@ -172,25 +175,25 @@ fn to_surface_result(raw: *sdl2::surface::ll::SDL_Surface) -> Result Result; + fn load(&self) -> SdlResult; /// load as a surface. This can load all supported image formats. - fn load_typed(&self, _type: &str) -> Result; + fn load_typed(&self, _type: &str) -> SdlResult; - fn load_cur(&self) -> Result; - fn load_ico(&self) -> Result; - fn load_bmp(&self) -> Result; - fn load_pnm(&self) -> Result; - fn load_xpm(&self) -> Result; - fn load_xcf(&self) -> Result; - fn load_pcx(&self) -> Result; - fn load_gif(&self) -> Result; - fn load_jpg(&self) -> Result; - fn load_tif(&self) -> Result; - fn load_png(&self) -> Result; - fn load_tga(&self) -> Result; - fn load_lbm(&self) -> Result; - fn load_xv(&self) -> Result; - fn load_webp(&self) -> Result; + fn load_cur(&self) -> SdlResult; + fn load_ico(&self) -> SdlResult; + fn load_bmp(&self) -> SdlResult; + fn load_pnm(&self) -> SdlResult; + fn load_xpm(&self) -> SdlResult; + fn load_xcf(&self) -> SdlResult; + fn load_pcx(&self) -> SdlResult; + fn load_gif(&self) -> SdlResult; + fn load_jpg(&self) -> SdlResult; + fn load_tif(&self) -> SdlResult; + fn load_png(&self) -> SdlResult; + fn load_tga(&self) -> SdlResult; + fn load_lbm(&self) -> SdlResult; + fn load_xv(&self) -> SdlResult; + fn load_webp(&self) -> SdlResult; fn is_cur(&self) -> bool; fn is_ico(&self) -> bool; @@ -209,76 +212,76 @@ pub trait ImageRWops { } impl ImageRWops for RWops { - fn load(&self) -> Result { + fn load(&self) -> SdlResult { let raw = unsafe { ffi::IMG_Load_RW(self.raw, 0) }; to_surface_result(raw) } - fn load_typed(&self, _type: &str) -> Result { + fn load_typed(&self, _type: &str) -> SdlResult { let raw = unsafe { ffi::IMG_LoadTyped_RW(self.raw, 0, _type.to_c_str().unwrap()) }; to_surface_result(raw) } - fn load_cur(&self) -> Result { + fn load_cur(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadCUR_RW(self.raw) }; to_surface_result(raw) } - fn load_ico(&self) -> Result { + fn load_ico(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadICO_RW(self.raw) }; to_surface_result(raw) } - fn load_bmp(&self) -> Result { + fn load_bmp(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadBMP_RW(self.raw) }; to_surface_result(raw) } - fn load_pnm(&self) -> Result { + fn load_pnm(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadPNM_RW(self.raw) }; to_surface_result(raw) } - fn load_xpm(&self) -> Result { + fn load_xpm(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadXPM_RW(self.raw) }; to_surface_result(raw) } - fn load_xcf(&self) -> Result { + fn load_xcf(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadXCF_RW(self.raw) }; to_surface_result(raw) } - fn load_pcx(&self) -> Result { + fn load_pcx(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadPCX_RW(self.raw) }; to_surface_result(raw) } - fn load_gif(&self) -> Result { + fn load_gif(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadGIF_RW(self.raw) }; to_surface_result(raw) } - fn load_jpg(&self) -> Result { + fn load_jpg(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadJPG_RW(self.raw) }; to_surface_result(raw) } - fn load_tif(&self) -> Result { + fn load_tif(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadTIF_RW(self.raw) }; to_surface_result(raw) } - fn load_png(&self) -> Result { + fn load_png(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadPNG_RW(self.raw) }; to_surface_result(raw) } - fn load_tga(&self) -> Result { + fn load_tga(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadTGA_RW(self.raw) }; to_surface_result(raw) } - fn load_lbm(&self) -> Result { + fn load_lbm(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadLBM_RW(self.raw) }; to_surface_result(raw) } - fn load_xv(&self) -> Result { + fn load_xv(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadXV_RW(self.raw) }; to_surface_result(raw) } - fn load_webp(&self) -> Result { + fn load_webp(&self) -> SdlResult { let raw = unsafe { ffi::IMG_LoadWEBP_RW(self.raw) }; to_surface_result(raw) } From 43f1f2ed1a7f9cb4ae09a3d080856857a76caaf1 Mon Sep 17 00:00:00 2001 From: Andelf Date: Sat, 31 May 2014 17:36:45 +0800 Subject: [PATCH 3/3] fix compile error: string change, raw accessor change --- src/demo/main.rs | 2 +- src/sdl2_image/lib.rs | 78 +++++++++++++++++++++---------------------- 2 files changed, 39 insertions(+), 41 deletions(-) diff --git a/src/demo/main.rs b/src/demo/main.rs index 8ff5fa81..75e2364e 100644 --- a/src/demo/main.rs +++ b/src/demo/main.rs @@ -19,6 +19,6 @@ fn main() { if args.len() < 2 { println!("Usage: ./demo image.[png|jpg]") } else { - video::main(&Path::new(args.get(1).to_owned())); + video::main(&Path::new(args.get(1).to_string())); } } diff --git a/src/sdl2_image/lib.rs b/src/sdl2_image/lib.rs index 81baa46d..402da7d4 100644 --- a/src/sdl2_image/lib.rs +++ b/src/sdl2_image/lib.rs @@ -18,9 +18,7 @@ use sdl2::render::Renderer; use sdl2::rwops::RWops; use sdl2::version::Version; use sdl2::get_error; - -// FIXME: this should be done in rust-sdl2 -pub type SdlResult = Result; +use sdl2::SdlResult; // Setup linking for all targets. #[cfg(target_os="macos")] @@ -77,7 +75,7 @@ impl LoadSurface for Surface { if raw == ptr::null() { Err(get_error()) } else { - Ok(Surface { raw: raw, owned: true }) + Ok(Surface::from_ll(raw, true)) } } } @@ -89,7 +87,7 @@ impl LoadSurface for Surface { if raw == ptr::null() { Err(get_error()) } else { - Ok(Surface { raw: raw, owned: true }) + Ok(Surface::from_ll(raw, true)) } } } @@ -99,7 +97,7 @@ impl SaveSurface for Surface { fn save(&self, filename: &Path) -> SdlResult<()> { //! Saves an SDL Surface to a file unsafe { - let status = ffi::IMG_SavePNG(self.raw, + let status = ffi::IMG_SavePNG(self.raw(), filename.to_c_str().unwrap()); if status != 0 { Err(get_error()) @@ -112,7 +110,7 @@ impl SaveSurface for Surface { fn save_rw(&self, dst: &mut RWops) -> SdlResult<()> { //! Saves an SDL Surface to an RWops unsafe { - let status = ffi::IMG_SavePNG_RW(self.raw, dst.raw, 0); + let status = ffi::IMG_SavePNG_RW(self.raw(), dst.raw(), 0); if status != 0 { Err(get_error()) @@ -132,7 +130,7 @@ impl LoadTexture for Renderer { fn load_texture(&self, filename: &Path) -> SdlResult { //! Loads an SDL Texture from a file unsafe { - let raw = ffi::IMG_LoadTexture(self.raw, + let raw = ffi::IMG_LoadTexture(self.raw(), filename.to_c_str().unwrap()); if raw == ptr::null() { Err(get_error()) @@ -169,7 +167,7 @@ fn to_surface_result(raw: *sdl2::surface::ll::SDL_Surface) -> SdlResult if raw == ptr::null() { Err(get_error()) } else { - Ok(Surface { raw: raw, owned: true }) + unsafe { Ok(Surface::from_ll(raw, true)) } } } @@ -214,118 +212,118 @@ pub trait ImageRWops { impl ImageRWops for RWops { fn load(&self) -> SdlResult { let raw = unsafe { - ffi::IMG_Load_RW(self.raw, 0) + ffi::IMG_Load_RW(self.raw(), 0) }; to_surface_result(raw) } fn load_typed(&self, _type: &str) -> SdlResult { let raw = unsafe { - ffi::IMG_LoadTyped_RW(self.raw, 0, _type.to_c_str().unwrap()) + ffi::IMG_LoadTyped_RW(self.raw(), 0, _type.to_c_str().unwrap()) }; to_surface_result(raw) } fn load_cur(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadCUR_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadCUR_RW(self.raw()) }; to_surface_result(raw) } fn load_ico(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadICO_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadICO_RW(self.raw()) }; to_surface_result(raw) } fn load_bmp(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadBMP_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadBMP_RW(self.raw()) }; to_surface_result(raw) } fn load_pnm(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadPNM_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadPNM_RW(self.raw()) }; to_surface_result(raw) } fn load_xpm(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadXPM_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadXPM_RW(self.raw()) }; to_surface_result(raw) } fn load_xcf(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadXCF_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadXCF_RW(self.raw()) }; to_surface_result(raw) } fn load_pcx(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadPCX_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadPCX_RW(self.raw()) }; to_surface_result(raw) } fn load_gif(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadGIF_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadGIF_RW(self.raw()) }; to_surface_result(raw) } fn load_jpg(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadJPG_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadJPG_RW(self.raw()) }; to_surface_result(raw) } fn load_tif(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadTIF_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadTIF_RW(self.raw()) }; to_surface_result(raw) } fn load_png(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadPNG_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadPNG_RW(self.raw()) }; to_surface_result(raw) } fn load_tga(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadTGA_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadTGA_RW(self.raw()) }; to_surface_result(raw) } fn load_lbm(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadLBM_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadLBM_RW(self.raw()) }; to_surface_result(raw) } fn load_xv(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadXV_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadXV_RW(self.raw()) }; to_surface_result(raw) } fn load_webp(&self) -> SdlResult { - let raw = unsafe { ffi::IMG_LoadWEBP_RW(self.raw) }; + let raw = unsafe { ffi::IMG_LoadWEBP_RW(self.raw()) }; to_surface_result(raw) } fn is_cur(&self) -> bool { - unsafe { ffi::IMG_isCUR(self.raw) == 1 } + unsafe { ffi::IMG_isCUR(self.raw()) == 1 } } fn is_ico(&self) -> bool { - unsafe { ffi::IMG_isICO(self.raw) == 1 } + unsafe { ffi::IMG_isICO(self.raw()) == 1 } } fn is_bmp(&self) -> bool { - unsafe { ffi::IMG_isBMP(self.raw) == 1 } + unsafe { ffi::IMG_isBMP(self.raw()) == 1 } } fn is_pnm(&self) -> bool { - unsafe { ffi::IMG_isPNM(self.raw) == 1 } + unsafe { ffi::IMG_isPNM(self.raw()) == 1 } } fn is_xpm(&self) -> bool { - unsafe { ffi::IMG_isXPM(self.raw) == 1 } + unsafe { ffi::IMG_isXPM(self.raw()) == 1 } } fn is_xcf(&self) -> bool { - unsafe { ffi::IMG_isXCF(self.raw) == 1 } + unsafe { ffi::IMG_isXCF(self.raw()) == 1 } } fn is_pcx(&self) -> bool { - unsafe { ffi::IMG_isPCX(self.raw) == 1 } + unsafe { ffi::IMG_isPCX(self.raw()) == 1 } } fn is_gif(&self) -> bool { - unsafe { ffi::IMG_isGIF(self.raw) == 1 } + unsafe { ffi::IMG_isGIF(self.raw()) == 1 } } fn is_jpg(&self) -> bool { - unsafe { ffi::IMG_isJPG(self.raw) == 1 } + unsafe { ffi::IMG_isJPG(self.raw()) == 1 } } fn is_tif(&self) -> bool { - unsafe { ffi::IMG_isTIF(self.raw) == 1 } + unsafe { ffi::IMG_isTIF(self.raw()) == 1 } } fn is_png(&self) -> bool { - unsafe { ffi::IMG_isPNG(self.raw) == 1 } + unsafe { ffi::IMG_isPNG(self.raw()) == 1 } } fn is_lbm(&self) -> bool { - unsafe { ffi::IMG_isLBM(self.raw) == 1 } + unsafe { ffi::IMG_isLBM(self.raw()) == 1 } } fn is_xv(&self) -> bool { - unsafe { ffi::IMG_isXV(self.raw) == 1 } + unsafe { ffi::IMG_isXV(self.raw()) == 1 } } fn is_webp(&self) -> bool { - unsafe { ffi::IMG_isWEBP(self.raw) == 1 } + unsafe { ffi::IMG_isWEBP(self.raw()) == 1 } } }