Merge lp:~injaon/indicator-sysmonitor/trunk into lp:indicator-sysmonitor/trunk

[Gabriel Lopez]

[Alex Eftimie (alexeftimie)]

This is basically a complete rewrite. I approve the changes, and coding style, generally.

[Alex Eftimie (alexeftimie)]

Please bump the version to 0.5

review: Needs Fixing

[Gabriel Lopez (injaon)]

I don't know how to do it :(

2012/9/24 Alex Eftimie <email address hidden>:
> Review: Needs Fixing
>
> Please bump the version to 0.5
> --
> https://code.launchpad.net/~pipodecnt/indicator-sysmonitor/trunk/+merge/125394
> You are the owner of lp:~pipodecnt/indicator-sysmonitor/trunk.

[Alex Eftimie (alexeftimie)]

Just change the variable VERSION value :)

[lp:~injaon/indicator-sysmonitor/trunk]

31. By Gabriel Lopez <email address hidden> on 2012-09-26

Change VERSION variable.

[Gabriel Lopez (injaon)]

> Just change the variable VERSION value :)

LOL. Tha hard work is done :P

[Alex - WarumLinuxBesserIst - (wlbi)]

This indicator is so great, it's my favourite one to see network speed.
In Ubuntu 15.04 I can't add the network activity sensor in teh "Advanced" settings.
If I like to save with the network sensor, there is the error: " {bat\d*} sensor not supported."
Is there a special package to add to have this?

=== modified file 'indicator-sysmonitor'
--- indicator-sysmonitor	2012-04-22 06:30:20 +0000
+++ indicator-sysmonitor	2012-09-26 17:56:20 +0000
@@ -7,39 +7,184 @@
 # Homepage: http://launchpad.net/indicator-sysmonitor
 # License: GPL v3
 #
+from gettext import gettext as _
+from gettext import textdomain, bindtextdomain
+textdomain("indicator-sysmonitor")
+bindtextdomain("indicator-sysmonitor", "./lang")
+
 import sys
 import os
 import shutil
 import json
-import string
 import time
-from copy import deepcopy
 from threading import Thread, Event
 import subprocess
 import psutil as ps
-
-import logging
-logging.basicConfig(file=sys.stderr,level=logging.INFO)
-
+import re
 import gobject
 import gtk
+gtk.gdk.threads_init()
 import appindicator
-
-VERSION='0.4.1~unreleased'
-
-gtk.gdk.threads_init()
+import logging
+logging.basicConfig(file=sys.stderr, level=logging.INFO)
+
+B_UNITS = ['', 'KB', 'MB', 'GB', 'TB']
+VERSION = '0.5.0~unreleased'
+HELP_MSG = """<span underline="single" size="x-large">{title}</span>
+
+{introduction}
+
+{basic}
+• cpu: {cpu_desc}
+• mem: {mem_desc}
+• bat<i>%d</i>: {bat_desc}
+• net: {net_desc}
+
+{compose}
+• fs//<i>mount-point</i> : {fs_desc}
+
+<big>{example}</big>
+CPU {{cpu}} | MEM {{mem}} | root {{fs///}}
+""".format(
+    title=_("Help Page"),
+    introduction=_("The sensors are the names of the devices you want to retrieve information from. They must be placed between brackets."),
+    basic=_("The basics are:"),
+    cpu_desc=_("It shows the average of CPU usage."),
+    mem_desc=_("It shows the physical memory in use."),
+    bat_desc=_("It shows the available battery which id is %d."),
+    net_desc=_("It shows the amount of data you are downloading and uploading through your network."),
+    compose=_("Also there are the following sensors that are composed with two parts divided by two slashes."),
+    fs_desc=_("Show available space in the file system."),
+    example=_("Example:"))
+
+
+class ISMError(Exception):
+    """General exception."""
+    def __init__(self, msg):
+        Exception.__init__(self, msg)
+
+
+def raise_dialog(parent, flags, type_, buttons, msg, title):
+    """It raise a dialog. It a blocking function."""
+    dialog = gtk.MessageDialog(
+        parent, flags, type_, buttons, msg)
+    dialog.set_title(title)
+    dialog.run()
+    dialog.destroy()
+
+supported_sensors = re.compile("mem|cpu|net|bat\d+|fs//.+?")
+settings = {
+    'custom_text': 'cpu: {cpu} mem: {mem}',
+    'interval': 2,
+    'on_startup': False,
+    'sensors': {
+        # 'name' => (desc, cmd)
+        'cpu': (_('Average CPU usage'), True),
+        'mem': (_('Physical memory in use.'), True),
+        'net': (_('Network activity.'), True),
+        'bat\d+': (_('Network activity.'), True),
+        'fs//.+': (_('Available space in file system.'), True)
+        }
+    }
+
+
+class Sensor(object):
+    """Singleton"""
+    _instance = None
+
+    def __init__(self):
+        """It must not be called. Use Sensor.get_instace()
+        to retrieve an instance of this class."""
+        if Sensor._instance is not None:
+            raise Exception("Sensor class can not be instanceted twice.")
+        else:
+            Sensor._instance = self
+        self.update_regex()
+
+    @classmethod
+    def get_instance(cls):
+        """Returns the unique instance of Sensor."""
+        if Sensor._instance is None:
+            Sensor._instance = Sensor()
+
+        return Sensor._instance
+
+    @staticmethod
+    def exists(name):
+        """Checks if the sensor name exists"""
+        return bool(supported_sensors.match(name))
+
+    def add(self, name, desc, cmd):
+        """Adds a custom sensors."""
+        if Sensor.exists(name):
+            raise ISMError(_("Sensor name already in use."))
+
+        settings["sensors"][name] = (desc, cmd)
+        self.update_regex()
+
+    @staticmethod
+    def update_regex(names=None):
+        if names is None:
+            names = settings["sensors"].keys()
+
+        reg = '|'.join(names)
+        global supported_sensors
+        supported_sensors = re.compile("{}".format(reg))
+
+    def delete(self, name):
+        """Deletes a custom sensors."""
+        sensors = settings['sensors']
+        names = sensors.keys()
+        if name not in names:
+            raise ISMError(_("Sensor is not defined."))
+
+        _desc, default = sensors[name]
+        if default is True:
+            raise ISMError(_("Can not delete default sensors."))
+
+        del sensors[name]
+        self.update_regex()
+
+    def edit(self, name, newname, desc, cmd):
+        """Edits a custom sensors."""
+        try:
+            sensors = settings['sensors']
+            _desc, default = sensors[name]
+
+        except KeyError:
+            raise ISMError(_("Sensor does not exists."))
+
+        if default is True:
+            raise ISMError(_("Can not edit default sensors."))
+        if newname != name:
+            if newname in sensors.keys():
+                raise ISMError(_("Sensor name already in use."))
+
+        sensors[newname] = (desc, cmd)
+        del sensors[name]
+        settings["custom_text"] = settings["custom_text"].replace(
+            name, newname)
+        self.update_regex()
+
 
 class StatusFetcher(Thread):
+    """It recollects the info about the sensors."""
+    digit_regex = re.compile(r'''\d+''')
+
     def __init__(self, parent):
         Thread.__init__(self)
-        self.parent = parent
+        self._parent = parent
         self.last = ps.cpu_times()
 
     def _fetch_cpu(self):
         last = self.last
         current = ps.cpu_times()
 
-        total_time_passed = sum([v-last.__dict__[k] if not isinstance(v,list) else 0 for k,v in current.__dict__.iteritems()])
+        total_time_passed = sum(
+            [v - last.__dict__[k]
+             if not isinstance(v, list)
+             else 0
+             for k, v in current.__dict__.iteritems()])
 
         sys_time = current.system - last.system
         usr_time = current.user - last.user
@@ -54,545 +199,618 @@
             return 0
 
     def _fetch_mem(self):
-        total_mem = subprocess.Popen("free -b | grep Mem | tr -s ' ' | cut -d\  -f 2",
-            stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
-        free_mem = subprocess.Popen("free -b | grep Mem | tr -s ' ' | cut -d\  -f 4-",
-            stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
-        free_mem = sum([int(i) for i in free_mem.split()])
-        return 100 - 100 * float(free_mem) / float(total_mem)
+        """It gets the total memory info and return the used in percentaje."""
+        with open('/proc/meminfo') as meminfo:
+            total = StatusFetcher.digit_regex.findall(meminfo.readline()).pop()
+            free = StatusFetcher.digit_regex.findall(meminfo.readline()).pop()
+            meminfo.readline()
+            cached = StatusFetcher.digit_regex.findall(meminfo.readline()).pop()
+            free = int(free) + int(cached)
+            return 100 - 100 * free / float(total)
 
     def _fetch_bat(self, bat_id):
-        current_bat = subprocess.Popen("grep 'remaining capacity:' /proc/acpi/battery/BAT%s/state |awk '{print $3}' |grep [0-9] || echo 10" % bat_id,
+        current_bat = subprocess.Popen(
+            "grep 'remaining capacity:' /proc/acpi/battery/BAT%s/state |awk '{print $3}' |grep [0-9] || echo 10" % bat_id,
             stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
         #total_bat = subprocess.Popen("cat /proc/acpi/battery/BAT0/info |grep -i 'design capacity:' |awk '{print $3}'",
-        total_bat = subprocess.Popen("grep 'last full capacity:' /proc/acpi/battery/BAT%s/info |awk '{print $4}' |grep [0-9] || echo 65130" % bat_id,
+        total_bat = subprocess.Popen(
+            "grep 'last full capacity:' /proc/acpi/battery/BAT%s/info | awk '{print $4}' |grep [0-9] || echo 65130" % bat_id,
             stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
         return 100 * float(current_bat) / float(total_bat)
 
     def _fetch_net(self):
-        total_net = subprocess.Popen("ifstat -a -n -q -S -T 0.5 1 | tail -1 | awk '{ printf(\"↓%dkB/s ↑%dkB/s\", $6, $7) }'", stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
+        """It use the command "ifstat" to know the total net usage"""
+        total_net = subprocess.Popen(
+            "ifstat -a -n -q -S -T 0.5 1 | tail -1 | awk '{ printf(\"↓%dkB/s ↑%dkB/s\", $6, $7) }'",
+            stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
         return total_net
 
-    def _fetch_sensor(self, sensor_name):
-        sensor_data = sensor_name.split('//')
-
-        if (len(sensor_data) != 2):
-            return 'N/A'
-
-        sensor_item = sensor_data[1].replace('-', '.')
-        postfix = ''
-        if sensor_data[0] == 'hddtemp':
-            sensor_cmd = 'netcat localhost 7634'
-            netcat_value = subprocess.Popen(sensor_cmd, stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
-            sensor_value = ''
-
-            for hd_data in self.parse_hddtemp_entries(netcat_value):
-                if hd_data[0] == sensor_item:
-                    sensor_value = hd_data[2] + '°' + hd_data[3]
-        else:
-            sensor_cmd = 'sensors -A ' + sensor_data[0] + " | grep -i '" + sensor_item + "' | cut -f 2 -d ':'  | awk '{print $1}'"
-            if sensor_data[0] == 'nvidia':
-                if sensor_item == 'gputemp':
-                    sensor_cmd = 'nvidia-settings -q [gpu:0]/GPUCoreTemp | grep "Attribute" | sed -e "s/.*: //g" -e "s/\.//g"'
-                    postfix = '°C'
-                elif sensor_item == 'fanspeed':
-                    sensor_cmd = 'nvidia-settings -q [fan:0]/GPUCurrentFanSpeed | grep "Attribute" | sed -e "s/.*: //g" -e "s/\.//g"'
-                    postfix = ' RPM'
-                else:
-                    sensor_cmd = None
-            elif sensor_data[0] == 'ati':
-                if sensor_item == 'gputemp':
-                    sensor_cmd = 'aticonfig --adapter=0 --od-gettemperature | grep "Sensor 0:" | awk ' + "'{ printf(\"%d\", $5) }'"
-                    postfix = '°C'
-
-            sensor_value = subprocess.Popen(sensor_cmd, stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
-
-        if len(sensor_value):
-            sensor_value = self._clean_value(sensor_value) # Cleaning the + prefix
-            return sensor_value + postfix
-        else:
-            if sensor_cmd == None:
-                logging.info('Sensor not supported: ' + sensor_name)
-            else:
-                logging.info('Sensor command failed:\n' + sensor_cmd)
-            return 'N/A'
-
-    def _clean_value(self, value):
-        if value.find('+') == 0:
-            return value[1:]
-        return value
-
-    def _get_sensors_to_fetch(self):
-        fmt = string.Formatter()
-        tokens = []
-        for token in fmt.parse(self.parent.custom_text):
-            tokens.append(str(token[1]))
-
-        return tokens
-
-    def _fetch(self):
+    def fetch(self):
+        """Return a dict whose element are the sensors
+        and their values"""
         res = {}
-        for sensor in self._get_sensors_to_fetch():
+        for sensor in Preferences.sensors_regex.findall(settings["custom_text"]):
+            sensor = sensor[1:-1]
+            if not Sensor.exists(sensor):
+                continue
             if sensor == 'cpu':
-                res['cpu'] = '%02.0f%%' % self._fetch_cpu()
+                res['cpu'] = "{:02.0f}%".format(self._fetch_cpu())
             elif sensor == 'mem':
-                res['mem'] = '%02.0f%%' % self._fetch_mem()
+                res['mem'] = '{:02.0f}%'.format(self._fetch_mem())
+            elif sensor == 'net':
+                res['net'] = self._fetch_net()
+
             elif sensor.startswith('bat'):
-                bat_id = sensor[3:]
+                bat_id = sensor[4:]
                 try:
                     bat_id = int(bat_id)
                 except:
                     bat_id = 0
-                res[sensor] = '%02.0f%%' % self._fetch_bat(bat_id)
-            elif sensor == 'net':
-                res['net'] = self._fetch_net()
-            else:
-                res[sensor] = '%s' % self._fetch_sensor(sensor)
+                res[sensor] = '{:02.0f}%'.format(self._fetch_bat(bat_id))
+
+            elif sensor.startswith('fs//'):
+                parts = sensor.split('//')
+                res[sensor] = self._fetch_fs(parts[1])
+
+            else:  # custom sensor
+                res[sensor] = self._exec(settings["sensors"][sensor][1])
 
         return res
 
-    def _fetch_user(self, command):
+    def _exec(self, command):
+        """Execute a custom command."""
         try:
-          output = subprocess.Popen(command, stdout=subprocess.PIPE,
-                                    shell=True).communicate()[0].strip()
-          if output == '':
-              output = '(no output)'
+            output = subprocess.Popen(command, stdout=subprocess.PIPE,
+                                      shell=True).communicate()[0].strip()
         except:
-          output = 'error'
-          logging.error('Error running: '+command)
-        return output
-
-    def parse_hddtemp_entries(self, netcat_value):
-        hddtemp_entries = []
-
-        if len(netcat_value):
-            for hd_row in netcat_value.strip('|').split('||'):
-                hddtemp_entries.append(hd_row.split('|'))
-
-        return hddtemp_entries
+            output = _("Error")
+            logging.error(_("Error running: {}").format(command))
+
+        return output if output else _("(no output)")
+
+    def _fetch_fs(self, mount_point):
+        """It returns the amount of bytes available in the fs in
+        a human-readble format."""
+        if not os.access(mount_point, os.F_OK):
+            return None
+
+        stat = os.statvfs(mount_point)
+        bytes_ = stat.f_bavail * stat.f_frsize
+
+        for unit in B_UNITS:
+            if bytes_ < 1024:
+                return "{} {}".format(bytes_, unit)
+            bytes_ /= 1024
 
     def run(self):
-        while(self.parent.alive.isSet()):
-            if self.parent.mode_user:
-                output = self._fetch_user(self.parent.user_command)
-                self.parent.update_text(output, output)
-            else:
-                data = self._fetch()
-                self.parent.update(data)
-            time.sleep(self.parent.interval)
-
-class SensorsListModel:
+        """It is the main loop."""
+        while self._parent.alive.isSet():
+            data = self.fetch()
+            self._parent.update(data)
+            time.sleep(settings["interval"])
+
+
+class SensorsListModel(object):
+    """A TreeView showing the available sensors. It allows to
+    add/edit/delete custom sensors."""
+
     def __init__(self, parent):
         self.ind_parent = parent
-        self.tree_store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
-
-        # lib sensors
-        for sensor_data in subprocess.Popen('sensors', stdout=subprocess.PIPE, shell=True).communicate()[0].split('\n\n'):
-            sensor_name = None
-            skip_line = False
-            for line in sensor_data.split('\n'):
-                if len(line):
-                    if skip_line:
-                        skip_line = False
-                    else:
-                        if sensor_name == None:
-                            logging.info("New sensor found: " + line)
-                            sensor_name = line
-                            parent = self.tree_store.append(None, (sensor_name, None, False))
-                            skip_line = True
-                        else:
-                            logging.info("Sensor entry: " + line)
-                            self.tree_store.append(parent, (line, self.generate_sensor_item_name(sensor_name, line), False))
-
-        # hddtemp
-        hddtemp = subprocess.Popen('netcat localhost 7634', stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
-        if len(hddtemp):
-            sensor_name = 'hddtemp'
-            logging.info("New sensor found: " + sensor_name)
-            parent = self.tree_store.append(None, (sensor_name, None, False))
-            for hd_data in self.ind_parent.ind_parent.fetch.parse_hddtemp_entries(hddtemp):
-                logging.info("Sensor entry: " + hd_data[0])
-                self.tree_store.append(parent, (hd_data[0] + ' - ' + hd_data[1] + ' - ' + hd_data[2] + '°' + hd_data[3], self.generate_sensor_item_name(sensor_name, hd_data[0]), False))
-
-        # nvidia GPU
-        nvidia_model = subprocess.Popen("lspci | grep nVidia | sed -e 's/.*\[//g' -e 's/\].*//g'", stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
-        if len(nvidia_model):
-            sensor_name = 'nvidia'
-            logging.info("New sensor found: " + sensor_name)
-            parent = self.tree_store.append(None, (sensor_name, None, False))
-            self.tree_store.append(parent, (nvidia_model + ' - Temperature', self.generate_sensor_item_name(sensor_name, 'gputemp'), False))
-            self.tree_store.append(parent, (nvidia_model + ' - Fan speed', self.generate_sensor_item_name(sensor_name, 'fanspeed'), False))
-
-        # ati GPU
-        ati_model = subprocess.Popen('lspci | grep \"ATI Radeon HD"' + " | sed -e 's/.*\[//g' -e 's/\].*//g'", stdout=subprocess.PIPE, shell=True).communicate()[0].strip()
-        if len(ati_model):
-            sensor_name = 'ati'
-            logging.info("New sensor found: " + sensor_name)
-            parent = self.tree_store.append(None, (sensor_name, None, False))
-            self.tree_store.append(parent, (ati_model + ' - Temperature', self.generate_sensor_item_name(sensor_name, 'gputemp'), False))
+        self._list_store = gtk.ListStore(str, str)
+        self._tree_view = gtk.TreeView(self._list_store)
+
+        sensors = settings['sensors']
+        for name in sensors.keys():
+            self._list_store.append([name, sensors[name][0]])
 
     def get_view(self):
-        self.view = gtk.HBox()
-
-        self.vb = gtk.VBox(False, 3)
-        l = gtk.Label('Sensors:')
-        l.set_alignment(0, 0.5)
-        self.vb.pack_start(l, expand=False, fill=False)
-
-        self.tree_view = gtk.TreeView(self.tree_store)
-
-        # setup the text cell renderer
-        self.renderer = gtk.CellRendererText()
-        self.renderer.set_property('editable', False)
-
-        # sensor name render
-        self.renderer1 = gtk.CellRendererText()
-        self.renderer1.set_property('editable', False)
-
-        # quick add checkbox render
-        self.renderer2 = gtk.CellRendererToggle()
-        self.renderer2.set_property('activatable', True)
-        self.renderer2.connect('toggled', self.quick_add_cb_toggled, self.tree_store)
-
+        """It's call from Preference. It create the view and return it"""
+        vbox = gtk.VBox(False, 3)
         # create columns
-        self.column0 = gtk.TreeViewColumn('Sensor', self.renderer, text=0)
-        self.column1 = gtk.TreeViewColumn('Identifier', self.renderer1, text=1)
-        self.column2 = gtk.TreeViewColumn('', self.renderer2, active=2)
-        self.tree_view.append_column(self.column0)
-        self.tree_view.append_column(self.column1)
-        self.tree_view.append_column(self.column2)
-
-        self.tree_view.expand_all()
+        renderer = gtk.CellRendererText()
+        renderer.set_property('editable', False)
+        column = gtk.TreeViewColumn(_('Sensor'), renderer, text=0)
+        self._tree_view.append_column(column)
+
+        renderer = gtk.CellRendererText()
+        renderer.set_property('editable', False)
+        column = gtk.TreeViewColumn(_('Description'), renderer, text=1)
+        self._tree_view.append_column(column)
+
+        self._tree_view.expand_all()
         sw = gtk.ScrolledWindow()
-        sw.add_with_viewport(self.tree_view)
-        self.vb.pack_start(sw, fill=True, expand=True)
-
-        self.add_bt = gtk.Button('Add selected sensors')
-        self.add_bt.connect('clicked', self.update_custom_text)
-        self.vb.pack_end(self.add_bt, fill=False, expand=False)
-
-        self.view.add(self.vb)
-        self.view.show()
-
-        return self.view
-
-    def quick_add_cb_toggled(self, cell, path, tree_store):
-        tree_store[path][2] = not tree_store[path][2]
-        iter = tree_store.iter_children(tree_store.get_iter(path))
-        while iter:
-            tree_store.set_value(iter, 2, tree_store[path][2])
-            iter = tree_store.iter_next(iter)
-
-    def generate_sensor_item_name(self, sensor_name, sensor_item_label):
-        return sensor_name + '//' + sensor_item_label.split(':')[0].lower().replace('.', '-')
-
-    def update_custom_text(self, event=None):
-        iter = self.tree_store.get_iter_root()
-
-        while iter:
-            iter_children = self.tree_store.iter_children(iter)
-            while iter_children:
-                if self.tree_store.get_value(iter_children, 2):
-                    current_text = self.ind_parent.custom_entry.get_text()
-                    to_add_value = '{' + self.tree_store.get_value(iter_children, 1) + '}'
-                    if string.find(current_text, to_add_value) == -1:
-                        self.ind_parent.custom_entry.set_text(current_text + ' ' + to_add_value)
-                iter_children = self.tree_store.iter_next(iter_children)
-
-            iter = self.tree_store.iter_next(iter)
-
-class Preferences(gtk.Window):
-    AUTOSTART_PATH = os.getenv("HOME") + '/.config/autostart/indicator-sysmonitor.desktop'
+        sw.add_with_viewport(self._tree_view)
+        vbox.pack_start(sw, fill=True, expand=True)
+
+        # add buttons
+        hbox = gtk.HBox()
+        new_button = gtk.Button(stock=gtk.STOCK_NEW)
+        new_button.connect('clicked', self._on_edit_sensor)
+        # hbox.pack_start(new_button, fill=False, expand=False)
+        hbox.pack_start(new_button, fill=False, expand=False)
+
+        edit_button = gtk.Button(stock=gtk.STOCK_EDIT)
+        edit_button.connect('clicked', self._on_edit_sensor, False)
+        hbox.pack_start(edit_button, fill=False, expand=False)
+
+        del_button = gtk.Button(stock=gtk.STOCK_DELETE)
+        del_button.connect('clicked', self._on_del_sensor)
+        hbox.pack_start(del_button, fill=False, expand=False)
+
+        add_button = gtk.Button(stock=gtk.STOCK_ADD)
+        add_button.connect('clicked', self._on_add_sensor)
+        hbox.pack_end(add_button, fill=False, expand=False)
+        vbox.pack_end(hbox, fill=False, expand=False)
+
+        frame = gtk.Frame(_('Sensors'))
+        frame.add(vbox)
+        return frame
+
+    def _get_selected_row(self):
+        """Returns an iter for the selected rows in the view or None."""
+        model, pathlist = self._tree_view.get_selection().get_selected_rows()
+        if len(pathlist):
+            path = pathlist.pop()
+            return model.get_iter(path)
+        return None
+
+    def _on_add_sensor(self, evnt=None, data=None):
+        tree_iter = self._get_selected_row()
+        if tree_iter is None:
+            return
+
+        sensor = self._list_store.get_value(tree_iter, 0)
+        self.ind_parent.custom_entry.insert_text(
+            "{{{}}}".format(sensor), -1)
+
+    def _on_edit_sensor(self, evnt=None, blank=True):
+        """Raises a dialog with a form to add/edit a sensor"""
+        name = desc = cmd = ""
+        tree_iter = None
+        if not blank:
+            # edit, so get the info from the selected row
+            tree_iter = self._get_selected_row()
+            if tree_iter is None:
+                return
+
+            name = self._list_store.get_value(tree_iter, 0)
+            desc = self._list_store.get_value(tree_iter, 1)
+            cmd = settings["sensors"][name][1]
+
+            if cmd is True:  # default sensor
+                raise_dialog(
+                    self.ind_parent,
+                    gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL,
+                    gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
+                    _("Can not edit defualt sensors."), _("Error"))
+                return
+
+        dialog = gtk.Dialog(_("Edit Sensor"), self.ind_parent,
+                            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+                            (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
+                             gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
+        vbox = dialog.get_content_area()
+
+        hbox = gtk.HBox()
+        label = gtk.Label(_("Sensor"))
+        sensor_entry = gtk.Entry()
+        sensor_entry.set_text(name)
+        hbox.pack_start(label)
+        hbox.pack_end(sensor_entry)
+        vbox.pack_start(hbox)
+
+        hbox = gtk.HBox()
+        label = gtk.Label(_("Description"))
+        desc_entry = gtk.Entry()
+        desc_entry.set_text(desc)
+        hbox.pack_start(label)
+        hbox.pack_end(desc_entry)
+        vbox.pack_start(hbox)
+
+        hbox = gtk.HBox()
+        label = gtk.Label(_("Command"))
+        cmd_entry = gtk.Entry()
+
+        cmd_entry.set_text(cmd)
+        hbox.pack_start(label)
+        hbox.pack_end(cmd_entry)
+        vbox.pack_end(hbox)
+
+        dialog.show_all()
+        response = dialog.run()
+
+        if response == gtk.RESPONSE_ACCEPT:
+            try:
+                newname, desc, cmd = str(sensor_entry.get_text()), \
+                    str(desc_entry.get_text()), str(cmd_entry.get_text())
+
+                if blank:
+                    Sensor.get_instance().add(newname, desc, cmd)
+                else:
+                    Sensor.get_instance().edit(name, newname, desc, cmd)
+                    self._list_store.remove(tree_iter)
+
+                self._list_store.append([newname, desc])
+                ctext = self.ind_parent.custom_entry.get_text()
+                self.ind_parent.custom_entry.set_text(
+                    ctext.replace(name, newname))
+
+            except ISMError as ex:
+                raise_dialog(
+                    self.ind_parent,
+                    gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL,
+                    gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
+                    ex.message, _("Error"))
+
+        dialog.destroy()
+
+    def _on_del_sensor(self, evnt=None, data=None):
+        """Remove a custom sensor."""
+        tree_iter = self._get_selected_row()
+        if tree_iter is None:
+            return
+
+        name = self._list_store.get_value(tree_iter, 0)
+        try:
+            Sensor.get_instance().delete(name)
+            self._list_store.remove(tree_iter)
+            ctext = self.ind_parent.custom_entry.get_text()
+            self.ind_parent.custom_entry.set_text(
+                ctext.replace("{{{}}}".format(name), ""))
+
+        except ISMError as ex:
+            raise_dialog(
+                self.ind_parent,
+                gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL,
+                gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
+                ex.message, _("Error"))
+
+
+class Preferences(gtk.Dialog):
+    """It define the the Preferences Dialog and its operations."""
+    AUTOSTART_PATH = '{}/.config/autostart/indicator-sysmonitor.desktop'.format(
+        os.getenv("HOME"))
     DESKTOP_PATH = '/usr/share/applications/indicator-sysmonitor.desktop'
+    sensors_regex = re.compile("{.+?}")
 
     def __init__(self, parent):
-        gtk.Window.__init__(self)
+        """It creates the widget of the dialogs"""
+        gtk.Dialog.__init__(self)
         self.ind_parent = parent
-        self.connect('delete-event', self.on_destroy)
+        self.connect('delete-event', self.on_cancel)
+        self.set_title(_('Preferences'))
+        self.resize(400, 350)
+        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
+        self._create_content()
+        self.set_data()
+        self.show_all()
 
+    def _create_content(self):
+        """It creates the content for this dialog."""
         notebook = gtk.Notebook()
         notebook.set_border_width(4)
 
-        vb = gtk.VBox(spacing=3)
-        hb = gtk.HBox()
-        hb.set_border_width(4)
-        l = gtk.Label('Run on startup:')
-        l.set_alignment(0, 0.5)
-        hb.pack_start(l)
+        # General page of the notebook {{{
+        vbox = gtk.VBox(spacing=3)
+        hbox = gtk.HBox()
+
+        hbox.set_border_width(4)
+        label = gtk.Label(_('Run on startup:'))
+        label.set_alignment(0, 0.5)
+        hbox.pack_start(label)
         self.autostart_check = gtk.CheckButton()
         self.autostart_check.set_active(self.get_autostart())
-        hb.pack_end(self.autostart_check, expand=False, fill=False)
-        vb.pack_start(hb, expand=False, fill=False)
+        hbox.pack_end(self.autostart_check, expand=False, fill=False)
+        vbox.pack_start(hbox, expand=False, fill=False)
 
-        hb = gtk.HBox()
-        l = gtk.Label('This is indicator-sysmonitor version: %s' % VERSION)
+        hbox = gtk.HBox()
+        l = gtk.Label(
+            _('This is indicator-sysmonitor version: {}').format(VERSION))
         l.set_alignment(0.5, 0.5)
-        hb.pack_start(l)
-        vb.pack_end(hb)
-        
-        notebook.append_page(vb, gtk.Label('General'))
+        hbox.pack_start(l)
+        vbox.pack_end(hbox)
+        notebook.append_page(vbox, gtk.Label(_('General')))
+        # }}}
 
-        vb = gtk.VBox(spacing=3)
-        hb = gtk.VBox()
-        self.custom_radio = gtk.RadioButton(label='Customize output:')
-        hb.pack_start(self.custom_radio)
+        # Advanced page in notebook {{{
+        vbox = gtk.VBox()  # main box
+        label = gtk.Label(_('Customize output:'))
+        label.set_alignment(0, 0)
+        vbox.pack_start(label, expand=False, fill=False)
         self.custom_entry = gtk.Entry()
-        hb.pack_end(self.custom_entry)
-        vb.pack_start(hb, expand=False, fill=False)
-
-        hb = gtk.VBox()
-        self.user_radio = gtk.RadioButton(group=self.custom_radio, label='Use this command:')
-        hb.pack_start(self.user_radio)
-        self.user_entry = gtk.Entry(max=100)
-        #info = gtk.Label('Use this option to specify a program to be run every time the indicator refreshes')
-        #info.set_line_wrap(True)
-        #hb.pack_end(info)
-        hb.pack_end(self.user_entry)
-        vb.pack_start(hb, expand=False, fill=False)
-
-        hb = gtk.HBox()
-        l = gtk.Label('Update interval:')
-        l.set_alignment(0, 0.5)
-        hb.pack_start(l)
+        vbox.pack_start(self.custom_entry, expand=False, fill=False)
+
+        hbox = gtk.HBox()
+        label = gtk.Label(_('Update interval:'))
+        label.set_alignment(0, 0)
+        hbox.pack_start(label)
         self.interval_entry = gtk.Entry(max=4)
-        self.interval_entry.set_width_chars(3)
-        hb.pack_end(self.interval_entry, expand=False, fill=False)
-        vb.pack_start(hb, expand=False, fill=False)
-
-        notebook.append_page(vb, gtk.Label('Advanced'))
-
-        if not parent.sensors_disabled:
-            sensors_list = SensorsListModel(self)
-            if sensors_list.tree_store.get_iter_root() != None:
-                vb.pack_start(sensors_list.get_view())
-
-        # footer
-        vb = gtk.VBox()
-        vb.pack_start(notebook)
+        self.interval_entry.set_width_chars(5)
+
+        hbox.pack_end(self.interval_entry, expand=False, fill=False)
+        vbox.pack_start(hbox, expand=False, fill=False)
+
+        sensors_list = SensorsListModel(self)
+        vbox.pack_start(sensors_list.get_view())
+        notebook.append_page(vbox, gtk.Label(_('Advanced')))
+        # }}}
+
+        # footer {{{
+        vbox = self.get_content_area()
+        vbox.pack_start(notebook)
         buttons = gtk.HButtonBox()
         buttons.set_layout(gtk.BUTTONBOX_EDGE)
-        test = gtk.Button('Test')
+        test = gtk.Button(_('Test'))
         test.connect('clicked', self.update_parent)
         buttons.pack_start(test)
+        # TODO: add an info message on hover
+
         cancel = gtk.Button(stock=gtk.STOCK_CANCEL)
-        cancel.connect('clicked', self.on_destroy)
+        cancel.connect('clicked', self.on_cancel)
         buttons.pack_end(cancel)
+
         close = gtk.Button(stock=gtk.STOCK_SAVE)
         close.connect('clicked', self.on_save)
         buttons.pack_end(close)
-        vb.pack_end(buttons, expand=False)
-
-        self.add(vb)
-        self.set_title('Preferences')
-        self.resize(400, 350)
-
-    def run(self):
-        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
-        self.show_all()
-        self.set_data()
-        gtk.main()
-
-    def on_destroy(self, event=None, data=None):
-        self.hide()
-        gtk.main_quit()
-        return False
-
-    def on_save(self, event=None, data=None):
-        self.update_parent()
+        vbox.pack_end(buttons, expand=False)
+        # }}}
+
+    def on_save(self, evnt=None, data=None):
+        """The action of the save button."""
+        try:
+            self.update_parent()
+        except Exception as ex:
+            error_dialog = gtk.MessageDialog(
+                None, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR,
+                gtk.BUTTONS_CLOSE, ex.message)
+            error_dialog.set_title("Error")
+            error_dialog.run()
+            error_dialog.destroy()
+            return False
+
         self.ind_parent.save_settings()
         self.update_autostart()
-        self.on_destroy()
+        self.destroy()
 
-    def on_cancel(self, event=None, data=None):
+    def on_cancel(self, evnt=None, data=None):
+        """The action of the cancel button."""
         self.ind_parent.load_settings()
-        self.on_destroy()
+        self.destroy()
+
+    def update_parent(self, evnt=None, data=None):
+        """It gets the config info from the widgets and sets them to the vars.
+        It does NOT update the config file."""
+        custom_text = self.custom_entry.get_text()
+
+        # check if the sensers are supported
+        sensors = Preferences.sensors_regex.findall(custom_text)
+        for sensor in sensors:
+            sensor = sensor[1:-1]
+            if not Sensor.exists(sensor):
+                raise ISMError(_("{} sensor not supported.").format(sensor))
+
+        try:
+            interval = float(self.interval_entry.get_text())
+            if interval <= 0:
+                raise ISMError(_("Interval value is not valid."))
+
+        except ValueError, ex:
+            raise ISMError(_("Interval value is not valid."))
+
+        settings["custom_text"] = custom_text
+        settings["interval"] = interval
+        # TODO: on_startup
+        self.ind_parent.update_indicator_guide()
 
     def set_data(self):
-        self.custom_entry.set_text(self.ind_parent.custom_text)
-        self.user_entry.set_text(self.ind_parent.user_command)
-        self.interval_entry.set_text(str(self.ind_parent.interval))
-        if self.ind_parent.mode_user:
-            self.user_radio.set_active(True)
-        else:
-            self.custom_radio.set_active(True)
-
-    def update_parent(self, event=None):
-        custom_text = self.custom_entry.get_text()
-        user_text = self.user_entry.get_text()
-        try: interval = int(self.interval_entry.get_text()); assert interval > 0
-        except: interval = self.ind_parent.interval
-        mode_user = [r for r in self.custom_radio.get_group() if r.get_active()][0]
-        self.ind_parent.custom_text = custom_text
-        self.ind_parent.user_command = user_text
-        self.ind_parent.mode_user = (mode_user == self.user_radio)
-        self.ind_parent.interval = interval
-        self.ind_parent.force_update()
+        """It sets the widgets with the config data."""
+        self.custom_entry.set_text(settings["custom_text"])
+        self.interval_entry.set_text(str(settings["interval"]))
 
     def update_autostart(self):
         autostart = self.autostart_check.get_active()
         if not autostart:
             try:
                 os.remove(Preferences.AUTOSTART_PATH)
-            except: pass
+            except:
+                pass
         else:
             try:
-                shutil.copy(Preferences.DESKTOP_PATH, Preferences.AUTOSTART_PATH)
+                shutil.copy(Preferences.DESKTOP_PATH,
+                            Preferences.AUTOSTART_PATH)
             except Exception as e:
                 logging.exception(e)
 
     def get_autostart(self):
         return os.path.exists(Preferences.AUTOSTART_PATH)
 
-class IndicatorSysmonitor:
+
+class IndicatorSysmonitor(object):
     SETTINGS_FILE = os.getenv("HOME") + '/.indicator-sysmonitor.json'
     SENSORS_DISABLED = False
 
     def __init__(self):
-        self.preferences_dialog = None
-        self.custom_text = 'cpu: {cpu} mem: {mem}'
-        self.user_command = ''
-        self.last_data, self.last_text, self.last_guide = {}, '', ''
-        self.mode_user = False
-        self.sensors_disabled = IndicatorSysmonitor.SENSORS_DISABLED
-        self.interval = 2
+        self._preferences_dialog = None
+        self._help_dialog = None
+        self._fetcher = StatusFetcher(self)
+        self.alive = Event()
 
-        self.ind = appindicator.Indicator ("indicator-sysmonitor",
+        self.ind = appindicator.Indicator("indicator-sysmonitor",
           "sysmonitor",
             appindicator.CATEGORY_SYSTEM_SERVICES)
-        self.ind.set_status (appindicator.STATUS_ACTIVE)
+        self.ind.set_status(appindicator.STATUS_ACTIVE)
         self.ind.set_label("Init...")
-        self.menu = gtk.Menu()
-       
-        full_sysmon = gtk.MenuItem('System Monitor')
+
+        self._create_menu()
+        self.load_settings()
+        self.alive.set()
+        self._fetcher.start()
+        logging.info("Fetcher started")
+
+    def _create_menu(self):
+        """Creates the main menu and shows it."""
+        # create menu {{{
+        menu = gtk.Menu()
+        # add System Monitor menu item
+        full_sysmon = gtk.MenuItem(_('System Monitor'))
         full_sysmon.connect('activate', self.on_full_sysmon_activated)
-        self.menu.add(full_sysmon)
-
-        self.menu.add(gtk.SeparatorMenuItem())
-
-        pref_menu = gtk.MenuItem('Preferences')
+        menu.add(full_sysmon)
+        menu.add(gtk.SeparatorMenuItem())
+
+        # add preferences menu item
+        pref_menu = gtk.ImageMenuItem(stock_id=gtk.STOCK_PREFERENCES)
         pref_menu.connect('activate', self.on_preferences_activated)
-        self.menu.add(pref_menu)
-
+        menu.add(pref_menu)
+
+        # add help menu item
+        help_menu = gtk.ImageMenuItem(stock_id=gtk.STOCK_HELP)
+        help_menu.connect('activate', self._on_help)
+        menu.add(help_menu)
+
+        #add preference menu item
         exit_menu = gtk.ImageMenuItem(stock_id=gtk.STOCK_QUIT)
         exit_menu.connect('activate', self.on_exit)
-        self.menu.add(exit_menu)
-       
-        self.menu.show_all()
-
-        self.ind.set_menu(self.menu)
-
+        menu.add(exit_menu)
+
+        menu.show_all()
+        self.ind.set_menu(menu)
         logging.info("Menu shown")
-
-        self.load_settings()
-
-        self.alive = Event()
-        self.alive.set()
-        self.fetch = StatusFetcher(self)
-        self.fetch.start()
-        logging.info("Fetcher started")
+        # }}} menu done!
+
+    def update_indicator_guide(self):
+        """Updates the label guide from appindicator."""
+        data = self._fetcher.fetch()
+        for key in data:
+            if key.startswith('fs'):
+                data[key] = '000gB'
+                break
+
+        data['mem'] = data['cpu'] = data['bat'] = '000%'
+        data['net'] = '↓666kB/s ↑666kB/s'
+
+        guide = settings['custom_text'].format(**data)
+        self.ind.set_property("label-guide", guide)
 
     def update(self, data):
+        """It updates the appindicator text with the the values
+        from data"""
         try:
-            label = self.custom_text.format(**data)
-            cdata = deepcopy(data)
-            cdata['mem'] = cdata['cpu'] = cdata['bat'] = '000%'
-            cdata['net'] = ''
-            guide = self.custom_text.format(**cdata)
-        except KeyError as e:
-            logging.exception(e)
-            logging.info('not found in dataset')
-            return
-        except:
-            label = 'Unknown error'
-        if not label:
-            label = '(no output)'
-        self.last_data = data
-        self.last_guide = guide
-        self.update_text(label, guide)
-
-    def update_text(self, text, guide):
-        self.last_text = text
-        self.last_guide = guide
-        self.ind.set_label(text, guide)
-
-    def force_update(self):
-        if self.mode_user:
-            self.update_text(self.last_text, self.last_guide)
-        else:
-            self.update(self.last_data)
-
-    def on_exit(self, event=None):
-        logging.info("Terminated")
-        self.alive.clear()
-        try: gtk.main_quit()
-        except RuntimeError: pass
+            label = settings["custom_text"].format(**data) if len(data)\
+                else _("(no output)")
+
+        except KeyError as ex:
+            label = _("Invalid Sensor: {}").format(ex.message)
+        except Exception as ex:
+            logging.exception(ex)
+            label = _("Unknown error: ").format(ex.message)
+
+        self.ind.set_label(label)
 
     def load_settings(self):
+        """It gets the settings from the config file and
+        sets them to the correct vars"""
         try:
             with open(IndicatorSysmonitor.SETTINGS_FILE, 'r') as f:
-              settings = json.load(f)
-            self.mode_user = settings['mode_user']
-            self.custom_text = settings['custom_text']
-            self.user_command = settings['user_command']
-            self.interval = settings['interval']
-            self.sensors_disabled = settings.get('sensors_disabled', IndicatorSysmonitor.SENSORS_DISABLED)
+                cfg = json.load(f)
+
+            if cfg['custom_text'] is not None:
+                settings['custom_text'] = cfg['custom_text']
+            if cfg['interval'] is not None:
+                settings['interval'] = cfg['interval']
+            if cfg['on_startup'] is not None:
+                settings['on_startup'] = cfg['on_startup']
+            if cfg['sensors'] is not None:
+                settings['sensors'] = cfg['sensors']
+
+            Sensor.update_regex()
+            self.update_indicator_guide()
+
         except Exception as e:
             logging.exception(e)
             logging.error('Reading settings failed')
 
-    def save_settings(self):
+    @staticmethod
+    def save_settings():
+        """It stores the current settings to the config file."""
         # TODO: use gsettings
-        settings = {'mode_user': self.mode_user,
-                  'custom_text': self.custom_text,
-                  'user_command': self.user_command,
-                  'interval': self.interval,
-                  'sensors_disabled': self.sensors_disabled}
         try:
-          with open(IndicatorSysmonitor.SETTINGS_FILE, 'w') as f:
-              f.write(json.dumps(settings))
+            with open(IndicatorSysmonitor.SETTINGS_FILE, 'w') as f:
+                f.write(json.dumps(settings))
+
         except Exception as e:
             logging.exception(e)
             logging.error('Writting settings failed')
 
+    # actions raised from menu
     def on_preferences_activated(self, event=None):
-        self.preferences_dialog = Preferences(self)
-        self.preferences_dialog.run()
+        """Raises the preferences dialog. If it's already open, it's
+        focused"""
+        if self._preferences_dialog is not None:
+            self._preferences_dialog.present()
+            return
+
+        self._preferences_dialog = Preferences(self)
+        self._preferences_dialog.run()
+        self._preferences_dialog = None
 
     def on_full_sysmon_activated(self, event=None):
         os.system('gnome-system-monitor &')
 
+    def on_exit(self, event=None, data=None):
+        """Action call when the main programs is closed."""
+        # close the open dialogs
+        if self._help_dialog is not None:
+            self._help_dialog.destroy()
+
+        if self._preferences_dialog is not None:
+            self._preferences_dialog.destroy()
+
+        logging.info("Terminated")
+        self.alive.clear()
+        try:
+            gtk.main_quit()
+        except RuntimeError:
+            pass
+
+    def _on_help(self, event=None, data=None):
+        """Raise a dialog with info about the app."""
+        if self._help_dialog is not None:
+            self._help_dialog.present()
+            return
+
+        self._help_dialog = gtk.MessageDialog(
+            None, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO,
+            gtk.BUTTONS_OK, None)
+
+        self._help_dialog.set_title(_("Help"))
+        self._help_dialog.set_markup(HELP_MSG)
+        self._help_dialog.run()
+        self._help_dialog.destroy()
+        self._help_dialog = None
+
+
 from optparse import OptionParser
 
 if __name__ == "__main__":
-    parser = OptionParser("usage: %prog [options]", version="%prog "+VERSION)
+    parser = OptionParser("usage: %prog [options]", version="%prog " + VERSION)
     parser.add_option("--config", "", default=None,
-                      help="use custom config file")
-    parser.add_option("--disable-sensors",  action="store_true",
-                      help="disable sensors", default=False)
-    parser.add_option("--enable-sensors",  action="store_true",
-                      help="re-enable sensors", default=False)
+                      help=_("Use custom config file."))
 
     (options, args) = parser.parse_args()
 
     if options.config:
         if not os.path.exists(options.config):
-            print options.config, "does not exist!"
+            logging.error(_("{} does not exist!").format(options.config))
             sys.exit(-1)
+        logging.info(_("Using config file: {}").format(options.config))
         IndicatorSysmonitor.SETTINGS_FILE = options.config
 
+    if not os.path.exists(IndicatorSysmonitor.SETTINGS_FILE):
+        IndicatorSysmonitor.save_settings()
+
     # setup an instance with config
-    i = IndicatorSysmonitor()
-    if options.disable_sensors:
-        i.sensors_disabled = True
-        i.save_settings()
-        logging.info("Sensors disabled")
-
-    if options.enable_sensors:
-        i.sensors_disabled = False
-        i.save_settings()
-        logging.info("Sensors enabled")
-
+    app = IndicatorSysmonitor()
     try:
         gtk.main()
     except KeyboardInterrupt:
-        i.on_exit()
+        app.on_exit()

=== added directory 'lang'
=== added directory 'lang/es'
=== added directory 'lang/es/LC_MESSAGES'
=== added file 'lang/es/LC_MESSAGES/indicator-sysmonitor.mo'
Binary files lang/es/LC_MESSAGES/indicator-sysmonitor.mo	1970-01-01 00:00:00 +0000 and lang/es/LC_MESSAGES/indicator-sysmonitor.mo	2012-09-26 17:56:20 +0000 differ
=== added file 'lang/es/es.po'
--- lang/es/es.po	1970-01-01 00:00:00 +0000
+++ lang/es/es.po	2012-09-26 17:56:20 +0000
@@ -0,0 +1,72 @@
+# Spanish translations for PACKAGE package
+# Traducciones al español para el paquete PACKAGE.
+# Copyright (C) 2012 THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# Gabriel Lopez <[e-mail]>, 2012.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2012-09-01 17:24-0300\n"
+"PO-Revision-Date: 2012-09-01 17:30-0300\n"
+"Last-Translator: Gabriel Lopez <[e-mail]>\n"
+"Language-Team: Argentinian\n"
+"Language: es_AR\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: indicator-sysmonitor:381
+msgid "Preferences"
+msgstr "Preferencias"
+
+#: indicator-sysmonitor:397
+msgid "Run on startup:"
+msgstr "Ejecutar en el inicio:"
+
+#: indicator-sysmonitor:407
+msgid "This is indicator-sysmonitor version: {}"
+msgstr "Esta es la versión de indicator-sysmonitor: {}"
+
+#: indicator-sysmonitor:411
+msgid "General"
+msgstr "General"
+
+#: indicator-sysmonitor:416
+msgid "Customize output:"
+msgstr "Salida personalizada:"
+
+#: indicator-sysmonitor:424
+msgid "Use this command:"
+msgstr "Usar este comando:"
+
+#: indicator-sysmonitor:431
+msgid "Update interval:"
+msgstr "Intervalo de actualización:"
+
+#: indicator-sysmonitor:439
+msgid "Advanced"
+msgstr "Avanzado"
+
+#: indicator-sysmonitor:452
+msgid "Test"
+msgstr "Prueba"
+
+#: indicator-sysmonitor:499
+msgid "{} sensor not supported."
+msgstr "{} sensor no soportado."
+
+#: indicator-sysmonitor:506
+msgid "Interval value is not valid."
+msgstr "Valor del intervalo no válido."
+
+#: indicator-sysmonitor:582
+msgid "System Monitor"
+msgstr "Monitor del Sistema"
+
+#: indicator-sysmonitor:712
+msgid "Help"
+msgstr "Ayuda"
+

=== added file 'messages.pot'
--- messages.pot	1970-01-01 00:00:00 +0000
+++ messages.pot	2012-09-26 17:56:20 +0000
@@ -0,0 +1,70 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2012-09-01 17:24-0300\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <[e-mail]>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=CHARSET\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: indicator-sysmonitor:381
+msgid "Preferences"
+msgstr ""
+
+#: indicator-sysmonitor:397
+msgid "Run on startup:"
+msgstr ""
+
+#: indicator-sysmonitor:407
+msgid "This is indicator-sysmonitor version: {}"
+msgstr ""
+
+#: indicator-sysmonitor:411
+msgid "General"
+msgstr ""
+
+#: indicator-sysmonitor:416
+msgid "Customize output:"
+msgstr ""
+
+#: indicator-sysmonitor:424
+msgid "Use this command:"
+msgstr ""
+
+#: indicator-sysmonitor:431
+msgid "Update interval:"
+msgstr ""
+
+#: indicator-sysmonitor:439
+msgid "Advanced"
+msgstr ""
+
+#: indicator-sysmonitor:452
+msgid "Test"
+msgstr ""
+
+#: indicator-sysmonitor:499
+msgid "{} sensor not supported."
+msgstr ""
+
+#: indicator-sysmonitor:506
+msgid "Interval value is not valid."
+msgstr ""
+
+#: indicator-sysmonitor:582
+msgid "System Monitor"
+msgstr ""
+
+#: indicator-sysmonitor:712
+msgid "Help"
+msgstr ""