Move GEGL things to its own library.

4 files changed, 186 insertions, 110 deletions

diff --git a/src/gegl.rs b/src/gegl.rs
new file mode 100644
index 0000000..b03fca1
--- /dev/null
+++ b/src/gegl.rs
@@ -0,0 +1,60 @@
+extern crate libc;
+
+use gegl_ffi as ffi;
+use std::ptr;
+use std::ffi::CString;
+
+pub struct GeglContext {
+    _private: ()
+}
+
+unsafe fn unref<T>(object: *mut T) {
+    ffi::g_object_unref(object as *mut libc::c_void);
+}
+
+impl GeglContext {
+    pub fn new() -> GeglContext {
+        unsafe { ffi::gegl_init(&mut 0, ptr::null_mut()) }
+        GeglContext { _private: () }
+    }
+
+    pub fn new_node(&self) -> GeglNode {
+        GeglNode(unsafe { ffi::gegl_node_new() })
+    }
+}
+
+impl Drop for GeglContext {
+    fn drop(&mut self) {
+        unsafe { ffi::gegl_exit(); }
+    }
+}
+
+pub struct GeglNode(*mut ffi::CGeglNode);
+
+impl GeglNode {
+    pub fn create_child(self, operation: &str) -> GeglNode {
+        GeglNode(unsafe {
+            let operation0 = CString::new(operation).unwrap();
+            ffi::gegl_node_create_child(self.0, operation0.as_ptr())
+        })
+    }
+}
+
+impl Drop for GeglNode {
+    fn drop(&mut self) {
+        unsafe { unref(self.0); }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use gegl_ffi as ffi;
+
+    #[test]
+    fn can_create_nodes() {
+        let context = GeglContext::new();
+        let node = context.new_node();
+        let node2 = context.new_node();
+    }
+}
diff --git a/src/gegl_ffi.rs b/src/gegl_ffi.rs
new file mode 100644
index 0000000..093fc3b
--- /dev/null
+++ b/src/gegl_ffi.rs
@@ -0,0 +1,34 @@
+extern crate libc;
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct GeglRectangle {
+    pub x: i32,
+    pub y: i32,
+    pub width: i32,
+    pub height: i32,
+}
+
+pub enum CGeglNode {}
+pub enum GeglBuffer {}
+
+#[link(name="gegl-0.3")]
+extern {
+    pub fn gegl_init(argc: *mut i32, argv: *mut *mut libc::c_char);
+    pub fn gegl_node_new() -> *mut CGeglNode;
+    pub fn gegl_node_create_child(parent: *mut CGeglNode,
+                                  operation: *const libc::c_char)
+                                  -> *mut CGeglNode;
+    pub fn gegl_node_set_property(node: *mut CGeglNode,
+                                  property_name: *const libc::c_char,
+                                  value: *const libc::c_void);
+    pub fn gegl_node_link(source: *mut CGeglNode,
+                          sink: *mut CGeglNode);
+    pub fn gegl_node_process(node: *mut CGeglNode);
+    pub fn g_object_unref(object: *mut libc::c_void);
+    pub fn gegl_exit();
+    pub fn gegl_buffer_new(extent: *mut libc::c_void, format: *mut libc::c_void)
+                           -> *mut GeglBuffer;
+    pub fn gegl_buffer_get_extent(buffer: *const libc::c_void) ->
+        *const GeglRectangle;
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..0acd7f0
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,2 @@
+pub mod gegl_ffi;
+pub mod gegl;
diff --git a/src/main.rs b/src/main.rs
index 27f3bc6..6bbf8b5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,120 +2,100 @@ extern crate libc;
 extern crate glib;
 extern crate gobject_sys as gobject_ffi;
 extern crate glib_sys as glib_ffi;
+extern crate phed;
+#[allow(unused_imports)]
+use phed::gegl_ffi::*;
+#[allow(unused_imports)]
 use std::ffi::CString;
+#[allow(unused_imports)]
 use std::ptr;
+#[allow(unused_imports)]
 use glib::translate::*;
+#[allow(unused_imports)]
 use glib::Value;
+#[allow(unused_imports)]
 use gobject_ffi::G_TYPE_POINTER;
 
-#[derive(Debug)]
-pub struct GeglBuffer(*mut libc::c_void);
+fn main () {}
 
-#[repr(C)]
-#[derive(Debug)]
-struct GeglRectangle {
-    x: i32,
-    y: i32,
-    width: i32,
-    height: i32,
-}
-
-impl GeglBuffer {
-    pub fn new() -> GeglBuffer {
-        GeglBuffer(ptr::null_mut())
-        // let mut bounds = GeglRectangle{x: 0, y: 0, width: 32, height: 32};
-        // GeglBuffer(unsafe {
-        //     gegl_buffer_new(&mut bounds as *mut _ as *mut libc::c_void,
-        //                     ptr::null_mut()) })
-    }
-
-    pub fn get_value(&self) -> Value {
-        unsafe {
-            let mut ret = Value::uninitialized();
-            gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
-            gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
-                                             self.0 as *mut libc::c_void);
-            ret
-        }
-    }
-
-    pub fn get_value_ptr(&mut self) -> Value {
-        unsafe {
-            let mut ret = Value::uninitialized();
-            gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
-            gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
-                                             &mut self.0 as *mut _ as *mut libc::c_void);
-            ret
-        }
-    }
-}
-
-impl Drop for GeglBuffer {
-    fn drop(&mut self) {
-        println!("Dropping geglbuffer: {:?}", self.0);
-        unsafe { g_object_unref(self.0); }
-        println!("Dropped");
-    }
-}
-
-#[link(name="gegl-0.3")]
-extern {
-    fn gegl_init(argc: *mut i32, argv: *mut *mut libc::c_char);
-    fn gegl_node_new() -> *mut libc::c_void;
-    fn gegl_node_create_child(parent: *mut libc::c_void,
-                              operation: *const libc::c_char)
-                              -> *mut libc::c_void;
-    fn gegl_node_set_property(node: *mut libc::c_void,
-                              property_name: *const libc::c_char,
-                              value: *const libc::c_void);
-    fn gegl_node_link(source: *mut libc::c_void,
-                      sink: *mut libc::c_void);
-    fn gegl_node_process(node: *mut libc::c_void);
-    fn g_object_unref(node: *mut libc::c_void);
-    fn gegl_exit();
-    fn gegl_buffer_new(extent: *mut libc::c_void, format: *mut libc::c_void)
-        -> *mut libc::c_void;
-    fn gegl_buffer_get_extent(buffer: *const libc::c_void) ->
-        *const GeglRectangle;
-}
-
-fn main() {
-    let mut graph : *mut libc::c_void;
-    unsafe {
-        let mut argc : i32 = 0;
-        gegl_init(&mut argc as *mut i32, ptr::null_mut());
-        graph = gegl_node_new();
-        let src = gegl_node_create_child(
-            graph, CString::new("gegl:load").unwrap().as_ptr());
-        gegl_node_set_property(
-            src,
-            CString::new("path").unwrap().as_ptr(),
-            Value::from("/tmp/test.jpg").to_glib_none().0
-                as *const libc::c_void);
-        let sink = gegl_node_create_child(graph,
-                                          CString::new("gegl:buffer-sink")
-                                          .unwrap().as_ptr());
-        let mut buffer = GeglBuffer::new();
-        println!("before set property: {:?}", buffer);
-        gegl_node_set_property(
-            sink,
-            CString::new("buffer").unwrap().as_ptr(),
-            buffer.get_value_ptr().to_glib_none().0 as *mut libc::c_void);
-
-        println!("before processing: {:?}", buffer);
-        gegl_node_link(src, sink);
-        gegl_node_process(sink);
-
-        println!("before extent: {:?}", buffer);
-        let extent = gegl_buffer_get_extent(buffer.0
-                                            as *mut libc::c_void);
-        println!("after extent: {:?}", buffer);
-        println!("height: {:?}", (*extent).height);
-
-        println!("got here");
-    }
-    unsafe {
-        g_object_unref(graph);
-        gegl_exit();
-    }
-}
+// #[derive(Debug)]
+// pub struct GeglBuffer(*mut libc::c_void);
+// 
+// impl GeglBuffer {
+//     pub fn new() -> GeglBuffer {
+//         GeglBuffer(ptr::null_mut())
+//         // let mut bounds = GeglRectangle{x: 0, y: 0, width: 32, height: 32};
+//         // GeglBuffer(unsafe {
+//         //     gegl_buffer_new(&mut bounds as *mut _ as *mut libc::c_void,
+//         //                     ptr::null_mut()) })
+//     }
+// 
+//     pub fn get_value(&self) -> Value {
+//         unsafe {
+//             let mut ret = Value::uninitialized();
+//             gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
+//             gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
+//                                              self.0 as *mut libc::c_void);
+//             ret
+//         }
+//     }
+// 
+//     pub fn get_value_ptr(&mut self) -> Value {
+//         unsafe {
+//             let mut ret = Value::uninitialized();
+//             gobject_ffi::g_value_init(ret.to_glib_none_mut().0, G_TYPE_POINTER);
+//             gobject_ffi::g_value_set_pointer(ret.to_glib_none_mut().0,
+//                                              &mut self.0 as *mut _ as *mut libc::c_void);
+//             ret
+//         }
+//     }
+// }
+// 
+// impl Drop for GeglBuffer {
+//     fn drop(&mut self) {
+//         println!("Dropping geglbuffer: {:?}", self.0);
+//         unsafe { g_object_unref(self.0); }
+//         println!("Dropped");
+//     }
+// }
+// 
+// fn main() {
+//     let mut graph : *mut libc::c_void;
+//     unsafe {
+//         let mut argc : i32 = 0;
+//         gegl_init(&mut argc as *mut i32, ptr::null_mut());
+//         graph = gegl_node_new();
+//         let src = gegl_node_create_child(
+//             graph, CString::new("gegl:load").unwrap().as_ptr());
+//         gegl_node_set_property(
+//             src,
+//             CString::new("path").unwrap().as_ptr(),
+//             Value::from("/tmp/test.jpg").to_glib_none().0
+//                 as *const libc::c_void);
+//         let sink = gegl_node_create_child(graph,
+//                                           CString::new("gegl:buffer-sink")
+//                                           .unwrap().as_ptr());
+//         let mut buffer = GeglBuffer::new();
+//         println!("before set property: {:?}", buffer);
+//         gegl_node_set_property(
+//             sink,
+//             CString::new("buffer").unwrap().as_ptr(),
+//             buffer.get_value_ptr().to_glib_none().0 as *mut libc::c_void);
+// 
+//         println!("before processing: {:?}", buffer);
+//         gegl_node_link(src, sink);
+//         gegl_node_process(sink);
+// 
+//         println!("before extent: {:?}", buffer);
+//         let extent = gegl_buffer_get_extent(buffer.0
+//                                             as *mut libc::c_void);
+//         println!("after extent: {:?}", buffer);
+//         println!("height: {:?}", (*extent).height);
+// 
+//         println!("got here");
+//     }
+//     unsafe {
+//         g_object_unref(graph);
+//         gegl_exit();
+//     }
+// }