Pulled native into mainloop

There is no runtime system in the standard library now (see
[Rust issue #17325] (rust-lang/rust#17325)),
so the original separation of code specific to the native runtime
has lost its purpose.

src/ffi.rs

@@ -25,15 +25,11 @@ use gtype::GType;
 
 use error;
 use mainloop;
-use native;
 use quark;
 
 pub type GError = error::raw::GError;
-
 pub type GMainContext = mainloop::MainContext;
-
-pub type GMainLoop = native::MainLoop;
-
+pub type GMainLoop = mainloop::MainLoop;
 pub type GQuark = quark::Quark;
 
 #[repr(C)]

src/lib.rs

@@ -32,7 +32,6 @@ pub mod error;
 pub mod gtype;
 pub mod mainloop;
 pub mod marker;
-pub mod native;
 pub mod object;
 pub mod quark;
 pub mod refcount;

src/mainloop.rs

@@ -20,6 +20,9 @@ use ffi;
 use marker;
 use refcount::Refcount;
 use refcount::{RefcountFuncs,RefFunc,UnrefFunc};
+use types::FALSE;
+
+use std::kinds::marker as std_marker;
 
 #[repr(C)]
 pub struct MainContext {
@@ -47,3 +50,80 @@ impl Refcount for MainContext {
         &MAIN_CONTEXT_REF_FUNCS
     }
 }
+
+#[repr(C)]
+pub struct MainLoop {
+    marker: marker::SyncObjectMarker
+}
+
+pub struct LoopRunner {
+    l: *mut MainLoop,
+
+    // Can't send the runner around due to the thread default stuff
+    no_send: std_marker::NoSend
+}
+
+impl LoopRunner {
+    pub fn new() -> LoopRunner {
+        unsafe {
+            let ctx = ffi::g_main_context_new();
+            let l = ffi::g_main_loop_new(ctx, FALSE);
+            ffi::g_main_context_unref(ctx);
+
+            LoopRunner { l: l, no_send: std_marker::NoSend }
+        }
+    }
+
+    pub fn run_after(&self, setup: |&mut MainLoop|) {
+        unsafe {
+            let ctx = ffi::g_main_loop_get_context(self.l);
+            ffi::g_main_context_push_thread_default(ctx);
+
+            setup(&mut *self.l);
+
+            ffi::g_main_loop_run(self.l);
+
+            ffi::g_main_context_pop_thread_default(ctx);
+        }
+    }
+}
+
+#[unsafe_destructor]
+impl Drop for LoopRunner {
+    fn drop(&mut self) {
+        unsafe {
+            ffi::g_main_loop_unref(self.l);
+        }
+    }
+}
+
+impl MainLoop {
+
+    pub fn get_context<'a>(&'a mut self) -> &'a mut MainContext {
+        unsafe {
+            &mut *ffi::g_main_loop_get_context(self)
+        }
+    }
+
+    pub fn quit(&mut self) {
+        unsafe {
+            ffi::g_main_loop_quit(self);
+        }
+    }
+}
+
+type MainLoopRefFunc   = unsafe extern "C" fn(p: *mut ffi::GMainLoop) -> *mut ffi::GMainLoop;
+type MainLoopUnrefFunc = unsafe extern "C" fn(p: *mut ffi::GMainLoop);
+
+static MAIN_LOOP_REF_FUNCS: RefcountFuncs = (
+        &ffi::g_main_loop_ref
+            as *const MainLoopRefFunc as *const RefFunc,
+        &ffi::g_main_loop_unref
+            as *const MainLoopUnrefFunc as *const UnrefFunc
+    );
+
+impl Refcount for MainLoop {
+    fn refcount_funcs(&self) -> &'static RefcountFuncs {
+        &MAIN_LOOP_REF_FUNCS
+    }
+}