Merge lp:~waldner/terminator/plugin-ng into lp:terminator/gtk3

[Waldner]

New plugin framework "plugin_ng"

New plugin framework "plugin_ng". See https://bazaar.launchpad.net/~waldner/terminator/plugin-ng/view/head:/plugin-ng.md for a description.

[Waldner (waldner)]

Is this too invasive? Bad style? All comments welcome.

[Bryce Harrington (bryce)]

I like the idea of generalizing the handling of selected patterns and being able to extend it to show different kinds of context menus. Conceptually seems quite interesting. Style looks fine to me, in fact it refactors things to look a bit cleaner. Needs a better name (I don't have suggestions myself, sorry), and I would like to see a couple use case/example ideas at the top of the docs (i.e. what are some useful kinds of things people could expect do with this functionality). A test/example plugin should be included. Those three things fixed I'd give this a +1.

[Waldner (waldner)]

For an example plugin, see https://github.com/waldner/terminator-runwith-plugin (needs the plugin-ng patched terminator, of course). There are some (admittedly simplistic and a bit silly) usage examples there as well.

I'll think about the name (suggestions welcome). What I use it for is to extract patterns from the terminal text (regex can include context, later thrown away, to avoid false matches) and use them as arguments to an external program or command. Think: you have a filename, and want to open it with your editor of choice. You have a github URL, and you want to run "git clone" with it. (more to be added)
Right-click on the element, runwith -> yourcommand and you're done. I'll try to come up with more use cases. Perhaps it's not a popular thing to do, but it definitely helped me.

[Waldner (waldner)]

Probably the most notable use case is the ability to create true context-sensitive menus, which was plain impossible with the old plugin system.

Unmerged revisions

1795. By Waldner on 2018-03-16

New plugin framework "plugin_ng".

=== added file 'plugin-ng.md'
--- plugin-ng.md	1970-01-01 00:00:00 +0000
+++ plugin-ng.md	2018-03-16 17:20:15 +0000
@@ -0,0 +1,129 @@
+#### plugin_ng
+
+- Better plugin support. The new system (called **plugin_ng** for lack of a better
+  name) has the following features:
+  
+    - A plugin can provide various services, and there is a callback for each (see below
+      for the details)
+    - A plugin can inject multiple patterns it's interested in (not just one as before),
+      and when a match is present in the terminal, the plugin is told which of its
+      matches it comes from, so it can take appropriate actions. This allows for eg the
+      creation of true context-sensitive popup menus (show different entries depending
+      on what's currently matching)
+    - Backwards-compatible with old-style plugins (not at the API level, but the code
+      paths that manage old-style plugins have been preserved)
+
+#### Getting started with plugin_ng plugins
+
+A plugin\_ng plugin must extend the `plugin.PluginNg` class and must declare the
+`plugin_ng` capability, so it can be correctly loaded by the plugin registry. The
+plugin must also declare its name in the `plugin_name` variable. Sample code:
+
+    # Every plugin you want Terminator to load *must* be listed
+    # in 'AVAILABLE'
+    AVAILABLE = [ 'MyNgPlugin' ]
+
+    class MyNgPlugin(plugin.PluginNg):
+        capabilities = ['plugin_ng']
+        plugin_name = 'my_ng_plugin' # must be unique
+        ...
+
+Next, the plugin has to implement the callback methods for the services it wants to
+provide, which might be all of them, although the plugin\_ng API was created
+specifically to be able to have better control upon contextual popup menus (eg, right
+click). Here are the available methods for the plugin\_ng callback API, in the order
+they may be called by Terminator.
+
+##### `callback_get_matches(self)`
+
+This method gets called when Terminator wants to know the patterns (ie, regexes) that
+this plugin wants to register. This method must return a dictionary containing
+key/pattern pairs, which represent all the patterns (regular expressions) the plugin
+wants to register. Keys must be unique, patterns are normal python regexes. In
+particular, it's possible to use named capture groups in patterns, eg
+`(?P<NAME>foobar)`, so when the plugin is called later and a match is present, parts
+of the matched text can be extracted.
+
+Example:
+
+```
+return { 'c_file': '\b(?<FILENAME>[^ ]+\.c)\b',
+         'py_file': '\b(?<FILENAME>[^ ]+\.py)\b' }
+```
+
+When other callbacks are run, the plugin will be passed the matched text so it can
+use `\g<FILENAME>` to extract the filename (this is just an example).
+
+##### `def callback_nameopen(self, matched_text, match_name)`
+
+This method is called by Terminator when the popup menu is about to be displayed and
+the context has a match for a pattern provided by this plugin. The purpose of this call
+is to give the plugin a chance to provide custom descriptions for the first two popup
+menu entries (usually "Open"/"Copy", like for example "Open link", "Copy address" when
+the menu pops up on a URI). The plugin is told which one of its registered patterns is
+matching (via the `match_name` variable) and what the text that actually is producing
+the match is (via the `matched_text` variable), so the plugin can take appropriate
+actions. If implemented, the callback must return a `nameopen, namecopy` pair, for
+example:
+
+```        
+return "Open file", "Copy filename"
+```
+
+It is worth noting that these are just descriptions, and can in no way influence the
+way Terminator will open or copy the link.
+
+
+##### `def callback_popup_menu(self, menuitems, terminal, matched_text, match_name)`
+
+This callback is called by Terminator just before showing the popup menu, so the plugin
+has a chance to add its own entries. If there is a match for the plugin, `matched_text`
+and `match_name` can help the plugin determine which one it is. The `menuitems` argument
+is provided by Terminator, and it's where the plugin must append its own entries. The
+`terminal` argument represents the terminal in which the popup menu is being invoked; it
+can be used to determine whether it's part of a terminal group and perhaps run the
+command(s) associated with our menu entries in all terminals.
+        
+Example:
+
+```
+  ...
+  my_command = [ 'ls', '-al', matched_text ]
+  my_entry = Gtk.MenuItem(my_command)
+
+  terminals = terminal.terminator.get_target_terms(terminal)
+
+  my_entry.connect("activate", self.run_command, {'terminals' : terminals, 'command' : my_command})
+  menuitems.append(my_entry)
+  
+  ...
+
+def run_command(self, widget, data):
+  for terminal in data['terminals']:
+    command = ' '.join(data['command']) + '\n'
+    terminal.vte.feed_child(command, len(command))
+```
+
+
+
+##### `def callback_open_transform(self, matched_text, match_name)`
+
+This method is called by Terminator when the popup menu was shown and the user clicked
+on the first menu entry (eg, "Open link" or "Open file" etc) and the current link
+matches a pattern that has been registered by this plugin. In this method the plugin
+has a chance to mangle the URL that will be eventually opened (but again, no way to set
+the way it will be opened, unless it does more than what it's supposed to do).
+As in other callbacks, the plugin is told which of its pattern has matched, so it can
+take appropriate action. The URL that terminator should open must be returned (it can
+also be the `matched_text` unchanged, though). Example:
+
+```
+# matched_text is "#1234"
+return "http://bugtracker.example.com/issue/%s" % matched_text[1:]
+```
+
+For a complete plugin example, see the
+[terminator-runwith-plugin](https://github.com/waldner/terminator-runwith-plugin)
+project, which creates a context-sensitive menu to run arbitrary commands on arbitrary
+text matches.
+

=== modified file 'terminatorlib/plugin.py'
--- terminatorlib/plugin.py	2016-11-25 01:29:55 +0000
+++ terminatorlib/plugin.py	2018-03-16 17:20:15 +0000
@@ -106,7 +106,7 @@
                                 self.instances[item] = func()
                     except Exception, ex:
                         err('PluginRegistry::load_plugins: Importing plugin %s \
-failed: %s' % (plugin, ex))
+                             failed: %s' % (plugin, ex))
 
         self.done = True
 
@@ -114,7 +114,7 @@
         """Return a list of plugins with a particular capability"""
         result = []
         dbg('PluginRegistry::get_plugins_by_capability: searching %d plugins \
-for %s' % (len(self.instances), capability))
+             for %s' % (len(self.instances), capability))
         for plugin in self.instances:
             if capability in self.instances[plugin].capabilities:
                 result.append(self.instances[plugin])
@@ -190,3 +190,39 @@
         """Callback to transform the enclosed URL"""
         raise NotImplementedError
 
+# PluginNg - Can add arbitrary number of regexes to the Terminal widget and provides a
+#               callback to run arbitrary actions
+class PluginNg(Plugin):
+    """Base class for Plugin NG"""
+
+    capabilities = ['plugin_ng']
+    plugin_name = None
+
+    def __init__(self):
+        """Class initialiser"""
+        Plugin.__init__(self)
+        terminator = Terminator()
+        for terminal in terminator.terminals:
+            terminal.pluginng_matches_add(self)
+
+    def callback_get_matches(self):
+        return {}
+
+    def callback_open_transform(self, matched_text, match_name):
+        """Callback to transform the matched text before opening it"""
+        return None
+
+    def callback_nameopen(self, matched_text, match_name):
+        """Callback to add custom open/copy description entries to popup menu"""
+        return None, None
+
+    def callback_popup_menu(self, menuitems, terminal, matched_text, match_name):
+        """Callback to edit the popup menu"""
+        raise NotImplementedError
+
+    def unload(self):
+        """Handle being removed"""
+        terminator = Terminator()
+        for terminal in terminator.terminals:
+            terminal.pluginng_matches_remove(self)
+

=== modified file 'terminatorlib/terminal.py'
--- terminatorlib/terminal.py	2017-06-24 02:02:38 +0000
+++ terminatorlib/terminal.py	2018-03-16 17:20:15 +0000
@@ -89,6 +89,7 @@
     pid = None
 
     matches = None
+    ng_matches = None
     regex_flags = None
     config = None
     default_encoding = None
@@ -255,50 +256,26 @@
 
         return(terminalbox)
 
+    def get_match_name(self, match_tag):
+
+        for match in self.matches:
+            if self.matches[match] == match_tag:
+                return match
+
+        return None
+
+
     def update_url_matches(self):
-        """Update the regexps used to match URLs"""
-        userchars = "-A-Za-z0-9"
-        passchars = "-A-Za-z0-9,?;.:/!%$^*&~\"#'"
-        hostchars = "-A-Za-z0-9:\[\]"
-        pathchars = "-A-Za-z0-9_$.+!*(),;:@&=?/~#%'"
-        schemes   = "(news:|telnet:|nntp:|file:/|https?:|ftps?:|webcal:)"
-        user      = "[" + userchars + "]+(:[" + passchars + "]+)?"
-        urlpath   = "/[" + pathchars + "]*[^]'.}>) \t\r\n,\\\"]"
-
-        lboundry = "\\b"
-        rboundry = "\\b"
-
-        re = (lboundry + schemes +
-                "//(" + user + "@)?[" + hostchars  +".]+(:[0-9]+)?(" + 
-                urlpath + ")?" + rboundry + "/?")
-        reg = GLib.Regex.new(re, self.regex_flags, 0)
-        self.matches['full_uri'] = self.vte.match_add_gregex(reg, 0)
-
-        if self.matches['full_uri'] == -1:
+
+        terminator = Terminator()
+
+        self.match_add('@builtin', 'full_uri', terminator.builtin_re['full_uri'])    
+
+        if self.matches['@builtin']['full_uri'] == -1:
             err ('Terminal::update_url_matches: Failed adding URL matches')
         else:
-            re = (lboundry +
-                    '(callto:|h323:|sip:)' + "[" + userchars + "+][" + 
-                    userchars + ".]*(:[0-9]+)?@?[" + pathchars + "]+" + 
-                    rboundry)
-            reg = GLib.Regex.new(re, self.regex_flags, 0)
-            self.matches['voip'] = self.vte.match_add_gregex(reg, 0)
-            re = (lboundry +
-                    "(www|ftp)[" + hostchars + "]*\.[" + hostchars + 
-                    ".]+(:[0-9]+)?(" + urlpath + ")?" + rboundry + "/?")
-            reg = GLib.Regex.new(re, self.regex_flags, 0)
-            self.matches['addr_only'] = self.vte.match_add_gregex(reg, 0)
-            re = (lboundry +
-                    "(mailto:)?[a-zA-Z0-9][a-zA-Z0-9.+-]*@[a-zA-Z0-9]" +
-                            "[a-zA-Z0-9-]*\.[a-zA-Z0-9][a-zA-Z0-9-]+" +
-                            "[.a-zA-Z0-9-]*" + rboundry)
-            reg = GLib.Regex.new(re, self.regex_flags, 0)
-            self.matches['email'] = self.vte.match_add_gregex(reg, 0)
-            re = (lboundry +
-                  """news:[-A-Z\^_a-z{|}~!"#$%&'()*+,./0-9;:=?`]+@""" +
-                            "[-A-Za-z0-9.]+(:[0-9]+)?" + rboundry)
-            reg = GLib.Regex.new(re, self.regex_flags, 0)
-            self.matches['nntp'] = self.vte.match_add_gregex(reg, 0)
+            for rex in [ 'voip', 'addr_only', 'email', 'nntp' ]:
+                self.match_add('@builtin', rex, terminator.builtin_re[rex])    
 
             # Now add any matches from plugins
             try:
@@ -309,32 +286,85 @@
                 for urlplugin in plugins:
                     name = urlplugin.handler_name
                     match = urlplugin.match
-                    if name in self.matches:
-                        dbg('refusing to add duplicate match %s' % name)
-                        continue
-                    reg = GLib.Regex.new(match, self.regex_flags, 0)
-                    self.matches[name] = self.vte.match_add_gregex(reg, 0)
-                    dbg('added plugin URL handler for %s (%s) as %d' % 
-                        (name, urlplugin.__class__.__name__,
-                        self.matches[name]))
+                    self.match_add(name, '@default', match, urlplugin.__class__.__name__)    
+
             except Exception, ex:
                 err('Exception occurred adding plugin URL match: %s' % ex)
 
-    def match_add(self, name, match):
-        """Register a URL match"""
-        if name in self.matches:
-            err('Terminal::match_add: Refusing to create duplicate match %s' % name)
+            # Matches for new-style plugins
+            try:
+                registry = plugin.PluginRegistry()
+                registry.load_plugins()
+                plugins = registry.get_plugins_by_capability('plugin_ng')
+
+                for ngplugin in plugins:
+                    self.pluginng_matches_add(ngplugin)
+
+            except Exception, ex:
+                err('Exception occurred adding plugin NG match: %s' % ex)
+
+    def pluginng_matches_add(self, plugin):
+
+        for key, pattern in plugin.callback_get_matches().items():
+
+            if str.find(pattern, '@builtin%') != 0:
+                self.match_add( plugin.plugin_name, key, pattern, plugin.plugin_name)    
+            else:
+                # just copy the ID
+                builtin_name = str.split(pattern, '%')[1]
+                self.matches[plugin.plugin_name][key] = self.matches['@builtin'][builtin_name]
+
+
+    def match_add(self, plugin_name, match_name, match, origin = None):
+        """Register a match"""
+        if plugin_name in self.matches and match_name in self.matches[plugin_name]:
+            err('Terminal::match_add: Refusing to create duplicate match %s/%s' % (plugin_name, match_name))
             return
+
+        if not plugin_name in self.matches:
+            self.matches[plugin_name] = {}
+
         reg = GLib.Regex.new(match, self.regex_flags, 0)
-        self.matches[name] = self.vte.match_add_gregex(reg, 0)
-
-    def match_remove(self, name):
+        self.matches[plugin_name][match_name] = self.vte.match_add_gregex(reg, 0)
+
+        if origin:
+            dbg('Terminal::match_add: added match regexp "%s" for %s/%s (%s) as %d' % 
+                (match, plugin_name, match_name, origin, self.matches[plugin_name][match_name]))
+
+    def pluginng_matches_remove(self, plugin):
+        self.match_remove( plugin.plugin_name, plugin.plugin_name)    
+
+    def match_remove(self, plugin_name, origin = None):
         """Remove a previously registered URL match"""
-        if name not in self.matches:
-            err('Terminal::match_remove: Unable to remove non-existent match %s' % name)
+        if plugin_name not in self.matches:
+            err('Terminal::match_remove: Unable to remove non-existent match %s' % plugin_name)
             return
-        self.vte.match_remove(self.matches[name])
-        del(self.matches[name])
+
+        for match_name in self.matches[plugin_name]:
+
+            if not self.is_builtin(self.matches[plugin_name][match_name]):
+                self.vte.match_remove(self.matches[plugin_name][match_name])
+
+            if origin:
+                dbg('Terminal::match_remove: removed match for %s/%s (%s) as %d' % 
+                    (plugin_name, match_name, origin, self.matches[plugin_name][match_name]))
+
+        del(self.matches[plugin_name])
+
+    def is_builtin(self, match_id):
+        for builtin_id in self.matches['@builtin'].keys():
+            if builtin_id == match_id:
+                return True
+        return False
+
+    def match_inverse_lookup(self, match_index):
+        for plugin_name in self.matches:
+            if plugin_name == '@builtin':
+                continue
+            for match_name in self.matches[plugin_name]:
+                if self.matches[plugin_name][match_name] == match_index:
+                    return plugin_name, match_name
+        return None, None
 
     def maybe_copy_clipboard(self):
         if self.config['copy_on_selection'] and self.vte.get_has_selection():
@@ -1447,30 +1477,59 @@
         url = urlmatch[0]
         match = urlmatch[1]
 
-        if match == self.matches['email'] and url[0:7] != 'mailto:':
+        if match == self.matches['@builtin']['email'] and url[0:7] != 'mailto:':
             url = 'mailto:' + url
-        elif match == self.matches['addr_only'] and url[0:3] == 'ftp':
+        elif match == self.matches['@builtin']['addr_only'] and url[0:3] == 'ftp':   # ????
             url = 'ftp://' + url
-        elif match == self.matches['addr_only']:
+        elif match == self.matches['@builtin']['addr_only']:
             url = 'http://' + url
-        elif match in self.matches.values():
+        else:
             # We have a match, but it's not a hard coded one, so it's a plugin
+
+            handled = False
+
+            dbg("*************************** PREPARE_URL " + url + ", " + str(match))
+            plugin_name, match_name = self.match_inverse_lookup(match)
+
             try:
                 registry = plugin.PluginRegistry()
                 registry.load_plugins()
-                plugins = registry.get_plugins_by_capability('url_handler')
+                plugins = registry.get_plugins_by_capability('plugin_ng')
 
-                for urlplugin in plugins:
-                    if match == self.matches[urlplugin.handler_name]:
-                        newurl = urlplugin.callback(url)
+                for ngplugin in plugins:
+                    if ngplugin.plugin_name == plugin_name:
+                        newurl = ngplugin.callback_open_transform(url, match_name)
                         if newurl is not None:
-                            dbg('Terminal::prepare_url: URL prepared by \
-%s plugin' % urlplugin.handler_name)
+                            dbg('Terminal::prepare_url: match prepared by \
+%s ng-plugin (%s)' % (ngplugin.plugin_name, match_name))
                             url = newurl
+                            handled = True
                         break
             except Exception, ex:
                 err('Exception occurred preparing URL: %s' % ex)
 
+            if handled == False:
+                try:
+                    registry = plugin.PluginRegistry()
+                    registry.load_plugins()
+                    plugins = registry.get_plugins_by_capability('url_handler')
+
+                    for urlplugin in plugins:
+
+                        if not urlplugin.handler_name in self.matches:
+                            continue
+
+                        if match == self.matches[urlplugin.handler_name]['@default']:
+                            newurl = urlplugin.callback(url)
+                            if newurl is not None:
+                                dbg('Terminal::prepare_url: URL prepared by \
+                                     %s URL plugin' % urlplugin.handler_name)
+                                url = newurl
+                            break
+                except Exception, ex:
+                    err('Exception occurred preparing URL: %s' % ex)
+
+
         return(url)
 
     def open_url(self, url, prepare=False):

=== modified file 'terminatorlib/terminal_popup_menu.py'
--- terminatorlib/terminal_popup_menu.py	2017-02-19 15:57:36 +0000
+++ terminatorlib/terminal_popup_menu.py	2018-03-16 17:20:15 +0000
@@ -49,38 +49,58 @@
             time = 0
             button = 3
 
+        all_match_values = [ e for value in terminal.matches for e in terminal.matches[value].values() ]
+
         if url and url[0]:
             dbg("URL matches id: %d" % url[1])
-            if not url[1] in terminal.matches.values():
+            if not url[1] in all_match_values:
                 err("Unknown URL match id: %d" % url[1])
                 dbg("Available matches: %s" % terminal.matches)
 
             nameopen = None
             namecopy = None
-            if url[1] == terminal.matches['email']:
+            if url[1] == terminal.matches['@builtin']['email']:
                 nameopen = _('_Send email to...')
                 namecopy = _('_Copy email address')
-            elif url[1] == terminal.matches['voip']:
+            elif url[1] == terminal.matches['@builtin']['voip']:
                 nameopen = _('Ca_ll VoIP address')
                 namecopy = _('_Copy VoIP address')
-            elif url[1] in terminal.matches.values():
-                # This is a plugin match
-                for pluginname in terminal.matches:
-                    if terminal.matches[pluginname] == url[1]:
-                        break
-
-                dbg("Found match ID (%d) in terminal.matches plugin %s" %
-                        (url[1], pluginname))
-                registry = plugin.PluginRegistry()
-                registry.load_plugins()
-                plugins = registry.get_plugins_by_capability('url_handler')
-                for urlplugin in plugins:
-                    if urlplugin.handler_name == pluginname:
-                        dbg("Identified matching plugin: %s" %
-                                urlplugin.handler_name)
-                        nameopen = _(urlplugin.nameopen)
-                        namecopy = _(urlplugin.namecopy)
-                        break
+            else:
+                # See whether some plugin provides custom open/copy description for menu entries
+
+                # NOTE: this assumed, and continues to assume, that only one plugin
+                # can "own" the current match. Not sure this is entirely right.
+
+                plugin_name, match_name = terminal.match_inverse_lookup(url[1])
+
+                if plugin_name != None and match_name != None:
+
+                    registry = plugin.PluginRegistry()
+                    registry.load_plugins()
+
+                    if match_name == '@default':
+                        # old style URL plugin
+                        plugins = registry.get_plugins_by_capability('url_handler')
+
+                        for urlplugin in plugins:
+                            if urlplugin.handler_name == plugin_name:
+                                dbg("Identified matching plugin: %s" %
+                                     urlplugin.handler_name)
+                                nameopen = _(urlplugin.nameopen)
+                                namecopy = _(urlplugin.namecopy)
+                                break
+                    else:
+                        # NG plugin
+                        plugins = registry.get_plugins_by_capability('plugin_ng')
+
+                        for ngplugin in plugins:
+                            if ngplugin.plugin_name == plugin_name:
+                                dbg("Identified matching plugin: %s" %
+                                     ngplugin.plugin_name)
+                                nameopen, namecopy = ngplugin.callback_nameopen(url[0], match_name)
+                                nameopen = _(nameopen)
+                                namecopy = _(namecopy)
+                                break
 
             if not nameopen:
                 nameopen = _('_Open link')
@@ -215,7 +235,34 @@
 
         self.add_encoding_items(menu)
 
+        # multiple plugins can all add their entries at once
         try:
+            
+            registry = plugin.PluginRegistry()
+            registry.load_plugins()
+
+            menuitems = []
+            plugins = registry.get_plugins_by_capability('plugin_ng')
+
+            if url and url[0]:
+                plugin_name, match_name = terminal.match_inverse_lookup(url[1])
+                matched_text = url[0]
+            else:
+                plugin_name, match_name = None, None
+                matched_text = None
+
+            for ngplugin in plugins:
+                if ngplugin.plugin_name == plugin_name:
+                    ngplugin.callback_popup_menu(menuitems, terminal, matched_text, match_name)
+                else:
+                    ngplugin.callback_popup_menu(menuitems, terminal, matched_text, None)
+         
+            if len(menuitems) > 0:
+                menu.append(Gtk.SeparatorMenuItem())
+
+            for menuitem in menuitems:
+                menu.append(menuitem)
+
             menuitems = []
             registry = plugin.PluginRegistry()
             registry.load_plugins()

=== modified file 'terminatorlib/terminator.py'
--- terminatorlib/terminator.py	2017-02-28 19:48:11 +0000
+++ terminatorlib/terminator.py	2018-03-16 17:20:15 +0000
@@ -65,11 +65,13 @@
     cur_gtk_theme_name = None
     gtk_settings = None
 
+    builtin_re = None
+
     def __init__(self):
         """Class initialiser"""
-
         Borg.__init__(self, self.__class__.__name__)
         self.prepare_attributes()
+        self.create_builtin_re()
 
     def prepare_attributes(self):
         """Initialise anything that isn't already"""
@@ -99,6 +101,37 @@
             self.attempt_gnome_client()
         self.connect_signals()
 
+    def create_builtin_re(self):
+
+
+        if self.builtin_re:
+            return
+
+        # built-in RE matches
+        self.builtin_re = {}
+
+        userchars = "-A-Za-z0-9"
+        passchars = "-A-Za-z0-9,?;.:/!%$^*&~\"#'"
+        hostchars = "-A-Za-z0-9:\[\]"
+        pathchars = "-A-Za-z0-9_$.+!*(),;:@&=?/~#%'"
+        schemes   = "(news:|telnet:|nntp:|file:/|https?:|ftps?:|webcal:)"
+        user      = "[" + userchars + "]+(:[" + passchars + "]+)?"
+        urlpath   = "/[" + pathchars + "]*[^]'.}>) \t\r\n,\\\"]"
+
+        lboundry = "\\b"
+        rboundry = "\\b"
+
+        self.builtin_re['full_uri'] = (lboundry + schemes + "//(" + user + "@)?[" + hostchars  +".]+(:[0-9]+)?(" + urlpath + ")?" + rboundry + "/?")
+        self.builtin_re['voip'] = (lboundry + '(callto:|h323:|sip:)' + "[" + userchars + "+][" + userchars + ".]*(:[0-9]+)?@?[" + pathchars + "]+" + rboundry)
+        self.builtin_re['addr_only'] = (lboundry + "(www|ftp)[" + hostchars + "]*\.[" + hostchars + ".]+(:[0-9]+)?(" + urlpath + ")?" + rboundry + "/?")
+        self.builtin_re['email'] = (lboundry + "(mailto:)?[a-zA-Z0-9][a-zA-Z0-9.+-]*@[a-zA-Z0-9]" + "[a-zA-Z0-9-]*\.[a-zA-Z0-9][a-zA-Z0-9-]+" + "[.a-zA-Z0-9-]*" + rboundry)
+        self.builtin_re['nntp'] = (lboundry + """news:[-A-Z\^_a-z{|}~!"#$%&'()*+,./0-9;:=?`]+@""" + "[-A-Za-z0-9.]+(:[0-9]+)?" + rboundry)
+
+        #for name in [ 'full_uri', 'voip', 'addr_only', 'email', 'nntp' ]:
+        #    print "%s: %s" % (name, self.builtin_re[name])
+
+
+
     def connect_signals(self):
         """Connect all the gtk signals"""
         self.gtk_settings=Gtk.Settings().get_default()