← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Tomboy/Plugins/Bugzilla.cs

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-11-16 21:24:14 UTC
  • mfrom: (1.1.7 upstream) (3 etch)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20061116212414-i9mqu3nnn90ulo7m
Tags: 0.5.0-0ubuntu1
* New upstream release
* debian/patches/52_applet-crash.patch:
  + Dropped, merged upstream
* debian/control,
  debian/patches/52_external-dbus-sharp.patch:
  + Build depend on libdbus-1-cil and build against it instead of the
    bundled version
* debian/rules:
  + Install DBus service file into the correct directory
* debian/patches/53_tomboy-tray-icon.patch:
  + Correctly set the icon for the trayicon

Show diffs side-by-side

added added

removed removed

Lines of Context:
Tomboy/Plugins/Bugzilla.cs
 
1
 
 
2
using System;
 
3
using System.IO;
 
4
using System.Runtime.InteropServices;
 
5
using System.Text;
 
6
using System.Xml;
 
7
 
 
8
using Tomboy;
 
9
 
 
10
public class InsertBugAction : SplitterAction
 
11
{
 
12
        BugzillaLink Tag;
 
13
        int Offset;
 
14
        string Id;
 
15
 
 
16
        public InsertBugAction (Gtk.TextIter start,
 
17
                                string id,
 
18
                                Gtk.TextBuffer buffer,
 
19
                                BugzillaLink tag)
 
20
        {
 
21
                Tag = tag;
 
22
                Id = id;
 
23
 
 
24
                Offset = start.Offset;
 
25
        }
 
26
 
 
27
        public override void Undo (Gtk.TextBuffer buffer)
 
28
        {
 
29
                // Tag images change the offset by one, but only when deleting.
 
30
                Gtk.TextIter start_iter = buffer.GetIterAtOffset (Offset);
 
31
                Gtk.TextIter end_iter = buffer.GetIterAtOffset (Offset + chop.Length + 1);
 
32
                buffer.Delete (ref start_iter, ref end_iter);
 
33
                buffer.MoveMark (buffer.InsertMark, buffer.GetIterAtOffset (Offset));
 
34
                buffer.MoveMark (buffer.SelectionBound, buffer.GetIterAtOffset (Offset));
 
35
 
 
36
                Tag.ImageLocation = null;
 
37
 
 
38
                ApplySplitTags (buffer);
 
39
        }
 
40
 
 
41
        public override void Redo (Gtk.TextBuffer buffer)
 
42
        {
 
43
                RemoveSplitTags (buffer);
 
44
 
 
45
                Gtk.TextIter cursor = buffer.GetIterAtOffset (Offset);
 
46
 
 
47
                Gtk.TextTag[] tags = {Tag};
 
48
                buffer.InsertWithTags (ref cursor, Id, tags);
 
49
 
 
50
                buffer.MoveMark (buffer.SelectionBound, buffer.GetIterAtOffset (Offset));
 
51
                buffer.MoveMark (buffer.InsertMark,
 
52
                                 buffer.GetIterAtOffset (Offset + chop.Length));
 
53
 
 
54
        }
 
55
 
 
56
        public override void Merge (EditAction action)
 
57
        {
 
58
                SplitterAction splitter = action as SplitterAction;
 
59
                this.splitTags = splitter.SplitTags;
 
60
                this.chop = splitter.Chop;
 
61
        }
 
62
 
 
63
        /*
 
64
         * The internal listeners will create an InsertAction when the text
 
65
         * is inserted.  Since it's ugly to have the bug insertion appear
 
66
         * to the user as two items in the undo stack, have this item eat
 
67
         * the other one.
 
68
         */
 
69
        public override bool CanMerge (EditAction action)
 
70
        {
 
71
                InsertAction insert = action as InsertAction;
 
72
                if (insert == null) {
 
73
                        return false;
 
74
                }
 
75
 
 
76
                if (String.Compare(Id, insert.Chop.Text) == 0) {
 
77
                        return true;
 
78
                }
 
79
 
 
80
                return false;
 
81
        }
 
82
 
 
83
        public override void Destroy ()
 
84
        {
 
85
        }
 
86
}
 
87
 
 
88
public class BugzillaLink : DynamicNoteTag
 
89
{
 
90
        Gdk.Pixbuf Icon;
 
91
 
 
92
        public BugzillaLink ()
 
93
                : base ()
 
94
        {
 
95
        }
 
96
 
 
97
        public override void Initialize (string element_name)
 
98
        {
 
99
                base.Initialize (element_name);
 
100
 
 
101
                Underline = Pango.Underline.Single;
 
102
                Foreground = "blue";
 
103
                CanActivate = true;
 
104
                CanGrow = true;
 
105
                CanSpellCheck = false;
 
106
                CanSplit = false;
 
107
        }
 
108
 
 
109
        public string BugUrl
 
110
        {
 
111
                get { return (string) Attributes ["uri"]; }
 
112
                set { Attributes ["uri"] = value; }
 
113
        }
 
114
 
 
115
        protected override bool OnActivate (NoteEditor editor, Gtk.TextIter start, Gtk.TextIter end)
 
116
        {
 
117
                if (BugUrl != string.Empty) {
 
118
                        Logger.Log ("Opening url '{0}'...", BugUrl);
 
119
                        Gnome.Url.Show (BugUrl);
 
120
                }
 
121
                return true;
 
122
        }
 
123
 
 
124
        public override void Read (XmlTextReader xml, bool start)
 
125
        {
 
126
                base.Read (xml, start);
 
127
        }
 
128
 
 
129
        public override Gdk.Pixbuf Image
 
130
        {
 
131
                get
 
132
                {
 
133
                        if (Icon != null)
 
134
                                return Icon;
 
135
 
 
136
                        System.Uri uri = new System.Uri(BugUrl);
 
137
                        if (uri == null)
 
138
                                return null;
 
139
 
 
140
                        string host = uri.Host;
 
141
                        string imageDir = "~/.tomboy/BugzillaIcons/";
 
142
 
 
143
                        string imagePath = imageDir.Replace ("~", Environment.GetEnvironmentVariable ("HOME")) + host + ".png";
 
144
 
 
145
                        try {
 
146
                                Icon = new Gdk.Pixbuf (imagePath);
 
147
                        } catch (GLib.GException) {
 
148
                                Icon = new Gdk.Pixbuf(null, "stock_bug.png");
 
149
                        }
 
150
 
 
151
                        return Icon;
 
152
                }
 
153
        }
 
154
}
 
155
 
 
156
public class BugzillaPlugin : NotePlugin
 
157
{
 
158
        static int last_bug;
 
159
 
 
160
        static BugzillaPlugin ()
 
161
        {
 
162
                last_bug = -1;
 
163
        }
 
164
 
 
165
        protected override void Initialize ()
 
166
        {
 
167
                if (!Note.TagTable.IsDynamicTagRegistered ("link:bugzilla")) {
 
168
                        Note.TagTable.RegisterDynamicTag ("link:bugzilla", typeof (BugzillaLink));
 
169
                }
 
170
        }
 
171
 
 
172
        protected override void Shutdown ()
 
173
        {
 
174
        }
 
175
 
 
176
        protected override void OnNoteOpened ()
 
177
        {
 
178
                Window.Editor.DragDataReceived += OnDragDataReceived;
 
179
        }
 
180
 
 
181
        [DllImport("libgobject-2.0.so.0")]
 
182
        static extern void g_signal_stop_emission_by_name (IntPtr raw, string name);
 
183
 
 
184
        [GLib.ConnectBefore]
 
185
        void OnDragDataReceived (object sender, Gtk.DragDataReceivedArgs args)
 
186
        {
 
187
                foreach (Gdk.Atom atom in args.Context.Targets) {
 
188
                        if (atom.Name == "text/uri-list" ||
 
189
                            atom.Name == "_NETSCAPE_URL") {
 
190
                                DropUriList (args);
 
191
                                return;
 
192
                        }
 
193
                }
 
194
        }
 
195
 
 
196
        void DropUriList (Gtk.DragDataReceivedArgs args)
 
197
        {
 
198
                string uriString = Encoding.UTF8.GetString (args.SelectionData.Data);
 
199
 
 
200
                if (uriString.IndexOf ("show_bug.cgi?id=") != -1) {
 
201
                        if (InsertBug (uriString)) {
 
202
                                Gtk.Drag.Finish (args.Context, true, false, args.Time);
 
203
                                g_signal_stop_emission_by_name(Window.Editor.Handle,
 
204
                                                               "drag_data_received");
 
205
                        }
 
206
                }
 
207
        }
 
208
 
 
209
        bool InsertBug(string uri)
 
210
        {
 
211
                try {
 
212
                        string bug = uri.Substring (uri.IndexOf ("show_bug.cgi?id=") + 16);
 
213
                        int id = int.Parse (bug);
 
214
                        // Debounce.  I'm not sure why this is necessary :(
 
215
                        if (id == last_bug) {
 
216
                                last_bug = -1;
 
217
                                return true;
 
218
                        }
 
219
                        last_bug = id;
 
220
 
 
221
                        BugzillaLink link_tag = (BugzillaLink)
 
222
                                Note.TagTable.CreateDynamicTag ("link:bugzilla");
 
223
                        link_tag.BugUrl = uri;
 
224
 
 
225
                        Gtk.TextIter cursor = Buffer.GetIterAtMark (Buffer.InsertMark);
 
226
 
 
227
                        Buffer.Undoer.AddUndoAction (new InsertBugAction (cursor, bug, Buffer, link_tag));
 
228
 
 
229
                        Gtk.TextTag[] tags = {link_tag};
 
230
                        Buffer.InsertWithTags (ref cursor, bug, tags);
 
231
                        return true;
 
232
                } catch {
 
233
                        return false;
 
234
                }
 
235
        }
 
236
}