~ubuntu-branches/ubuntu/lucid/tomboy/lucid-proposed

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Xml;

using Tomboy;

public class InsertBugAction : SplitterAction
{
	BugzillaLink Tag;
	int Offset;
	string Id;

	public InsertBugAction (Gtk.TextIter start,
	                        string id,
	                        Gtk.TextBuffer buffer,
				BugzillaLink tag)
	{
		Tag = tag;
		Id = id;

		Offset = start.Offset;
	}

	public override void Undo (Gtk.TextBuffer buffer)
	{
		// Tag images change the offset by one, but only when deleting.
		Gtk.TextIter start_iter = buffer.GetIterAtOffset (Offset);
		Gtk.TextIter end_iter = buffer.GetIterAtOffset (Offset + chop.Length + 1);
		buffer.Delete (ref start_iter, ref end_iter);
		buffer.MoveMark (buffer.InsertMark, buffer.GetIterAtOffset (Offset));
		buffer.MoveMark (buffer.SelectionBound, buffer.GetIterAtOffset (Offset));

		Tag.ImageLocation = null;

		ApplySplitTags (buffer);
	}

	public override void Redo (Gtk.TextBuffer buffer)
	{
		RemoveSplitTags (buffer);

		Gtk.TextIter cursor = buffer.GetIterAtOffset (Offset);

		Gtk.TextTag[] tags = {Tag};
		buffer.InsertWithTags (ref cursor, Id, tags);

		buffer.MoveMark (buffer.SelectionBound, buffer.GetIterAtOffset (Offset));
		buffer.MoveMark (buffer.InsertMark,
		                 buffer.GetIterAtOffset (Offset + chop.Length));

	}

	public override void Merge (EditAction action)
	{
		SplitterAction splitter = action as SplitterAction;
		this.splitTags = splitter.SplitTags;
		this.chop = splitter.Chop;
	}

	/*
	 * The internal listeners will create an InsertAction when the text
	 * is inserted.  Since it's ugly to have the bug insertion appear
	 * to the user as two items in the undo stack, have this item eat
	 * the other one.
	 */
	public override bool CanMerge (EditAction action)
	{
		InsertAction insert = action as InsertAction;
		if (insert == null) {
			return false;
		}

		if (String.Compare(Id, insert.Chop.Text) == 0) {
			return true;
		}

		return false;
	}

	public override void Destroy ()
	{
	}
}

public class BugzillaLink : DynamicNoteTag
{
	Gdk.Pixbuf Icon;

	public BugzillaLink ()
		: base ()
	{
	}

	public override void Initialize (string element_name)
	{
		base.Initialize (element_name);

		Underline = Pango.Underline.Single;
		Foreground = "blue";
		CanActivate = true;
		CanGrow = true;
		CanSpellCheck = false;
		CanSplit = false;
	}

	public string BugUrl
	{
		get { return (string) Attributes ["uri"]; }
		set { Attributes ["uri"] = value; }
	}

	protected override bool OnActivate (NoteEditor editor, Gtk.TextIter start, Gtk.TextIter end)
	{
		if (BugUrl != string.Empty) {
			Logger.Log ("Opening url '{0}'...", BugUrl);
			Gnome.Url.Show (BugUrl);
		}
		return true;
	}

	public override void Read (XmlTextReader xml, bool start)
	{
		base.Read (xml, start);
	}

	public override Gdk.Pixbuf Image
	{
		get
		{
			if (Icon != null)
				return Icon;

			System.Uri uri = new System.Uri(BugUrl);
			if (uri == null)
				return null;

			string host = uri.Host;
			string imageDir = "~/.tomboy/BugzillaIcons/";

			string imagePath = imageDir.Replace ("~", Environment.GetEnvironmentVariable ("HOME")) + host + ".png";

			try {
				Icon = new Gdk.Pixbuf (imagePath);
			} catch (GLib.GException) {
				Icon = new Gdk.Pixbuf(null, "stock_bug.png");
			}

			return Icon;
		}
	}
}

public class BugzillaPlugin : NotePlugin
{
	static int last_bug;

	static BugzillaPlugin ()
	{
		last_bug = -1;
	}

	protected override void Initialize ()
	{
		if (!Note.TagTable.IsDynamicTagRegistered ("link:bugzilla")) {
			Note.TagTable.RegisterDynamicTag ("link:bugzilla", typeof (BugzillaLink));
		}
	}

	protected override void Shutdown ()
	{
	}

	protected override void OnNoteOpened ()
	{
		Window.Editor.DragDataReceived += OnDragDataReceived;
	}

	[DllImport("libgobject-2.0.so.0")]
	static extern void g_signal_stop_emission_by_name (IntPtr raw, string name);

	[GLib.ConnectBefore]
	void OnDragDataReceived (object sender, Gtk.DragDataReceivedArgs args)
	{
		foreach (Gdk.Atom atom in args.Context.Targets) {
			if (atom.Name == "text/uri-list" ||
			    atom.Name == "_NETSCAPE_URL") {
				DropUriList (args);
				return;
			}
		}
	}

	void DropUriList (Gtk.DragDataReceivedArgs args)
	{
		string uriString = Encoding.UTF8.GetString (args.SelectionData.Data);

		if (uriString.IndexOf ("show_bug.cgi?id=") != -1) {
			if (InsertBug (uriString)) {
				Gtk.Drag.Finish (args.Context, true, false, args.Time);
				g_signal_stop_emission_by_name(Window.Editor.Handle,
							       "drag_data_received");
			}
		}
	}

	bool InsertBug(string uri)
	{
		try {
			string bug = uri.Substring (uri.IndexOf ("show_bug.cgi?id=") + 16);
			int id = int.Parse (bug);
			// Debounce.  I'm not sure why this is necessary :(
			if (id == last_bug) {
				last_bug = -1;
				return true;
			}
			last_bug = id;

			BugzillaLink link_tag = (BugzillaLink)
				Note.TagTable.CreateDynamicTag ("link:bugzilla");
			link_tag.BugUrl = uri;

			Gtk.TextIter cursor = Buffer.GetIterAtMark (Buffer.InsertMark);

			Buffer.Undoer.AddUndoAction (new InsertBugAction (cursor, bug, Buffer, link_tag));

			Gtk.TextTag[] tags = {link_tag};
			Buffer.InsertWithTags (ref cursor, bug, tags);
			return true;
		} catch {
			return false;
		}
	}
}