reverted combination of Surface+SurfaceRef

Author: nrxus

src/sdl2/mouse/mod.rs

@@ -1,7 +1,7 @@
 use std::ptr;
 
 use get_error;
-use surface::Surface;
+use surface::SurfaceRef;
 use video;
 use EventPump;
 
@@ -55,9 +55,9 @@ impl Cursor {
     }
 
     // TODO: figure out how to pass Surface in here correctly
-    pub fn from_surface<'a>(surface: &Surface<'a>, hot_x: i32, hot_y: i32) -> Result<Cursor, String> {
+    pub fn from_surface<S: AsRef<SurfaceRef>>(surface: S, hot_x: i32, hot_y: i32) -> Result<Cursor, String> {
         unsafe {
-            let raw = ll::SDL_CreateColorCursor(surface.raw(), hot_x, hot_y);
+            let raw = ll::SDL_CreateColorCursor(surface.as_ref().raw(), hot_x, hot_y);
 
             if raw == ptr::null_mut() {
                 Err(get_error())

src/sdl2/render.rs

@@ -30,7 +30,7 @@
 
 use video::{Window, WindowContext};
 use surface;
-use surface::{Surface, SurfaceContext};
+use surface::{Surface, SurfaceRef, SurfaceContext};
 use pixels;
 use pixels::PixelFormatEnum;
 use get_error;
@@ -286,13 +286,13 @@ impl<'s> Canvas<Surface<'s>, SurfaceContext<'s>> {
 
     /// Gets a reference to the associated surface of the Canvas
     #[inline]
-    pub fn surface(&self) -> &Surface<'s> {
+    pub fn surface(&self) -> &SurfaceRef {
         &self.target
     }
 
     /// Gets a mutable reference to the associated surface of the Canvas
     #[inline]
-    pub fn surface_mut(&mut self) -> &mut Surface<'s> {
+    pub fn surface_mut(&mut self) -> &mut SurfaceRef {
         &mut self.target
     }
 
@@ -602,11 +602,13 @@ impl<T> TextureCreator<T> {
     /// Creates a texture from an existing surface.
     /// # Remarks
     /// The access hint for the created texture is `TextureAccess::Static`.
-    pub fn create_texture_from_surface<'a>(&self,
-                                           surface: &Surface<'a>)
-                                           -> Result<Texture, TextureValueError> {
+    pub fn create_texture_from_surface<S: AsRef<SurfaceRef>>
+        (&self,
+         surface: S)
+         -> Result<Texture, TextureValueError> {
         use self::TextureValueError::*;
-        let result = unsafe { ll::SDL_CreateTextureFromSurface(self.context.raw, surface.raw()) };
+        let result =
+            unsafe { ll::SDL_CreateTextureFromSurface(self.context.raw, surface.as_ref().raw()) };
         if result == ptr::null_mut() {
             Err(SdlError(get_error()))
         } else {

src/sdl2/surface.rs

@@ -1,5 +1,6 @@
 use std::marker::PhantomData;
 use std::mem;
+use std::ops::{Deref, DerefMut};
 use std::path::Path;
 use std::rc::Rc;
 
@@ -17,21 +18,13 @@ use sys::surface as ll;
 /// Holds a `SDL_Surface`
 ///
 /// When the `SurfaceContext` is dropped, it frees the `SDL_Surface`
+///
+/// *INTERNAL USE ONLY*
 pub struct SurfaceContext<'a> {
     raw: *mut ll::SDL_Surface,
     _marker: PhantomData<&'a ()>
 }
 
-/// Unsafe if the `*mut SDL_Surface` is used after the `SurfaceContext` is dropped
-impl<'a> SurfaceContext<'a> {
-    pub unsafe fn from_ll(raw: *mut ll::SDL_Surface) -> SurfaceContext<'a> {
-        SurfaceContext {
-            raw: raw,
-            _marker: PhantomData,
-        }
-    }
-}
-
 impl<'a> Drop for SurfaceContext<'a> {
     #[inline]
     fn drop(&mut self) {
@@ -47,20 +40,68 @@ pub struct Surface<'a> {
     context: Rc<SurfaceContext<'a>>,
 }
 
-impl<'a> From<SurfaceContext<'a>> for Surface<'a> {
-    fn from(context: SurfaceContext<'a>) -> Surface<'a> {
-        Surface { context: Rc::new(context) }
+/// An unsized Surface reference.
+///
+/// This type is used whenever Surfaces need to be borrowed from the SDL library, without concern
+/// for freeing the Surface.
+pub struct SurfaceRef {
+    // It's nothing! (it gets transmuted to SDL_Surface later).
+    // The empty private field is need to a) make `std::mem::swap()` copy nothing instead of
+    // clobbering two surfaces (SDL_Surface's size could change in the future),
+    // and b) prevent user initialization of this type.
+    _raw: ()
+}
+
+impl AsRef<SurfaceRef> for SurfaceRef  {
+    fn as_ref(&self) -> &SurfaceRef {
+        self
     }
 }
 
-impl<'a> Surface<'a> {
-    pub unsafe fn from_ll<'b>(raw: *mut ll::SDL_Surface) -> Surface<'b> {
-        let context = SurfaceContext::from_ll(raw);
-        context.into()
+#[test]
+fn test_surface_ref_size() {
+    // `SurfaceRef` must be 0 bytes.
+    assert_eq!(::std::mem::size_of::<SurfaceRef>(), 0);
+}
+
+impl<'a> Deref for Surface<'a> {
+    type Target = SurfaceRef;
+
+    #[inline]
+    fn deref(&self) -> &SurfaceRef {
+        unsafe { mem::transmute(self.context.raw) }
+    }
+}
+
+impl<'a> DerefMut for Surface<'a> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut SurfaceRef {
+        unsafe { mem::transmute(self.context.raw) }
+    }
+}
+
+impl<'a> AsRef<SurfaceRef> for Surface<'a> {
+    #[inline]
+    fn as_ref(&self) -> &SurfaceRef {
+        unsafe { mem::transmute(self.context.raw) }
     }
+}
 
-    pub unsafe fn from_ref(context: Rc<SurfaceContext<'a>>) -> Surface<'a> {
-        Surface { context: context }
+impl<'a> AsMut<SurfaceRef> for Surface<'a> {
+    #[inline]
+    fn as_mut(&mut self) -> &mut SurfaceRef {
+        unsafe { mem::transmute(self.context.raw) }
+    }
+}
+
+
+impl<'a> Surface<'a> {
+    pub unsafe fn from_ll<'b>(raw: *mut ll::SDL_Surface) -> Surface<'b> {
+        let context = SurfaceContext {
+            raw: raw,
+            _marker: PhantomData,
+        };
+        Surface { context: Rc::new(context) }
     }
 
     /// Creates a new surface using a pixel format.
@@ -151,15 +192,27 @@ impl<'a> Surface<'a> {
     pub fn context(&self) -> Rc<SurfaceContext<'a>> {
         self.context.clone()
     }
+}
+
+impl SurfaceRef {
+    #[inline]
+    pub unsafe fn from_ll<'a>(raw: *mut ll::SDL_Surface) -> &'a SurfaceRef {
+        mem::transmute(raw)
+    }
+
+    #[inline]
+    pub unsafe fn from_ll_mut<'a>(raw: *mut ll::SDL_Surface) -> &'a mut SurfaceRef {
+        mem::transmute(raw)
+    }
 
     #[inline]
     pub fn raw(&self) -> *mut ll::SDL_Surface {
-        self.context.raw
+        unsafe { mem::transmute(self) }
     }
 
     #[inline]
     fn raw_ref(&self) -> &ll::SDL_Surface {
-        unsafe { &*self.context.raw }
+        unsafe { mem::transmute(self) }
     }
 
     pub fn width(&self) -> u32 {
@@ -485,8 +538,8 @@ impl<'a> Surface<'a> {
     /// Performs surface blitting (surface copying).
     ///
     /// Returns the final blit rectangle, if a `dst_rect` was provided.
-    pub fn blit<'b, R1, R2>(&self, src_rect: R1,
-            dst: &mut Surface<'b>, dst_rect: R2)
+    pub fn blit<R1, R2>(&self, src_rect: R1,
+            dst: &mut SurfaceRef, dst_rect: R2)
             -> Result<Option<Rect>, String> 
         where R1: Into<Option<Rect>>,
               R2: Into<Option<Rect>>,
@@ -518,8 +571,8 @@ impl<'a> Surface<'a> {
     ///
     /// Unless you know what you're doing, use `blit()` instead, which will clip the input rectangles.
     /// This function could crash if the rectangles aren't pre-clipped to the surface, and is therefore unsafe.
-    pub unsafe fn lower_blit<'b, R1, R2>(&self, src_rect: R1,
-                      dst: &mut Surface<'b>, dst_rect: R2) -> Result<(), String>
+    pub unsafe fn lower_blit<R1, R2>(&self, src_rect: R1,
+                      dst: &mut SurfaceRef, dst_rect: R2) -> Result<(), String> 
     where R1: Into<Option<Rect>>,
           R2: Into<Option<Rect>>,
     {
@@ -542,8 +595,8 @@ impl<'a> Surface<'a> {
     /// Performs scaled surface bliting (surface copying).
     ///
     /// Returns the final blit rectangle, if a `dst_rect` was provided.
-    pub fn blit_scaled<'b, R1, R2>(&self, src_rect: R1,
-                             dst: &mut Surface<'b>, dst_rect: R2) -> Result<Option<Rect>, String>
+    pub fn blit_scaled<R1, R2>(&self, src_rect: R1,
+                             dst: &mut SurfaceRef, dst_rect: R2) -> Result<Option<Rect>, String> 
     where R1: Into<Option<Rect>>,
           R2: Into<Option<Rect>>,
     {
@@ -569,8 +622,8 @@ impl<'a> Surface<'a> {
     ///
     /// Unless you know what you're doing, use `blit_scaled()` instead, which will clip the input rectangles.
     /// This function could crash if the rectangles aren't pre-clipped to the surface, and is therefore unsafe.
-    pub unsafe fn lower_blit_scaled<'b, R1, R2>(&self, src_rect: R1,
-                             dst: &mut Surface<'b>, dst_rect: R2) -> Result<(), String>
+    pub unsafe fn lower_blit_scaled<R1, R2>(&self, src_rect: R1,
+                             dst: &mut SurfaceRef, dst_rect: R2) -> Result<(), String> 
     where R1: Into<Option<Rect>>,
           R2: Into<Option<Rect>>
     {

src/sdl2/video.rs

@@ -6,7 +6,7 @@ use std::error::Error;
 
 use rect::Rect;
 use render::CanvasBuilder;
-use surface::Surface;
+use surface::SurfaceRef;
 use pixels::PixelFormatEnum;
 use VideoSubsystem;
 use EventPump;
@@ -1045,9 +1045,9 @@ impl Window {
         }
     }
 
-    pub fn set_icon<'b>(&mut self, icon: &Surface<'b>) {
+    pub fn set_icon<S: AsRef<SurfaceRef>>(&mut self, icon: S) {
         unsafe {
-            ll::SDL_SetWindowIcon(self.context.raw, icon.raw())
+            ll::SDL_SetWindowIcon(self.context.raw, icon.as_ref().raw())
         }
     }
 
@@ -1177,13 +1177,23 @@ impl Window {
         }
     }
 
-    pub fn surface<'a>(&'a mut self, _e: &'a EventPump) -> Result<Surface<'a>, String> {
+    pub fn surface<'a>(&'a self, _e: &'a EventPump) -> Result<&'a SurfaceRef, String> {
         let raw = unsafe { ll::SDL_GetWindowSurface(self.context.raw) };
 
         if raw.is_null() {
             Err(get_error())
         } else {
-            unsafe { Ok(Surface::from_ll(raw)) }
+            unsafe { Ok(SurfaceRef::from_ll(raw)) }
+        }
+    }
+
+    pub fn surface_mut<'a>(&'a mut self, _e: &'a EventPump) -> Result<&'a mut SurfaceRef, String> {
+        let raw = unsafe { ll::SDL_GetWindowSurface(self.context.raw) };
+
+        if raw.is_null() {
+            Err(get_error())
+        } else {
+            unsafe { Ok(SurfaceRef::from_ll_mut(raw)) }
         }
     }