diff --git a/sdl2-sys/src/render.rs b/sdl2-sys/src/render.rs index 589dde0201e..91bf93efc55 100644 --- a/sdl2-sys/src/render.rs +++ b/sdl2-sys/src/render.rs @@ -52,7 +52,7 @@ pub struct SDL_Renderer; pub struct SDL_Texture; //SDL_blendmode.h -pub type SDL_BlendMode = c_uint; +pub type SDL_BlendMode = c_int; pub const SDL_BLENDMODE_NONE : SDL_BlendMode = 0x00000000; pub const SDL_BLENDMODE_BLEND : SDL_BlendMode = 0x00000001; pub const SDL_BLENDMODE_ADD : SDL_BlendMode = 0x00000002; diff --git a/src/sdl2/audio.rs b/src/sdl2/audio.rs index f198e84f999..6febded4640 100644 --- a/src/sdl2/audio.rs +++ b/src/sdl2/audio.rs @@ -40,22 +40,22 @@ pub enum AudioStatus { Paused = ll::SDL_AUDIO_PAUSED as isize, } -pub fn get_num_audio_drivers() -> isize { - unsafe { ll::SDL_GetNumAudioDrivers() as isize } +pub fn get_num_audio_drivers() -> i32 { + unsafe { ll::SDL_GetNumAudioDrivers() as i32 } } -pub fn get_audio_driver(index: isize) -> String { +pub fn get_audio_driver(index: i32) -> String { unsafe { let driver = ll::SDL_GetAudioDriver(index as c_int); String::from_utf8_lossy(c_str_to_bytes(&driver)).to_string() } } -pub fn get_num_audio_devices(iscapture: isize) -> isize { - unsafe { ll::SDL_GetNumAudioDevices(iscapture as c_int) as isize } +pub fn get_num_audio_devices(iscapture: i32) -> i32 { + unsafe { ll::SDL_GetNumAudioDevices(iscapture as c_int) as i32 } } -pub fn get_audio_device_name(index: isize, iscapture: isize) -> String { +pub fn get_audio_device_name(index: i32, iscapture: i32) -> String { unsafe { let dev_name = ll::SDL_GetAudioDeviceName(index as c_int, iscapture as c_int); String::from_utf8_lossy(c_str_to_bytes(&dev_name)).to_string() @@ -345,7 +345,7 @@ impl AudioDevice { pub fn get_status(&self) -> AudioStatus { unsafe { let status = ll::SDL_GetAudioDeviceStatus(self.device_id.id()); - FromPrimitive::from_int(status as isize).unwrap() + FromPrimitive::from_i32(status as i32).unwrap() } } diff --git a/src/sdl2/event.rs b/src/sdl2/event.rs index 7045d8f0d5a..dddbba047a5 100644 --- a/src/sdl2/event.rs +++ b/src/sdl2/event.rs @@ -648,7 +648,7 @@ pub fn wait_event() -> SdlResult { } /// Wait until the specified timeout (in milliseconds) for the next available event. -pub fn wait_event_timeout(timeout: isize) -> SdlResult { +pub fn wait_event_timeout(timeout: i32) -> SdlResult { let raw = null_event(); let success = unsafe { ll::SDL_WaitEventTimeout(&raw, timeout as c_int) == 1 as c_int }; @@ -700,12 +700,12 @@ pub fn get_event_state(_type: EventType) -> bool { } /// allocate a set of user-defined events, and return the beginning event number for that set of events -pub fn register_events(num: isize) -> Option { - let ret = unsafe { ll::SDL_RegisterEvents(num as c_int) }; +pub fn register_events(num_events: i32) -> Option { + let ret = unsafe { ll::SDL_RegisterEvents(num_events as c_int) }; if ret == (-1 as uint32_t) { None } else { - Some(ret as usize) + Some(ret as u32) } } diff --git a/src/sdl2/mouse.rs b/src/sdl2/mouse.rs index 75e4267c746..d9fe54d75d4 100644 --- a/src/sdl2/mouse.rs +++ b/src/sdl2/mouse.rs @@ -41,7 +41,7 @@ impl Drop for Cursor { } impl Cursor { - pub fn new(data: &[u8], mask: &[u8], width: isize, height: isize, hot_x: isize, hot_y: isize) -> SdlResult { + pub fn new(data: &[u8], mask: &[u8], width: i32, height: i32, hot_x: i32, hot_y: i32) -> SdlResult { unsafe { let raw = ll::SDL_CreateCursor(data.as_ptr(), mask.as_ptr(), @@ -57,10 +57,9 @@ impl Cursor { } // TODO: figure out how to pass Surface in here correctly - pub fn from_surface(surface: &surface::Surface, hot_x: isize, hot_y: isize) -> SdlResult { + pub fn from_surface(surface: &surface::Surface, hot_x: i32, hot_y: i32) -> SdlResult { unsafe { - let raw = ll::SDL_CreateColorCursor(surface.raw(), hot_x as i32, - hot_y as i32); + let raw = ll::SDL_CreateColorCursor(surface.raw(), hot_x, hot_y); if raw == ptr::null() { Err(get_error()) @@ -127,21 +126,21 @@ pub fn get_mouse_focus() -> Option { } } -pub fn get_mouse_state() -> (MouseState, isize, isize) { +pub fn get_mouse_state() -> (MouseState, i32, i32) { let x = 0; let y = 0; unsafe { let raw = ll::SDL_GetMouseState(&x, &y); - return (MouseState::from_bits(raw).unwrap(), x as isize, y as isize); + return (MouseState::from_bits(raw).unwrap(), x as i32, y as i32); } } -pub fn get_relative_mouse_state() -> (MouseState, isize, isize) { +pub fn get_relative_mouse_state() -> (MouseState, i32, i32) { let x = 0; let y = 0; unsafe { let raw = ll::SDL_GetRelativeMouseState(&x, &y); - return (MouseState::from_bits(raw).unwrap(), x as isize, y as isize); + return (MouseState::from_bits(raw).unwrap(), x as i32, y as i32); } } diff --git a/src/sdl2/render.rs b/src/sdl2/render.rs index c9a5a7809e2..636380262e6 100644 --- a/src/sdl2/render.rs +++ b/src/sdl2/render.rs @@ -21,7 +21,7 @@ pub use sys::render as ll; #[derive(Copy, Clone)] pub enum RenderDriverIndex { Auto, - Index(isize) + Index(i32) } #[derive(Copy, Clone, PartialEq, FromPrimitive)] @@ -45,8 +45,8 @@ pub struct RendererInfo { pub name: String, pub flags: RendererFlags, pub texture_formats: Vec, - pub max_texture_width: isize, - pub max_texture_height: isize + pub max_texture_width: i32, + pub max_texture_height: i32 } #[derive(Copy, Clone, PartialEq, FromPrimitive)] @@ -77,8 +77,8 @@ impl RendererInfo { name: String::from_utf8_lossy(c_str_to_bytes(&info.name)).to_string(), flags: actual_flags, texture_formats: texture_formats, - max_texture_width: info.max_texture_width as isize, - max_texture_height: info.max_texture_height as isize + max_texture_width: info.max_texture_width as i32, + max_texture_height: info.max_texture_height as i32 } } } @@ -125,7 +125,7 @@ impl Renderer { } } - pub fn new_with_window(width: isize, height: isize, window_flags: video::WindowFlags) -> SdlResult { + pub fn new_with_window(width: i32, height: i32, window_flags: video::WindowFlags) -> SdlResult { let raw_window: *const video::ll::SDL_Window = ptr::null(); let raw_renderer: *const ll::SDL_Renderer = ptr::null(); let result = unsafe { ll::SDL_CreateWindowAndRenderer(width as c_int, height as c_int, window_flags.bits(), &raw_window, &raw_renderer) == 0}; @@ -205,20 +205,20 @@ impl Renderer { unsafe { ll::SDL_RenderPresent(self.raw) } } - pub fn get_output_size(&self) -> SdlResult<(isize, isize)> { + pub fn get_output_size(&self) -> SdlResult<(i32, i32)> { let width: c_int = 0; let height: c_int = 0; let result = unsafe { ll::SDL_GetRendererOutputSize(self.raw, &width, &height) == 0 }; if result { - Ok((width as isize, height as isize)) + Ok((width as i32, height as i32)) } else { Err(get_error()) } } - pub fn create_texture(&self, format: pixels::PixelFormatFlag, access: TextureAccess, width: isize, height: isize) -> SdlResult { + pub fn create_texture(&self, format: pixels::PixelFormatFlag, access: TextureAccess, width: i32, height: i32) -> SdlResult { let result = unsafe { ll::SDL_CreateTexture(self.raw, format as uint32_t, access as c_int, width as c_int, height as c_int) }; if result == ptr::null() { Err(get_error()) @@ -267,21 +267,21 @@ impl Renderer { } } - pub fn set_logical_size(&self, width: isize, height: isize) -> SdlResult<()> { + pub fn set_logical_size(&self, width: i32, height: i32) -> SdlResult<()> { 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) -> (isize, isize) { + pub fn get_logical_size(&self) -> (i32, i32) { let width: c_int = 0; let height: c_int = 0; unsafe { ll::SDL_RenderGetLogicalSize(self.raw, &width, &height) }; - (width as isize, height as isize) + (width as i32, height as i32) } pub fn set_viewport(&self, rect: Option) -> SdlResult<()> { @@ -492,8 +492,8 @@ impl Renderer { pub struct TextureQuery { pub format: pixels::PixelFormatFlag, pub access: TextureAccess, - pub width: isize, - pub height: isize + pub width: i32, + pub height: i32 } #[derive(PartialEq)] #[allow(raw_pointer_derive)] @@ -525,8 +525,8 @@ impl Texture { Ok(TextureQuery { format: FromPrimitive::from_i64(format as i64).unwrap(), access: FromPrimitive::from_i64(access as i64).unwrap(), - width: width as isize, - height: height as isize + width: width as i32, + height: height as i32 }) } else { Err(get_error()) @@ -588,7 +588,7 @@ impl Texture { } } - pub fn update(&self, rect: Option, pixel_data: &[u8], pitch: isize) -> SdlResult<()> { + pub fn update(&self, rect: Option, pixel_data: &[u8], pitch: i32) -> SdlResult<()> { let ret = unsafe { let actual_rect = match rect { Some(ref rect) => rect as *const _, @@ -669,16 +669,16 @@ impl Texture { } -pub fn get_num_render_drivers() -> SdlResult { +pub fn get_num_render_drivers() -> SdlResult { let result = unsafe { ll::SDL_GetNumRenderDrivers() }; if result > 0 { - Ok(result as isize) + Ok(result as i32) } else { Err(get_error()) } } -pub fn get_render_driver_info(index: isize) -> SdlResult { +pub fn get_render_driver_info(index: i32) -> SdlResult { let out = ll::SDL_RendererInfo { name: ptr::null(), flags: 0, diff --git a/src/sdl2/surface.rs b/src/sdl2/surface.rs index bbea942dc98..8e650422122 100644 --- a/src/sdl2/surface.rs +++ b/src/sdl2/surface.rs @@ -42,7 +42,7 @@ impl_owned_accessors!((Surface, owned)); impl_raw_constructor!((Surface, Surface (raw: *const ll::SDL_Surface, owned: bool))); impl Surface { - pub fn new(surface_flags: SurfaceFlag, width: isize, height: isize, bpp: isize, + pub fn new(surface_flags: SurfaceFlag, width: i32, height: i32, bpp: i32, rmask: u32, gmask: u32, bmask: u32, amask: u32) -> SdlResult { unsafe { let raw = ll::SDL_CreateRGBSurface(surface_flags.bits(), width as c_int, height as c_int, bpp as c_int, @@ -56,7 +56,7 @@ impl Surface { } } - pub fn from_data(data: &mut [u8], width: isize, height: isize, bpp: isize, pitch: isize, + pub fn from_data(data: &mut [u8], width: i32, height: i32, bpp: i32, pitch: i32, rmask: u32, gmask: u32, bmask: u32, amask: u32) -> SdlResult { unsafe { @@ -72,19 +72,19 @@ impl Surface { } } - pub fn get_width(&self) -> isize { - unsafe { (*self.raw).w as isize } + pub fn get_width(&self) -> i32 { + unsafe { (*self.raw).w as i32 } } - pub fn get_height(&self) -> isize { - unsafe { (*self.raw).h as isize } + pub fn get_height(&self) -> i32 { + unsafe { (*self.raw).h as i32 } } - pub fn get_pitch(&self) -> isize { - unsafe { (*self.raw).pitch as isize } + pub fn get_pitch(&self) -> i32 { + unsafe { (*self.raw).pitch as i32 } } - pub fn get_size(&self) -> (isize, isize) { + pub fn get_size(&self) -> (i32, i32) { (self.get_width(), self.get_height()) } @@ -271,7 +271,7 @@ impl Surface { pub fn set_blend_mode(&mut self, mode: BlendMode) -> SdlResult<()> { let result = unsafe { - ll::SDL_SetSurfaceBlendMode(self.raw, FromPrimitive::from_int(mode as isize).unwrap()) + ll::SDL_SetSurfaceBlendMode(self.raw, mode as c_int) }; match result { @@ -281,13 +281,13 @@ impl Surface { } pub fn get_blend_mode(&self) -> SdlResult { - let mode: ll::SDL_BlendMode = FromPrimitive::from_int(0).unwrap(); + let mode: ll::SDL_BlendMode = 0; let result = unsafe { ll::SDL_GetSurfaceBlendMode(self.raw, &mode) }; match result { - 0 => Ok(FromPrimitive::from_int(mode as isize).unwrap()), + 0 => Ok(FromPrimitive::from_i32(mode as i32).unwrap()), _ => Err(get_error()) } } diff --git a/src/sdl2/video.rs b/src/sdl2/video.rs index 6f575685923..ee3479c41be 100644 --- a/src/sdl2/video.rs +++ b/src/sdl2/video.rs @@ -63,14 +63,14 @@ fn empty_sdl_display_mode() -> ll::SDL_DisplayMode { #[derive(Clone, PartialEq)] pub struct DisplayMode { pub format: u32, - pub w: isize, - pub h: isize, - pub refresh_rate: isize + pub w: i32, + pub h: i32, + pub refresh_rate: i32 } impl DisplayMode { - pub fn new(format: u32, w: isize, h: isize, refresh_rate: isize) -> DisplayMode { + pub fn new(format: u32, w: i32, h: i32, refresh_rate: i32) -> DisplayMode { DisplayMode { format: format, w: w, @@ -82,9 +82,9 @@ impl DisplayMode { pub fn from_ll(raw: &ll::SDL_DisplayMode) -> DisplayMode { DisplayMode::new( raw.format as u32, - raw.w as isize, - raw.h as isize, - raw.refresh_rate as isize + raw.w as i32, + raw.h as i32, + raw.refresh_rate as i32 ) } @@ -129,7 +129,7 @@ pub enum FullscreenType { pub enum WindowPos { PosUndefined, PosCentered, - Positioned(isize) + Positioned(i32) } fn unwrap_windowpos (pos: WindowPos) -> ll::SDL_WindowPos { @@ -188,7 +188,7 @@ impl Drop for Window { } impl Window { - pub fn new(title: &str, x: WindowPos, y: WindowPos, width: isize, height: isize, window_flags: WindowFlags) -> SdlResult { + pub fn new(title: &str, x: WindowPos, y: WindowPos, width: i32, height: i32, window_flags: WindowFlags) -> SdlResult { unsafe { let buff = CString::from_slice(title.as_bytes()).as_ptr(); let raw = ll::SDL_CreateWindow( @@ -217,12 +217,12 @@ impl Window { } } - pub fn get_display_index(&self) -> SdlResult { + pub fn get_display_index(&self) -> SdlResult { let result = unsafe { ll::SDL_GetWindowDisplayIndex(self.raw) }; if result < 0 { return Err(get_error()) } else { - Ok(result as isize) + Ok(result as i32) } } @@ -293,51 +293,51 @@ impl Window { unsafe { ll::SDL_SetWindowPosition(self.raw, unwrap_windowpos(x), unwrap_windowpos(y)) } } - pub fn get_position(&self) -> (isize, isize) { + pub fn get_position(&self) -> (i32, i32) { let x: c_int = 0; let y: c_int = 0; unsafe { ll::SDL_GetWindowPosition(self.raw, &x, &y) }; - (x as isize, y as isize) + (x as i32, y as i32) } - pub fn set_size(&self, w: isize, h: isize) { + pub fn set_size(&self, w: i32, h: i32) { unsafe { ll::SDL_SetWindowSize(self.raw, w as c_int, h as c_int) } } - pub fn get_size(&self) -> (isize, isize) { + pub fn get_size(&self) -> (i32, i32) { let w: c_int = 0; let h: c_int = 0; unsafe { ll::SDL_GetWindowSize(self.raw, &w, &h) }; - (w as isize, h as isize) + (w as i32, h as i32) } - pub fn get_drawable_size(&self) -> (isize, isize) { + pub fn get_drawable_size(&self) -> (i32, i32) { let w: c_int = 0; let h: c_int = 0; unsafe { ll::SDL_GL_GetDrawableSize(self.raw, &w, &h) }; - (w as isize, h as isize) + (w as i32, h as i32) } - pub fn set_minimum_size(&self, w: isize, h: isize) { + pub fn set_minimum_size(&self, w: i32, h: i32) { unsafe { ll::SDL_SetWindowMinimumSize(self.raw, w as c_int, h as c_int) } } - pub fn get_minimum_size(&self) -> (isize, isize) { + pub fn get_minimum_size(&self) -> (i32, i32) { let w: c_int = 0; let h: c_int = 0; unsafe { ll::SDL_GetWindowMinimumSize(self.raw, &w, &h) }; - (w as isize, h as isize) + (w as i32, h as i32) } - pub fn set_maximum_size(&self, w: isize, h: isize) { + pub fn set_maximum_size(&self, w: i32, h: i32) { unsafe { ll::SDL_SetWindowMaximumSize(self.raw, w as c_int, h as c_int) } } - pub fn get_maximum_size(&self) -> (isize, isize) { + pub fn get_maximum_size(&self) -> (i32, i32) { let w: c_int = 0; let h: c_int = 0; unsafe { ll::SDL_GetWindowMaximumSize(self.raw, &w, &h) }; - (w as isize, h as isize) + (w as i32, h as i32) } pub fn set_bordered(&self, bordered: bool) { @@ -454,16 +454,16 @@ impl Window { } } -pub fn get_num_video_drivers() -> SdlResult { +pub fn get_num_video_drivers() -> SdlResult { let result = unsafe { ll::SDL_GetNumVideoDrivers() }; if result < 0 { Err(get_error()) } else { - Ok(result as isize) + Ok(result as i32) } } -pub fn get_video_driver(id: isize) -> String { +pub fn get_video_driver(id: i32) -> String { unsafe { let buf = ll::SDL_GetVideoDriver(id as c_int); String::from_utf8_lossy(c_str_to_bytes(&buf)).to_string() @@ -486,23 +486,23 @@ pub fn get_current_video_driver() -> String { } } -pub fn get_num_video_displays() -> SdlResult { +pub fn get_num_video_displays() -> SdlResult { let result = unsafe { ll::SDL_GetNumVideoDisplays() }; if result < 0 { Err(get_error()) } else { - Ok(result as isize) + Ok(result as i32) } } -pub fn get_display_name(display_index: isize) -> String { +pub fn get_display_name(display_index: i32) -> String { unsafe { let display = ll::SDL_GetDisplayName(display_index as c_int); String::from_utf8_lossy(c_str_to_bytes(&display)).to_string() } } -pub fn get_display_bounds(display_index: isize) -> SdlResult { +pub fn get_display_bounds(display_index: i32) -> SdlResult { let out: Rect = Rect::new(0, 0, 0, 0); let result = unsafe { ll::SDL_GetDisplayBounds(display_index as c_int, &out) == 0 }; @@ -513,16 +513,16 @@ pub fn get_display_bounds(display_index: isize) -> SdlResult { } } -pub fn get_num_display_modes(display_index: isize) -> SdlResult { +pub fn get_num_display_modes(display_index: i32) -> SdlResult { let result = unsafe { ll::SDL_GetNumDisplayModes(display_index as c_int) }; if result < 0 { Err(get_error()) } else { - Ok(result as isize) + Ok(result as i32) } } -pub fn get_display_mode(display_index: isize, mode_index: isize) -> SdlResult { +pub fn get_display_mode(display_index: i32, mode_index: i32) -> SdlResult { let dm = empty_sdl_display_mode(); let result = unsafe { ll::SDL_GetDisplayMode(display_index as c_int, mode_index as c_int, &dm) == 0}; @@ -533,7 +533,7 @@ pub fn get_display_mode(display_index: isize, mode_index: isize) -> SdlResult SdlResult { +pub fn get_desktop_display_mode(display_index: i32) -> SdlResult { let dm = empty_sdl_display_mode(); let result = unsafe { ll::SDL_GetDesktopDisplayMode(display_index as c_int, &dm) == 0}; @@ -544,7 +544,7 @@ pub fn get_desktop_display_mode(display_index: isize) -> SdlResult } } -pub fn get_current_display_mode(display_index: isize) -> SdlResult { +pub fn get_current_display_mode(display_index: i32) -> SdlResult { let dm = empty_sdl_display_mode(); let result = unsafe { ll::SDL_GetCurrentDisplayMode(display_index as c_int, &dm) == 0}; @@ -555,7 +555,7 @@ pub fn get_current_display_mode(display_index: isize) -> SdlResult } } -pub fn get_closest_display_mode(display_index: isize, mode: &DisplayMode) -> SdlResult { +pub fn get_closest_display_mode(display_index: i32, mode: &DisplayMode) -> SdlResult { let input = mode.to_ll(); let out = empty_sdl_display_mode(); @@ -608,16 +608,16 @@ pub fn gl_extension_supported(extension: &str) -> bool { unsafe { ll::SDL_GL_ExtensionSupported(buff) == 1 } } -pub fn gl_set_attribute(attr: GLAttr, value: isize) -> bool { +pub fn gl_set_attribute(attr: GLAttr, value: i32) -> bool { unsafe { ll::SDL_GL_SetAttribute(FromPrimitive::from_u64(attr as u64).unwrap(), value as c_int) == 0 } } -pub fn gl_get_attribute(attr: GLAttr) -> SdlResult { +pub fn gl_get_attribute(attr: GLAttr) -> SdlResult { let out: c_int = 0; let result = unsafe { ll::SDL_GL_GetAttribute(FromPrimitive::from_u64(attr as u64).unwrap(), &out) } == 0; if result { - Ok(out as isize) + Ok(out as i32) } else { Err(get_error()) } @@ -641,10 +641,10 @@ pub fn gl_get_current_context() -> SdlResult { } } -pub fn gl_set_swap_interval(interval: isize) -> bool { +pub fn gl_set_swap_interval(interval: i32) -> bool { unsafe { ll::SDL_GL_SetSwapInterval(interval as c_int) == 0 } } -pub fn gl_get_swap_interval() -> isize { - unsafe { ll::SDL_GL_GetSwapInterval() as isize } +pub fn gl_get_swap_interval() -> i32 { + unsafe { ll::SDL_GL_GetSwapInterval() as i32 } }