GNOME.org
 

[banshee] Bring back the in-tree copy of notify-sharp, updated to latest svn

commit 39d4f5b2bf26fd4b630120018ba84b85ec45f834
Author: Bertrand Lorentz <bertrand lorentz gmail com>
Date:   Fri May 15 12:31:32 2009 +0200

    Bring back the in-tree copy of notify-sharp, updated to latest svn
    
    Revert commit b28f9d36425e5c4260561316efe6dc6986642a42 and update the
    in-tree notify-sharp code to its latest svn (rev. 3032).
---
 build/m4/banshee/notify-sharp.m4                   |   10 +-
 .../Banshee.NotificationArea/Makefile.am           |   11 +
 .../Notifications/Notification.cs                  |  384 ++++++++++++++++++++
 .../Notifications/Notifications.cs                 |   95 +++++
 4 files changed, 498 insertions(+), 2 deletions(-)

diff --git a/build/m4/banshee/notify-sharp.m4 b/build/m4/banshee/notify-sharp.m4
index 3b5bd2b..bbe444a 100644
--- a/build/m4/banshee/notify-sharp.m4
+++ b/build/m4/banshee/notify-sharp.m4
@@ -1,6 +1,12 @@
 AC_DEFUN([BANSHEE_CHECK_NOTIFY_SHARP],
 [
-	PKG_CHECK_MODULES(NOTIFY_SHARP, notify-sharp)
-	AC_SUBST(NOTIFY_SHARP_LIBS)
+	PKG_CHECK_MODULES(NOTIFY_SHARP, notify-sharp, have_notify_sharp=yes, have_notify_sharp=no)
+	if test "x$have_notify_sharp" = "xyes"; then
+		AC_SUBST(NOTIFY_SHARP_LIBS)
+		AM_CONDITIONAL(EXTERNAL_NOTIFY_SHARP, true)
+	else
+		AM_CONDITIONAL(EXTERNAL_NOTIFY_SHARP, false)
+		AC_MSG_RESULT([no])
+	fi
 ])
 
diff --git a/src/Extensions/Banshee.NotificationArea/Makefile.am b/src/Extensions/Banshee.NotificationArea/Makefile.am
index 0b3f901..6b001ec 100644
--- a/src/Extensions/Banshee.NotificationArea/Makefile.am
+++ b/src/Extensions/Banshee.NotificationArea/Makefile.am
@@ -1,3 +1,12 @@
+REAL_NOTIFY_SHARP_SOURCES = Notifications/Notifications.cs Notifications/Notification.cs
+if EXTERNAL_NOTIFY_SHARP
+NOTIFY_SHARP_SOURCES = 
+NOTIFY_SHARP_LIBS = $(NOTIFY_SHARP_LIBS)
+else
+NOTIFY_SHARP_SOURCES = $(REAL_NOTIFY_SHARP_SOURCES)
+NOTIFY_SHARP_LIBS = 
+endif
+
 ASSEMBLY = Banshee.NotificationArea
 TARGET = library
 LINK = $(REF_EXTENSION_NOTIFICATIONAREA) $(NOTIFY_SHARP_LIBS)
@@ -11,6 +20,8 @@ SOURCES =  \
 	Banshee.NotificationArea/X11NotificationArea.cs \
 	Banshee.NotificationArea/X11NotificationAreaBox.cs
 
+SOURCES += $(NOTIFY_SHARP_SOURCES)
+
 RESOURCES =  \
 	Resources/Banshee.NotificationArea.addin.xml \
 	Resources/NotificationAreaMenu.xml
diff --git a/src/Extensions/Banshee.NotificationArea/Notifications/Notification.cs b/src/Extensions/Banshee.NotificationArea/Notifications/Notification.cs
new file mode 100644
index 0000000..87852a0
--- /dev/null
+++ b/src/Extensions/Banshee.NotificationArea/Notifications/Notification.cs
@@ -0,0 +1,384 @@
+/*
+ * Copyright (c) 2006 Sebastian Dröge <slomo circular-chaos org>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+
+using GLib;
+using Gdk;
+using Gtk;
+
+using NDesk.DBus;
+using org.freedesktop;
+using org.freedesktop.DBus;
+
+namespace Notifications {
+	public enum Urgency : byte {
+		Low = 0,
+		Normal,
+		Critical
+	}
+
+	public class ActionArgs : EventArgs {
+		private string action;
+		public string Action {
+			get { return action; }
+		}
+
+		public ActionArgs (string action) {
+			this.action = action;
+		}
+	}
+
+	public class CloseArgs : EventArgs {
+		private CloseReason reason;
+		public CloseReason Reason {
+			get { return reason; }
+		}
+
+		public CloseArgs (CloseReason reason) {
+			this.reason = reason;
+		}
+	}
+
+	public delegate void ActionHandler (object o, ActionArgs args);
+	public delegate void CloseHandler (object o, CloseArgs args);
+	
+	public class Notification {
+		private struct IconData {
+			public int Width;
+			public int Height;
+			public int Rowstride;
+			public bool HasAlpha;
+			public int BitsPerSample;
+			public int NChannels;
+			public byte[] Pixels;
+		}
+
+		private struct ActionTuple {
+			public string Label;
+			public ActionHandler Handler;
+
+			public ActionTuple (string label, ActionHandler handler) {
+				Label = label;
+				Handler = handler;
+			}
+		}
+
+		private INotifications nf;
+
+		private bool updates_pending = false;
+		private bool shown = false;
+
+		private string app_name;
+		private uint id = 0;
+		private int timeout = -1;
+		private string summary = String.Empty, body = String.Empty;
+		private string icon = String.Empty;
+		private Gtk.Widget attach_widget = null;
+		private Gtk.StatusIcon status_icon = null;
+		private IDictionary <string, ActionTuple> action_map = new Dictionary<string, ActionTuple> ();
+		private IDictionary <string, object> hints  = new Dictionary<string, object> ();
+
+		public event EventHandler Closed;
+
+		static Notification () {
+			BusG.Init ();
+		}
+		
+		public Notification () {
+			nf = Global.DBusObject;
+
+			nf.NotificationClosed += OnClosed;
+			nf.ActionInvoked += OnActionInvoked;
+
+			this.app_name = Assembly.GetCallingAssembly().GetName().Name;
+		}
+
+		public Notification (string summary, string body) : this () {
+			this.summary = summary;
+			this.body = body;
+		}
+
+		public Notification (string summary, string body, string icon) : this (summary, body) {
+			this.icon = icon;
+		}
+
+		public Notification (string summary, string body, Pixbuf icon) : this (summary, body) {
+			SetPixbufHint (icon);
+		}
+
+		public Notification (string summary, string body, Pixbuf icon, Gtk.Widget widget) : this (summary, body, icon) {
+			AttachToWidget (widget);
+		}
+		
+		public Notification (string summary, string body, string icon, Gtk.Widget widget) : this (summary, body, icon) {
+			AttachToWidget (widget);
+		}
+
+		public Notification (string summary, string body, Pixbuf icon, Gtk.StatusIcon status_icon) : this (summary, body, icon) {
+			AttachToStatusIcon (status_icon);
+		}
+		
+		public Notification (string summary, string body, string icon, Gtk.StatusIcon status_icon) : this (summary, body, icon) {
+			AttachToStatusIcon (status_icon);
+		}
+
+
+		public string Summary {
+			set {
+				summary = value;
+				Update ();
+			}
+			get {
+				return summary;
+			}
+		}
+
+		public string Body {
+			set {
+				body = value;
+				Update ();
+			}
+			get {
+				return body;
+			}
+		}
+
+		public int Timeout {
+			set {
+				timeout = value;
+				Update ();
+			}
+			get {
+				return timeout;
+			}
+		}
+
+		public Urgency Urgency {
+			set {
+				hints["urgency"] = (byte) value;
+				Update ();
+			}
+			get {
+				return hints.ContainsKey ("urgency") ? (Urgency) hints["urgency"] : Urgency.Normal;
+			}
+		}
+
+		public string Category {
+			set {
+				hints["category"] = value;
+				Update ();
+			}
+			get {
+				return hints.ContainsKey ("category") ? (string) hints["category"] : String.Empty;
+			}
+
+		}
+
+		public Pixbuf Icon {
+			set {
+				SetPixbufHint (value);
+				icon = String.Empty;
+				Update ();
+			}
+		}
+
+		public string IconName {
+			set {
+				icon = value;
+				hints.Remove ("icon_data");
+				Update ();
+			}
+		}
+
+		public uint Id {
+			get {
+				return id;
+			}
+		}
+
+		public Gtk.Widget AttachWidget {
+			get {
+				return attach_widget;
+			}
+			set {
+				AttachToWidget (value);
+			}
+		}
+
+		public Gtk.StatusIcon StatusIcon {
+			get {
+				return status_icon;
+			}
+			set {
+				AttachToStatusIcon (value);
+			}
+		}
+
+		private void SetPixbufHint (Pixbuf pixbuf) {
+			IconData icon_data = new IconData ();
+			icon_data.Width = pixbuf.Width;
+			icon_data.Height = pixbuf.Height;
+			icon_data.Rowstride = pixbuf.Rowstride;
+			icon_data.HasAlpha = pixbuf.HasAlpha;
+			icon_data.BitsPerSample = pixbuf.BitsPerSample;
+			icon_data.NChannels = pixbuf.NChannels;
+
+			int len = (icon_data.Height - 1) * icon_data.Rowstride + icon_data.Width *
+				((icon_data.NChannels * icon_data.BitsPerSample + 7) / 8);
+			icon_data.Pixels = new byte[len];
+			System.Runtime.InteropServices.Marshal.Copy (pixbuf.Pixels, icon_data.Pixels, 0, len);
+
+			hints["icon_data"] = icon_data;
+		}
+
+		public void AttachToWidget (Gtk.Widget widget) {
+			int x, y;
+
+			widget.GdkWindow.GetOrigin (out x, out y);
+
+			if (widget.GetType() != typeof (Gtk.Window) || ! widget.GetType().IsSubclassOf(typeof (Gtk.Window))) {
+				x += widget.Allocation.X;
+				y += widget.Allocation.Y;
+			}
+
+			x += widget.Allocation.Width / 2;
+			y += widget.Allocation.Height / 2;
+
+			SetGeometryHints (widget.Screen, x, y);
+			attach_widget = widget;
+			status_icon = null;
+		}
+
+		public void AttachToStatusIcon (Gtk.StatusIcon status_icon) {
+			Gdk.Screen screen;
+			Gdk.Rectangle rect;
+			Orientation orientation;
+			int x, y;
+
+			if (!status_icon.GetGeometry (out screen, out rect, out orientation)) {
+				return;
+			}
+
+			x = rect.X + rect.Width / 2;
+			y = rect.Y + rect.Height / 2;
+
+			SetGeometryHints (screen, x, y);
+
+			this.status_icon = status_icon;
+			attach_widget = null;
+		}
+
+		public void SetGeometryHints (Screen screen, int x, int y) {
+			hints["x"] = x;
+			hints["y"] = y;
+			hints["xdisplay"] = screen.MakeDisplayName ();
+			Update ();
+		}
+
+		private void Update () {
+			if (shown && !updates_pending) {
+				updates_pending = true;
+				GLib.Timeout.Add (100, delegate {
+					if (updates_pending) {
+						Show ();
+						updates_pending = false;
+					}
+					return false;
+				});
+			}
+		}
+		
+		public void Show () {
+			string[] actions;
+			lock (action_map) {
+				actions = new string[action_map.Keys.Count * 2];
+				int i = 0;
+				foreach (KeyValuePair<string,ActionTuple> pair in action_map) {
+					actions[i++] = pair.Key;
+					actions[i++] = pair.Value.Label;
+				}
+			}
+			id = nf.Notify (app_name, id, icon, summary, body, actions, hints, timeout);
+			shown = true;
+		}
+
+		public void Close () {
+			nf.CloseNotification (id);
+			id = 0;
+			shown = false;
+		}
+
+		private void OnClosed (uint id, uint reason) {
+			if (this.id == id) {
+				this.id = 0;
+				shown = false;
+				if (Closed != null) {
+					Closed (this, new CloseArgs ((CloseReason) reason));
+				}
+			}
+		}
+
+		public void AddAction (string action, string label, ActionHandler handler) {
+			if (Notifications.Global.Capabilities != null &&
+			    Array.IndexOf (Notifications.Global.Capabilities, "actions") > -1) {
+				lock (action_map) {
+					action_map[action] = new ActionTuple (label, handler);
+				}
+				Update ();
+			}
+		}
+
+		public void RemoveAction (string action) {
+			lock (action_map) {
+				action_map.Remove (action);
+			}
+			Update ();
+		}
+
+		public void ClearActions () {
+			lock (action_map) {
+				action_map.Clear ();
+			}
+			Update ();
+		}
+
+		private void OnActionInvoked (uint id, string action) {
+			lock (action_map) {
+				if (this.id == id && action_map.ContainsKey (action))
+					action_map[action].Handler (this, new ActionArgs (action));
+			}
+		}
+
+		public void AddHint (string name, object value) {
+			hints[name] = value;
+			Update ();
+		}
+
+		public void RemoveHint (string name) {
+			hints.Remove (name);
+			Update ();
+		}
+	}
+}
diff --git a/src/Extensions/Banshee.NotificationArea/Notifications/Notifications.cs b/src/Extensions/Banshee.NotificationArea/Notifications/Notifications.cs
new file mode 100644
index 0000000..25ac1e1
--- /dev/null
+++ b/src/Extensions/Banshee.NotificationArea/Notifications/Notifications.cs
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2006 Sebastian Dröge <slomo circular-chaos org>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+using NDesk.DBus;
+using org.freedesktop;
+using org.freedesktop.DBus;
+
+namespace Notifications {
+	[Interface ("org.freedesktop.Notifications")]
+	internal interface INotifications : Introspectable, Properties {
+		ServerInformation ServerInformation { get; }
+		string[] Capabilities { get; }
+		void CloseNotification (uint id);
+		uint Notify (string app_name, uint id, string icon, string summary, string body,
+			string[] actions, IDictionary<string, object> hints, int timeout);
+		event NotificationClosedHandler NotificationClosed;
+		event ActionInvokedHandler ActionInvoked;
+	}
+
+	public enum CloseReason : uint {
+		Expired = 1,
+		User = 2,
+		API = 3,
+		Reserved = 4
+	}
+
+	internal delegate void NotificationClosedHandler (uint id, uint reason);
+	internal delegate void ActionInvokedHandler (uint id, string action);
+
+	public struct ServerInformation {
+		public string Name;
+		public string Vendor;
+		public string Version;
+		public string SpecVersion;
+	}
+
+	public static class Global {
+		private const string interface_name = "org.freedesktop.Notifications";
+		private const string object_path = "/org/freedesktop/Notifications";
+
+		private static INotifications dbus_object = null;
+		private static object dbus_object_lock = new object ();
+
+		internal static INotifications DBusObject {
+			get {
+				if (dbus_object != null)
+					return dbus_object;
+
+				lock (dbus_object_lock) {
+					if (! Bus.Session.NameHasOwner (interface_name))
+						Bus.Session.StartServiceByName (interface_name);
+
+					dbus_object = Bus.Session.GetObject<INotifications>
+						(interface_name, new ObjectPath (object_path));
+					return dbus_object;
+				}
+			}
+		}
+
+		public static string[] Capabilities {
+			get {
+				return DBusObject.Capabilities;
+			}
+		}
+		
+		public static ServerInformation ServerInformation {
+			get {
+				return DBusObject.ServerInformation;
+			}
+		}
+	}
+}
+
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]