Bump version to 0.4.1

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "libnotify"
-version = "0.5.0"
+version = "0.4.1"
 authors = ["Mika Attila <radiantstatue@gmail.com>", "Julian Ospald <hasufell@posteo.de>"]
 license = "MIT"
 description = "Rust bindings to libnotify"
@@ -11,9 +11,6 @@ documentation = "http://crumblingstatue.github.io/doc/libnotify/libnotify/"
 keywords = ["libnotify", "notification"]
 
 [dependencies]
-libnotify-sys = "^0.5.0"
+libnotify-sys = "0.3"
-gdk-pixbuf = "^0.1.3"
+glib-2-0-sys = "0.46.0"
-gdk-pixbuf-sys = "^0.3.4"
+gtypes = "0.2"
-glib-sys = "^0.3.4"
-gtypes = "^0.2.0"
-glib = "^0.1.3"

examples/show.rs

@@ -4,8 +4,7 @@ fn main() {
     // Create a libnotify context
     let notify = libnotify::Context::new("myapp").unwrap();
     // Create a new notification and show it
-    let n = notify.new_notification("Summary", Some("Optional Body"), None)
+    let n = notify.new_notification("Summary", Some("Optional Body"), None).unwrap();
-        .unwrap();
     n.show().unwrap();
     // You can also use the .show() convenience method on the context
     notify.show("I am another notification", None, None).unwrap();

src/lib.rs

@@ -19,53 +19,16 @@
 
 #![warn(missing_docs)]
 
-extern crate gdk_pixbuf;
-extern crate gdk_pixbuf_sys;
-extern crate glib;
-extern crate glib_sys;
-extern crate gtypes;
 extern crate libnotify_sys as sys;
+extern crate glib_2_0_sys as glib;
+extern crate gtypes;
 
-use gdk_pixbuf_sys::GdkPixbuf;
-use glib::translate::*;
-use gtypes::{TRUE, FALSE};
-use std::error::Error;
 use std::ffi::{self, CStr, CString};
-use std::fmt;
 use std::marker::PhantomData;
-use std::os::raw::c_int;
+use std::fmt;
-
+use std::error::Error;
-
-/// The urgency level of the notification.
-pub enum Urgency {
-    /// Low urgency. Used for unimportant notifications.
-    Low,
-    /// Normal urgency. Used for most standard notifications.
-    Normal,
-    /// Critical urgency. Used for very important notifications.
-    Critical,
-}
-
-impl From<sys::NotifyUrgency> for Urgency {
-    fn from(urgency: sys::NotifyUrgency) -> Urgency {
-        match urgency {
-            sys::NotifyUrgency::NotifyUrgencyLow => Urgency::Low,
-            sys::NotifyUrgency::NotifyUrgencyNormal => Urgency::Normal,
-            sys::NotifyUrgency::NotifyUrgencyCritical => Urgency::Critical,
-        }
-    }
-}
-
-impl From<Urgency> for sys::NotifyUrgency {
-    fn from(urgency: Urgency) -> sys::NotifyUrgency {
-        match urgency {
-            Urgency::Low => sys::NotifyUrgency::NotifyUrgencyLow,
-            Urgency::Normal => sys::NotifyUrgency::NotifyUrgencyNormal,
-            Urgency::Critical => sys::NotifyUrgency::NotifyUrgencyCritical,
-        }
-    }
-}
 
+use gtypes::{TRUE, FALSE};
 
 /// Error that can happen on context creation
 #[derive(Debug)]
@@ -95,7 +58,6 @@ impl From<ffi::NulError> for ContextCreationError {
     }
 }
 
-
 #[derive(Debug)]
 /// An error that can happen when attempting to create a notification.
 pub enum NotificationCreationError {
@@ -103,8 +65,6 @@ pub enum NotificationCreationError {
     NulError(ffi::NulError),
     /// An unknown error happened.
     Unknown,
-    /// Invalid parameter passed to a glib function
-    InvalidParameter,
 }
 
 impl fmt::Display for NotificationCreationError {
@@ -113,7 +73,6 @@ impl fmt::Display for NotificationCreationError {
         match *self {
             NulError(ref e) => write!(f, "{}", e),
             Unknown => write!(f, "Unknown error"),
-            InvalidParameter => write!(f, "An invalid parameter was passed"),
         }
     }
 }
@@ -130,7 +89,6 @@ impl Error for NotificationCreationError {
     }
 }
 
-
 /// The context which within libnotify operates.
 ///
 /// Only one context can exist at a time.
@@ -154,7 +112,6 @@ impl Context {
         }
         Ok(Context)
     }
-
     /// Creates a new Notification.
     ///
     /// Arguments:
@@ -162,12 +119,11 @@ impl Context {
     /// - summary: Required summary text
     /// - body: Optional body text
     /// - icon: Optional icon theme icon name or filename
-    pub fn new_notification
+    pub fn new_notification(&self,
-        (&self,
+                            summary: &str,
-         summary: &str,
+                            body: Option<&str>,
-         body: Option<&str>,
+                            icon: Option<&str>)
-         icon: Option<&str>)
+                            -> Result<Notification, NotificationCreationError> {
-         -> Result<Notification, NotificationCreationError> {
         let summary = try!(CString::new(summary));
         let body = match body {
             Some(body) => Some(try!(CString::new(body))),
@@ -187,20 +143,17 @@ impl Context {
         };
 
         unsafe {
-            let n = sys::notify_notification_new(summary.as_ptr(),
+            let n = sys::notify_notification_new(summary.as_ptr(), body_ptr, icon_ptr);
-                                                 body_ptr,
-                                                 icon_ptr);
             if n.is_null() {
                 return Err(NotificationCreationError::Unknown);
             }
 
             Ok(Notification {
-                   handle: n,
+                handle: n,
-                   _phantom: PhantomData,
+                _phantom: PhantomData,
-               })
+            })
         }
     }
-
     /// Show a notification.
     ///
     /// This is a convenience method that creates a new notification,
@@ -224,7 +177,6 @@ impl Drop for Context {
     }
 }
 
-
 /// A passive pop-up notification
 pub struct Notification<'a> {
     handle: *mut sys::NotifyNotification,
@@ -236,152 +188,20 @@ impl<'a> Notification<'a> {
     /// on the screen.
     pub fn show(&'a self) -> Result<(), NotificationShowError> {
         unsafe {
-            let mut err: *mut glib_sys::GError = std::ptr::null_mut();
+            let mut err: *mut glib::GError = std::ptr::null_mut();
             sys::notify_notification_show(self.handle, &mut err);
             if !err.is_null() {
                 let result = Err(NotificationShowError {
-                                     message: CStr::from_ptr((*err).message)
+                    message: CStr::from_ptr((*err).message).to_string_lossy().into_owned(),
-                                         .to_string_lossy()
+                });
-                                         .into_owned(),
+                glib::g_error_free(err);
-                                 });
-                glib_sys::g_error_free(err);
                 return result;
             }
             Ok(())
         }
     }
-
-    /// Set the notification timeout. Note that the server might ignore
-    /// the timeout.
-    pub fn set_notification_timeout(&self, timeout: i32) {
-        let _timeout: c_int = From::from(timeout);
-
-        unsafe { sys::notify_notification_set_timeout(self.handle, _timeout) }
-    }
-
-    /// Updates the notification text and icon. This won't send the update
-    /// out and display it on the screen. For that, you will need to
-    /// call `.show()`.
-    pub fn update(&self,
-                  summary: &str,
-                  body: Option<&str>,
-                  icon: Option<&str>)
-                  -> Result<(), NotificationCreationError> {
-        let summary = try!(CString::new(summary));
-        let body = match body {
-            Some(body) => Some(try!(CString::new(body))),
-            None => None,
-        };
-        let body_ptr = match body {
-            Some(ref body) => body.as_ptr(),
-            None => std::ptr::null(),
-        };
-        let icon = match icon {
-            Some(icon) => Some(try!(CString::new(icon))),
-            None => None,
-        };
-        let icon_ptr = match icon {
-            Some(ref icon) => icon.as_ptr(),
-            None => std::ptr::null(),
-        };
-
-        unsafe {
-            let b = sys::notify_notification_update(self.handle,
-                                                    summary.as_ptr(),
-                                                    body_ptr,
-                                                    icon_ptr);
-            if b == FALSE {
-                return Err(NotificationCreationError::InvalidParameter);
-            }
-        }
-
-        return Ok(());
-    }
-
-    /// Sets a hint for `key` with value `value`. If value is `None`,
-    /// then key is unset.
-    pub fn set_hint(&self,
-                    key: &str,
-                    value: Option<glib::variant::Variant>)
-                    -> Result<(), NotificationCreationError> {
-        let key = try!(CString::new(key));
-
-        let gvalue: *mut glib_sys::GVariant = {
-            match value {
-                Some(ref value) => value.to_glib_none().0,
-                None => std::ptr::null_mut(),
-            }
-        };
-
-        unsafe {
-            sys::notify_notification_set_hint(self.handle, key.as_ptr(), gvalue)
-        }
-
-        return Ok(());
-    }
-
-    /// Sets the category of this notification. This can be used by the
-    /// notification server to filter or display the data in a certain way.
-    pub fn set_category(&self, category: &str) -> Result<(), NotificationCreationError> {
-        let category = try!(CString::new(category));
-        unsafe {
-            sys::notify_notification_set_category(self.handle,
-                                                   category.as_ptr());
-        }
-
-        return Ok(());
-    }
-
-    /// Sets the urgency level of this notification.
-    pub fn set_urgency(&self, urgency: Urgency) {
-        let urgency: sys::NotifyUrgency = From::from(urgency);
-
-        unsafe {
-            sys::notify_notification_set_urgency(self.handle,
-                                             urgency);
-        }
-    }
-
-    /// Sets the image in the notification from a Pixbuf.
-    pub fn set_image_from_pixbuf(&self, pixbuf: &gdk_pixbuf::Pixbuf) {
-        let pixbuf: *mut GdkPixbuf = pixbuf.to_glib_none().0;
-
-        unsafe {
-            sys::notify_notification_set_image_from_pixbuf(self.handle,
-                                                            pixbuf);
-        }
-    }
-
-    /// Clears all hints from the notification.
-    pub fn clear_hints(&self) {
-        unsafe {
-            sys::notify_notification_clear_hints(self.handle);
-        }
-    }
-
-    /// Synchronously tells the notification server to hide the
-    /// notification on the screen.
-    pub fn close(&self) -> Result<(), NotificationShowError> {
-        unsafe {
-            let mut err: *mut glib_sys::GError = std::ptr::null_mut();
-            sys::notify_notification_close(self.handle,
-                                           &mut err);
-
-            if !err.is_null() {
-                let result = Err(NotificationShowError {
-                                     message: CStr::from_ptr((*err).message)
-                                         .to_string_lossy()
-                                         .into_owned(),
-                                 });
-                glib_sys::g_error_free(err);
-                return result;
-            }
-        }
-        return Ok(());
-    }
 }
 
-
 /// An error that can happen when attempting to show a notification.
 #[derive(Debug)]
 pub struct NotificationShowError {