Remove doc(hidden) hack for get_wrapped_event

Factor it out into a module higher up the tree.

Author: crumblingstatue

src/ext/event.rs

@@ -0,0 +1,130 @@
+use csfml_window_sys as sys;
+use csfml_window_sys::*;
+use window::event;
+
+fn type_(evt: &mut sfEvent) -> *mut sfEventType {
+    unsafe { ::std::mem::transmute(evt) }
+}
+
+fn size(evt: &mut sfEvent) -> event::Event {
+    let e: *mut sfSizeEvent = unsafe { ::std::mem::transmute(evt) };
+    unsafe { event::Resized { width: (*e).width, height: (*e).height } }
+}
+
+fn key(evt: &mut sfEvent, type_: sfEventType) -> event::Event {
+    let e: *mut sfKeyEvent = unsafe { ::std::mem::transmute(evt) };
+    let code = unsafe { ::std::mem::transmute((*e).code as i64) };
+    let alt = unsafe { (*e).alt.to_bool() };
+    let ctrl = unsafe { (*e).control.to_bool() };
+    let shift = unsafe { (*e).shift.to_bool() };
+    let system = unsafe { (*e).system.to_bool() };
+    match type_ {
+        sys::sfEvtKeyPressed => {
+            event::KeyPressed {
+                code: code,
+                alt: alt,
+                ctrl: ctrl,
+                shift: shift,
+                system: system
+            }
+        },
+        sys::sfEvtKeyReleased => {
+            event::KeyReleased {
+                code: code,
+                alt: alt,
+                ctrl: ctrl,
+                shift: shift,
+                system: system
+            }
+        },
+        _ => unreachable!()
+    }
+}
+
+fn text(evt: &mut sfEvent) -> event::Event {
+    let e: *mut sfTextEvent = unsafe { ::std::mem::transmute(evt) };
+    unsafe { event::TextEntered { code: ((*e).unicode as u8) as char } }
+}
+
+fn mouse_move(evt: &mut sfEvent) -> event::Event {
+    let e: *mut sfMouseMoveEvent = unsafe { ::std::mem::transmute(evt) };
+    unsafe { event::MouseMoved {x: (*e).x, y: (*e).y } }
+}
+
+fn mouse_button(evt: &mut sfEvent, type_: sfEventType) -> event::Event {
+    let e: *mut sfMouseButtonEvent = unsafe { ::std::mem::transmute(evt) };
+    let button = unsafe { ::std::mem::transmute((*e).button as u8) };
+    let x = unsafe { (*e).x };
+    let y = unsafe { (*e).y };
+
+    match type_ {
+        sys::sfEvtMouseButtonReleased => event::MouseButtonReleased { button: button, x: x, y: y },
+        sys::sfEvtMouseButtonPressed => event::MouseButtonPressed { button: button, x: x, y: y },
+        _ => unreachable!()
+    }
+}
+
+fn mouse_wheel(evt: &mut sfEvent) -> event::Event {
+    let e: *mut sfMouseWheelEvent = unsafe { ::std::mem::transmute(evt) };
+    unsafe { event::MouseWheelMoved { delta: (*e).delta, x: (*e).x, y: (*e).y } }
+}
+
+fn joystick_move(evt: &mut sfEvent) -> event::Event {
+    let e: *mut sfJoystickMoveEvent = unsafe { ::std::mem::transmute(evt) };
+    event::JoystickMoved {
+        joystickid: unsafe { (*e).joystickid },
+        axis: unsafe { ::std::mem::transmute((*e).axis as u8) },
+        position: unsafe { (*e).position }
+    }
+}
+
+fn joystick_button(evt: &mut sfEvent, type_: sfEventType) -> event::Event {
+    let e: *mut sfJoystickButtonEvent = unsafe { ::std::mem::transmute(evt) };
+    let jid = unsafe { (*e).joystickid };
+    let btn = unsafe { (*e).button };
+
+    match type_ {
+        sys::sfEvtJoystickButtonPressed =>
+            event::JoystickButtonPressed { joystickid: jid, button: btn },
+        sys::sfEvtJoystickButtonReleased =>
+            event::JoystickButtonReleased { joystickid: jid, button: btn },
+        _ => unreachable!()
+    }
+}
+
+fn joystick_connect(evt: &mut sfEvent, type_: sfEventType) -> event::Event {
+    let e: *mut sfJoystickConnectEvent = unsafe { ::std::mem::transmute(evt) };
+    let jid = unsafe { (*e).joystickid };
+
+    match type_ {
+        sys::sfEvtJoystickConnected => event::JoystickConnected { joystickid: jid },
+        sys::sfEvtJoystickDisconnected => event::JoystickDisconnected { joystickid: jid},
+        _ => unreachable!()
+    }
+}
+
+pub fn get_wrapped_event(event: &mut ::csfml_window_sys::sfEvent) -> event::Event {
+    let type_ = unsafe { *type_(event) };
+
+    match type_ {
+        sys::sfEvtClosed => event::Closed,
+        sys::sfEvtResized => size(event),
+        sys::sfEvtLostFocus => event::LostFocus,
+        sys::sfEvtGainedFocus => event::GainedFocus,
+        sys::sfEvtTextEntered => text(event),
+        sys::sfEvtKeyPressed => key(event, type_),
+        sys::sfEvtKeyReleased => key(event, type_),
+        sys::sfEvtMouseWheelMoved => mouse_wheel(event),
+        sys::sfEvtMouseButtonPressed => mouse_button(event, type_),
+        sys::sfEvtMouseButtonReleased => mouse_button(event, type_),
+        sys::sfEvtMouseMoved => mouse_move(event),
+        sys::sfEvtMouseEntered => event::MouseEntered,
+        sys::sfEvtMouseLeft => event::MouseLeft,
+        sys::sfEvtJoystickButtonPressed => joystick_button(event, type_),
+        sys::sfEvtJoystickButtonReleased => joystick_button(event, type_),
+        sys::sfEvtJoystickMoved => joystick_move(event),
+        sys::sfEvtJoystickConnected => joystick_connect(event, type_),
+        sys::sfEvtJoystickDisconnected => joystick_connect(event, type_),
+        _ => event::NoEvent
+    }
+}

src/graphics/render_window.rs

@@ -42,6 +42,7 @@ use graphics::{Drawable, Color, CircleShape, RectangleShape, Text, Sprite, Verte
 use sfml_types::sfBool;
 use csfml_graphics_sys as ffi;
 use std::marker::PhantomData;
+use ext;
 
 /// Window that can serve as a target for 2D drawing.
 ///
@@ -199,7 +200,7 @@ impl RenderWindow {
             ffi::sfRenderWindow_pollEvent(self.render_window, &mut event)
         }.to_bool();
         if have_event {
-            event::raw::get_wrapped_event(&mut event)
+            ext::event::get_wrapped_event(&mut event)
         } else {
             event::NoEvent
         }
@@ -222,7 +223,7 @@ impl RenderWindow {
             ffi::sfRenderWindow_waitEvent(self.render_window, &mut event)
         }.to_bool();
         if have_event {
-            event::raw::get_wrapped_event(&mut event)
+            ext::event::get_wrapped_event(&mut event)
         } else {
             event::NoEvent
         }
@@ -867,7 +868,7 @@ impl<'a> Iterator for Events<'a> {
     fn next(&mut self) -> Option<event::Event> {
         let mut event = ::csfml_window_sys::sfEvent { data: [032; 6] };
         if unsafe { ffi::sfRenderWindow_pollEvent(self.render_window, &mut event) }.to_bool() {
-            Some(event::raw::get_wrapped_event(&mut event))
+            Some(ext::event::get_wrapped_event(&mut event))
         } else {
             None
         }

src/lib.rs

@@ -105,6 +105,9 @@ extern crate csfml_network_sys;
 
 mod inputstream;
 mod raw_conv;
+mod ext {
+    pub mod event;
+}
 
 pub mod system;
 pub mod window;

src/window/event.rs

@@ -158,151 +158,3 @@ pub enum Event {
     /// No Event
     NoEvent
 }
-
-#[doc(hidden)]
-#[allow(non_upper_case_globals, non_camel_case_types)]
-pub mod raw {
-    use csfml_window_sys::*;
-
-    trait sfEventExt {
-        fn type_(&mut self) -> *mut sfEventType;
-        fn size(&mut self) -> super::Event;
-        fn key(&mut self, type_: sfEventType) -> super::Event;
-        fn text(&mut self) -> super::Event;
-        fn mouse_move(&mut self) -> super::Event;
-        fn mouse_button(&mut self, type_: sfEventType) -> super::Event;
-        fn mouse_wheel(&mut self) -> super::Event;
-        fn joystick_move(&mut self) -> super::Event;
-        fn joystick_button(&mut self, type_: sfEventType) -> super::Event;
-        fn joystick_connect(&mut self, type_: sfEventType) -> super::Event;
-    }
-
-    impl sfEventExt for sfEvent {
-        fn type_(&mut self) -> *mut sfEventType {
-            unsafe { ::std::mem::transmute(self) }
-        }
-
-        fn size(&mut self) -> super::Event {
-            let e: *mut sfSizeEvent = unsafe { ::std::mem::transmute(self) };
-            unsafe { super::Resized { width: (*e).width, height: (*e).height } }
-        }
-
-        fn key(&mut self, type_: sfEventType) -> super::Event {
-            let e: *mut sfKeyEvent = unsafe { ::std::mem::transmute(self) };
-            let code = unsafe { ::std::mem::transmute((*e).code as i64) };
-            let alt = unsafe { (*e).alt.to_bool() };
-            let ctrl = unsafe { (*e).control.to_bool() };
-            let shift = unsafe { (*e).shift.to_bool() };
-            let system = unsafe { (*e).system.to_bool() };
-            match type_ {
-                sfEvtKeyPressed => {
-                    super::KeyPressed {
-                        code: code,
-                        alt: alt,
-                        ctrl: ctrl,
-                        shift: shift,
-                        system: system
-                    }
-                },
-                sfEvtKeyReleased => {
-                    super::KeyReleased {
-                        code: code,
-                        alt: alt,
-                        ctrl: ctrl,
-                        shift: shift,
-                        system: system
-                    }
-                },
-                _ => unreachable!()
-            }
-        }
-
-        fn text(&mut self) -> super::Event {
-            let e: *mut sfTextEvent = unsafe { ::std::mem::transmute(self) };
-            unsafe { super::TextEntered { code: ((*e).unicode as u8) as char } }
-        }
-
-        fn mouse_move(&mut self) -> super::Event {
-            let e: *mut sfMouseMoveEvent = unsafe { ::std::mem::transmute(self) };
-            unsafe { super::MouseMoved {x: (*e).x, y: (*e).y } }
-        }
-
-        fn mouse_button(&mut self, type_: sfEventType) -> super::Event {
-            let e: *mut sfMouseButtonEvent = unsafe { ::std::mem::transmute(self) };
-            let button = unsafe { ::std::mem::transmute((*e).button as u8) };
-            let x = unsafe { (*e).x };
-            let y = unsafe { (*e).y };
-
-            match type_ {
-                sfEvtMouseButtonReleased => super::MouseButtonReleased { button: button, x: x, y: y },
-                sfEvtMouseButtonPressed => super::MouseButtonPressed { button: button, x: x, y: y },
-                _ => unreachable!()
-            }
-        }
-
-        fn mouse_wheel(&mut self) -> super::Event {
-            let e: *mut sfMouseWheelEvent = unsafe { ::std::mem::transmute(self) };
-            unsafe { super::MouseWheelMoved { delta: (*e).delta, x: (*e).x, y: (*e).y } }
-        }
-
-        fn joystick_move(&mut self) -> super::Event {
-            let e: *mut sfJoystickMoveEvent = unsafe { ::std::mem::transmute(self) };
-            super::JoystickMoved {
-                joystickid: unsafe { (*e).joystickid },
-                axis: unsafe { ::std::mem::transmute((*e).axis as u8) },
-                position: unsafe { (*e).position }
-            }
-        }
-
-        fn joystick_button(&mut self, type_: sfEventType) -> super::Event {
-            let e: *mut sfJoystickButtonEvent = unsafe { ::std::mem::transmute(self) };
-            let jid = unsafe { (*e).joystickid };
-            let btn = unsafe { (*e).button };
-
-            match type_ {
-                sfEvtJoystickButtonPressed =>
-                    super::JoystickButtonPressed { joystickid: jid, button: btn },
-                sfEvtJoystickButtonReleased =>
-                    super::JoystickButtonReleased { joystickid: jid, button: btn },
-                _ => unreachable!()
-            }
-        }
-
-        fn joystick_connect(&mut self, type_: sfEventType) -> super::Event {
-            let e: *mut sfJoystickConnectEvent = unsafe { ::std::mem::transmute(self) };
-            let jid = unsafe { (*e).joystickid };
-
-            match type_ {
-                sfEvtJoystickConnected => super::JoystickConnected { joystickid: jid },
-                sfEvtJoystickDisconnected => super::JoystickDisconnected { joystickid: jid},
-                _ => unreachable!()
-            }
-        }
-    }
-
-    pub fn get_wrapped_event(event: &mut ::csfml_window_sys::sfEvent) -> super::Event {
-        let type_ = unsafe { *event.type_() };
-
-        match type_ {
-            sfEvtClosed => super::Closed,
-            sfEvtResized => event.size(),
-            sfEvtLostFocus => super::LostFocus,
-            sfEvtGainedFocus => super::GainedFocus,
-            sfEvtTextEntered => event.text(),
-            sfEvtKeyPressed => event.key(type_),
-            sfEvtKeyReleased => event.key(type_),
-            sfEvtMouseWheelMoved => event.mouse_wheel(),
-            sfEvtMouseButtonPressed => event.mouse_button(type_),
-            sfEvtMouseButtonReleased => event.mouse_button(type_),
-            sfEvtMouseMoved => event.mouse_move(),
-            sfEvtMouseEntered => super::MouseEntered,
-            sfEvtMouseLeft => super::MouseLeft,
-            sfEvtJoystickButtonPressed => event.joystick_button(type_),
-            sfEvtJoystickButtonReleased => event.joystick_button(type_),
-            sfEvtJoystickMoved => event.joystick_move(),
-            sfEvtJoystickConnected => event.joystick_connect(type_),
-            sfEvtJoystickDisconnected => event.joystick_connect(type_),
-            _ => super::NoEvent
-        }
-    }
-}

src/window/window.rs

@@ -39,6 +39,7 @@ use sfml_types::{Vector2i, Vector2u};
 
 use sfml_types::sfBool;
 use csfml_window_sys as ffi;
+use ext;
 
 ///
 /// Window manipulation
@@ -153,7 +154,7 @@ impl Window {
             ffi::sfWindow_pollEvent(self.window, &mut event).to_bool()
         };
         if have_event {
-            event::raw::get_wrapped_event(&mut event)
+            ext::event::get_wrapped_event(&mut event)
         } else {
             event::NoEvent
         }
@@ -176,7 +177,7 @@ impl Window {
             ffi::sfWindow_waitEvent(self.window, &mut event).to_bool()
         };
         if have_event {
-            event::raw::get_wrapped_event(&mut event)
+            ext::event::get_wrapped_event(&mut event)
         } else {
             event::NoEvent
         }
@@ -441,7 +442,7 @@ impl<'a> Iterator for Events<'a> {
     fn next(&mut self) -> Option<event::Event> {
         let mut event = ffi::sfEvent { data: [032; 6] };
         if unsafe { ffi::sfWindow_pollEvent(self.window, &mut event) }.to_bool() {
-            Some(event::raw::get_wrapped_event(&mut event))
+            Some(ext::event::get_wrapped_event(&mut event))
         } else {
             None
         }