From dedea94e7a2cd6550d689b9b7009518e8447eb8d Mon Sep 17 00:00:00 2001 From: Andelf Date: Tue, 15 Apr 2014 00:03:16 +0800 Subject: [PATCH] render.rs: change bool return type to Result --- src/sdl2/render.rs | 180 ++++++++++++++++++++++++++++++--------------- 1 file changed, 121 insertions(+), 59 deletions(-) diff --git a/src/sdl2/render.rs b/src/sdl2/render.rs index 59e7fa56..561e35e2 100644 --- a/src/sdl2/render.rs +++ b/src/sdl2/render.rs @@ -283,15 +283,17 @@ impl Renderer { } } - pub fn set_draw_color(&self, color: pixels::Color) -> bool { - match color { + pub fn set_draw_color(&self, color: pixels::Color) -> Result<(), ~str> { + let ret = match color { pixels::RGB(r, g, b) => { - unsafe { ll::SDL_SetRenderDrawColor(self.raw, r, g, b, 255) == 0 } + unsafe { ll::SDL_SetRenderDrawColor(self.raw, r, g, b, 255) } }, pixels::RGBA(r, g, b, a) => { - unsafe { ll::SDL_SetRenderDrawColor(self.raw, r, g, b, a) == 0 } + unsafe { ll::SDL_SetRenderDrawColor(self.raw, r, g, b, a) } } - } + }; + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_draw_color(&self) -> Result { @@ -307,8 +309,10 @@ impl Renderer { } } - pub fn clear(&self) -> bool { - unsafe { ll::SDL_RenderClear(self.raw) == 0 } + pub fn clear(&self) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderClear(self.raw) }; + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn present(&self) { @@ -350,13 +354,17 @@ impl Renderer { unsafe { ll::SDL_RenderTargetSupported(self.raw) == 1 } } - pub fn set_render_target(&self, texture: Option<&Texture>) -> bool { + pub fn set_render_target(&self, texture: Option<&Texture>) -> Result<(), ~str> { unsafe { let actual_texture = match texture { Some(texture) => cast::transmute(texture.raw), None => ptr::null() }; - ll::SDL_SetRenderTarget(self.raw, actual_texture) == 0 + if ll::SDL_SetRenderTarget(self.raw, actual_texture) == 0 { + Ok(()) + } else { + Err(get_error()) + } } } @@ -373,8 +381,11 @@ impl Renderer { } } - pub fn set_logical_size(&self, width: int, height: int) -> bool { - unsafe { ll::SDL_RenderSetLogicalSize(self.raw, width as c_int, height as c_int) == 0 } + pub fn set_logical_size(&self, width: int, height: int) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderSetLogicalSize(self.raw, width as c_int, height as c_int) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_logical_size(&self) -> (int, int) { @@ -387,8 +398,11 @@ impl Renderer { (width as int, height as int) } - pub fn set_viewport(&self, rect: &Rect) -> bool { - unsafe { ll::SDL_RenderSetViewport(self.raw, rect) == 0 } + pub fn set_viewport(&self, rect: &Rect) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderSetViewport(self.raw, rect) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_viewport(&self) -> Rect { @@ -402,8 +416,11 @@ impl Renderer { rect } - pub fn set_clip_rect(&self, rect: &Rect) -> bool { - unsafe { ll::SDL_RenderSetClipRect(self.raw, rect) == 0 } + pub fn set_clip_rect(&self, rect: &Rect) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderSetClipRect(self.raw, rect) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_clip_rect(&self) -> Rect { @@ -417,8 +434,11 @@ impl Renderer { rect } - pub fn set_scale(&self, scale_x: f64, scale_y: f64) -> bool { - unsafe { ll::SDL_RenderSetScale(self.raw, scale_x as c_float, scale_y as c_float) == 0 } + pub fn set_scale(&self, scale_x: f64, scale_y: f64) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderSetScale(self.raw, scale_x as c_float, scale_y as c_float) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_scale(&self) -> (f64, f64) { @@ -428,48 +448,72 @@ impl Renderer { (scale_x as f64, scale_y as f64) } - pub fn draw_point(&self, point: Point) -> bool { - unsafe { ll::SDL_RenderDrawPoint(self.raw, point.x, point.y) == 0 } + pub fn draw_point(&self, point: Point) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderDrawPoint(self.raw, point.x, point.y) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn draw_points(&self, points: &[Point]) -> bool { - unsafe { - ll::SDL_RenderDrawPoints(self.raw, cast::transmute(points.as_ptr()), points.len() as c_int) == 0 - } + pub fn draw_points(&self, points: &[Point]) -> Result<(), ~str> { + let ret = unsafe { + ll::SDL_RenderDrawPoints(self.raw, cast::transmute(points.as_ptr()), points.len() as c_int) + }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn draw_line(&self, start: Point, end: Point) -> bool { - unsafe { ll::SDL_RenderDrawLine(self.raw, start.x, start.y, end.x, end.y) == 0 } + pub fn draw_line(&self, start: Point, end: Point) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderDrawLine(self.raw, start.x, start.y, end.x, end.y) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn draw_lines(&self, points: &[Point]) -> bool { - unsafe { - ll::SDL_RenderDrawLines(self.raw, cast::transmute(points.as_ptr()), points.len() as c_int) == 0 - } + pub fn draw_lines(&self, points: &[Point]) -> Result<(), ~str> { + let ret = unsafe { + ll::SDL_RenderDrawLines(self.raw, cast::transmute(points.as_ptr()), points.len() as c_int) + }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn draw_rect(&self, rect: &Rect) -> bool { - unsafe { ll::SDL_RenderDrawRect(self.raw, rect) == 0 } + pub fn draw_rect(&self, rect: &Rect) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderDrawRect(self.raw, rect) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn draw_rects(&self, rects: &[Rect]) -> bool { - unsafe { - ll::SDL_RenderDrawRects(self.raw, cast::transmute(rects.as_ptr()), rects.len() as c_int) == 0 - } + pub fn draw_rects(&self, rects: &[Rect]) -> Result<(), ~str> { + let ret = unsafe { + ll::SDL_RenderDrawRects(self.raw, cast::transmute(rects.as_ptr()), rects.len() as c_int) + }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn fill_rect(&self, rect: &Rect) -> bool { - unsafe { ll::SDL_RenderFillRect(self.raw, rect) == 0 } + pub fn fill_rect(&self, rect: &Rect) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderFillRect(self.raw, rect) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn fill_rects(&self, rects: &[Rect]) -> bool { - unsafe { - ll::SDL_RenderFillRects(self.raw, cast::transmute(rects.as_ptr()), rects.len() as c_int) == 0 - } + pub fn fill_rects(&self, rects: &[Rect]) -> Result<(), ~str> { + let ret = unsafe { + ll::SDL_RenderFillRects(self.raw, cast::transmute(rects.as_ptr()), rects.len() as c_int) + }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } - pub fn copy(&self, texture: &Texture, src: Option, dst: Option) -> bool { - unsafe { + pub fn copy(&self, texture: &Texture, src: Option, dst: Option) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderCopy( self.raw, texture.raw, @@ -481,13 +525,16 @@ impl Renderer { Some(rect) => cast::transmute(&rect), None => ptr::null() } - ) == 0 - } + ) + }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } //TODO: Check whether RendererFlip is supposed to be combinable - pub fn copy_ex(&self, texture: &Texture, src: Option, dst: Option, angle: f64, center: Option, flip: RendererFlip) -> bool { - unsafe { + pub fn copy_ex(&self, texture: &Texture, src: Option, dst: Option, angle: f64, center: Option, flip: RendererFlip) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_RenderCopyEx( self.raw, texture.raw, @@ -505,8 +552,11 @@ impl Renderer { None => ptr::null() }, FromPrimitive::from_i64(flip as i64).unwrap() - ) == 0 - } + ) + }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } //TODO: Figure out how big the Pixels array is supposed to be @@ -559,8 +609,11 @@ impl Texture { } } - pub fn set_color_mod(&self, red: u8, green: u8, blue: u8) -> bool { - unsafe { ll::SDL_SetTextureColorMod(self.raw, red, green, blue) == 0 } + pub fn set_color_mod(&self, red: u8, green: u8, blue: u8) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_SetTextureColorMod(self.raw, red, green, blue) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_color_mod(&self) -> Result<(u8, u8, u8), ~str> { @@ -576,8 +629,11 @@ impl Texture { } } - pub fn set_alpha_mod(&self, alpha: u8) -> bool { - unsafe { ll::SDL_SetTextureAlphaMod(self.raw, alpha) == 0 } + pub fn set_alpha_mod(&self, alpha: u8) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_SetTextureAlphaMod(self.raw, alpha) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_alpha_mod(&self) -> Result { @@ -591,8 +647,11 @@ impl Texture { } } - pub fn set_blend_mode(&self, blend: BlendMode) -> bool { - unsafe { ll::SDL_SetTextureBlendMode(self.raw, FromPrimitive::from_i64(blend as i64).unwrap()) == 0} + pub fn set_blend_mode(&self, blend: BlendMode) -> Result<(), ~str> { + let ret = unsafe { ll::SDL_SetTextureBlendMode(self.raw, FromPrimitive::from_i64(blend as i64).unwrap()) }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } pub fn get_blend_mode(&self) -> Result { @@ -605,15 +664,18 @@ impl Texture { } } - pub fn update(&self, rect: Option, pixel_data: &[u8], pitch: int) -> bool { - unsafe { + pub fn update(&self, rect: Option, pixel_data: &[u8], pitch: int) -> Result<(), ~str> { + let ret = unsafe { let actual_rect = match rect { Some(rect) => cast::transmute(&rect), None => ptr::null() }; - ll::SDL_UpdateTexture(self.raw, actual_rect, cast::transmute(pixel_data.as_ptr()), pitch as c_int) == 0 - } + ll::SDL_UpdateTexture(self.raw, actual_rect, cast::transmute(pixel_data.as_ptr()), pitch as c_int) + }; + + if ret == 0 { Ok(()) } + else { Err(get_error()) } } //TODO: Figure out how big pixels ends up