Merge lp:~sncf-pde/specto/pattern_search into lp:specto

[kouao aaron]

[lp:~sncf-pde/specto/pattern_search]

169. By Aaron KOUAO <email address hidden> on 2012-03-14

add possibility to choose whether to send email to inform

[Jeff Fortin Tam (kiddo)]

Bonjour,
I couldn't run the code yet, it adds a bunch of dependencies, some of which [like "MySQLdb"] are not available in linux distributions and I'm not sure what to expect from such a huge merge.

However, from a look at the surface of things, there are various problems that I've detected. Just run a directory comparison with meld (http://meld.sf.net) between your branch and the "main" branch and it should become quite apparent.
- You committed a bunch of unrelated files from a build/ directory.
- The merge is unclean (there are merge conflicts). If possible, rebase your branch onto the latest code (maybe you could use for this if you're used to it).
- You added code that is commented out, and print statements. Please do not add unused code.
- You added a huge amount of "public domain" code as a pdfminer directory. Instead, you should depend on a pdfminer library being packaged by Linux distributions, not copy-paste/statically link all that code into specto (which I can't afford to maintain anyway)...

In short, the code needs fixing, various things shouldn't be part of the commits at all (like the build stuff or the pdfminer library) and you should ideally rebase everything onto the latest lp:specto to make the merge easier.

Thanks in advance!

review: Needs Fixing

Unmerged revisions

169. By Aaron KOUAO <email address hidden> on 2012-03-14

add possibility to choose whether to send email to inform

168. By Aaron KOUAO <email address hidden> on 2012-03-14

Add the possibility to crawl pdf page

167. By Fabien_SNCF-PDE on 2011-07-13

- Add a window to set database settings and check them in preferences (default set to sqlite). database in bdd.py and sqlalchemy. Don't finished actually, still work with files
- Add a class to crawl webpage "crawl.py" manually. actually just crawl, don't check pattern and no difference between rss and html page
- Add a window to manage contact and mail address in group (work with database)
- Add possibility to check multiple pattern and exception

166. By Fabien_SNCF-PDE on 2011-04-26

- Fix a little bug in the previous version
- Add a window to set settings for send mails and check them in preferences
- Add a little window to alert if settings are not set when adding a watch (if you give mail adress to the watch without set smtp server the watch will ignore it)
- Add mail settings to gconf and use keyring for password

165. By Fabien_SNCF-PDE on 2011-04-12

Add class to send email when a pattern is found in rss page and a best work for detecting new pattern

164. By Fabien_SNCF-PDE on 2011-04-05

First very simple version

=== added directory 'build'
=== added directory 'build/lib.linux-i686-2.6'
=== added directory 'build/lib.linux-i686-2.6/spectlib'
=== added file 'build/lib.linux-i686-2.6/spectlib/__init__.py'
=== added file 'build/lib.linux-i686-2.6/spectlib/about.py'
--- build/lib.linux-i686-2.6/spectlib/about.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/about.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       about.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+import pygtk
+pygtk.require("2.0")
+import gtk
+
+from spectlib.util import show_webpage, get_path
+
+
+class About:
+    """
+    Class to create a window with the credits
+    and licensing information about Specto.
+    """
+
+    def __init__(self, specto):
+        self.specto = specto
+
+        license_file_path = (os.path.join(get_path(category="doc"), "COPYING"))
+        with open(license_file_path, "r") as license_file:
+            license = license_file.read()
+
+        authors_file_path = (os.path.join(get_path(category="doc"), "AUTHORS"))
+        with open(authors_file_path, "r") as authors_file:
+            # this is a hack, because gtk.AboutDialog expects a list, not a file
+            authors = authors_file.readlines()
+
+        logo = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_about.png"))
+
+        # gtk.AboutDialog will detect if "translator-credits" is untranslated,
+        # and hide the tab.
+        translator_credits = _("translator-credits")
+
+        #create tree
+        self.about = gtk.AboutDialog()
+
+        self.about.set_name("Specto")
+        self.about.set_version(self.specto.VERSION)
+        self.about.set_copyright("Copyright © Jean-François Fortin Tam & Wout Clymans")
+        self.about.set_comments(_("Be notified of everything"))
+        self.about.set_license(license)
+        #self.wTree.set_wrap_license(license)
+        gtk.about_dialog_set_url_hook(lambda about, url: show_webpage(url))
+        self.about.set_website("http://specto.sourceforge.net")
+        self.about.set_website_label(_("Specto's Website"))
+        self.about.set_authors(authors)
+        #self.about.set_documenters(documenters)
+        #self.about.set_artists(artists)
+        self.about.set_translator_credits(translator_credits)
+        self.about.set_logo(logo)
+
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.about.set_icon(icon)
+
+        self.about.connect("response", lambda d, r: self.close())
+
+        self.about.show_all()
+
+    def close(self):
+        self.about.destroy()
+
+
+if __name__ == "__main__":
+    #run the gui
+    app = About()
+    gtk.main()

=== added file 'build/lib.linux-i686-2.6/spectlib/add_watch.py'
--- build/lib.linux-i686-2.6/spectlib/add_watch.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/add_watch.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       add_watch.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+try:
+    import pygtk
+    pygtk.require("2.0")
+except:
+    pass
+
+try:
+    import gtk
+    import spectlib.gtkutil
+except:
+    pass
+
+
+class Add_watch:
+    """Class to create the add watch dialog."""
+    # Please do not use confusing widget names such as 'lbl' and 'tbl',
+    # Use full names like 'label' and 'table'.
+    def __init__(self, specto, notifier, watch_type):
+        self.specto = specto
+        self.notifier = notifier
+        #create tree
+        uifile = os.path.join(self.specto.PATH, "uis/add_watch.ui")
+        windowname = "add_watch"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+
+        self.watch_type = watch_type
+        #save the option for hiding the table
+        self.option_visible = -1
+
+        #catch some events
+        dic = {"on_button_cancel_clicked": self.cancel_clicked,
+        "on_button_add_clicked": self.add_clicked,
+        "on_button_help_clicked": self.help_clicked,
+        "on_add_watch_delete_event": self.delete_event,
+        "check_command_toggled": self.command_toggled,
+        "check_open_toggled": self.open_toggled,
+        "on_refresh_unit_changed": self.set_refresh_values}
+
+        #attach the events
+        self.builder.connect_signals(dic)
+
+        self.add_watch = self.builder.get_object("add_watch")
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.add_watch.set_icon(icon)
+        self.add_watch.set_resizable(False)
+
+        self.name = self.builder.get_object("name")
+        self.refresh = self.builder.get_object("refresh")
+        self.refresh_unit = self.builder.get_object("refresh_unit")
+
+        #create the gui
+        self.plugins_ = {}
+        self.watch_options = {}
+
+        self.set_options(watch_type)
+
+        #set the default values
+        self.refresh_unit.set_active(2)
+        self.refresh.set_value(1.0)
+
+        self.name.grab_focus()
+
+    def set_options(self, watch_type):
+        """ Show the table with the right watch options. """
+        self.watch_options[watch_type] = []
+        if hasattr(self.specto.watch_db.plugin_dict[watch_type], 'get_add_gui_info'):
+            values = self.specto.watch_db.plugin_dict[watch_type].get_add_gui_info()
+        else:
+            values = []
+        
+        try:
+            if self.specto.watch_db.plugin_dict[watch_type].dbus_watch == True:
+                self.refresh.hide()
+                self.refresh_unit.hide()
+                self.builder.get_object("label_refresh1").hide()
+        except:
+            pass
+
+        #create the options gui
+        if len(values) > 0:
+            self.table = gtk.Table(rows=len(values), columns=1, homogeneous=False)
+            self.table.set_row_spacings(6)
+            self.table.set_col_spacings(6)
+            self.watch_options[watch_type] = {}
+
+            i = 0
+            for value, widget in values:
+                table, _widget = widget.get_object()
+                self.table.attach(table, 0, 1, i, i + 1)
+                self.watch_options[watch_type].update({value: widget})
+                i += 1
+
+            self.table.show()
+            vbox = self.builder.get_object("vbox_watch_options")
+            vbox.pack_start(self.table, False, False, 0)
+
+    def set_refresh_values(self, widget):
+        """ Set the max and min values for the refresh unit. """
+        digits = 0
+        climb_rate = 1.0
+        refresh_unit = self.refresh_unit.get_active()
+        self.old_refresh_value = self.refresh.get_value_as_int()  # Grab the current value for reuse after the scale changes
+
+        # Set the new ranges for the refresh value spinbutton
+        if refresh_unit == 0 or refresh_unit == 1:
+            adjustment = gtk.Adjustment(value=1, lower=1, upper=60, step_incr=1, page_incr=10, page_size=0)
+        if refresh_unit == 2:
+            adjustment = gtk.Adjustment(value=1, lower=1, upper=24, step_incr=1, page_incr=10, page_size=0)
+        if refresh_unit == 3:
+            adjustment = gtk.Adjustment(value=1, lower=1, upper=365, step_incr=1, page_incr=30, page_size=0)
+
+        self.refresh.configure(adjustment, climb_rate, digits)
+        self.refresh.set_value(self.old_refresh_value)  # Reuse the previous value, otherwise setting the new scales will reset it to 1
+
+    def add_clicked(self, widget):
+        """
+        Add the watch to the watches repository.
+        """
+        values = {}
+        #get the standard options from a watch
+        values['name'] = self.name.get_text()
+
+        #check if the watch is unique
+        if self.specto.watch_io.is_unique_watch(values['name']):
+            unique_dialog = Unique_Dialog(self.specto)
+            result = unique_dialog.run()
+
+            if result ==1:
+                self.name.grab_focus()
+            else: #edit the existing watch
+                self.add_watch.hide_all()
+                name = values['name']
+                self.notifier.show_edit_watch(-1, name)
+
+        else:
+            values['refresh'] = self.specto.watch_db.set_interval(self.refresh.get_value_as_int(), self.refresh_unit.get_active())
+            values['type'] = self.watch_type
+            values['active'] = True
+            values['last_changed'] = ""
+            values['changed'] = False
+            if self.builder.get_object("check_command").get_active() == True:
+                values['command'] = self.builder.get_object("entry_changed_command").get_text()
+
+            if self.builder.get_object("check_open").get_active() == True:
+                values['open_command'] = self.builder.get_object("entry_open_command").get_text()
+                use_standard_command = False
+            else:
+                values['open_command'] = ""
+                use_standard_command = True
+            
+            if hasattr(self.specto.watch_db.plugin_dict[values['type']], 'get_add_gui_info'):
+                gui_values = self.specto.watch_db.plugin_dict[values['type']].get_add_gui_info()
+            window_options = self.watch_options[values['type']]
+
+            for key in window_options:
+                values[key] = window_options[key].get_value()
+                window_options[key].set_color(0xFFFF, 0xFFFF, 0xFFFF)
+
+            self.builder.get_object("name").modify_base(gtk.STATE_NORMAL, gtk.gdk.Color(0xFFFF, 0xFFFF, 0xFFFF))
+
+            try:
+                id = self.specto.watch_db.create({0: values})[0] #write the options in the configuration file
+            except AttributeError, error_fields:
+                fields = str(error_fields).split(",")
+                i = 1
+                for field in fields:
+                    if field == " name":
+                        self.builder.get_object("name").modify_base(gtk.STATE_NORMAL, gtk.gdk.Color(65535, 0, 0))
+                        self.builder.get_object("name").grab_focus()
+                    else:
+                        field = window_options[field.strip()]
+                        if i == 1:
+                            field.grab_focus()
+                            i = 0
+                        field.set_color(65535, 0, 0)
+            else:
+                self.add_watch.destroy()
+                if use_standard_command:
+                    try:
+                        self.specto.watch_db[id].open_command = self.specto.watch_db[id].standard_open_command
+                    except:
+                        self.specto.watch_db[id].open_command = ""
+                #very simple dialog to display, there is no smtp server in the gconf and block any try to send mail
+                if (self.specto.specto_gconf.get_entry("smtp_entry") == "") and ( values['mail'] != ""):
+                    boite = gtk.Dialog("Attention !", self.add_watch,
+                    gtk.DIALOG_MODAL,
+                    (gtk.STOCK_OK, gtk.RESPONSE_OK))
+
+                    label2 = gtk.Label()
+                    label2.set_text("Veuillez renseigner les paramètres d'envoi d'email dans préférences \n L'envoi de mail n'est pas possible pour l'instant, les autres fonctionnalités fonctionnent normalement")
+                    boite.vbox.pack_start(label2, True, False, 0)
+                    boite.vbox.show_all()
+                    boite.run()
+                    boite.destroy()
+                
+                
+                self.specto.watch_io.write_watch(values)
+                self.notifier.add_notifier_entry(id)
+                self.specto.watch_db[id].start()
+
+    def help_clicked(self, widget):
+        """ Call the show help function. """
+        self.specto.util.show_webpage("http://code.google.com/p/specto/wiki/AddingWatches")
+
+    def cancel_clicked(self, widget):
+        """ Destroy the add watch window. """
+        self.add_watch.destroy()
+
+    def delete_event(self, widget, event, data=None):
+        """ Destroy the window. """
+        self.add_watch.destroy()
+        return True
+
+    def command_toggled(self, widget):
+        sensitive = self.builder.get_object("check_command").get_active()
+        self.builder.get_object("entry_changed_command").set_sensitive(sensitive)
+
+    def open_toggled(self, widget):
+        sensitive = self.builder.get_object("check_open").get_active()
+        self.builder.get_object("entry_open_command").set_sensitive(sensitive)
+
+
+class Unique_Dialog:
+    """
+    Class to create a message when you add a watch with an existing name.
+    """
+
+    def __init__(self, specto):
+        self.specto = specto
+        self.uifile = os.path.join(self.specto.PATH, "uis/dialog_add_watch.ui")
+        self.dialogname = "dialog"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(self.uifile)
+        self.unique_dialog = self.builder.get_object("dialog")
+
+    def run(self):
+        """ Show the unique dialog. """
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.unique_dialog.set_icon(icon)
+        self.unique_dialog.set_resizable(False)
+        result = self.unique_dialog.run()
+
+        self.unique_dialog.destroy()
+
+        return result
+
+
+if __name__ == "__main__":
+    #run the gui
+    app = Add_watch()
+    gtk.main()

=== added file 'build/lib.linux-i686-2.6/spectlib/balloons.py'
--- build/lib.linux-i686-2.6/spectlib/balloons.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/balloons.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       balloons.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import pygtk
+pygtk.require('2.0')
+import pynotify
+import sys
+import gtk
+import spectlib.util
+from time import sleep
+
+notifyInitialized = False
+
+
+class NotificationToast:
+    _notifyRealm = 'Specto'
+    _Urgencies = {'low': pynotify.URGENCY_LOW,
+                'critical': pynotify.URGENCY_CRITICAL,
+                'normal': pynotify.URGENCY_NORMAL}
+
+    def __open_watch(self, n, action, id):
+        if self.specto.notifier.open_watch(id):
+            self.specto.notifier.mark_watch_as_read('', id)
+
+    def __init__(self, specto, notifier):
+        global notifyInitialized
+        self.specto = specto
+        self.notifier = notifier
+
+        if not notifyInitialized:
+            pynotify.init(self._notifyRealm)
+            notifyInitialized = True
+
+        # Check the features available from the notification daemon
+        self.capabilities = {'actions': False,
+                        'body': False,
+                        'body-hyperlinks': False,
+                        'body-images': False,
+                        'body-markup': False,
+                        'icon-multi': False,
+                        'icon-static': False,
+                        'sound': False,
+                        'image/svg+xml': False,
+                        'append': False}
+        caps = pynotify.get_server_caps()
+        if caps is None:
+            print "Failed to receive server caps."
+            sys.exit(1)
+        for cap in caps:
+            self.capabilities[cap] = True
+
+    def show_toast(self, body, icon=None, urgency="low", summary=_notifyRealm, name=None):
+        tray_x = 0
+        tray_y = 0
+
+        if notifyInitialized:
+            sleep(0.5)  # FIXME: issue #43, associate the balloon with the notification icon properly. Currently, this is a hack to leave time for the tray icon to appear before getting its coordinates
+            if self.notifier.tray:
+                tray_x = self.notifier.tray.get_x()
+                tray_y = self.notifier.tray.get_y()
+            else:
+                tray_x = 0
+                tray_y = 0
+            self.toast = pynotify.Notification(summary, body)
+            if name:
+                # If name is not None and exists in specto.watch_db, a button is added to the notification
+                w = self.specto.watch_db.find_watch(name)
+                if w != -1 and self.capabilities["actions"]:  # Don't request action buttons if the notification daemon (ex: notify-osd) rejects them
+                    self.toast.add_action("clicked", gtk.stock_lookup(gtk.STOCK_JUMP_TO)[1].replace('_', ''), self.__open_watch, w)
+            self.toast.set_urgency(self._Urgencies[urgency])
+            if icon:
+                #self.toast.set_property('icon-name', icon)  # We now use a pixbuf in the line below to allow themable icons
+                self.toast.set_icon_from_pixbuf(icon)
+
+            if tray_x != 0 and tray_y != 0:  # grab the x and y position of the tray icon and make the balloon emerge from it
+                self.toast.set_hint("x", tray_x)
+                self.toast.set_hint("y", tray_y)
+
+            try:
+                self.toast.show()
+            except:
+                self.specto.logger.log(_("Cannot display notification message. Make sure that libnotify and D-Bus are available on your system."), "error", self.specto)

=== added file 'build/lib.linux-i686-2.6/spectlib/bdd.py'
--- build/lib.linux-i686-2.6/spectlib/bdd.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/bdd.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       bdd.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+from sqlalchemy import MetaData, create_engine, Column, Integer, String, Text, Boolean, Float, DateTime
+from sqlalchemy.orm import scoped_session, sessionmaker, mapper, column_property
+from sqlalchemy.schema import Table
+import datetime
+
+class Group(object):
+    """ This class represents the group information """
+    def __init__(self, name="", description=""):
+        self.name = name
+        self.description = description
+        self.listmail = []
+        
+    def adduser(self, mail):
+        self.listmail.append(mail)
+        
+    def deluser(self, mail):
+        pass
+        
+    def getinfo(self):
+        return [self.name, self.description]
+    
+    def getmail(self):
+        return self.listmail
+        
+class Mail(object):
+    """This class represents all the mail information"""
+    
+    def __init__(self, name="", firstname="", mail="", group=""):
+        
+        self.name = name
+        self.firstname = firstname
+        self.mail = mail
+        self.group = group
+        
+    def getinfo(self):
+        return [self.name, self.firstname, self.mail, self.group]
+        
+    def setinfo(self, name, firstname, mail, group):
+        self.name = name
+        self.firstname = firstname
+        self.mail = mail
+        self.group = group
+
+class List_rss(object):
+    """ class to save alert in rss page """
+    def __init__(self,title,link,description,page,pattern,mail,observateur):
+        self.title = title
+        self.link = link
+        self.description = description
+        self.page = page.decode('utf-8')
+        self.pattern = pattern
+        self.mail = mail
+        self.obs = observateur
+        
+
+class List_html(object):
+    """ class to save alert in html page """
+    def __init__(self,txt,link,page,pattern,mail,observateur):
+        self.txt = txt
+        self.link = link
+        self.page = page
+        self.pattern = pattern
+        self.mail = mail
+        self.obs = observateur
+        
+class Crawl(object):
+    """ class to save already crawled webpage """
+    def __init__(self,pid, curl, title):
+        self.parentid = pid
+        self.url = curl
+        self.title = title
+        
+#class Save_watch(object):
+#    pass
+    
+class Cache(object):
+    """ class to save capture of page """
+    def __init__(self, name, page, size):
+        self.name = name
+        self.page = page
+        self.size = size
+        
+class Queue(object):
+    """ class to get a queue to crawl """
+    def __init__(self,parent,depth,url):
+        self.parent = parent
+        self.depth = depth
+        self.url = url
+
+class Bdd( object ):
+    """this is an sql handler"""
+    def __init__(self,**datas):
+        url = self.url(**datas)
+        self.metadata = MetaData(url)
+        self.table_contact = Table('contact', self.metadata,
+            Column('id', Integer, primary_key=True),
+            Column('name', String(40)),
+            Column('firstname', String(40)),
+            Column('mail', String(40)),
+            Column('group', String(40)),
+        )
+        self.table_group = Table('groupe', self.metadata,
+            Column('id_g', Integer, primary_key=True),
+            Column('name', String(40)),
+            Column('description', String(40)),
+        )
+        self.table_list_rss = Table('list_rss', self.metadata,
+            Column('id', Integer, primary_key=True),
+            Column('title', String(1000)),
+            Column('link', Text),
+            Column('description', Text),
+            Column('page', Text),
+            Column('pattern', Text),
+            Column('mail', String(60)),
+            Column('watch', String(40)),
+            Column('date', DateTime(timezone=True), default=datetime.datetime.now())
+        )
+        self.table_list_html = Table('list_html', self.metadata,
+            Column('id', Integer, primary_key=True),
+            Column('txt', String(1000)),
+            Column('link', Text),
+            Column('page', Text),
+            Column('pattern', Text),
+            Column('mail', String(60)),
+            Column('watch', String(40)),
+            Column('date', DateTime(timezone=True), default=datetime.datetime.now())
+        )
+        """self.table_watch = Table('watch', self.metadata,
+            Column('id', Integer, primary_key=True),
+            Column('name', String(60)),
+            Column('username', String(60)),
+            Column('redirect', Boolean),
+            Column('error_margin', Float),
+            Column('pattern', Text),
+            Column('open_command', Text),
+            Column('changed', Boolean),
+            Column('last_changed', Text),
+            Column('refresh', Integer),
+            Column('uri', Text),
+            Column('command', Text),
+            Column('mail', String(60)),
+            Column('active', Boolean),
+            Column('password', String(60)),
+            Column('type', String(60)),
+            Column('crawl', Boolean),
+            Column('deep', Integer),
+        )don't work"""
+        """self.table_crawl = Table('crawl', self.metadata,
+            Column('id', Integer, primary_key=True),
+            Column('parent_id', Integer),
+            Column('depth', Integer),
+            Column('url', String(60)),
+            Column('title', Text),
+            Column('date', DateTime),
+            Column('id_watch', Integer),
+            Column('name_watch', String(60)),
+            Column('page', Text),
+            Column('size', Integer),
+        ) for now don't work with this table but more intersting for future"""
+        self.table_cache = Table('cache', self.metadata,
+            Column('id', Integer, primary_key=True),
+            Column('name', String(60)),
+            Column('page', Text),
+            Column('size', Integer),
+        )
+        self.table_crawl = Table('crawl', self.metadata,
+            Column('id',Integer,primary_key=True),
+            Column('parentid',Integer),
+            Column('url',Text),
+            Column('title',Text),
+            Column('date', DateTime(timezone=True), default=datetime.datetime.now()),
+        )
+        self.table_queue = Table('queue', self.metadata,
+            Column('id',Integer,primary_key=True),
+            Column('parent',Integer),
+            Column('depth',Integer),
+            Column('url',Text),
+        )
+        
+        engine = create_engine(url)
+        self.Session = scoped_session(sessionmaker(bind=engine,autoflush=True,autocommit=True))
+        self.session = self.Session()
+        #if table don't exist we create them
+        try:
+            if not engine.engine.has_table('contact'):
+                engine.create(self.table_contact)
+            if not engine.engine.has_table('groupe'):
+                engine.create(self.table_group)
+            if not engine.engine.has_table('list_rss'):
+                engine.create(self.table_list_rss)
+            if not engine.engine.has_table('list_html'):
+                engine.create(self.table_list_html)
+            if not engine.engine.has_table('watch'):
+                engine.create(self.table_watch)
+            if not engine.engine.has_table('cache'):
+                engine.create(self.table_cache)
+            if not engine.engine.has_table('crawl'):
+                engine.create(self.table_crawl)
+            if not engine.engine.has_table('queue'):
+                engine.create(self.table_queue)
+        except Exception, err:
+            print err
+        #Map class with table
+        contact_mapper = mapper(Mail,self.table_contact)
+        group_mapper = mapper(Group,self.table_group)
+        list_rss_mapper = mapper(List_rss,self.table_list_rss)
+        list_html_mapper = mapper(List_html,self.table_list_html)
+        #list_watch_mapper = mapper(Save_watch,self.table_watch)
+        cache_mapper = mapper(Cache,self.table_cache)
+        crawl_mapper = mapper(Crawl,self.table_crawl)
+        queue_mapper = mapper(Queue,self.table_queue)
+        
+    def url( self, **datas):
+        if datas["type"]=="sqlite":
+            return "%(type)s:///%(directory)s"%datas
+        else:
+            return "%(type)s://%(user)s:%(pass)s@%(host)s:%(port)s/%(name)s"%datas
+                        
+    def getAll(self,obj):
+        return self.session.query(obj).all()
+        
+    def get(self, obj, name):
+        try:
+            return self.session.query(obj).filter(getattr(Cache,"name") == "%s"%name).one()
+        except Exception, err:
+            print err
+            return 'True'
+            
+    def getlink(self, obj, name):
+        try:
+            return self.session.query(obj).filter(getattr(Queue,"url") == "%s"%name).one()
+        except:
+            return 'True'
+                       
+    def getqueue(self, obj):
+        try:
+            return self.session.query(obj).first()
+        except Exception, err:
+            print err
+            return 'False'
+                       
+    def add(self, obj):
+        """ Add a row in the table matching with object type """
+        try:
+            self.session.begin(subtransactions=True)
+            self.session.add(obj)
+            self.session.flush()
+            self.session.commit()
+        except Exception,err:
+            self.session.rollback()
+            print err
+        finally:
+            try: 
+                pass
+                #self.session.close()
+            except: 
+                pass
+
+    def delete(self,obj):
+        """ delete the row in table matching with object """
+        try:
+            self.session.begin(subtransactions=True)
+            self.session.delete(obj)
+            self.session.flush()
+            self.session.commit()
+            #self.session.close()
+        except Exception, err:
+            #print "probleme suppression"
+            print err
+    
+    def updatecontact(self,obj,newname):
+        self.session.begin(subtransactions=True)
+        for c in self.session.query(type(obj)):
+            if c.group == obj.group:
+                c.group = newname
+        self.session.flush()
+        self.session.commit()
+        
+    def updatepage(self, obj, new):
+        self.session.begin(subtransactions=True)
+        for c in self.session.query(type(obj)):
+            if c.page == obj.page:
+                c.page = new
+        self.session.flush()
+        self.session.commit()
+        
+    def update(self,obj,column,new):
+        self.session.begin(subtransactions=True)
+        for c in self.session.query(type(obj)):
+            if c.column == obj.column:
+                c.column = new
+        self.session.flush()
+        self.session.commit()
+#can be in the same method but i didn't find the correct syntax

=== added file 'build/lib.linux-i686-2.6/spectlib/config.py'
--- build/lib.linux-i686-2.6/spectlib/config.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/config.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       config.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+class Integer():
+    """A config node containing a integer value.
+    Supports restricting the valid values to a range.
+    """
+
+    def __init__(self, mandatory, low=None, high=None):
+        self.mandatory = mandatory
+        self.low = low
+        self.high = high
+
+    def checkRestrictions(self, value):
+        try:
+            val = int(value)
+        except ValueError:
+            return False, -1
+        return True, val
+
+    def getStandardValue(self):
+        return -1
+
+
+class String():
+    """A config node containing a string value."""
+
+    def __init__(self, mandatory):
+        self.mandatory = mandatory
+
+    def checkRestrictions(self, value):
+        try:
+            val = str(value)
+        except ValueError:
+            return False
+        return True, val
+
+    def getStandardValue(self):
+        return ""
+
+
+class Dec():
+    """
+    A config node containing a decimal value.
+    """
+
+    def __init__(self, mandatory):
+        self.mandatory = mandatory
+
+    def checkRestrictions(self, value):
+        try:
+            val = float(value)
+        except ValueError:
+            return False
+        return True, val
+
+    def getStandardValue(self):
+        return -1
+
+
+class Boolean():
+    """
+    A config node containing a boolean value.
+    """
+
+    def __init__(self, mandatory):
+        self.mandatory = mandatory
+
+    def checkRestrictions(self, value):
+        valid = False
+        if value == "True" or value == 1 or value == True:
+            val = True
+            valid = True
+        if value == "False" or value == 0 or value == False:
+            val = False
+            valid = True
+
+        if valid == False:
+            return False, ""
+        else:
+            return True, val
+
+    def getStandardValue(self):
+        return False

=== added file 'build/lib.linux-i686-2.6/spectlib/console.py'
--- build/lib.linux-i686-2.6/spectlib/console.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/console.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       notifier.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+
+class Console:
+
+    def __init__(self, specto, args):
+        self.specto = specto
+        self.only_changed = False
+
+        if args:
+            if args == "--only-changed":
+                self.only_changed = True
+
+    def start_watches(self):
+        self.specto.watch_db.restart_all_watches()
+
+    def mark_watch_status(self, status, id):
+        """ show the right icon for the status from the watch. """
+        watch = self.specto.watch_db[id]
+
+        if status == "changed":
+            print watch.name, "-", _("Watch has changed.")
+            print watch.get_extra_information()
+        elif self.only_changed:
+            return
+        elif status == "checking":
+            print watch.name, "-", _("Watch started checking.")
+        elif status == "idle":
+            print watch.name, "-", _("Watch is idle.")
+        elif status == "no-network":
+            print _("No network connection detected")
+        elif status == "error":
+            print watch.name, "-", _("There was an error checking the watch")

=== added file 'build/lib.linux-i686-2.6/spectlib/constants.py'
--- build/lib.linux-i686-2.6/spectlib/constants.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/constants.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+# The Specto version
+VERSION = "0.3.1"
+
+# The prefix were Specto is installed to.
+PREFIX = "/usr/local"

=== added file 'build/lib.linux-i686-2.6/spectlib/contact.py'
--- build/lib.linux-i686-2.6/spectlib/contact.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/contact.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       contact.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+import gobject
+from spectlib.bdd import Group, Mail
+try:
+    import pygtk
+    pygtk.require("2.0")
+except:
+    pass
+
+try:
+    import gtk
+except:
+    pass
+
+
+class Contact:
+    """ Display the contact window. """
+    def __init__(self, specto, notifier):
+        
+        self.specto = specto
+        self.notifier = notifier
+        self.base = self.specto.base
+            
+        uifile = os.path.join(self.specto.PATH, "uis/contact.ui")
+        windowname = "contact"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+            
+        #catch some events
+        dic = {"on_add_contact_clicked": self.add_contact_clicked,
+              "on_add_group_clicked": self.add_group_clicked,
+              "on_modify_button_clicked": self.modify_button_clicked,
+              "on_delete_button_clicked": self.delete_button_clicked,
+              "on_contact_view_button_press_event": self.contact_view_button_press_event}
+
+        #attach the events
+        self.builder.connect_signals(dic)
+        self.contact = self.builder.get_object("contact")
+        self.contact.set_size_request(500,300)
+
+        self.groupes = gtk.TreeViewColumn()
+        self.groupes.set_title("Groups")
+                
+        self.cell = gtk.CellRendererText()
+        self.groupes.pack_start(self.cell, True)
+        self.groupes.add_attribute(self.cell, "text", 0)
+        #Get the treeView from the widget Tree
+        self.contactview = self.builder.get_object("contact_view")
+        self.contactview.props.has_tooltip = True
+        self.contactview.connect("query-tooltip", self.query_tooltip_tree_view_cb)
+        self.contactview.get_selection().connect("changed",
+                                          self.selection_changed_cb, self.contactview)
+        
+        self.liststore1 = gtk.TreeStore(str, gobject.TYPE_PYOBJECT)
+        self.contactview.append_column(self.groupes)
+        self.contactview.set_model(self.liststore1)
+        self.gettree()
+
+    def add_group_clicked(self, widget):
+        """Called when the use wants to add a group"""
+        #Create the dialog, show it, and store the results
+        groupDlg = Group_Dialog(self.specto)
+        result,newgroup = groupDlg.run()
+        self.already_exist = 0
+        if (result == gtk.RESPONSE_OK):
+            it = self.liststore1.append(None, [newgroup.name, newgroup])
+            self.base.add(newgroup)
+            
+    def add_contact_clicked(self, widget):
+        """ Open contact dialog """
+        #Create the dialog, show it, and store the results
+        contactDlg = Contact_Dialog(self.specto, self.liststore1)
+        result,self.newuser = contactDlg.run()
+        if (result == gtk.RESPONSE_OK):
+            self.liststore1.foreach(self.add, self.newuser)
+            self.base.add(self.newuser)
+
+    def add(self, model, path, iter, user):
+        """ add a user """
+        value = model.get(iter, 1)
+        if value[0].name == user.group:#FIXME specto got trouble when a group got same name with a mail
+            model.append(iter, [(user.name+" "+user.firstname), user])
+
+    def modify_button_clicked(self, widget):
+        """ Open contact dialog for modify"""
+        #récupère les valeurs de l'élement selectionné
+        try:
+            model, iter = self.contactview.get_selection().get_selected()
+            value = model.get(iter, 1)
+        except:
+            quit
+            
+        if isinstance(value[0], Group): 
+            groupDlg = Group_Dialog(self.specto)
+            groupDlg.setvalue(value[0].name, value[0].description)
+            result,self.newgroup = groupDlg.run()
+            if (result == gtk.RESPONSE_OK):
+                dest = model.append(None,[self.newgroup.name, self.newgroup])
+                if value[0].name != self.newgroup.name:
+                    nb = model.iter_n_children(iter)
+                    n = 0
+                    while n < nb:
+                        it = model.iter_children(iter)
+                        valeurs1 = model.get(it, 1)[0]
+                        valeurs0 = model.get(it, 0)[0]
+                        model.remove(it)
+                        #self.base.delete(valeurs1)
+                        model.append(dest, [valeurs0, valeurs1])
+                        #self.base.add(Mail(valeurs1.name, valeurs1.firstname, valeurs1.mail, self.newgroup.name))
+                        #self.base.update(valeurs1,"contact",self.newgroup.name)
+                        self.base.updatecontact(valeurs1,self.newgroup.name)
+                        n = n + 1
+                    model.remove(iter)
+                    self.base.delete(value[0])
+                    self.base.add(self.newgroup)
+                else:
+                    nb = model.iter_n_children(iter)
+                    n = 0
+                    while n < nb:
+                        it = model.iter_children(iter)
+                        valeurs1 = model.get(it, 1)[0]
+                        valeurs0 = model.get(it, 0)[0]
+                        model.remove(it)
+                        model.append(dest, [valeurs0, valeurs1])
+                        n = n + 1
+                    model.remove(iter)
+                    self.base.delete(value[0])
+                    self.base.add(self.newgroup)
+                #model.set_value(iter, 0, [self.newgroup.name, self.newgroup][0])
+                    
+        if isinstance(value[0], Mail):
+            contactDlg = Contact_Dialog(self.specto, self.liststore1)
+            contactDlg.setvalue(value[0].name, value[0].firstname, value[0].mail)
+            result,self.newuser = contactDlg.run()
+            if (result == gtk.RESPONSE_OK):
+                model.remove(iter)
+                self.base.delete(value[0])
+                self.base.add(self.newuser)
+                self.liststore1.foreach(self.add, self.newuser)
+        
+    def delete_button_clicked(self, widget):
+        """ delete item selected """
+        try:
+            model, iter = self.contactview.get_selection().get_selected()
+            value = model.get(iter, 1)
+            if isinstance(value[0], Group): 
+                nb = model.iter_n_children(iter)
+                n = 0
+                while n < nb:
+                    it = model.iter_children(iter)
+                    valeurs1 = model.get(it, 1)[0]
+                    valeurs0 = model.get(it, 0)[0]
+                    model.remove(it)
+                    self.base.delete(valeurs1)
+                    n = n + 1
+                model.remove(iter)
+                self.base.delete(value[0])
+            else:
+                self.base.delete(value[0])
+                model.remove(iter)
+        except:
+            pass
+            
+    def query_tooltip_tree_view_cb(self, widget, x, y, keyboard_tip, tooltip):
+        """ show tooltip  """
+        if not widget.get_tooltip_context(x, y, keyboard_tip):
+            return False
+        else:
+            model, path, iter = widget.get_tooltip_context(x, y, keyboard_tip)
+            value = model.get(iter, 1)
+            if isinstance(value[0], Group):
+                tooltip.set_markup("%s" %(value[0].description))
+            else:
+                tooltip.set_markup("%s" %(value[0].mail))
+            widget.set_tooltip_row(tooltip, path)
+            return True
+    
+    def selection_changed_cb(self, selection, tree_view):
+        tree_view.trigger_tooltip_query()
+        
+    def contact_view_button_press_event(self, treeview, event):
+        """clic sur un element"""
+        if event.button == 3:
+            x = int(event.x)
+            y = int(event.y)
+            pthinfo = treeview.get_path_at_pos(x, y)
+            if pthinfo != None:
+                path, col, cellx, celly = pthinfo
+                treeview.grab_focus()
+                treeview.set_cursor( path, col, 0)
+            model = treeview.get_model()
+            iter = model.get_iter(path)
+            #Je récupère la troisième valeur
+            content = model[iter][0]
+        
+    def gettree(self):
+        listg = self.base.getAll(Group)
+        listm = self.base.getAll(Mail)
+        for group in listg:
+            it = self.liststore1.append(None, [group.name, group])
+            
+        for mail in listm:
+            self.liststore1.foreach(self.add, mail)
+                    
+class Group_Dialog:
+    """ This class is used to show Group dialog """
+    
+    def __init__(self, specto):
+    
+        self.specto = specto
+        uifile = os.path.join(self.specto.PATH, "uis/group_contact_dialog.ui")
+        windowname = "group_dialog"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+
+    def run(self):
+        self.group_dlg = self.builder.get_object("group_dialog")
+        self.result = self.group_dlg.run()
+        self.getparam()
+        self.group_dlg.destroy()
+        return self.result,self.group
+
+    def getparam(self):
+        self.name = self.builder.get_object("groupname_entry")
+        self.n = self.name.get_text()
+        self.description = self.builder.get_object("description_entry")
+        self.d = self.description.get_text()
+        self.group = Group(self.n,self.d)
+            
+    def setvalue(self, name, description):
+        self.name = self.builder.get_object("groupname_entry")
+        self.name.set_text(name)
+        self.description = self.builder.get_object("description_entry")
+        self.description.set_text(description)
+ 
+class Contact_Dialog:
+    """ This class is used to show Contact dialog """
+    
+    def __init__(self, specto, model):
+        
+        self.specto = specto
+        self.model = model
+        uifile = os.path.join(self.specto.PATH, "uis/contact_dialog.ui")
+        windowname = "contact_dialog"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+        #catch some events
+        dic = {"on_combo_changed": self.combo_changed}
+        #attach the events
+        self.builder.connect_signals(dic)
+        
+    def run(self):
+        self.setparam()
+        self.contact_dlg = self.builder.get_object("contact_dialog")
+        self.result = self.contact_dlg.run()
+        self.getparam()
+        self.contact_dlg.destroy()
+        return self.result,self.email
+
+    def combo_changed(self, widget):
+        model = self.group.get_model()
+        index = self.group.get_active()
+        if index:
+            self.groupname = model[index][0]
+        else:
+            self.groupname = "pas recu"
+
+    def getparam(self):
+        self.name = self.builder.get_object("name_entry")
+        self.n = self.name.get_text()
+        self.firstname = self.builder.get_object("firstname_entry")
+        self.f = self.firstname.get_text()
+        self.mail = self.builder.get_object("mail_entry")
+        self.m = self.mail.get_text()
+        self.email = Mail(self.n,self.f,self.m,self.groupname)
+ 
+    def setparam(self):
+        self.group = self.builder.get_object("combo")
+        self.liststore1 = gtk.ListStore(str)
+        self.case = gtk.CellRendererText()
+        self.group.pack_start(self.case, True)
+        self.group.add_attribute(self.case, 'text', 0) 
+        self.liststore1.append(['Vous pouvez choisir un groupe:'])
+        self.model.foreach(self.addcombo)
+        self.group.set_model(self.liststore1)
+        self.group.set_active(0)
+        
+    def setvalue(self, name, firstname, mail):
+        self.name = self.builder.get_object("name_entry")
+        self.name.set_text(name)
+        self.firstname = self.builder.get_object("firstname_entry")
+        self.firstname.set_text(firstname)
+        self.mail = self.builder.get_object("mail_entry")
+        self.mail.set_text(mail)
+
+    def addcombo(self, model, path, iter):
+        value = model.get(iter, 1)
+        if isinstance(value[0], Group):
+            self.liststore1.append([value[0].name])
+            
+if __name__ == "__main__":
+    #run the gui
+    app = Contact()
+    gtk.main()

=== added file 'build/lib.linux-i686-2.6/spectlib/crawl.py'
--- build/lib.linux-i686-2.6/spectlib/crawl.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/crawl.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       crawl.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import urllib2
+##import lxml.html
+from spectlib.bdd import Bdd, Crawl, Queue
+import robotparser
+import threading
+import urlparse
+import sys, re
+import time
+
+class Crawler(threading.Thread):
+    """ class to crawl webpage """
+    def __init__(self, depth, domain, base, starturl):
+        threading.Thread.__init__(self)
+        self.rp = robotparser.RobotFileParser()
+        self.crawled = []
+        self.base = base
+        #add url to the queue
+        try:
+            self.base.add(Queue(0, 0, starturl))
+        except Exception,err:
+            print err
+        self.crawldepth = depth
+        self.domain = domain
+    def run(self):
+        while 1:
+            try:
+                # Get the first item from the queue
+                crawling = self.base.getqueue(Queue)
+
+                # if theres nothing in the que, then set the status to done and exit
+                # Remove the item from the queue
+                if crawling:
+                    try:
+                        self.base.delete(crawling)
+                    except Exception,err:
+                        print err
+                else:
+                    return
+            except Exception, err:
+                print err
+
+            # Crawl the link
+            self.crawl(crawling)
+                
+    def crawl(self, obj):
+        print "Crawling.........."
+        cid = obj.id
+        # parent id. 0 if start url
+        pid = obj.parent
+        # current depth
+        curdepth = obj.depth
+        # crawling url
+        curl = obj.url
+        # Split the link into its sections
+        url = urlparse.urlparse(curl)
+        
+        try:
+            # Have our robot parser grab the robots.txt file and read it
+            self.rp.set_url('http://' + url[1] + '/robots.txt')
+            self.rp.read()
+    
+            # If we're not allowed to open a url, return the function to skip it
+            if not self.rp.can_fetch('specto', curl):
+                print curl + " not allowed by robots.txt"
+                return
+        except:
+            pass
+        
+        try:
+            # Add the link to the already crawled list
+            self.crawled.append(curl)
+        except MemoryError:
+            # If the crawled array is too big, deleted it and start over
+            del self.crawled[:]
+        try:
+            request = urllib2.Request(curl)
+            request.add_header("User-Agent", "specto")
+            opener = urllib2.build_opener()
+            msg = opener.open(request).read()
+        except:
+            return
+    
+        # Find what's between the title tags
+        title = ""
+        startPos = msg.find('<title>')
+        if startPos != -1:
+            endPos = msg.find('</title>', startPos+7)
+            if endPos != -1:
+                title = msg[startPos+7:endPos]
+        
+        #with lxml library, find all link in a page
+        if curdepth < self.crawldepth:
+            html = urllib2.urlopen(curl).read()
+            etree = lxml.html.fromstring(html)
+            for href in etree.xpath("//a/@href"):
+                row = self.base.getlink(Queue, href) #check if link don't exist already
+                if row != 'True':
+                    continue
+                if not href.startswith("http://"):
+                    if href.startswith('/'):
+                        href = 'http://' + url[1] + href #complete the url
+                    elif href.startswith('#'):
+                        continue
+                    elif not href.startswith('http'):
+                        href = urlparse.urljoin(url.geturl(),href)
+                print href #to debug 
+                if href not in self.crawled: #.decode('utf-8')
+                    if self.domain == True and re.search("http://"+url[1],href):#check if url is in domain
+                        try:
+                            self.base.add(Queue(pid, curdepth+1, href))
+                        except Exception, err:
+                            print err
+                            continue
+                    else:
+                        try:
+                            self.base.add(Queue(pid, curdepth+1, href))
+                        except Exception, err:
+                            print err
+                            continue
+            try:
+                # Put now crawled link into the db
+                self.base.add(Crawl(pid, curl, title))
+            except Exception, err:
+                print err
+        else:
+            pass

=== added file 'build/lib.linux-i686-2.6/spectlib/edit_watch.py'
--- build/lib.linux-i686-2.6/spectlib/edit_watch.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/edit_watch.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       add_watch.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+try:
+    import pygtk
+    pygtk.require("2.0")
+except:
+    pass
+
+try:
+    import gtk
+    import spectlib.gtkconfig
+except:
+    pass
+
+
+class Edit_watch:
+    """Class to create the edit watch dialog."""
+    # Please do not use confusing widget names such as 'lbl' and 'tbl',
+    # use full names like 'label' and 'table'.
+    def __init__(self, specto, notifier, id):
+        self.specto = specto
+        self.notifier = notifier
+        self.watch = self.specto.watch_db[id]
+        # Create the tree
+        uifile = os.path.join(self.specto.PATH, "uis/edit_watch.ui")
+        windowname = "edit_watch"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+
+        # Catch some events
+        dic = {"on_button_cancel_clicked": self.cancel_clicked,
+            "on_button_save_clicked": self.save_clicked,
+            "on_button_remove_clicked": self.remove_clicked,
+            #"on_button_clear_clicked": self.clear_clicked,  # clear error_log textfield
+            "on_button_save_as_clicked": self.save_as_clicked,  # save error_log text
+            "on_edit_watch_delete_event": self.delete_event,
+            "check_command_toggled": self.command_toggled,
+            "check_open_toggled": self.open_toggled,
+            "on_refresh_unit_changed": self.set_refresh_values}
+
+        # Attach the events
+        self.builder.connect_signals(dic)
+
+        # Set the info from the watch
+        self.edit_watch = self.builder.get_object("edit_watch")
+        self.edit_watch.set_title(_("Edit watch: ") + self.watch.name)
+        self.builder.get_object("name").set_text(self.watch.name)
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.edit_watch.set_icon(icon)
+        self.edit_watch.set_resizable(False)
+
+        refresh, refresh_unit = self.specto.watch_db.get_interval(self.watch.refresh)
+        self.builder.get_object("refresh_unit").set_active(refresh_unit)
+        self.builder.get_object("refresh").set_value(refresh)
+
+        # Create the gui
+        self.watch_options = {}
+        self.create_edit_gui()
+
+        if not self.specto.DEBUG:
+            self.builder.get_object("notebook1").remove_page(2)
+        else:
+            if self.builder.get_object("notebook1").get_n_pages() == 3:
+                # Put the logfile in the textview
+                log_text = self.specto.logger.watch_log(self.watch.name)
+                self.log_buffer = self.builder.get_object("error_log").get_buffer()
+                self.log_buffer.create_tag("ERROR", foreground="#a40000")
+                self.log_buffer.create_tag("INFO", foreground="#4e9a06")
+                self.log_buffer.create_tag("WARNING", foreground="#c4a000")
+                iter = self.log_buffer.get_iter_at_offset(0)
+                for line in log_text:
+                    self.log_buffer.insert_with_tags_by_name(iter, line[1], line[0])
+
+    def cancel_clicked(self, widget):
+        """ Destroy the edit watch dialog. """
+        self.edit_watch.destroy()
+
+    def set_refresh_values(self, widget):
+        """ Set the max and min values for the refresh unit. """
+        digits = 0
+        climb_rate = 1.0
+        refresh_unit = self.builder.get_object("refresh_unit").get_active()
+
+        if refresh_unit == 0 or refresh_unit == 1:
+            adjustment = gtk.Adjustment(value=1, lower=1, upper=60, step_incr=1, page_incr=10, page_size=0)
+        if refresh_unit == 2:
+            adjustment = gtk.Adjustment(value=1, lower=1, upper=24, step_incr=1, page_incr=10, page_size=0)
+        if refresh_unit == 3:
+            adjustment = gtk.Adjustment(value=1, lower=1, upper=365, step_incr=1, page_incr=30, page_size=0)
+
+        self.builder.get_object("refresh").configure(adjustment, climb_rate, digits)
+
+    def save_clicked(self, widget):
+        """ Save the new options from the edited watch. """
+        values = {}
+        #get the standard options from a watch
+        values['name'] = self.builder.get_object("name").get_text()#FIXME: cfgparse cannot have single quotes (') it seems. We must watch out for the watch name or arguments not to have them.
+
+        values['type'] = self.watch.type
+        refresh_value = self.builder.get_object("refresh").get_value_as_int()
+        refresh_unit = self.builder.get_object("refresh_unit").get_active()
+        values['refresh'] = self.specto.watch_db.set_interval(refresh_value, refresh_unit)
+        values['active'] = self.watch.active
+        values['last_changed'] = self.watch.last_changed
+
+        if self.builder.get_object("check_command").get_active() == True:
+            values['command'] = self.builder.get_object("entry_changed_command").get_text()
+
+        if self.builder.get_object("check_open").get_active() == True:
+            values['open_command'] = self.builder.get_object("entry_open_command").get_text()
+        else:
+            values['open_command'] = ""
+
+        if hasattr(self.specto.watch_db.plugin_dict[values['type']], 'get_add_gui_info'):
+            gui_values = self.specto.watch_db.plugin_dict[values['type']].get_add_gui_info()
+        window_options = self.watch_options[values['type']]
+
+        for key in window_options:
+            values[key] = window_options[key].get_value()
+            window_options[key].set_color(0xFFFF, 0xFFFF, 0xFFFF)
+
+        self.builder.get_object("name").modify_base(gtk.STATE_NORMAL, gtk.gdk.Color(0xFFFF, 0xFFFF, 0xFFFF))
+
+        try:
+            self.specto.watch_db[self.watch.id].set_values(values, True)
+        except AttributeError, error_fields:
+            fields = str(error_fields).split(",")
+            i = 1
+            for field in fields:
+                if field == " name":
+                    self.builder.get_object("name").modify_base(gtk.STATE_NORMAL, gtk.gdk.Color(65535, 0, 0))
+                    self.builder.get_object("name").grab_focus()
+                else:
+                    field = window_options[field.strip()]
+                    if i == 1:
+                        field.grab_focus()
+                        i = 0
+                    field.set_color(65535, 0, 0)
+        else:
+            if not self.specto.watch_io.is_unique_watch(values['name']):
+                self.specto.watch_io.replace_name(self.watch.name, values['name'])
+                # Change the name in the notifier window
+                self.specto.notifier.change_name(values['name'], self.watch.id)
+
+            self.specto.watch_db[self.watch.id].set_values(values)
+
+            self.specto.watch_io.write_watch(values)
+            self.specto.notifier.show_watch_info()
+            self.edit_watch.destroy()
+
+            if self.watch.active == True:
+                self.specto.watch_db[self.watch.id].restart()
+
+    def remove_clicked(self, widget):
+        """ Remove the watch. """
+        dialog = spectlib.gtkconfig.RemoveDialog(_("Remove a watch"),
+        (_('<big>Remove the watch "%s"?</big>\nThis operation cannot be undone.') % self.watch.name))
+        answer = dialog.show()
+        if answer == True:
+            self.edit_watch.destroy()
+            self.notifier.remove_notifier_entry(self.watch.id)
+            self.specto.watch_db.remove(self.watch.id) #remove the watch
+            self.specto.watch_io.remove_watch(self.watch.name)
+            if self.notifier.tray:
+                self.notifier.tray.show_tooltip()
+
+    def clear_clicked(self, widget):
+        """ Clear the log window. """
+        self.specto.logger.remove_watch_log(self.watch.name)
+        self.log = self.specto.logger.watch_log(self.watch.name)
+        self.logwindow.set_text(self.log)
+
+    def save_as_clicked(self, widget):
+        """ Open the Save as dialog window. """
+        Save_dialog(self, self.log)
+
+    def delete_event(self, widget, event, data=None):
+        """ Destroy the window. """
+        self.edit_watch.destroy()
+        return True
+
+    def create_edit_gui(self):
+        """ Create the gui for the different kinds of watches. """
+        vbox_options = self.builder.get_object("vbox_watch_options")
+        watch_type = self.watch.type
+        self.watch_options[watch_type] = []
+        try:
+            self.table.destroy()
+        except:
+            pass
+        
+        try:
+            if self.specto.watch_db.plugin_dict[watch_type].dbus_watch == True:
+                self.builder.get_object("refresh").hide()
+                self.builder.get_object("refresh_unit").hide()
+                self.builder.get_object("label_refresh1").hide()
+        except:
+            pass
+        
+        if hasattr(self.specto.watch_db.plugin_dict[watch_type], 'get_add_gui_info'):
+            values = self.specto.watch_db.plugin_dict[watch_type].get_add_gui_info()
+        else:
+            values = []
+            
+        watch_values = self.watch.get_values()
+
+        if watch_values['command'] != "":
+            self.builder.get_object("entry_changed_command").set_text(watch_values['command'])
+            self.builder.get_object("check_command").set_active(True)
+        else:
+            self.builder.get_object("entry_changed_command").set_text("")
+            self.builder.get_object("check_command").set_active(False)
+
+        if watch_values['open_command'] != "":
+            self.builder.get_object("entry_open_command").set_text(watch_values['open_command'])
+            self.builder.get_object("check_open").set_active(True)
+        else:
+            self.builder.get_object("entry_open_command").set_text("")
+            self.builder.get_object("check_open").set_active(False)
+
+
+        # Create the options gui
+        if len(values) > 0:
+            self.table = gtk.Table(rows=len(values), columns=2, homogeneous=False)
+            self.table.set_row_spacings(6)
+            self.table.set_col_spacings(6)
+            self.watch_options[watch_type] = {}
+
+            i = 0
+            for value, widget in values:
+                table, _widget = widget.get_object()
+                widget.set_value(watch_values[value])
+                self.table.attach(table, 0, 1, i, i + 1)
+                self.watch_options[watch_type].update({value: widget})
+                i += 1
+
+            self.table.show()
+            vbox_options.pack_start(self.table, False, False, 0)
+
+    def command_toggled(self, widget):
+        sensitive = self.builder.get_object("check_command").get_active()
+        self.builder.get_object("entry_changed_command").set_sensitive(sensitive)
+
+    def open_toggled(self, widget):
+        sensitive = self.builder.get_object("check_open").get_active()
+        self.builder.get_object("entry_open_command").set_sensitive(sensitive)
+
+
+class Save_dialog:
+    """
+    Class to create the save dialog.
+    """
+
+    def __init__(self, specto, *args):
+        """ Display the save as dialog. """
+        self.specto = specto
+        self.text = args[0]
+        # Create the tree
+        uifile = os.path.join(self.specto.PATH, "uis/edit_watch.ui")
+        windowname = "file_chooser"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+        self.save_dialog = self.builder.get_object("file_chooser")
+
+        dic = {"on_button_cancel_clicked": self.cancel,
+            "on_button_save_clicked": self.save}
+        # Attach the events
+        self.builder.connect_signals(dic)
+
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.save_dialog.set_icon(icon)
+        self.save_dialog.set_filename(os.environ['HOME'] + "/ ")
+
+    def cancel(self, *args):
+        """ Destroy the window. """
+        self.save_dialog.destroy()
+
+    def save(self, *args):
+        """ Save the file. """
+        file_name = self.save_dialog.get_filename()
+
+        f = open(file_name, "w")
+        f.write(self.text)
+        f.close()
+
+        self.save_dialog.destroy()
+
+
+if __name__ == "__main__":
+    # Run the gui
+    app = Edit_watch()
+    gtk.main()

=== added file 'build/lib.linux-i686-2.6/spectlib/export_watch.py'
--- build/lib.linux-i686-2.6/spectlib/export_watch.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/export_watch.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       import_export.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+from spectlib.watch import Watch_io
+from spectlib.gtkconfig import SaveDialog
+
+try:
+    import pygtk
+    pygtk.require("2.0")
+except:
+    pass
+
+try:
+    import gtk
+    import gobject
+except:
+    pass
+
+
+class Export_watch:
+    """
+    Class to create the import/export watch dialog.
+    """
+
+    def __init__(self, specto, notifier):
+        self.specto = specto
+        self.notifier = notifier
+
+        #create tree
+        uifile = os.path.join(self.specto.PATH, "uis/import_export.ui")
+        windowname = "import_export"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+        self.export_watch = self.builder.get_object("import_export")
+        self.export_watch.set_title(_("Export watches"))
+        self.builder.get_object("button_action").set_label(_("Export watches"))
+
+        self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gtk.gdk.Pixbuf, \
+                    gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING)
+        self.new_watch_db = {}
+
+        #catch some events
+        dic = {"on_button_select_all_clicked": self.select_all,
+              "on_button_deselect_all_clicked": self.deselect_all,
+              "on_button_action_clicked": self.do_action,
+              "on_button_close_clicked": self.delete_event}
+
+        #attach the events
+        self.builder.connect_signals(dic)
+
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.export_watch.set_icon(icon)
+
+        self.treeview = self.builder.get_object("treeview")
+        self.treeview.set_model(self.model)
+        self.treeview.set_flags(gtk.TREE_MODEL_ITERS_PERSIST)
+        self.iter = {}
+
+        ### Checkbox
+        self.renderer = gtk.CellRendererToggle()
+        self.renderer.set_property("activatable", True)
+        self.renderer.connect("toggled", self.check_clicked, self.model)
+        self.columnCheck = gtk.TreeViewColumn(_("Select"), \
+                            self.renderer, active=0)
+        self.treeview.append_column(self.columnCheck)
+
+        ### Icon
+        self.renderer = gtk.CellRendererPixbuf()
+        self.columnIcon = gtk.TreeViewColumn(_("Type"), \
+                            self.renderer, pixbuf=1)
+        self.treeview.append_column(self.columnIcon)
+
+        ### Titre
+        self.renderer = gtk.CellRendererText()
+        self.columnTitel = gtk.TreeViewColumn(_("Name"), \
+                            self.renderer, markup=2)
+        self.columnTitel.set_expand(True)
+        self.columnTitel.set_resizable(True)
+        self.treeview.append_column(self.columnTitel)
+
+        ### ID
+        self.renderer = gtk.CellRendererText()
+        self.column = gtk.TreeViewColumn(_("ID"), self.renderer, markup=3)
+        self.column.set_visible(False)
+        #self.column.set_sort_column_id(3)
+        self.treeview.append_column(self.column)
+
+        ### type
+        self.renderer = gtk.CellRendererText()
+        self.columnType = gtk.TreeViewColumn(_("TYPE"), \
+                            self.renderer, markup=4)
+        self.columnType.set_visible(False)
+        #self.columnType.set_sort_column_id(4)
+        self.treeview.append_column(self.columnType)
+
+        for watch in self.specto.watch_db:
+            if watch.deleted == False:
+                self.add_watch_entry(watch.id)
+
+    def select_all(self, widget):
+        db = self.specto.watch_db
+
+        for watch in db:
+            if watch.deleted == False:
+                self.model.set_value(self.iter[watch.id], 0, 1)
+
+    def deselect_all(self, widget):
+        db = self.specto.watch_db
+
+        for watch in db:
+            if watch.deleted == False:
+                self.model.set_value(self.iter[watch.id], 0, 0)
+
+    def do_action(self, widget):
+        self.export_watch.hide_all()
+        export_save_dialog = ExportSaveDialog(self.specto, None, False, \
+                self.get_selected_watches())
+        response = export_save_dialog.run()
+        if response == gtk.RESPONSE_OK:
+            export_save_dialog.save()
+        else:
+            export_save_dialog.cancel()
+
+    def delete_event(self, widget, *args):
+        """ Destroy the window. """
+        self.export_watch.destroy()
+        return True
+
+    def get_selected_watches(self):
+        selected_watches_db = {}
+        i = 0
+        watch_db = self.specto.watch_db
+
+        for watch in watch_db:
+            if watch.deleted == False:
+                if self.model.get_value(self.iter[watch.id], 0) == True:
+                    selected_watches_db[i] = watch
+                    i += 1
+        return selected_watches_db
+
+    def add_watch_entry(self, id):
+        """ Add an entry to the notifier list. """
+        watch = self.specto.watch_db[id]
+        entry_name = watch.name.replace("&", "&amp;")
+        icon = self.notifier.get_icon(watch.icon, 50, False)
+        self.iter[id] = self.model.insert_before(None, None)
+        self.model.set_value(self.iter[id], 0, 0)
+        self.model.set_value(self.iter[id], 1, icon)
+        self.model.set_value(self.iter[id], 2, entry_name)
+        self.model.set_value(self.iter[id], 3, watch.id)
+        self.model.set_value(self.iter[id], 4, watch.type)
+
+    def set_new_watch_db(self, watch_db):
+        self.new_watch_db = watch_db
+
+    def check_clicked(self, object, path, model):
+        """ Call the main function to start/stop the selected watch. """
+        sel = self.treeview.get_selection()
+        sel.select_path(path)
+        model, iter = self.treeview.get_selection().get_selected()
+
+        if model.get_value(iter, 0):
+            model.set_value(iter, 0, 0)
+        else:
+            model.set_value(iter, 0, 1)
+
+
+class ExportSaveDialog(SaveDialog):
+    """
+    Class for displaying the save as dialog.
+    """
+
+    def __init__(self, specto, _import, action_type, watches_db):
+        SaveDialog.__init__(self, specto)
+        self.specto = specto
+        self._export = _import
+        windowname = "export_file_chooser"
+        self.action_type = action_type
+        self.watches_db = watches_db
+
+    def save(self, *args):
+        """ Save the file. """
+        file_name = self.get_filename()
+
+        for i in self.watches_db.keys():
+            values = {}
+            values['name'] = self.watches_db[i].name
+            values['type'] = self.watches_db[i].type
+            values['refresh'] = self.watches_db[i].refresh
+            values.update(self.watches_db[i].get_values())
+            self.write_options(file_name, values)
+
+        self.destroy()
+
+    def write_options(self, file_name, values):
+        """
+        Write or change the watch options in a configuration file.
+        Values has to be a dictionary with the name from the options
+        and the value. example: { 'name':'value', 'name':'value' }
+        If the name is not found, a new watch will be added,
+        else the excisting watch will be changed.
+        """
+        watch_io = Watch_io(self.specto, file_name)
+        watch_io.write_watch(values)
+
+if __name__ == "__main__":
+    #run the gui
+    app = Export_watch()
+    gtk.main()

=== added file 'build/lib.linux-i686-2.6/spectlib/gtkconfig.py'
--- build/lib.linux-i686-2.6/spectlib/gtkconfig.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/gtkconfig.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,588 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       gtkutil.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import gtk
+import os
+
+import spectlib.util
+
+
+class Entry():
+
+    def __init__(self, label, text=None):
+        self.table = gtk.Table(rows=1, columns=2)
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        self.entry = gtk.Entry()
+        if text != None:
+            self.entry.set_text(text)
+        self.entry.show()
+        self.table.attach(self.entry, 1, 2, 0, 1, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        self.entry.set_text(value)
+
+    def get_value(self):
+        return self.entry.get_text()
+
+    def get_object(self):
+        return self.table, self.entry
+
+    def set_color(self, red, blue, green):
+        self.entry.modify_base(gtk.STATE_NORMAL, \
+            gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.entry.grab_focus()
+
+
+class PasswordEntry():
+
+    def __init__(self, label, text=None):
+        self.table = gtk.Table(rows=1, columns=2)
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        self.entry = gtk.Entry()
+        self.entry.set_visibility(False)
+        if text != None:
+            self.entry.set_text(text)
+        self.entry.show()
+        self.table.attach(self.entry, 1, 2, 0, 1, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        self.entry.set_text(value)
+
+    def get_value(self):
+        return self.entry.get_text()
+
+    def get_object(self):
+        return self.table, self.entry
+
+    def set_color(self, red, blue, green):
+        self.entry.modify_base(gtk.STATE_NORMAL, \
+            gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.entry.grab_focus()
+
+
+class Spinbutton():
+
+    def __init__(self, label, value=1, lower=1, upper=100, \
+                    step_incr=1, page_incr=10, page_size=0):
+        self.table = gtk.Table(rows=1, columns=2)
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        adjustment = gtk.Adjustment(value, lower, upper, \
+                        step_incr, page_incr, page_size)
+        self.spinbutton = gtk.SpinButton(adjustment)
+        self.spinbutton.show()
+        self.table.attach(self.spinbutton, 1, 2, 0, 1, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        self.spinbutton.set_value(value)
+
+    def get_value(self):
+        return self.spinbutton.get_value()
+
+    def get_object(self):
+        return self.table, self.spinbutton
+
+    def set_color(self, red, blue, green):
+        self.spinbutton.modify_base(gtk.STATE_NORMAL, \
+                    gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.spinbutton.grab_focus()
+
+
+class CheckButton():
+
+    def __init__(self, label, value=False):
+        self.table = gtk.Table(rows=1, columns=2)
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        self.checkbutton = gtk.CheckButton()
+        self.checkbutton.set_active(value)
+        self.checkbutton.set_alignment(xalign=1.0, yalign=0.0)
+        self.checkbutton.show()
+        self.table.attach(self.checkbutton, 1, 2, 0, 1, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        self.checkbutton.set_active(value)
+
+    def get_value(self):
+        return self.checkbutton.get_active()
+
+    def get_object(self):
+        return self.table, self.checkbutton
+
+    def set_color(self, red, blue, green):
+        self.checkbutton.modify_base(gtk.STATE_NORMAL, \
+                        gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.checkbutton.grab_focus()
+
+
+class FileChooser():
+
+    def __init__(self, label, value=False):
+        self.table = gtk.Table(rows=2, columns=1)
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        self.filechooser = gtk.FileChooserButton(_("Choose a file"))
+##        filter = gtk.FileFilter()
+##        filter.set_name("PDF files")
+##        filter.add_pattern("*.pdf")
+##        self.filechooser.add_filter(filter)
+
+        self.filechooser.set_action(gtk.FILE_CHOOSER_ACTION_OPEN)
+        self.filechooser.set_filename(os.environ['HOME'])
+        self.filechooser.show()
+        self.table.attach(self.filechooser, 0, 1, 1, 2, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        self.filechooser.set_filename(value)
+
+    def get_value(self):
+        return self.filechooser.get_filename()
+
+    def get_object(self):
+        return self.table, self.filechooser
+
+    def set_color(self, red, blue, green):
+        self.filechooser.modify_base(gtk.STATE_NORMAL, \
+                        gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.filechooser.grab_focus()
+        
+class FileChooserpdf():
+
+    def __init__(self, label, value=False):
+        self.table = gtk.Table(rows=2, columns=1)
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        self.filechooser = gtk.FileChooserButton(_("Choose a file"))
+        filter = gtk.FileFilter()
+        filter.set_name("PDF files")
+        filter.add_pattern("*.pdf")
+        self.filechooser.add_filter(filter)
+
+        self.filechooser.set_action(gtk.FILE_CHOOSER_ACTION_OPEN)
+        self.filechooser.set_filename(os.environ['HOME'])
+        self.filechooser.show()
+        self.table.attach(self.filechooser, 0, 1, 1, 2, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        self.filechooser.set_filename(value)
+
+    def get_value(self):
+        return self.filechooser.get_filename()
+
+    def get_object(self):
+        return self.table, self.filechooser
+
+    def set_color(self, red, blue, green):
+        self.filechooser.modify_base(gtk.STATE_NORMAL, \
+                        gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.filechooser.grab_focus()
+
+
+class FolderChooser():
+
+    def __init__(self, label, value=False):
+        self.table = gtk.Table(rows=2, columns=1)
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        self.dirchooser = gtk.FileChooserButton(_("Choose a directory"))
+        self.dirchooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
+        self.dirchooser.set_filename(os.environ['HOME'])
+        self.dirchooser.show()
+        self.table.attach(self.dirchooser, 0, 1, 1, 2, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        self.dirchooser.set_filename(value)
+
+    def get_value(self):
+        return self.dirchooser.get_filename()
+
+    def get_object(self):
+        return self.table, self.dirchooser
+
+    def set_color(self, red, blue, green):
+        self.dirchooser.modify_base(gtk.STATE_NORMAL, \
+                        gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.dirchooser.grab_focus()
+
+
+class Scale():
+
+    def __init__(self, label, value=0, lower=0, upper=100, \
+                   step_incr=1.0, page_incr=1.0, page_size=10):
+        self.table = gtk.Table(rows=2, columns=1)
+
+        self.gtkLabel = gtk.Label((label + ":"))
+        self.gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        self.gtkLabel.show()
+        self.table.attach(self.gtkLabel, 0, 1, 0, 1)
+
+        self.value = value
+        self.lower = lower
+        self.upper = upper
+        self.step_incr = step_incr
+        self.page_incr = page_incr
+        self.page_size = page_size
+
+        _adjustment = gtk.Adjustment(value, lower, upper, \
+                            step_incr, page_incr, page_size)
+        self.scale = gtk.HScale(adjustment=_adjustment)
+        self.scale.set_digits(1)
+        self.scale.set_value_pos(gtk.POS_RIGHT)
+        self.scale.show()
+        self.table.attach(self.scale, 0, 1, 1, 2, xoptions=gtk.FILL)
+        self.table.show()
+
+    def set_value(self, value):
+        _adjustment = gtk.Adjustment(value, self.lower, self.upper, \
+                       self.step_incr, self.page_incr, self.page_size)
+        self.scale.set_adjustment(_adjustment)
+
+    def get_value(self):
+        return self.scale.get_value()
+
+    def get_object(self):
+        return self.table, self.scale
+
+    def set_color(self, red, blue, green):
+        self.scale.modify_base(gtk.STATE_NORMAL, \
+                 gtk.gdk.Color(red, blue, green))
+
+    def grab_focus(self):
+        self.scale.grab_focus()
+
+
+class RemoveDialog():
+
+    def __init__(self, title, text):
+        dialog = gtk.Dialog(title, None, gtk.DIALOG_MODAL | \
+            gtk.DIALOG_NO_SEPARATOR | gtk.DIALOG_DESTROY_WITH_PARENT, None)
+        #HIG tricks
+        dialog.set_has_separator(False)
+
+        dialog.add_button(gtk.STOCK_CANCEL, -1)
+        dialog.add_button(gtk.STOCK_REMOVE, 3)
+
+        dialog.label_hbox = gtk.HBox(spacing=6)
+
+        icon = gtk.Image()
+        icon.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
+        dialog.label_hbox.pack_start(icon, True, True, 6)
+        icon.show()
+
+        text = text.replace("&", "&amp;")
+        label = gtk.Label(text)
+        label.set_use_markup(True)
+        dialog.label_hbox.pack_start(label, True, True, 6)
+        label.show()
+
+        dialog.vbox.pack_start(dialog.label_hbox, True, True, 12)
+        dialog.label_hbox.show()
+
+        icon = gtk.gdk.pixbuf_new_from_file(spectlib.util.get_path() \
+                                        + 'icons/specto_window_icon.svg')
+        dialog.set_icon(icon)
+        self.dialog = dialog
+
+    def show(self):
+        answer = self.dialog.run()
+        if answer == 3:
+            self.dialog.destroy()
+            return True
+        else:
+            self.dialog.destroy()
+            return False
+
+
+class ErrorDialog():
+
+    def __init__(self, specto, error_message):
+        self.specto = specto
+        uifile = os.path.join(self.specto.PATH, "uis/notifier.ui")
+        windowname = "error_dialog"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+
+        self.builder.get_object("ok").connect("clicked", self.delete_event)
+        self.builder.get_object("send").connect("clicked", self.send)
+
+        self.error_dialog = self.builder.get_object("error_dialog")
+        self.error_dialog.show()
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.error_dialog.set_icon(icon)
+
+        self.errorwindow = gtk.TextBuffer(None)
+        self.builder.get_object("error_message").set_buffer(self.errorwindow)
+        self.errorwindow.set_text(error_message)
+
+        self.builder.get_object("image").set_from_stock(gtk.STOCK_DIALOG_ERROR, \
+                                                         gtk.ICON_SIZE_DIALOG)
+
+        self.builder.get_object("label4").set_use_markup(True)
+        self.builder.get_object("label4").set_label(_("<b>Specto encountered an error</b>\nPlease verify if this bug has been entered in our issue tracker, and if not, file a bug report so we can fix it."))
+
+    def send(self, *args):
+        url = "http://code.google.com/p/specto/issues/list"
+        os.system(spectlib.util.return_webpage(url) + " &")
+
+    def delete_event(self, widget, *args):
+        """ Destroy the window. """
+        self.error_dialog.destroy()
+        return True
+
+
+class SaveDialog(gtk.FileChooserDialog):
+    """
+    Class for displaying a generic save dialog for Specto.
+    """
+
+    def __init__(self, specto):
+        gtk.FileChooserDialog.__init__(self, _("Save file as"), None,
+                gtk.FILE_CHOOSER_ACTION_SAVE,
+                (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
+                 gtk.STOCK_SAVE,   gtk.RESPONSE_OK))
+        self.specto = specto
+        windowname = "filechooser"
+
+        self.set_icon(gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png")))
+        self.set_filename(os.environ['HOME'] + "/ ")
+
+    def cancel(self, *args):
+        """ Close the dialog. """
+        self.destroy()
+
+    def save(self, *args):
+        raise NotImplementedError
+
+class OpenDialog(gtk.FileChooserDialog):
+    """
+    Class for displaying a generic open dialog for Specto.
+    """
+
+    def __init__(self, specto):
+        gtk.FileChooserDialog.__init__(self, _("Open file"), None,
+                gtk.FILE_CHOOSER_ACTION_OPEN,
+                (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
+                 gtk.STOCK_OPEN,   gtk.RESPONSE_OK))
+        self.specto = specto
+        windowname = "open_file_chooser"
+
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.set_icon(icon)
+        self.set_filename(os.environ['HOME'] + "/ ")
+
+    def cancel(self, *args):
+        """ Close the save as dialog. """
+        self.destroy()
+
+    def open(self, *args):
+        raise NotImplementedError
+
+
+def create_widget(table, widget_type, value, label, position):
+    i = position
+    watch_options = {}
+
+    if not widget_type == "scale":
+        gtkLabel = gtk.Label((label + ":"))
+        gtkLabel.set_alignment(xalign=0.0, yalign=0.5)
+        gtkLabel.show()
+        table.attach(gtkLabel, 0, 1, i, i + 1)
+
+    if widget_type == "entry":
+        entry = gtk.Entry()
+        entry.show()
+        watch_options.update({value: entry})
+        table.attach(entry, 1, 2, i, i + 1)
+    elif widget_type == "password":
+        entry = gtk.Entry()
+        entry.set_visibility(False)
+        entry.show()
+        watch_options.update({value: entry})
+        table.attach(entry, 1, 2, i, i + 1)
+    elif widget_type == "scale":
+        scale_table = gtk.Table(rows=2, columns=1, homogeneous=False)
+
+        adjustment_label = gtk.Label((label + ":"))
+        adjustment_label.set_alignment(xalign=0.0, yalign=0.5)
+        adjustment_label.show()
+        scale_table.attach(adjustment_label, 0, 1, 0, 1)
+
+        _adjustment = gtk.Adjustment(value=2.0, lower=0, upper=50, \
+                        step_incr=0.1, page_incr=1.0, page_size=10)
+        scale = gtk.HScale(adjustment=_adjustment)
+        scale.set_digits(1)
+        scale.set_value_pos(gtk.POS_RIGHT)
+        scale.show()
+        scale_table.attach(scale, 0, 1, 1, 2)
+
+        watch_options.update({value: scale})
+        scale_table.show()
+        table.attach(scale_table, 0, 2, i, i + 1)
+    elif widget_type == "checkbox":
+        checkbox = gtk.CheckButton()
+        checkbox.show()
+        watch_options.update({value: checkbox})
+        table.attach(checkbox, 1, 2, i, i + 1)
+    elif widget_type == "filechooser":
+        filechooser = gtk.FileChooserButton(_("Choose a file"))
+        filechooser.set_action(gtk.FILE_CHOOSER_ACTION_OPEN)
+        filechooser.show()
+        watch_options.update({value: filechooser})
+        table.attach(filechooser, 1, 2, i, i + 1)
+    elif widget_type == "dirchooser":
+        dirchooser = gtk.FileChooserButton(_("Choose a directory"))
+        dirchooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
+        dirchooser.show()
+        watch_options.update({value: dirchooser})
+        table.attach(dirchooser, 1, 2, i, i + 1)
+    elif widget_type == "calendar":
+        calendar = gtk.Calendar()
+        #calendar.show()
+        watch_options.update({value: calendar})
+        table.attach(calendar, 1, 2, i, i + 1)
+    elif widget_type == "time":
+        time_table = gtk.Table(rows=1, columns=2, homogeneous=False)
+        minutes_adjustment = gtk.Adjustment(value=1, lower=1, upper=60, \
+                                step_incr=1, page_incr=10, page_size=0)
+        hours_adjustment = gtk.Adjustment(value=1, lower=1, upper=24, \
+                                  step_incr=1, page_incr=10, page_size=0)
+        hours = gtk.SpinButton(hours_adjustment)
+        hours.show()
+        minutes = gtk.SpinButton(minutes_adjustment)
+        minutes.show()
+        time_table.attach(hours, 1, 2, 1, 2)
+        time_table.attach(minutes, 2, 3, 1, 2)
+        #time_table.show()
+        watch_options.update({value: (hours, minutes)})
+        table.attach(time_table, 1, 2, i, i + 1)
+
+    return watch_options, table
+
+
+def set_widget_value(widget_type, widget, value):
+    if widget_type == "entry" or widget_type == "password":
+        widget.set_text(value)
+    elif widget_type == "scale":
+        _adjustment = gtk.Adjustment(value=value * 100, lower=0, \
+                upper=50, step_incr=0.1, page_incr=1.0, page_size=10)
+        widget.set_adjustment(_adjustment)
+    elif widget_type == "checkbox":
+        if value == "True" or value == True:
+            widget.set_active(1)
+        else:
+            widget.set_active(0)
+    elif widget_type == "filechooser" or widget_type == "dirchooser":
+        widget.set_filename(value)
+    elif widget_type == "calendar":
+        try: #if value = string
+            value = value.replace("(", "")
+            value = value.replace(")", "")
+            value = value.split(",")
+        except: # value = tuple
+            pass
+        widget.select_month(int(value[1]), int(value[0]))
+        widget.select_day(int(value[2]))
+    elif widget_type == "time":
+        widget[0].set_value(int(value[0]))
+        widget[1].set_value(int(value[1]))
+
+
+def get_object_value(widget_type, value):
+    result = ""
+    if widget_type == "entry" or widget_type == "password":
+        result = value.values()[0].get_text()
+    elif widget_type == "scale":
+        result = value.values()[0].get_value()
+    elif widget_type == "checkbox":
+        result = value.values()[0].get_active()
+    elif widget_type == "filechooser" or widget_type == "dirchooser":
+        result = value.values()[0].get_filename()
+    elif widget_type == "calendar":
+        result = value.values()[0].get_date()
+    elif widget_type == "time":
+        result = (value.values()[0][0].get_value(), \
+                    value.values()[0][1].get_value())
+
+    return result
+
+def create_menu_item(label, callback=None, icon=None):
+    menuItem = gtk.MenuItem(label, True)
+    if icon:
+        menuItem = gtk.ImageMenuItem(label)
+        image = gtk.Image()
+        # handle the icon as a stock icon.
+        try:
+            image.set_from_stock(icon, gtk.ICON_SIZE_MENU)
+        except TypeError:
+            # err, icon is a string, do nothing.
+            image = icon
+        menuItem.set_image(image)
+        image.show()
+    if callback:
+        menuItem.connect('activate', callback)
+    return menuItem

=== added file 'build/lib.linux-i686-2.6/spectlib/i18n.py'
--- build/lib.linux-i686-2.6/spectlib/i18n.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/i18n.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       il8n.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+import gettext
+import locale
+
+# If Specto is installed read prefix from constants module
+MESSAGES_DIR = ''
+try:
+    from spectlib.constants import PREFIX
+    MESSAGES_DIR = "%s/share/locale" % PREFIX
+except ImportError:
+    pass
+
+def setup_locale_and_gettext():
+    package_name = 'specto'
+    # Install _() builtin for gettext; always returning unicode objects
+    # also install ngettext()
+    gettext.install(package_name, localedir=MESSAGES_DIR, unicode=True,
+                    names=("ngettext",))
+    locale.bindtextdomain(package_name, MESSAGES_DIR)
+    locale.bind_textdomain_codeset(package_name, "UTF-8")
+
+    try:
+        locale.setlocale(locale.LC_ALL, "")
+    except locale.Error, e:
+        pass
+
+setup_locale_and_gettext()

=== added file 'build/lib.linux-i686-2.6/spectlib/i18n_safedict.py'
--- build/lib.linux-i686-2.6/spectlib/i18n_safedict.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/i18n_safedict.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,70 @@
+# Copyright (C) 1998,1999,2000,2001,2002 by the Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+"""A `safe' dictionary for string interpolation."""
+
+from types import StringType
+from UserDict import UserDict
+
+COMMASPACE = ', '
+
+
+class SafeDict(UserDict):
+    """Dictionary which returns a default value for unknown keys.
+
+    This is used in maketext so that editing templates is a bit more robust.
+    """
+
+    def __getitem__(self, key):
+        try:
+            return self.data[key]
+        except KeyError:
+            if isinstance(key, StringType):
+                return '%('+key+')s'
+            else:
+                return '<Missing key: %s>' % `key`
+
+    def interpolate(self, template):
+        return template % self
+
+
+class MsgSafeDict(SafeDict):
+
+    def __init__(self, msg, dict=None):
+        self.__msg = msg
+        SafeDict.__init__(self, dict)
+
+    def __getitem__(self, key):
+        if key.startswith('msg_'):
+            return self.__msg.get(key[4:], 'n/a')
+        elif key.startswith('allmsg_'):
+            missing = []
+            all = self.__msg.get_all(key[7:], missing)
+            if all is missing:
+                return 'n/a'
+            return COMMASPACE.join(all)
+        else:
+            return SafeDict.__getitem__(self, key)
+
+    def copy(self):
+        d = self.data.copy()
+        for k in self.__msg.keys():
+            vals = self.__msg.get_all(k)
+            if len(vals) == 1:
+                d['msg_'+k.lower()] = vals[0]
+            else:
+                d['allmsg_'+k.lower()] = COMMASPACE.join(vals)
+        return d

=== added file 'build/lib.linux-i686-2.6/spectlib/imail.py'
--- build/lib.linux-i686-2.6/spectlib/imail.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/imail.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       imail.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import smtplib
+import sys
+
+keyring = True
+try:
+    from spectlib.tools.keyringmanager import Keyring
+except:
+    keyring = False
+
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from spectlib.bdd import Group, Mail
+
+class Imail():
+    """Class who send email alert """
+    def __init__(self,adresse,specto,name,values,item):
+        self.specto_adr = "[e-mail]"
+        self.adr = adresse
+##        print values
+        # Create message container - the correct MIME type is multipart/alternative.
+        self.msg = MIMEMultipart('alternative')
+        self.msg['Subject'] = "Alerte specto"
+        self.msg['From'] = self.specto_adr
+        self.msg['To'] = self.adr
+        self.specto = specto
+        self.name = name
+        #get settings
+        self.smtp = self.specto.specto_gconf.get_entry("smtp_entry")
+##        print  self.smtp
+        self.User = self.specto.specto_gconf.get_entry("login_entry")
+        if self.specto.use_keyring == True and keyring == True:
+            try:
+                k = Keyring("password_entry", "Specto " + "password_entry", "network")
+                self.Password = k.get_credentials()[1]
+            except:
+                self.Password = self.specto.specto_gconf.get_entry("password_entry")
+        self.tls = self.specto.specto_gconf.get_entry("button_tls")
+        
+        listgroup = self.specto.base.getAll(Group)
+        listmail = self.specto.base.getAll(Mail)
+        self.list = self.get_mail_tosend(listmail,listgroup)
+##        self.alert_html(name,values['pattern'],item,values['uri'])
+                
+    def alert_rss(self,name,pattern,title,link,description):
+        """ Send Email for rss alert"""
+        description = '"'+description+'"'
+        # Create the body of the message (a plain-text and an HTML version).
+        text = "Bonjour,\nUne alerte a été générée par l'observateur "+name+" suite à l'apparition du motif "+pattern+"\n"+title+"\n"+link+"\n"+description+""
+        html = """\
+        <html>
+        <head></head>
+        <body>
+            <p>Bonjour,<br><br>
+        Une alerte a été générée par l'observateur <u>"""+name+"""</u> suite à l'apparition du motif <i>"""+pattern+"""</i><br><br>
+        <a href="""+link+""">"""+title+"""</a><br>
+        """+description+"""
+        </p>
+        </body>
+        </html>
+        """
+
+        # Record the MIME types of both parts - text/plain and text/html.
+        part1 = MIMEText(text, 'plain')
+        part2 = MIMEText(html, 'html')
+
+        # Attach parts into message container.
+        # According to RFC 2046, the last part of a multipart message, in this case
+        # the HTML message, is best and preferred.
+        self.msg.attach(part1)
+        self.msg.attach(part2)
+        
+        try:
+            if (self.smtp != ""):
+                for m in self.list:
+                    self.s = smtplib.SMTP(self.smtp)
+                    if self.tls == True:
+                        self.s.ehlo()
+                        self.s.starttls()
+                        self.s.ehlo()
+                    if (self.User != "") and (self.Password != ""):
+                        self.s.login(self.User, self.Password)
+                    self.s.sendmail(self.specto_adr, m, self.msg.as_string())
+                    self.s.quit()
+        except:
+            self.set_error()
+            
+    def alert_html(self,name,pattern,item,link):
+##        print "bonjour alerte html dans imail"
+##        print name,pattern,item,link
+        """ Send Email for html alert """
+        # Create the body of the message (a plain-text and an HTML version).
+        text = "Bonjour,\nUne alerte a ete generee par l'observateur "+name+" suite a l'apparition du motif "+pattern+"\n Lien vers la page : "+link+"\n"+item+"\n"
+        html = """\
+        <html>
+        <head></head>
+        <body>
+            <p>Bonjour,<br><br>
+        Une alerte a été générée par l'observateur <u>"""+name+"""</u> suite à l'apparition du motif <i>"""+pattern+"""</i><br><br>
+        <a href="""+link+""">Lien vers la page</a><br>
+        """+item+"""
+        </p>
+        </body>
+        </html>
+        """
+        # Record the MIME types of both parts - text/plain and text/html.
+        part1 = MIMEText(text, 'plain')
+        #part2 = MIMEText(html, 'html')
+
+        # Attach parts into message container.
+        # According to RFC 2046, the last part of a multipart message, in this case
+        # the HTML message, is best and preferred.
+        self.msg.attach(part1)
+        #self.msg.attach(part2)
+        
+        try:
+            if (self.smtp != ""):
+                for m in self.list:
+                    self.s = smtplib.SMTP(self.smtp)
+                    if self.tls == True:
+                        self.s.ehlo()
+                        self.s.starttls()
+                        self.s.ehlo()
+                    if (self.User != "") and (self.Password != ""):
+                        self.s.login(self.User, self.Password)
+##                        print "before"
+                    self.s.sendmail(self.specto_adr, m, self.msg.as_string())
+##                    print "Message send"
+                    self.s.quit()
+        except:
+            self.set_error()
+            
+    def alert_pdfhtml(self,name,pattern,item,link):
+##        print "bonjour alerte pdfhtml dans imail"
+##        print name,pattern,item,link
+        """ Send Email for html alert """
+        # Create the body of the message (a plain-text and an HTML version).
+        text = "Bonjour,\nUne alerte a ete generee par l'observateur "+name+" suite a l'apparition du motif "+pattern+"\n dans le document PDF : "+link+"\n"+item+"\n"
+        html = """\
+        <html>
+        <head></head>
+        <body>
+            <p>Bonjour,<br><br>
+        Une alerte a été générée par l'observateur <u>"""+name+"""</u> suite à l'apparition du motif <i>"""+pattern+"""</i><br><br>
+        <a href="""+link+""">Document PDF</a><br>
+        """+item+"""
+        </p>
+        </body>
+        </html>
+        """
+        # Record the MIME types of both parts - text/plain and text/html.
+        part1 = MIMEText(text, 'plain')
+        #part2 = MIMEText(html, 'html')
+
+        # Attach parts into message container.
+        # According to RFC 2046, the last part of a multipart message, in this case
+        # the HTML message, is best and preferred.
+        self.msg.attach(part1)
+        #self.msg.attach(part2)
+##        print html
+        try:
+            if (self.smtp != ""):
+                for m in self.list:
+                    self.s = smtplib.SMTP(self.smtp)
+                    if self.tls == True:
+                        self.s.ehlo()
+                        self.s.starttls()
+                        self.s.ehlo()
+                    if (self.User != "") and (self.Password != ""):
+                        self.s.login(self.User, self.Password)
+##                        print "before"
+                    self.s.sendmail(self.specto_adr, m, self.msg.as_string())
+##                    print "Message send"
+                    self.s.quit()
+        except:
+            self.set_error()
+
+    def get_adr(self):
+        """ return adress """
+        return self.adr
+        
+    def set_error(self, message=""):
+        self.error = True
+        if message != "":
+            self.error_message = str(message).replace('\n',' ')
+            self.specto.logger.log(('%s') % self.error_message, "error", self.name)
+        else:
+            self.error_message = _("Unexpected error:") + " " + str(sys.exc_info()[1])
+            self.specto.logger.log(self.error_message, "error", self.name)
+            
+    def check_mail_conf(self):
+        """ check if something change in mail settings """
+        if (self.specto.specto_gconf.get_entry("smtp_entry") != self.smtp):
+            self.smtp = self.specto.specto_gconf.get_entry("smtp_entry")
+            self.User = self.specto.specto_gconf.get_entry("login_entry")
+
+            if self.specto.use_keyring == True and keyring == True:
+                try:
+                    k = Keyring("password_entry", "Specto " + "password_entry", "network")
+                    self.Password = k.get_credentials()[1]
+                except:
+                    self.Password = self.specto.specto_gconf.get_entry("password_entry")
+                    
+    def get_mail_tosend(self,listmail,listgroup):
+        tosend = []
+        for g in listgroup:
+            if g.name == self.adr:
+                for m in listmail:
+                    if m.group == self.adr:
+                        tosend.append(m.mail)
+        if len(tosend) == 0:
+            tosend.append(self.adr)
+        return tosend
+
+class Mail_test():
+    """ class to test mail settings"""
+    def __init__(self,specto,tmp_smtp,tmp_log,tmp_pass,tmp_mail,tmp_tls):
+        self.specto_adr = "[e-mail]"
+        self.adr = tmp_mail
+        
+        self.msg = MIMEMultipart('alternative')
+        self.msg['Subject'] = "Message de test"
+        self.msg['From'] = self.specto_adr
+        self.msg['To'] = self.adr
+        self.specto = specto
+        self.error_message = "Un message de test a été envoyé sur votre adresse"
+ 
+        self.smtp = tmp_smtp
+        self.User = tmp_log
+        self.Password = tmp_pass
+        self.tls = tmp_tls
+
+    def test_settings(self):
+        """ method to test mail settings """
+        text = "Bonjour,\nSi vous voyez ce message c'est que vos paramètres sont bien configurés\n Enjoy!"
+        html = """\
+        <html>
+        <head></head>
+        <body>
+            <p>Bonjour,<br><br>
+        Si vous voyez ce message c'est que vos paramètres sont bien configurés\n<br><br>
+        Enjoy !
+        </p>
+        </body>
+        </html>
+        """
+
+        part1 = MIMEText(text, 'plain')
+        part2 = MIMEText(html, 'html')
+
+        self.msg.attach(part1)
+        self.msg.attach(part2)
+        
+        if (self.smtp != ""):
+            try:
+                self.s = smtplib.SMTP(self.smtp)
+                if self.tls == True:
+                    self.s.ehlo()
+                    self.s.starttls()
+                    self.s.ehlo()
+                if (self.User != "") and (self.Password != ""):
+                    self.s.login(self.User, self.Password)
+                self.s.sendmail(self.specto_adr, self.adr, self.msg.as_string())
+                self.s.quit()
+            except:
+                self.set_error()
+                    
+    def set_error(self, message=""):
+        self.error_message = _("Unexpected error:")+ str(sys.exc_info()[1])
+
+    def get_error(self):
+        return self.error_message

=== added file 'build/lib.linux-i686-2.6/spectlib/import_watch.py'
--- build/lib.linux-i686-2.6/spectlib/import_watch.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/import_watch.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,281 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       import_export.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+from spectlib.watch import Watch_io
+from spectlib.watch import Watch_collection
+from spectlib.gtkconfig import OpenDialog
+
+try:
+    import pygtk
+    pygtk.require("2.0")
+except:
+    pass
+
+try:
+    import gtk
+    import gobject
+except:
+    pass
+
+
+class Import_watch:
+    """
+    Class to create the import/export watch dialog.
+    """
+
+    def __init__(self, specto, notifier):
+        self.specto = specto
+        self.notifier = notifier
+
+        self.import_open_dialog = ImportOpenDialog(self.specto, self, None)
+        response = self.import_open_dialog.run()
+        if response == gtk.RESPONSE_OK:
+            self.import_open_dialog.open()
+        else:
+            self.import_open_dialog.cancel()
+
+    def create_import_window(self):
+        #create tree
+        uifile = os.path.join(self.specto.PATH, "uis/import_export.ui")
+        windowname = "import_export"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+        self.import_watch = self.builder.get_object("import_export")
+
+        self.import_watch.set_title(_("Import watches"))
+        self.builder.get_object("button_action").set_label(_("Import watches"))
+
+        self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gtk.gdk.Pixbuf, gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING)
+        self.new_watch_db = {}
+
+        #catch some events
+        dic = {"on_button_select_all_clicked": self.select_all,
+            "on_button_deselect_all_clicked": self.deselect_all,
+            "on_button_action_clicked": self.import_watches,
+            "on_button_close_clicked": self.delete_event}
+
+        #attach the events
+        self.builder.connect_signals(dic)
+
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.import_watch.set_icon(icon)
+
+        self.treeview = self.builder.get_object("treeview")
+        self.treeview.set_model(self.model)
+        self.treeview.set_flags(gtk.TREE_MODEL_ITERS_PERSIST)
+        self.iter = {}
+
+        ### Checkbox
+        self.renderer = gtk.CellRendererToggle()
+        self.renderer.set_property("activatable", True)
+        self.renderer.connect("toggled", self.check_clicked, self.model)
+        self.columnCheck = gtk.TreeViewColumn(_("Select"), self.renderer, active=0)
+        self.treeview.append_column(self.columnCheck)
+
+        ### Icon
+        self.renderer = gtk.CellRendererPixbuf()
+        self.columnIcon = gtk.TreeViewColumn(_("Type"), self.renderer, pixbuf=1)
+        self.treeview.append_column(self.columnIcon)
+
+        ### Titre
+        self.renderer = gtk.CellRendererText()
+        self.columnTitel = gtk.TreeViewColumn(_("Name"), self.renderer, markup=2)
+        self.columnTitel.set_expand(True)
+        self.columnTitel.set_resizable(True)
+        self.treeview.append_column(self.columnTitel)
+
+        ### ID
+        self.renderer = gtk.CellRendererText()
+        self.column = gtk.TreeViewColumn(_("ID"), self.renderer, markup=3)
+        self.column.set_visible(False)
+        #self.column.set_sort_column_id(3)
+        self.treeview.append_column(self.column)
+
+        ### type
+        self.renderer = gtk.CellRendererText()
+        self.columnType = gtk.TreeViewColumn(_("TYPE"), self.renderer, markup=4)
+        self.columnType.set_visible(False)
+        #self.columnType.set_sort_column_id(4)
+        self.treeview.append_column(self.columnType)
+
+    def select_all(self, widget):
+        db = self.new_watch_db
+        for watch in db:
+            if watch.deleted == False:
+                self.model.set_value(self.iter[watch.id], 0, 1)
+
+    def deselect_all(self, widget):
+        db = self.new_watch_db
+        for watch in db:
+            if watch.deleted == False:
+                self.model.set_value(self.iter[watch.id], 0, 0)
+
+    def import_watches(self, widget):
+        self.import_watch.hide_all()
+
+        watches = self.get_selected_watches()
+        all_values = {}
+        for i in watches:
+            values = {}
+            watch = self.new_watch_db[watches[i].id]
+            values.update(self.new_watch_db[watches[i].id].get_values())
+
+            values['name'] = watch.name
+            if self.specto.watch_io.is_unique_watch(values['name']):
+                y = 1
+                while self.specto.watch_io.is_unique_watch(values['name'] + str(y)):
+                    y += 1
+                values['name'] = values['name'] + str(y)
+
+            values['type'] = watch.type
+            values['refresh'] = watch.refresh
+            values['active'] = True
+            values['last_changed'] = watch.last_changed
+            values['changed'] = False
+            all_values[i] = values
+        _id = self.specto.watch_db.create(all_values)
+
+        for values in all_values.values():
+            self.specto.watch_io.write_watch(values)
+
+        for id in _id:  # Create notifier entries
+            self.specto.notifier.add_notifier_entry(id)
+
+        for id in _id:  # Start the new watches
+            self.specto.watch_db[id].start()
+
+    def delete_event(self, widget, *args):
+        """ Destroy the window. """
+        self.import_watch.destroy()
+        return True
+
+    def get_selected_watches(self):
+        selected_watches_db = {}
+        i = 0
+        watch_db = self.new_watch_db
+        for watch in watch_db:
+            if watch.deleted == False:
+                if self.model.get_value(self.iter[watch.id], 0) == True:
+                    selected_watches_db[i] = watch
+                    i += 1
+        return selected_watches_db
+
+    def add_watch_entry(self, id):
+        """ Add an entry to the notifier list. """
+        watch = self.new_watch_db[id]
+        entry_name = watch.name.replace("&", "&amp;")
+        icon = self.notifier.get_icon(watch.icon, 50, False)
+        self.iter[id] = self.model.insert_before(None, None)
+        self.model.set_value(self.iter[id], 0, 0)
+        self.model.set_value(self.iter[id], 1, icon)#self.specto.notifier.make_transparent(icon, 50))#does not need transparency here
+        self.model.set_value(self.iter[id], 2, entry_name)
+        self.model.set_value(self.iter[id], 3, watch.id)
+        self.model.set_value(self.iter[id], 4, watch.type)
+
+    def set_new_watch_db(self, watch_db):
+        self.new_watch_db = watch_db
+
+    def check_clicked(self, object, path, model):
+        """ Call the main function to start/stop the selected watch. """
+        sel = self.treeview.get_selection()
+        sel.select_path(path)
+        model, iter = self.treeview.get_selection().get_selected()
+
+        if model.get_value(iter, 0):
+            model.set_value(iter, 0, 0)
+        else:
+            model.set_value(iter, 0, 1)
+
+
+class ImportOpenDialog(OpenDialog):
+    """
+    Class for displaying the open dialog.
+    """
+
+    def __init__(self, specto, _import, watches_db):
+        OpenDialog.__init__(self, specto)
+        self.specto = specto
+        self._import = _import
+        windowname = "import_file_chooser"
+
+    def open(self, *args):
+        """ Save the file. """
+        self.hide_all()
+        self._import.create_import_window()
+        file_name = self.get_filename()
+        self.read_options(file_name)
+        self._import.import_watch.show()
+        self.destroy()
+
+    def read_options(self, file_name):
+        watch_io = Watch_io(self.specto, file_name)
+        if watch_io.valid == False:
+            return False
+
+        values = watch_io.read_all_watches()
+        for i in values:
+            try:
+                int(values[i]['type'])
+            except:
+                pass
+            else:
+                values[i]['open_command'] = ""
+                values[i]['last_changed'] = ""
+
+            # Import from Specto 0.2
+            # FIXME: wouldn't this code be more efficient with a case/switch?
+            if values[i]['type'] == "0":
+                values[i]['type'] = "Watch_web_static"
+            elif values[i]['type'] == "1":
+                if values[i]['prot'] == "0":
+                    values[i]['type'] = "Watch_mail_pop3"
+                if values[i]['prot'] == "1":
+                    values[i]['type'] = "Watch_mail_imap"
+                if values[i]['prot'] == "2":
+                    values[i]['type'] = "Watch_mail_gmail"
+                del values[i]['prot']
+            elif values[i]['type'] == "2":
+                if values[i]['mode'] == "file":
+                    values[i]['type'] = "Watch_system_file"
+                else:
+                    values[i]['type'] = "Watch_system_folder"
+                del values[i]['mode']
+            elif values[i]['type'] == "3":
+                values[i]['type'] = "Watch_system_process"
+            elif values[i]['type'] == "4":
+                values[i]['type'] = "Watch_system_port"
+            elif values[i]['type'] == "5":
+                values[i]['type'] = "Watch_web_greader"
+        watch_collection = Watch_collection(self.specto)
+        watch_collection.create(values)
+        self._import.set_new_watch_db(watch_collection)
+        for watch in watch_collection:
+            self._import.add_watch_entry(watch.id)
+
+
+if __name__ == "__main__":
+    # Run the gui
+    app = Import_watch()
+    gtk.main()

=== added file 'build/lib.linux-i686-2.6/spectlib/logger.py'
--- build/lib.linux-i686-2.6/spectlib/logger.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/logger.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,344 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       logger.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+import logging
+import sys
+import os
+import re
+from datetime import datetime
+import traceback
+import shutil
+
+try:
+    import pygtk
+    pygtk.require("2.0")
+except:
+    pass
+
+try:
+    import gtk
+except:
+    pass
+
+from spectlib.gtkconfig import SaveDialog
+
+
+class Log_dialog:
+    """
+    Class to create the log dialog window.
+    """
+
+    def __init__(self, specto, notifier):
+        self.specto = specto
+        self.notifier = notifier
+        #create tree
+        uifile = os.path.join(self.specto.PATH, "uis/log_dialog.ui")
+        windowname = "log_dialog"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+
+        dic = {"on_button_help_clicked": self.show_help,
+               "on_button_save_clicked": self.save,
+               "on_button_clear_clicked": self.clear,
+               "on_button_close_clicked": self.delete_event,
+               "on_button_find_clicked": self.find}
+
+        #attach the events
+        self.builder.connect_signals(dic)
+
+        self.log_dialog = self.builder.get_object("log_dialog")
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.png"))
+        self.log_dialog.set_icon(icon)
+
+        self.builder.get_object("combo_level").set_active(0)
+
+        #read the log file
+        self.read_log()
+
+        self.logwindow = gtk.TextBuffer(None)
+        self.log_buffer = self.builder.get_object("log_field").get_buffer()
+        self.log_buffer.create_tag("ERROR", foreground="#a40000")
+        self.log_buffer.create_tag("INFO", foreground="#4e9a06")
+        self.log_buffer.create_tag("WARNING", foreground="#c4a000")
+        self.log_buffer.create_tag("DEBUG", foreground="#815902")
+        self.log_buffer.create_tag("CRITICAL", foreground="#2e3436")
+
+        start = self.log_buffer.get_start_iter()
+        end = self.log_buffer.get_end_iter()
+        self.log_buffer.delete(start, end)
+
+        iter = self.log_buffer.get_iter_at_offset(0)
+        self.log = self.log.split("\n")
+        for line in self.log:
+            if line != "":
+                tag = line.split(" - ")[1].strip()
+                self.log_buffer.insert_with_tags_by_name(iter, \
+                                                    line + "\n", tag)
+
+    def save(self, widget):
+        """ Save the text in the logwindow. """
+        text = self.log_buffer.get_text(self.log_buffer.get_start_iter(), \
+                                            self.log_buffer.get_end_iter())
+        logger_save_dialog = LoggerSaveDialog(self.specto, text)
+        response = logger_save_dialog.run()
+        if response == gtk.RESPONSE_OK:
+            logger_save_dialog.save()
+        else:
+            logger_save_dialog.cancel()
+		
+
+    def clear(self, widget):
+        """ Clear the text in the log window and from the log file. """
+        start = self.log_buffer.get_start_iter()
+        end = self.log_buffer.get_end_iter()
+        self.log_buffer.delete(start, end)
+        f = open(self.file_name, "w")
+        f.write("")
+        f.close()
+        os.chmod(self.file_name, 0600)
+
+    def find(self, widget):
+        """ Find the lines in the log file that contain the filter word. """
+        self.read_log()
+        level = self.builder.get_object("combo_level").get_active()
+        buffer_log = self.log.split("\n")
+        filtered_log = ""
+
+        if level == 1:
+            pattern = ("DEBUG")
+        elif level == 2:
+            pattern = ("INFO")
+        elif level == 3:
+            pattern = ("WARNING")
+        elif level == 4:
+            pattern = ("ERROR")
+        elif level == 5:
+            pattern = ("CRITICAL")
+        elif level == -1:
+            pattern = self.builder.get_object("combo_level").child.get_text()
+
+        start = self.log_buffer.get_start_iter()
+        end = self.log_buffer.get_end_iter()
+        self.log_buffer.delete(start, end)
+        iter = self.log_buffer.get_iter_at_offset(0)
+
+        if level == 0:  # Show everything
+            for line in buffer_log:
+                if line:  # If the line is not empty
+                    tag = line.split(" - ")[1].strip()
+                    self.log_buffer.insert_with_tags_by_name(iter, \
+                                                        line + "\n", tag)
+        else:  # Show the filtered log
+            # Do the filtering
+            for i in buffer_log:
+                if re.search(pattern, i, re.IGNORECASE):
+                    filtered_log += i + "\n"
+            filtered_log = filtered_log.split("\n")
+            for line in filtered_log:
+                if line:  # If the line is not empty
+                    tag = line.split(" - ")[1].strip()
+                    self.log_buffer.insert_with_tags_by_name(iter, \
+                                                        line + "\n", tag)
+
+    def read_log(self):
+        """ Read the log file. """
+        self.file_name = self.specto.SPECTO_DIR + "/specto.log"
+        if not os.path.exists(self.file_name):
+            f = open(self.file_name, "w")
+            f.close()
+        os.chmod(self.file_name, 0600)
+
+        log_file = open(self.file_name, "r")
+        self.log = log_file.read().replace("&Separator;", " - ")
+        log_file.close()
+
+    def show_help(self, widget):
+        """ Show the help webpage. """
+        self.specto.util.show_webpage(\
+         "http://code.google.com/p/specto/wiki/Troubleshooting")
+
+    def delete_event(self, widget, *args):
+        """ Close the window. """
+        self.log_dialog.destroy()
+        return True
+
+
+class LoggerSaveDialog(SaveDialog):
+    """
+    Class for displaying the save as dialog.
+    """
+
+    def __init__(self, specto, *args):
+        SaveDialog.__init__(self, specto)
+        windowname = "logger_file_chooser"
+
+        self.text = args[0]
+
+    def save(self, *args):
+        """ Save the file. """
+        file_name = self.get_filename()
+
+        if not os.path.exists(file_name):
+            f = open(file_name, "w")
+            f.close()
+        os.chmod(file_name, 0600)
+
+        f = open(file_name, "w")
+        f.write(self.text)
+        f.close()
+
+        self.destroy()
+
+
+class Logger:
+    """
+    Class for logging in Specto.
+    """
+
+    def __init__(self, specto):
+        self.specto = specto
+        self.file_name = self.specto.SPECTO_DIR + "/specto.log"
+
+        if not os.path.exists(self.file_name):
+            f = open(self.file_name, "a")
+            f.close()
+        os.chmod(self.file_name, 0600)
+
+        self.error_file = self.specto.SPECTO_DIR + "/error.log"
+        if not os.path.exists(self.error_file):
+            f = open(self.error_file, "a")
+            f.close()
+        os.chmod(self.error_file, 0600)
+
+        self.log_rotation()
+
+        #write to log file
+        #TODO:XXX: Do we need to gettextize it? Maybe just the date.
+        logging.basicConfig(level=logging.INFO,
+              format='%(asctime)s &Separator; %(levelname)s &Separator;' \
+              + ' %(name)s &Separator; %(message)s',
+              datefmt='%Y-%m-%d %H:%M:%S',
+              filename=self.file_name,
+              filemode='a')
+
+        #write to console
+        console = logging.StreamHandler()
+        console.setLevel(logging.DEBUG)
+
+        formatter = logging.Formatter('%(levelname)s - %(name)s - %(message)s')
+        #formatter = logging.Formatter('%(levelname)s - %(message)s')
+        console.setFormatter(formatter)
+        logging.getLogger('').addHandler(console)
+
+    def log(self, message, level, logger):
+        """ Log a message. """
+        log = logging.getLogger(str(logger))
+
+        if self.specto.DEBUG == True:
+            if level == "debug":
+                log.debug(message)
+            elif level == "info":
+                log.info(message)
+            elif level == "warning":
+                log.warn(message)
+            elif level == "error":
+                log.error(message)
+                self.log_error()
+            else:
+                log.critical(message)
+                self.log_error()
+
+    def read_log(self):
+        """ Read the log file. """
+        #get the info from the log file
+        log_file = open(self.file_name, "r")
+        self.logfile = log_file.read()
+        self.logfile.replace("&Separator;", " - ")
+        log_file.close()
+
+    def watch_log(self, watch_name):
+        """ Filter the log for a watch name. """
+        self.read_log()
+        buffer_log = self.logfile.split("\n")
+        filtered_log = []
+
+        for line in buffer_log:
+            if line != "" and line.split("&Separator;")[2].strip() == \
+                                                                watch_name:
+                info = line.split("&Separator;")
+                filtered_log.append([info[1].strip(), info[0] + " - " \
+                                                        + info[3] + "\n"])
+        return filtered_log
+
+    def remove_watch_log(self, watch_name):
+        """ Remove a watch from the log file. """
+        self.read_log()
+        buffer_log = self.logfile.split("\n")
+        filtered_log = ""
+
+        for i in buffer_log:
+            if not re.search(watch_name, i) and i != "":
+                filtered_log += i + "\n"
+
+        f = open(self.file_name, "w")
+        f.write(filtered_log)
+        f.close()
+
+    def clear_log(self, *args):
+        """ Clear the log file. """
+        f = open(self.file_name, "w")
+        f.write("")
+        f.close()
+        os.chmod(self.file_name, 0600)
+
+    def log_error(self):
+        error_message = "Error on: " + \
+            datetime.today().strftime("%A %d %b %Y %H:%M") + "\n"
+
+        et, ev, tb = sys.exc_info()
+        while tb:
+            co = tb.tb_frame.f_code
+            error_message += "Filename: " + str(co.co_filename) + "\n"
+            error_message += "Error Line # : " \
+                                + str(traceback.tb_lineno(tb)) + "\n"
+            tb = tb.tb_next
+
+        error_message += "Type: " + str(et) + "\n" + "Error: " + \
+                                str(ev) + "\n\n"
+
+        f = open(self.error_file, "a")
+        f.write(error_message)
+        f.close()
+
+    def log_rotation(self):
+        if os.path.getsize(self.file_name) > 150000:
+            shutil.move(self.file_name, self.file_name + ".1")
+            f = open(self.file_name, "a")
+            f.close()
+            os.chmod(self.file_name, 0600)
+
+        if os.path.getsize(self.error_file) > 150000:
+            shutil.move(self.error_file, self.error_file + ".1")
+            f = open(self.error_file, "a")
+            f.close()
+            os.chmod(self.error_file, 0600)

=== added file 'build/lib.linux-i686-2.6/spectlib/main.py'
--- build/lib.linux-i686-2.6/spectlib/main.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/main.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,417 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       main.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+# Definition of the watch_db
+# watch_db[0] = instance of the first watch
+
+global GTK
+global DEBUG #the DEBUG constant which controls how much info is output
+
+# Setup locale and gettext
+import spectlib.i18n
+
+import os
+import sys
+import signal
+import gobject
+import gettext
+
+import spectlib.util as util
+from spectlib.watch import Watch_collection
+from spectlib.watch import Watch_io
+from spectlib.console import Console
+from spectlib.logger import Logger
+from spectlib.tools.specto_gconf import Specto_gconf
+from spectlib.tools import networkmanager as conmgr
+from spectlib.bdd import Bdd
+
+
+VERSION = "undefined"
+try:
+    from spectlib.constants import VERSION
+except ImportError:
+    with open("VERSION", 'r') as version_file:
+        VERSION = version_file.read().strip()
+
+#create a gconf object
+specto_gconf = Specto_gconf("/apps/specto")
+
+DEBUG = specto_gconf.get_entry("debug_mode")
+
+try:
+    import pygtk
+    pygtk.require("2.0")
+    import gtk
+except:
+    print _("no GTK, activating console mode")
+    GTK = False
+else:
+    GTK = True
+    from spectlib.notifier import Notifier, INDICATOR
+    
+keyring = True
+try:
+    from spectlib.tools.keyringmanager import Keyring
+except:
+    keyring = False
+
+
+class Specto:
+    """ The main Specto class. """
+
+    def __init__(self):
+        self.DEBUG = DEBUG
+        self.util = util
+
+        self.PATH = self.util.get_path()
+        self.SRC_PATH = self.util.get_path("src")
+        self.SPECTO_DIR = self.util.get_path("specto")
+        self.CACHE_DIR = self.util.get_path("tmp")
+        self.FILE = self.util.get_file()
+
+        self.logger = Logger(self)
+
+        self.VERSION = VERSION # The Specto version number
+
+        self.GTK = GTK
+        
+        if not self.check_instance(): #see if specto is already running
+            self.specto_gconf = specto_gconf
+            self.check_default_settings()
+
+            self.connection_manager = conmgr.get_net_listener()
+            self.use_keyring = self.specto_gconf.get_entry("use_keyring")
+            
+            if self.specto_gconf.get_entry("button_mysql"):
+                print "Mysql"
+                if self.use_keyring == True and keyring == True:
+                    try:
+                        k = Keyring("entry_passwd", "Specto " + "entry_passwd", "network")
+                        password = k.get_credentials()[1]
+                    except:
+                        password = specto_gconf.get_entry("entry_passwd")
+                
+                    datas = {"type":"mysql",
+                            "user":self.specto_gconf.get_entry("entry_username"),
+                            "pass":password,
+                            "host":self.specto_gconf.get_entry("entry_server"),
+                            "port":self.specto_gconf.get_entry("entry_port"),
+                            "name":self.specto_gconf.get_entry("entry_database")}
+            else:
+                print "sql lite"
+                datas = {"type":"sqlite",
+                            "directory":"ici.db"}
+            self.base = Bdd(**datas)
+
+            #create the watch collection and add the watches
+            self.watch_db = Watch_collection(self)
+            self.watch_io = Watch_io(self, self.FILE)
+
+            if (sys.argv[1:] and "--console" in sys.argv[1:][0]) or not self.GTK:
+                self.logger.log(_("Console mode enabled."), "debug", "specto")
+                self.GTK = False
+                self.CONSOLE = True
+                try:
+                    args = sys.argv[1:][1]
+                except:
+                    args = ""
+                self.console = Console(self, args)
+
+            elif self.GTK:
+                self.GTK = True
+                self.CONSOLE = False
+                self.icon_theme = gtk.icon_theme_get_default()
+
+                #allow users to hide the window on startup
+                if sys.argv[1:] and "--no-window" in sys.argv[1:][0]:
+                    self.notifier_hide = True
+                #always show if there's no icon and no indicator support
+                elif self.specto_gconf.get_entry("always_show_icon") == False and not INDICATOR:
+                    self.notifier_hide = False
+                elif self.specto_gconf.get_entry("show_notifier")==True:
+                    self.notifier_hide = False
+                elif self.specto_gconf.get_entry("show_notifier")==False:
+                    self.notifier_hide = True
+                else:#just in case the entry was never created in gconf
+                    self.notifier_keep_hidden = False
+                    
+                self.notifier = Notifier(self)
+            else:
+                sys.exit(0)
+
+            #listen for gconf keys
+            self.specto_gconf.notify_entry("debug_mode", self.key_changed, "debug")
+
+            values = self.watch_io.read_all_watches(True)
+            try:
+                self.watch_db.create(values)
+            except AttributeError, error_fields:
+                self.logger.log(_("Could not create a watch, because it is corrupt."), \
+                                    "critical", "specto")
+
+
+            if self.GTK:
+                for watch in self.watch_db:
+                    self.notifier.add_notifier_entry(watch.id)
+                
+                # Listen for USR1. If received, answer and show the window
+                def listen_for_USR1(signum, frame):
+                    f = open(self.SPECTO_DIR + "/" + "specto.pid.boot")
+                    pid = int(f.readline())
+                    f.close()
+                    os.kill(pid, signal.SIGUSR1)
+                    # If window was not shown, make it appear
+                    if not self.notifier.get_state():
+                        self.logger.log("Showing window, the user ran another instance of specto", "debug", "specto")
+                        self.toggle_notifier()
+                    else:
+                        # Based on http://www.pygtk.org/docs/pygtk/class-gtkwindow.html#method-gtkwindow--present
+                        self.logger.log("Window is already visible! Raising it to the front.", "debug", "specto")
+                        self.notifier.notifier.present()
+                
+                signal.signal(signal.SIGUSR1, listen_for_USR1)
+                
+                self.notifier.refresh_all_watches()
+            else:
+                self.console.start_watches()
+
+        if self.GTK:
+            gtk.main()
+        else:
+            try:
+                self.go = gobject.MainLoop()
+                self.go.run()
+            except (KeyboardInterrupt, SystemExit):
+                sys.exit(0)
+
+    def key_changed(self, *args):
+        """ Listen for gconf keys. """
+        label = args[3]
+
+        if label == "debug":
+            self.DEBUG = self.specto_gconf.get_entry("debug_mode")
+
+    def check_default_settings(self):
+        """ This is used to set the default settings
+        properly the first time Specto is run,
+        without using gconf schemas """
+        #check if the ekiga sounds exists
+        if os.path.exists("/usr/share/sounds/ekiga/voicemail.wav"):
+            changed_sound = "/usr/share/sounds/ekiga/voicemail.wav"
+        else:
+            changed_sound = ""
+
+        self.default_settings = (
+            ["always_show_icon", False], #True would be against the HIG!
+            ["debug_mode", False],
+            ["follow_website_redirects", True],
+            ["pop_toast", True],
+            ["show_deactivated_watches", True],
+            ["show_in_windowlist", True],
+            ["show_notifier", True],
+            ["show_toolbar", True],
+            ["sort_function", "name"],
+            ["sort_order", "asc"],
+            ["changed_sound", changed_sound],
+            ["use_changed_sound", False],
+            ["window_notifier_height", 500],
+            ["window_notifier_width", 500],
+            ["use_keyring", True])
+        for default_setting in self.default_settings:
+            if self.specto_gconf.get_entry(default_setting[0]) == None:
+                self.specto_gconf.set_entry(default_setting[0], \
+                                                    default_setting[1])
+
+    def check_instance(self):
+        """ Check if specto is already running. """
+        pidfile = self.SPECTO_DIR + "/" + "specto.pid"
+        if not os.path.exists(pidfile):
+            f = open(pidfile, "w")
+            f.close()
+        os.chmod(pidfile, 0600)
+
+        #see if specto is already running
+        with open(pidfile, "r") as f:
+            pid = f.readline()
+        if pid:
+            p = os.system("ps --no-heading --pid " + pid)
+            p_name = os.popen("ps -f --pid " + pid).read()
+            if p == 0 and "specto" in p_name:
+                if self.GTK:
+                    # Save our pid and prepare a 'pong' system
+                    f = open(pidfile + ".boot", "w")
+                    f.write(str(os.getpid()))
+                    f.close()
+                    
+                    def not_responding(signum, frame):
+                        """ Launch the already running dialog if the
+                            other instance doesn't respond """
+                        os.unlink(pidfile + ".boot")
+                        self.already_running_dialog()
+                        
+                    def response_received(signum, frame):
+                        """ Kill this specto if the other one answers """
+                        signal.alarm(0)
+                        os.unlink(pidfile + ".boot")
+                        self.logger.log("Specto is already running! The old instance will be brought to front.", "debug", "specto")
+                        sys.exit(0)
+                        
+                    signal.signal(signal.SIGALRM, not_responding)
+                    signal.signal(signal.SIGUSR1, response_received)
+                    signal.alarm(5)
+                    
+                    # Send signal to raise window
+                    os.kill(int(pid), signal.SIGUSR1)
+                    
+                    # Wait for signals
+                    signal.pause()
+                    
+                    return True
+                elif DEBUG:
+                    self.logger.log(_("Specto is already running!"), "critical", "specto")
+                    sys.exit(0)
+                else:
+                    print _("Specto is already running!")
+                    sys.exit(0)
+
+        #write the pid file
+        with open(pidfile, "w") as f:
+            f.write(str(os.getpid()))
+
+    def mark_watch_status(self, status, id):
+        """ get the watch status (checking, changed, idle) """
+        if self.GTK:
+            self.notifier.mark_watch_status(status, id)
+        elif self.CONSOLE:
+            self.console.mark_watch_status(status, id)
+
+    def toggle_notifier(self, *args):
+        """
+        Toggle the state of the notifier, hidden or shown.
+        It will save the size, position,
+        and the last state when you closed Specto.
+        """
+        #Creating the notifier window, but keeping it hidden
+        if self.notifier.get_state() == True and not self.notifier_hide:
+            self.specto_gconf.set_entry("show_notifier", True)
+            self.notifier.restore_size_and_position()
+            self.notifier.notifier.show()
+            self.notifier_hide = True
+        elif self.notifier.get_state()==True and self.notifier_hide:
+            self.notifier.save_size_and_position()
+            self.specto_gconf.set_entry("show_notifier", False)
+            self.notifier.notifier.hide()
+            self.notifier_hide = False
+        else:
+            self.specto_gconf.set_entry("show_notifier", True)
+            self.notifier.restore_size_and_position()
+            self.notifier.notifier.show()
+            self.notifier_hide = True
+
+    def quit(self, *args):
+        """ Save the save and position from the notifier and quit Specto. """
+        if self.notifier.get_state() == True and self.notifier_hide:
+            self.notifier.save_size_and_position()
+        try:
+            gtk.main_quit()
+        except:
+            #create a close dialog
+            self.dialog = gtk.Dialog(_("Cannot quit yet"), None, gtk.DIALOG_NO_SEPARATOR | gtk.DIALOG_DESTROY_WITH_PARENT, None)
+            self.dialog.set_modal(False)  # Needed to prevent the notifier UI and refresh process from blocking. Also, do not use dialog.run(), because it automatically sets modal to true.
+
+            #HIG tricks
+            self.dialog.set_has_separator(False)
+
+            self.dialog.add_button(_("Murder!"), 3)
+            self.dialog.add_button(gtk.STOCK_CANCEL, -1)
+
+            self.dialog.label_hbox = gtk.HBox(spacing=6)
+
+            icon = gtk.Image()
+            icon.set_from_pixbuf(self.icon_theme.\
+                        load_icon("dialog-warning", 64, 0))
+            self.dialog.label_hbox.pack_start(icon, True, True, 6)
+            icon.show()
+
+            label = gtk.Label(_('<b><big>Specto is currently busy and cannot quit yet.</big></b>\n\nThis may be because it is checking for watch changes.\nHowever, you can try forcing it to quit by clicking the murder button.'))
+            label.set_use_markup(True)
+            self.dialog.label_hbox.pack_start(label, True, True, 6)
+            label.show()
+
+            self.dialog.vbox.pack_start(self.dialog.label_hbox, True, True, 12)
+            self.dialog.label_hbox.show()
+
+            icon = gtk.gdk.pixbuf_new_from_file(self.PATH + \
+                                'icons/specto_window_icon.svg')
+            self.dialog.set_icon(icon)
+            self.dialog.connect("delete_event", self.quit_dialog_response)
+            self.dialog.connect("response", self.quit_dialog_response)
+            self.dialog.show_all()
+
+    def quit_dialog_response(self, widget, answer):
+        if answer == 3:
+            try:#go figure, it never works!
+                self.notifier.stop_refresh = True
+                sys.exit(0)
+            except:
+                #kill the specto process with killall
+                os.system('killall specto')
+        else:
+            self.dialog.hide()
+            
+    def already_running_dialog(self, *args):
+        """ Save the save and position from the notifier and quit Specto. """
+        #create a dialog
+        self.dialog = gtk.Dialog(_("Error"), None, gtk.DIALOG_NO_SEPARATOR | gtk.DIALOG_DESTROY_WITH_PARENT, None)
+        self.dialog.set_modal(False)  # Needed to prevent the notifier UI and refresh process from blocking. Also, do not use dialog.run(), because it automatically sets modal to true.
+
+        #HIG tricks
+        self.dialog.set_has_separator(False)
+
+        #self.dialog.add_button(_("Murder!"), 3)
+        self.dialog.add_button(gtk.STOCK_OK, 3)
+
+        self.dialog.label_hbox = gtk.HBox(spacing=6)
+
+        icon = gtk.Image()
+        icon.set_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_DIALOG)
+        self.dialog.label_hbox.pack_start(icon, True, True, 6)
+        icon.show()
+
+        label = gtk.Label(_('Specto is already running!'))
+        label.set_use_markup(True)
+        self.dialog.label_hbox.pack_start(label, True, True, 6)
+        label.show()
+
+        self.dialog.vbox.pack_start(self.dialog.label_hbox, True, True, 12)
+        self.dialog.label_hbox.show()
+
+        icon = gtk.gdk.pixbuf_new_from_file(self.PATH + 'icons/specto_window_icon.svg')
+        self.dialog.set_icon(icon)
+        self.dialog.connect("delete_event", self.running_dialog_response)
+        self.dialog.connect("response", self.running_dialog_response)
+        self.dialog.show_all()
+
+    def running_dialog_response(self, widget, answer):
+        if answer == 3:
+            sys.exit(0)

=== added file 'build/lib.linux-i686-2.6/spectlib/notifier.py'
--- build/lib.linux-i686-2.6/spectlib/notifier.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-i686-2.6/spectlib/notifier.py	2012-03-14 09:03:18 +0000
@@ -0,0 +1,1080 @@
+# -*- coding: utf-8 -*-
+
+# Specto , Unobtrusive event notifier
+#
+#       notifier.py
+#
+# See the AUTHORS file for copyright ownership information
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public
+# License along with this program; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import os
+from random import randrange
+from datetime import datetime
+
+from spectlib.contact import Contact
+from spectlib.preferences import Preferences
+from spectlib.add_watch import Add_watch
+from spectlib.about import About
+from spectlib.edit_watch import Edit_watch
+from spectlib.logger import Log_dialog
+from spectlib.balloons import NotificationToast
+from spectlib.import_watch import Import_watch
+from spectlib.export_watch import Export_watch
+from spectlib.trayicon import Tray
+from spectlib.crawl import Crawler
+    
+INDICATOR = True
+try:
+    from spectlib.tools.indicator import Indicator
+except:
+    INDICATOR = False
+
+SOUND = True
+try:
+    from spectlib.tools.sound import Sound
+except:
+    SOUND = False
+
+
+from spectlib.util import show_webpage
+from spectlib.gtkconfig import ErrorDialog, RemoveDialog, create_menu_item
+
+try:
+    import pygtk
+    pygtk.require("2.0")
+except:
+    pass
+
+try:
+    import gtk
+    import gobject
+    import pango
+except:
+    pass
+
+
+class Notifier:
+    """
+    Class to create the main specto window
+    """
+    add_w = ""
+    edit_w = ""
+    error_l = ""
+    about = ""
+    export_watch = ""
+    import_watch = ""
+
+    def __init__(self, specto):
+        """
+        In this init we are going to display the main notifier window.
+        """
+        self.specto = specto
+        uifile = os.path.join(self.specto.PATH, "uis/notifier.ui")
+        windowname = "notifier"
+        self.builder = gtk.Builder()
+        self.builder.set_translation_domain("specto")
+        self.builder.add_from_file(uifile)
+        self.notifier = self.builder.get_object("notifier")
+        if INDICATOR:
+            self.indicator = Indicator(specto)
+            self.tray = None
+        else:
+            self.tray = Tray(specto, self)
+            self.indicator = None
+        if SOUND:
+            self.sound = Sound()
+        else:
+            self.sound = None
+        self.balloon = NotificationToast(specto, self)
+        self.preferences_initialized = False
+        self.contact_initialized = False
+
+        #create tree
+        self.iter = {}
+        self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gtk.gdk.Pixbuf, gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING, pango.Weight)
+
+        #catch some events
+        dic = {
+        "on_add_activate": self.show_add_watch_menu,
+        "on_edit_activate": self.show_edit_watch,
+        "on_clear_all_activate": self.mark_all_as_read,
+        "on_preferences_activate": self.show_preferences,
+        "on_contact_activate":self.show_contact,
+        "on_refresh_activate": self.refresh_all_watches,
+        "on_close_activate": self.close_event,
+        "on_quit_activate": self.delete_event,
+        "on_import_watches_activate": self.import_watches,
+        "on_export_watches_activate": self.export_watches,
+        "on_error_log_activate": self.show_error_log,
+        "on_display_all_watches_activate": self.toggle_show_deactivated_watches,
+        "on_display_toolbar_activate": self.toggle_display_toolbar,
+        "on_help_activate": self.show_help,
+        "on_about_activate": self.show_about,
+        "on_treeview_row_activated": self.open_watch_callback,
+        "on_btnOpen_clicked": self.open_watch_callback,
+        "on_btnClear_clicked": self.mark_watch_as_read,
+        "on_treeview_cursor_changed": self.show_watch_info,
+        "on_btnEdit_clicked": self.show_edit_watch,
+        "on_by_watch_type_activate": self.sort_type,
+        "on_by_name_activate": self.sort_name,
+        "on_by_watch_active_activate": self.sort_active,
+        "on_remove_clicked": self.remove_watch,
+        "on_clear_activate": self._mark_watch_as_read,
+        "on_remove_activate": self.remove_watch}
+        self.builder.connect_signals(dic)
+
+        icon = gtk.gdk.pixbuf_new_from_file(os.path.join(self.specto.PATH, "icons/specto_window_icon.svg"))
+        self.notifier.set_icon(icon)
+        self.specto.notifier_initialized = True
+        self.create_notifier_gui()
+        self.stop_refresh = False
+
+    def mark_watch_as_read(self, widget, *id):
+        """
+        Call the main function to mark the watch as read and reset the name in the notifier.
+        If widget == '' then id will be used to mark the watch as read else the selected watch will be marked as read.
+        """
+        try:
+            id = id[0]
+        except:
+            model, iter = self.treeview.get_selection().get_selected()
+            id = int(model.get_value(iter, 3))
+        watch = self.specto.watch_db[id]
+        watch.mark_as_read()
+        self.model.set(self.iter[id], 2, watch.name, 5, pango.WEIGHT_NORMAL)
+        if self.model.iter_is_valid(self.iter[id]) and not watch.error:
+            self.model.set_value(self.iter[id], 1, self.get_icon(watch.icon, 50, False))
+        if watch.changed == False:
+            self.builder.get_object("btnClear").set_sensitive(False)
+        else:
+            self.builder.get_object("btnClear").set_sensitive(True)
+        #check if all watches has been marked as read
+        changed_watches = False
+        changes = self.specto.watch_db.count_changed_watches()
+        for changed in changes.values():
+            if changed > 0:
+                changed_watches = True
+        if changed_watches == False:
+            self.builder.get_object("button_clear_all").set_sensitive(False)
+
+    def mark_all_as_read(self, widget):
+        """ Call the main function to mark all watches as read and reset the name in the notifier. """
+        self.builder.get_object("btnClear").set_sensitive(False)
+        self.builder.get_object("button_clear_all").set_sensitive(False)
+        self.builder.get_object("clear_all1").set_sensitive(False)
+        for watch in self.specto.watch_db:
+            if self.model.iter_is_valid(self.iter[watch.id]):
+                self.mark_watch_as_read("", watch.id)
+
+    def refresh_all_watches(self, *widget):
+        """ Call the main funcion to refresh all active watches and change refresh icon to stop. """
+        if self.builder.get_object("button_refresh").get_stock_id() == "gtk-refresh":
+            self.builder.get_object("button_refresh").set_stock_id("gtk-stop") #menu item, does not allow changing label
+            self.builder.get_object("button_refresh").set_label(_("Stop"))
+            self.builder.get_object("button_add").set_sensitive(False)
+            self.builder.get_object("btnEdit").set_sensitive(False)
+            for i in self.iter:
+                if self.stop_refresh == True:
+                    self.stop_refresh = False
+                    break
+                try:
+                    iter = self.model.get_iter(i)
+                    if self.model.iter_is_valid(iter):
+                        model = self.model
+                        id = int(model.get_value(iter, 3))
+                except:
+                    break
+                if self.specto.watch_db[id].active == True:
+                    try:
+                        self.specto.watch_db[id].stop()
+                    except:
+                        pass
+                    self.specto.watch_db[id].start()
+            self.builder.get_object("button_refresh").set_stock_id("gtk-refresh") #menu item, does not allow changing label
+            self.builder.get_object("button_refresh").set_label(_("Refresh All"))
+            self.builder.get_object("button_add").set_sensitive(True)
+            self.builder.get_object("btnEdit").set_sensitive(True)
+        else:
+            self.stop_refresh = True
+
+    def mark_error(self, error_message):
+        error_dialog = ErrorDialog(self.specto, error_message)
+
+    def mark_watch_status(self, status, id):
+        """ show the right icon for the status from the watch. """
+        watch = self.specto.watch_db[id]
+        statusbar = self.builder.get_object("statusbar1")
+        icon = self.get_icon("error", 50, False)
+
+        try:
+            if status == "checking":
+                icon = self.get_icon("reload", 0, False)
+                statusbar.push(0, (datetime.today().strftime("%H:%M") + " - " + _('The watch "%s" is checking.') % watch.name))
+
+            elif status == "idle":
+                if self.tray:
+                    self.tray.show_tooltip() #check if all watches are cleared
+                if watch.changed == True:
+                    self.model.set(self.iter[id], 2, "%s" % watch.name, 5, pango.WEIGHT_BOLD)
+                    self.builder.get_object("button_clear_all").set_sensitive(True)
+                    self.builder.get_object("clear_all1").set_sensitive(True)
+                    icon = self.get_icon(watch.icon, 0, False)
+                else:
+                    self.model.set(self.iter[id], 2, "%s" % watch.name, 5, pango.WEIGHT_NORMAL)
+                    self.builder.get_object("clear_all1").set_sensitive(False)
+                    icon = self.get_icon(watch.icon, 50, False)
+                statusbar.push(0, "")  # As per HIG, make the status bar empty when nothing is happening
+                
+            elif status == "no-network":
+                statusbar.push(0, (datetime.today().strftime("%H:%M") + " - " + _('The network connection seems to be down, networked watches will not check until then.')))
+                if self.tray:
+                    self.tray.show_tooltip()
+                icon = self.get_icon(watch.icon, 50, False)
+
+            elif status == "error":
+                statusbar.push(0, (datetime.today().strftime("%H:%M") + " - " + _('The watch "%s" has a problem.') % watch.name))
+                balloon_icon = self.get_icon("error", 0, True)
+                icon = self.get_icon("error", 50, False)
+                if self.specto.specto_gconf.get_entry("pop_toast") == True:
+                    body = watch.escape(watch.error_message)
+                    self.balloon.show_toast(body, balloon_icon, urgency="critical", summary=(_("%s encountered a problem") % watch.name))
+                if self.specto.specto_gconf.get_entry("use_problem_sound") and self.sound:
+                    problem_sound = self.specto.specto_gconf.get_entry("problem_sound")
+                    self.sound.play(problem_sound)
+
+            elif status == "changed":
+                if self.indicator:
+                    self.indicator.add_indicator(watch)
+                statusbar.push(0, (datetime.today().strftime("%H:%M") + " - " + _('The watch "%s" has changed.') % watch.name))
+
+                self.model.set(self.iter[id], 2, "%s" % watch.name, 5, pango.WEIGHT_BOLD)
+
+                self.builder.get_object("button_clear_all").set_sensitive(True)
+                self.builder.get_object("clear_all1").set_sensitive(True)
+
+                if self.model.iter_is_valid(self.iter[id]):
+                    icon = self.get_icon(watch.icon, 0, False)
+
+                if self.tray:
+                    self.tray.show_tooltip()
+
+                balloon_icon = self.get_icon(watch.icon, 0, True)
+                if self.specto.specto_gconf.get_entry("pop_toast") == True:
+                    self.balloon.show_toast(watch.get_balloon_text(), balloon_icon, summary=(_("%s has changed") % watch.name), name=watch.name)
+
+                icon = self.get_icon(watch.icon, 0, False)
+                if self.specto.specto_gconf.get_entry("use_changed_sound") and self.sound:
+                    changed_sound = self.specto.specto_gconf.get_entry("changed_sound")
+                    self.sound.play(changed_sound)
+                    
+            elif status == "read":
+                if self.indicator:
+                    self.indicator.remove_indicator(id)
+
+            self.model.set_value(self.iter[id], 1, icon)
+
+            try:
+                model, iter = self.treeview.get_selection().get_selected()
+                id2 = int(model.get_value(iter, 3))
+                if id == id2:
+                    self.show_watch_info()
+            except:
+                pass
+        except:
+            self.specto.logger.log(_("There was an error marking the watch status"), "error", watch.name)
+
+    def deactivate(self, id):
+        """ Disable the checkbox from the watch. """
+        watch = self.specto.watch_db[id]
+        self.model.set_value(self.iter[id], 0, 0)#TODO: make the text label in the "Name" column and the buttons insensitive
+
+    def activate(self, id):
+        """ enable the checkbox from the watch. """
+        watch = self.specto.watch_db[id]
+        self.model.set_value(self.iter[id], 0, 1)#TODO: make the text label in the "Name" column and the buttons insensitive
+
+    def get_icon(self, icon, percent, size):
+        """ Calculate the alpha and return a transparent pixbuf. The input percentage is the 'transparency' percentage. 0 means no transparency. """
+        if icon == "":
+            icon = "dialog-information"
+
+        if size == True:
+            size = 64
+        else:
+            size = 22
+
+        try:
+            icon = self.specto.icon_theme.load_icon(icon, size, 0)
+        except gobject.GError:
+            try:
+                icon = gtk.gdk.pixbuf_new_from_file_at_size(os.path.join(self.specto.PATH, ("icons/" + icon + ".svg")), size, size)
+            except:
+                try:
+                    icon = gtk.gdk.pixbuf_new_from_file_at_size(os.path.join(self.specto.PATH, ("icons/" + icon + ".png")), size, size)
+                except:
+                    return None
+
+        icon = icon.add_alpha(False, '0', '0', '0')
+        for row in icon.get_pixels_array():
+            for pix in row:
+                pix[3] = min(int(pix[3]), 255 - (percent * 0.01 * 255))#note: we must *0.01, NOT /100, otherwise it won't work
+        return icon
+
+    def add_notifier_entry(self, id):
+        """ Add an entry to the notifier list. """
+        watch = self.specto.watch_db[id]
+        if watch.active == True:
+            active = 1
+        else:
+            active = 0
+
+        self.iter[id] = self.model.insert_before(None, None)
+        self.model.set_value(self.iter[id], 0, active)
+        if watch.changed == True:
+            self.model.set_value(self.iter[id], 1, self.get_icon(watch.icon, 0, False))
+            self.model.set(self.iter[id], 5, pango.WEIGHT_BOLD)
+        else:
+            self.model.set_value(self.iter[id], 1, self.get_icon(watch.icon, 50, False))
+            self.model.set(self.iter[id], 5, pango.WEIGHT_NORMAL)            
+        self.model.set_value(self.iter[id], 2, watch.name)
+        self.model.set_value(self.iter[id], 3, watch.id)
+        self.model.set_value(self.iter[id], 4, watch.type)
+
+        if not self.builder.get_object("display_all_watches").active and active == 0: #dont creat the entry
+            self.remove_notifier_entry(id)
+
+    def remove_notifier_entry(self, id):
+        path = self.model.get_path(self.iter[id])
+        iter = self.model.get_iter(path)
+        id = int(self.model.get_value(iter, 3))
+        self.model.remove(iter)
+
+    def check_clicked(self, object, path, model):
+        """ Call the main function to start/stop the selected watch. """
+        sel = self.treeview.get_selection()
+        sel.select_path(path)
+
+        model, iter = self.treeview.get_selection().get_selected()
+        id = int(model.get_value(iter, 3))
+        watch = self.specto.watch_db[id]
+
+        if model.get_value(iter, 0):
+            model.set_value(iter, 0, 0)
+            if watch.changed:
+                self.mark_watch_as_read("", id)
+            self.mark_watch_status("idle", id)
+            self.mark_watch_status("idle", id)
+            watch.stop()
+            if not self.builder.get_object("display_all_watches").active:
+                self.remove_notifier_entry(id)
+        else:
+            model.set_value(iter, 0, 1)
+            watch.start()
+
+    def connected_message(self, connected):
+        return
+        if not connected:
+            self.builder.get_object("statusbar1").push(0, _("The network connection seems to be down, networked watches will not check until then."))
+            self.builder.get_object("statusbar1").show()
+        else:
+            self.builder.get_object("statusbar1").hide()
+
+    def show_watch_info(self, *args):
+        """ Show the watch information in the notifier window. """
+        model, iter = self.treeview.get_selection().get_selected()
+
+        if iter != None and self.model.iter_is_valid(iter):
+            self.builder.get_object("edit").set_sensitive(True)
+            self.builder.get_object("remove").set_sensitive(True)
+
+            if not self.info_table.flags() & gtk.VISIBLE:
+                #hide the tip of the day and show the buttons
+                self.quicktip.hide()
+                self.quicktip_image.hide()
+                self.builder.get_object("vbox_panel_buttons").show()
+                self.builder.get_object("notebook1").show()
+                self.info_table.show()
+
+            id = int(model.get_value(iter, 3))
+
+            watch = self.specto.watch_db[id]
+            watch_values = watch.get_gui_info()
+
+            #set the error log field
+            if not self.specto.DEBUG:
+                self.builder.get_object("notebook1").remove_page(2)
+            else:
+                if self.builder.get_object("notebook1").get_n_pages() == 2:
+                    self.builder.get_object("notebook1").append_page(self.error_log_window, self.label_error_log)
+                log_text = self.specto.logger.watch_log(watch.name)
+
+                start = self.log_buffer.get_start_iter()
+                end = self.log_buffer.get_end_iter()
+                self.log_buffer.delete(start, end)
+
+                iter = self.log_buffer.get_iter_at_offset(0)
+                for line in log_text:
+                    self.log_buffer.insert_with_tags_by_name(iter, line[1], line[0])
+
+            if watch.changed == False:
+                self.builder.get_object("clear").set_sensitive(False)
+                self.builder.get_object("btnClear").set_sensitive(False)
+                self.builder.get_object("lblExtraInfo").set_label(_("No extra information available."))
+            else:
+                self.builder.get_object("clear").set_sensitive(True)
+                self.builder.get_object("btnClear").set_sensitive(True)
+                try:
+                    self.extra_info = watch.get_extra_information()
+                    if self.extra_info != "":
+                        try:
+                            self.builder.get_object("lblExtraInfo").set_label(self.extra_info)
+                        except:
+                            self.specto.logger.log(_("Extra information could not be set"), "error", self.specto.watch_db[id].name)
+                except:
+                    self.specto.logger.log(_("Extra information could not be set"), "error", self.specto.watch_db[id].name)
+
+            i = 0
+            while i < 4:
+                if i >= len(watch_values):
+                    self.info_labels[i][0].set_label("")
+                    self.info_labels[i][1].set_label("")
+                else:
+                    #create label
+                    self.info_labels[i][0].set_label("<b>" + str(watch_values[i][0]) + ":</b>")
+                    label = watch.escape(str(watch_values[i][1]))
+                    self.info_labels[i][1].set_label(label)
+
+                i += 1
+
+            image = self.builder.get_object("watch_icon")
+            image.set_from_pixbuf(self.get_icon(watch.icon, 0, True))
+
+    def open_watch(self, id):
+        """
+        Open the selected watch.
+        Returns False if the watch failed to open
+        """
+        return self.specto.watch_db[id].open_watch()
+
+    def open_watch_callback(self, *args):
+        """
+        Opens the selected watch and mark it as unchanged
+        """
+        model, iter = self.treeview.get_selection().get_selected()
+        id = int(model.get_value(iter, 3))
+        self.open_watch(id)
+        if self.specto.watch_db[id].changed == True:
+            self.mark_watch_as_read(None, id)
+
+    def show_watch_popup(self, treeview, event, data=None):
+        if event.button == 3:
+            x = int(event.x)
+            y = int(event.y)
+            time = event.time
+            pthinfo = treeview.get_path_at_pos(x, y)
+            if pthinfo is not None:
+                path, col, cellx, celly = pthinfo
+                treeview.grab_focus()
+                treeview.set_cursor(path, col, 0)
+                menu = self.create_menu(self, self.notifier, None)
+                menu.popup(None, None, None, 3, time)
+            return 1
+
+    def _mark_watch_as_read(self, *widget):
+        try:
+            model, iter = self.treeview.get_selection().get_selected()
+            id = int(model.get_value(iter, 3))
+
+            self.mark_watch_as_read(id)
+        except:
+            pass
+
+    def refresh_watch(self, widget):
+        model, iter = self.treeview.get_selection().get_selected()
+        id = int(model.get_value(iter, 3))
+        watch = self.specto.watch_db[id]
+        watch.restart()
+
+    def edit_watch(self, widget):
+        model, iter = self.treeview.get_selection().get_selected()
+        id = int(model.get_value(iter, 3))
+        self.show_edit_watch(self, widget, id)
+
+    def create_menu(self, window, event, data=None):
+        model, iter = self.treeview.get_selection().get_selected()
+        id = int(model.get_value(iter, 3))
+        watch = self.specto.watch_db[id]
+        menu = gtk.Menu()
+        menuItem = None
+
+        menuItem = create_menu_item(_("Refresh"), self.refresh_watch,
+            gtk.STOCK_REFRESH)
+        if not watch.active:
+            menuItem.set_sensitive(False)
+        menu.append(menuItem)
+
+        menuItem = create_menu_item(_("Mark as read"), self._mark_watch_as_read,
+            gtk.STOCK_CLEAR)
+        if not watch.changed:
+            menuItem.set_sensitive(False)
+        menu.append(menuItem)
+        
+        menuItem = create_menu_item(_("Crawl"), self.crawl_watch, gtk.STOCK_EDIT)
+        menu.append(menuItem)
+
+        separator = gtk.SeparatorMenuItem()
+        menu.append(separator)
+
+        menuItem = create_menu_item(_("Edit"), self.edit_watch, gtk.STOCK_EDIT)
+        menu.append(menuItem)
+
+        menuItem = create_menu_item(_("Remove"), self.remove_watch,
+            gtk.STOCK_REMOVE)
+        menu.append(menuItem)
+
+        menu.show_all()
+        return menu
+
+    def change_entry_name(self, *args):
+        """ Edit the name from the watch in the notifier window. """
+        # Change the name in the treeview
+        model, iter = self.treeview.get_selection().get_selected()
+        id = int(model.get_value(iter, 3))
+        self.change_name(args[2], id)
+
+    def change_name(self, new_name, id):
+        if self.specto.watch_db[id].changed == True:
+            weight = pango.WEIGHT_BOLD
+        else:
+            weight = pango.WEIGHT_NORMAL
+        self.model.set(self.iter[id], 2, new_name, 5, weight)
+
+        # Write the new name in watches.list
+        self.specto.watch_io.replace_name(self.specto.watch_db[id].name, new_name)
+        # Change the name in the database
+        self.specto.watch_db[id].name = new_name
+        self.show_watch_info()
+
+### GUI FUNCTIONS ###
+    def get_quick_tip(self):
+        """Return a random tip of the day to be shown on startup"""
+        tips = [_("You can add all kinds of websites as watches. Static pages, RSS or Atom feeds, etc. Specto will automatically handle them."),
+                    _("Website watches can use an error margin that allows you to set a minimum difference percentage. This allows you to adapt to websites that change constantly or have lots of advertising."),
+                    _("Single-click an existing watch to display information, and double-click it to open the content."),
+                    _("Please set a reasonable refresh interval in order to save bandwidth and prevent you from being blocked from content providers.")]
+        chosen_tip = tips[randrange(len(tips))]
+        return chosen_tip
+
+    def toggle_display_toolbar(self, *args):
+        """ Show or hide the toolbar. """
+        if self.builder.get_object("display_toolbar").active:
+            self.builder.get_object("toolbar").show()
+            self.specto.specto_gconf.set_entry("hide_toolbar", False)
+        else:
+            self.builder.get_object("toolbar").hide()
+            self.specto.specto_gconf.set_entry("hide_toolbar", True)
+
+    def toggle_show_deactivated_watches(self, *widget):
+        """ Display only active watches or all watches. """
+        if self.startup != True:
+            self.startup = False  # This is important to prevent *widget from messing with us. If you don't believe me, print startup ;)
+        if self.startup == True:
+            self.startup = False
+        else:
+            if self.builder.get_object("display_all_watches").active:
+                for watch in self.specto.watch_db:
+                    if watch.active == False:  # For each watch that is supposed to be inactive, show it in the notifier but don't activate it
+                        if self.startup == False:  # Recreate the item because it was deleted
+                            self.add_notifier_entry(watch.id)
+                self.specto.specto_gconf.set_entry("show_deactivated_watches", True)
+            else:  # Hide the deactivated watches
+                for i in self.iter:
+                    if self.model.iter_is_valid(self.iter[i]):
+                        path = self.model.get_path(self.iter[i])
+                        iter = self.model.get_iter(path)
+                        model = self.model
+                        id = int(model.get_value(iter, 3))
+
+                        if self.specto.watch_db[id].active == False:
+                            model.remove(iter)
+                self.specto.specto_gconf.set_entry("show_deactivated_watches", False)
+
+    def remove_watch(self, *widget):
+        try:
+            model, iter = self.treeview.get_selection().get_selected()
+            id = int(model.get_value(iter, 3))
+        except:
+            pass
+        else:
+            dialog = RemoveDialog(_("Remove a watch"),
+            (_('<big>Remove the watch "%s"?</big>\nThis operation cannot be undone.') % self.specto.watch_db[id].name))
+            answer = dialog.show()
+            if answer == True:
+                self.remove_notifier_entry(id)
+                self.specto.watch_db.remove(id) #remove the watch
+                self.specto.watch_io.remove_watch(self.specto.watch_db[id].name)
+                if self.tray:
+                    self.tray.show_tooltip()
+
+    def delete_event(self, *args):
+        """
+        quit specto
+        """
+        self.save_size_and_position()
+        self.specto.quit()
+        return True
+
+            
+    def close_event(self, *args):
+        """
+        if the trayicon and the indicator or not available then quit specto else hide the notifier window
+        """
+        if self.specto.specto_gconf.get_entry("always_show_icon") == True or self.indicator:
+            self.notifier.hide()
+            self.specto.specto_gconf.set_entry("show_notifier", False)#save the window state for the next time specto starts
+            return True
+        else:
+            self.specto.quit()
+            return True            
+
+    def restore_size_and_position(self):
+        """
+        Restore the size and the postition from the notifier window.
+        """
+        saved_window_width = self.specto.specto_gconf.get_entry("window_notifier_width")
+        saved_window_height = self.specto.specto_gconf.get_entry("window_notifier_height")
+        saved_window_x = self.specto.specto_gconf.get_entry("window_notifier_x")
+        saved_window_y = self.specto.specto_gconf.get_entry("window_notifier_y")
+        if self.specto.specto_gconf.get_entry("hide_from_windowlist")==True:
+            self.notifier.set_skip_taskbar_hint(True)  # Hide from the window list applet
+
+        if saved_window_width != None and saved_window_height != None:  # Check if the size is not 0
+            self.builder.get_object("notifier").resize(saved_window_width, saved_window_height)
+
+        if saved_window_x != None and saved_window_y != None:  # Check if the position is not 0
+            self.builder.get_object("notifier").move(saved_window_x, saved_window_y)
+
+    def save_size_and_position(self):
+        """
+        Save the size and position from the notifier in gconf when the window is closed.
+        """
+        # Save the size in gconf
+        current_window_size = self.builder.get_object("notifier").get_size()
+        current_window_width = current_window_size[0]
+        current_window_height = current_window_size[1]
+        self.specto.specto_gconf.set_entry("window_notifier_width", current_window_width)
+        self.specto.specto_gconf.set_entry("window_notifier_height", current_window_height)
+
+        # Save the window position in gconf when the window is closed
+        current_window_xy = self.builder.get_object("notifier").get_position()
+        current_window_x = current_window_xy[0]
+        current_window_y = current_window_xy[1]
+        self.specto.specto_gconf.set_entry("window_notifier_x", current_window_x)
+        self.specto.specto_gconf.set_entry("window_notifier_y", current_window_y)
+
+    def get_state(self):
+        """ Return True if the notifier window is visible. """
+        return bool(self.notifier.flags() & gtk.VISIBLE)
+
+    def create_notifier_gui(self):
+        """ Create the gui from the notifier. """
+        self.treeview = self.builder.get_object("treeview")
+        self.treeview.set_model(self.model)
+        self.treeview.set_flags(gtk.TREE_MODEL_ITERS_PERSIST)
+        self.treeview.connect("button_press_event", self.show_watch_popup, None)
+        self.builder.get_object("button_clear_all").set_sensitive(False)
+        self.builder.get_object("clear_all1").set_sensitive(False)
+        
+        if self.specto.specto_gconf.get_entry("always_show_icon") == False and not self.indicator:
+            self.builder.get_object("close").set_sensitive(False)
+
+        if self.specto.specto_gconf.get_entry("show_in_windowlist") == False:
+            self.notifier.set_skip_taskbar_hint(True)
+
+
+        ### Initiate the window
+        self.restore_size_and_position()
+        self.show_toolbar = self.specto.specto_gconf.get_entry("show_toolbar")
+        if  self.show_toolbar == False:
+            self.builder.get_object("display_toolbar").set_active(False)
+            self.toggle_display_toolbar()
+        else:
+            self.builder.get_object("display_toolbar").set_active(True)
+            self.toggle_display_toolbar()
+
+        self.startup = True
+        if self.specto.specto_gconf.get_entry("show_deactivated_watches") == True:
+            self.builder.get_object("display_all_watches").set_active(True)
+        else:
+            self.builder.get_object("display_all_watches").set_active(False)
+        self.startup = False
+
+        if not self.specto.notifier_hide:
+            self.notifier.show()
+
+        ### Checkbox
+        self.columnCheck_renderer = gtk.CellRendererToggle()
+        self.columnCheck_renderer.set_property("activatable", True)
+        self.columnCheck_renderer.connect("toggled", self.check_clicked, self.model)
+        self.columnCheck = gtk.TreeViewColumn(_("Active"), self.columnCheck_renderer, active=0)
+        self.columnCheck.connect("clicked", self.sort_active_from_treeview_headers)
+        self.columnCheck.set_sort_column_id(0)
+        self.treeview.append_column(self.columnCheck)
+
+        ### Icon
+        self.columnIcon_renderer = gtk.CellRendererPixbuf()
+        self.columnIcon = gtk.TreeViewColumn(_("Type"), self.columnIcon_renderer, pixbuf=1)
+        self.columnIcon.set_clickable(True)
+        self.columnIcon.connect("clicked", self.sort_type_from_treeview_headers)
+        self.treeview.append_column(self.columnIcon)
+
+        ### Titre
+        self.columnTitle_renderer = gtk.CellRendererText()
+        #self.columnTitle_renderer.set_property("editable", True)
+        #self.columnTitle_renderer.connect('edited', self.change_entry_name)
+        self.columnTitle = gtk.TreeViewColumn(_("Name"), self.columnTitle_renderer, text=2, weight=5)
+        self.columnTitle.connect("clicked", self.sort_name_from_treeview_headers)
+        self.columnTitle.set_expand(True)
+        self.columnTitle.set_resizable(True)
+        self.columnTitle.set_sort_column_id(2)
+        self.treeview.append_column(self.columnTitle)
+
+        ### ID
+        self.columnID_renderer = gtk.CellRendererText()
+        self.columnID = gtk.TreeViewColumn(_("ID"), self.columnID_renderer, markup=3)
+        self.columnID.set_visible(False)
+        self.columnID.set_sort_column_id(3)
+        self.treeview.append_column(self.columnID)
+
+        ### type
+        self.renderer = gtk.CellRendererText()
+        self.columnType = gtk.TreeViewColumn(_("TYPE"), self.renderer, markup=4)
+        self.columnType.set_visible(False)
+        self.columnType.set_sort_column_id(4)
+        self.treeview.append_column(self.columnType)
+
+        self.get_startup_sort_order()
+
+
+        ###Create info-panel
+        vbox_info = self.builder.get_object("vbox_info")
+
+        #show tip of the day
+        self.quicktip = self.get_quick_tip()
+        self.quicktip_image = gtk.Image()
+        self.quicktip_image.set_from_pixbuf(self.get_icon("dialog-information", 0, True))
+        self.quicktip_image.show()
+        vbox_info.pack_start(self.quicktip_image, False, False, 0)
+        self.quicktip = gtk.Label(("<big>" + _("Tip of the Day:") + "</big> "+ self.quicktip))
+        self.quicktip.set_line_wrap(True)
+        self.quicktip.set_use_markup(True)
+        self.quicktip.set_alignment(xalign=0.0, yalign=0.5)
+        self.quicktip.show()
+        vbox_info.pack_start(self.quicktip, False, False, 0)
+
+        #create the info table
+        self.info_table = gtk.Table(rows=4, columns=2, homogeneous=True)
+        self.info_table.set_row_spacings(6)
+        self.info_table.set_col_spacings(6)
+        vbox_watch_info = self.builder.get_object("vbox_watch_info")
+        vbox_watch_info.pack_start(self.info_table, False, False, 0)   #show the image
+
+        i = 0
+        self.info_labels = []
+        while i < 4:
+            gtk_label = gtk.Label()
+            gtk_label.set_alignment(xalign=0.0, yalign=0.5)
+            gtk_label.set_use_markup(True)
+            gtk_label.set_ellipsize(pango.ELLIPSIZE_END)
+            gtk_label.show()
+
+            #create value
+            gtk_label1 = gtk.Label()
+            gtk_label1.set_alignment(xalign=0.0, yalign=0.5)
+            gtk_label1.set_use_markup(True)
+            gtk_label1.set_ellipsize(pango.ELLIPSIZE_END)
+            gtk_label1.show()
+
+            self.info_labels.extend([(gtk_label, gtk_label1)])
+            self.info_table.attach(self.info_labels[i][1], 1, 2, i, i + 1)
+            self.info_table.attach(self.info_labels[i][0], 0, 1, i, i + 1)
+
+            i += 1
+
+        #create the error log textview and notebook label
+        self.error_log = gtk.TextView()
+        self.log_buffer = self.error_log.get_buffer()
+        self.log_buffer.create_tag("ERROR", foreground="#a40000")
+        self.log_buffer.create_tag("INFO", foreground="#4e9a06")
+        self.log_buffer.create_tag("WARNING", foreground="#c4a000")
+        self.error_log_window = gtk.ScrolledWindow()
+        self.error_log_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.error_log_window.add_with_viewport(self.error_log)
+        self.error_log_window.show()
+        self.label_error_log = gtk.Label(_("Error log"))
+        self.error_log.show()
+        self.label_error_log.show()
+
+        #hide the buttons
+        self.builder.get_object("vbox_panel_buttons").hide()
+
+        self.builder.get_object("edit").set_sensitive(False)
+        self.builder.get_object("clear").set_sensitive(False)
+        self.builder.get_object("remove").set_sensitive(False)
+
+        self.builder.get_object("statusbar1").show()
+
+        self.builder.get_object("notebook1").hide()
+
+        self.generate_add_menu()
+
+### Sort functions ###
+    def get_startup_sort_order(self):
+        order = self.get_gconf_sort_order()
+        sort_function = self.specto.specto_gconf.get_entry("sort_function")
+        if  sort_function == "name":
+            self.builder.get_object("by_name").set_active(True)
+            self.model.set_sort_column_id(2, order)
+        elif sort_function == "type":
+            self.builder.get_object("by_watch_type").set_active(True)
+            self.model.set_sort_column_id(4, order)
+        elif sort_function == "active":
+            self.builder.get_object("by_watch_active").set_active(True)
+            self.model.set_sort_column_id(0, order)
+
+    def get_gconf_sort_order(self):
+        """ Get the order (asc, desc) from a gconf key. """
+        order = self.specto.specto_gconf.get_entry("sort_order")
+        if order == "asc":
+            sort_order = gtk.SORT_ASCENDING
+        else:
+            sort_order = gtk.SORT_DESCENDING
+        return sort_order
+
+    def set_gconf_sort_order(self, order):
+        """ Set the order (asc, desc) for a gconf keys. """
+        if order == gtk.SORT_ASCENDING:
+            sort_order = "asc"
+        else:
+            sort_order = "desc"
+        return sort_order
+
+    def sort_name(self, *args):
+        """ Sort by watch name. """
+        self.model.set_sort_column_id(2, not self.columnTitle.get_sort_order())
+        self.specto.specto_gconf.set_entry("sort_function", "name")
+
+    def sort_type(self, *args):
+        """ Sort by watch type. """