Merge lp:~dcaro/clicompanion/fix-608608 into lp:clicompanion

[David Caro]

Done a lot (and I mean a lot) of changes in the code, this new version has a lot of improvements and now it's easy to extend and mantain. A lot of things can still be done but I think that it is now usable and stable enough for at least replace the version wthat we have not.

See the commit message for the features, i've tested it during two days, but as usual, there's no hurry, test it until you are convinced that it is good to go.

Thanks!

[David Caro (dcaro)]

Also added the -d command line option to enable the debug mode (very handy).

[lp:~dcaro/clicompanion/fix-608608]

99. By David Caro "<email address hidden>" on 2012-01-08

Missed to try to install from the setup.py file... fixed.

100. By David Caro "<email address hidden>" on 2012-01-08

Added new files to the manifest

[Marek Bardoński (bdfhjk)]

Code reviewed - no errors reported.

Questions:
1. What with notebook/netbook mode, did You tested clicompanion on small resolutions like (1024x600) ?

Bugs solved:
Bug #608608: Wishlist: Integration with Snipplr & Commandlinefu Services [OK, but icons not work, desc. below]
Bug #673556: tabs should be renameable [Sorry, I don't see that tab can be renamed]
Bug #689046: Function keys [OK]
Bug #790047: help button corrupts partially entered command [OK]
Bug #910687: Change font type and size [OK, very small bug here desc. below]

New bugs:
1. Low ERROR: Wrong config value for font: Ubuntu Mono 13 ,using default one Ubuntu Mono 13 - on startup
2. Medium Icons on the left side in tab Commandline FU not working, clicking on they have no effects

Regresion:
1. Low /usr/local/lib/python2.7/dist-packages/clicompanionlib/view.py:586: GtkWarning: Failed to set text from markup due to error parsing markup ///- on application startup
2. Don't remeber exactly how to reproduce :

"""
Traceback (most recent call last):
  File "/usr/local/lib/python2.7/dist-packages/clicompanionlib/view.py", line 332, in <lambda>
    self.cmd_notebook.get_command()[0]).run())
  File "/usr/local/lib/python2.7/dist-packages/clicompanionlib/helpers.py", line 40, in __init__
    choose_row_error()
NameError: global name 'choose_row_error' is not defined
Traceback (most recent call last):
  File "/usr/local/lib/python2.7/dist-packages/clicompanionlib/view.py", line 332, in <lambda>
    self.cmd_notebook.get_command()[0]).run())
  File "/usr/local/lib/python2.7/dist-packages/clicompanionlib/helpers.py", line 40, in __init__
    choose_row_error()
NameError: global name 'choose_row_error' is not defined
"""

One more time excellent work David!
It need a few 5 min patches, but a lot is done.
Thanks!

review: Needs Information

[lp:~dcaro/clicompanion/fix-608608]

101. By David Caro "<email address hidden>" on 2012-01-08

fixed a problem with the man page when no command selected

102. By David Caro "<email address hidden>" on 2012-01-08

fixed a little bug with detecting if the current font is a valid one when parsing the config

[David Caro (dcaro)]

Hi Marek! Thanks for the fast review!

New errors:
1. Very strange, what it does is get the list of allowed fonts in the system and if the font is not there, tries to guess the system font. Can you try to execute this on a python console and pass me the results?

------ Get the default system font -------
import gconf
gconf_cli = gconf.client_get_default()
value = gconf_cli.get('/desktop/gnome/interface/monospace_font_name')
value.get_string()

----- Show available fonts -----------
import gtk
families = gtk.TextView().create_pango_context().list_families()
[fam.get_name() for fam in families]

.... OK, now i've seen where is the error, when parsing the font name, I get the first part of the space separated font as the name and the second as the size, so for ubuntu mono 10, ubuntu is the font and mono 10 the size XD -- Fixed (revision 102)

Thanks!

2. They work for me :(, the should open a new tab (or window) on the current web browser with the info page of the command (just like the help-online menu option), can you try to execute this on a python console and see what happens? It should open a new tab...

import webbrowser
webbrowser.open('https://launchpad.net/clicompanion')

Regresion bugs:
1. This is caused by the new tooltips, when the command has something that can be interpreted as markup by the tooltip class (a & for example), it shows this warning. It's not stright forward to fix this, and is commentesd in the commit message. But i'm going to open a new bug report to avoid it getting lost. Can you pass me your cheatsheet file to see what command makes the warning show up? (i've seen it with &, but the error is slightly different).

2. This is caused when trying to show the man page for a command when no command is selected (usually after adding a new command), fixed (revision 101)

review: Needs Information

[David Caro (dcaro)]

I forgot!
Bug #673556: tabs should be renameable [Sorry, I don't see that tab can be renamed] -- right click in the terminal zone and the option 'rename' in the menu

[Marek Bardoński (bdfhjk)]

I noticed, that icons work after double-click. So it is OK, but in my opinion single click will be more intuitive. But this is only my opinion.

The rest of bugs are fixed.

Good work!

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2010-08-22 00:14:56 +0000
+++ .bzrignore	2012-01-08 10:37:24 +0000
@@ -3,3 +3,6 @@
 .ropeproject/globalnames
 .ropeproject/history
 .ropeproject/objectdb
+./tags
+./build
+*~

=== modified file 'MANIFEST'
--- MANIFEST	2011-11-18 08:58:05 +0000
+++ MANIFEST	2012-01-08 10:37:24 +0000
@@ -1,8 +1,11 @@
 setup.py
 clicompanion
 clicompanionlib/__init__.py
-clicompanionlib/controller.py
+clicompanionlib/config.py
+clicompanionlib/helpers.py
 clicompanionlib/menus_buttons.py
+clicompanionlib/plugins.py
+clicompanionlib/preferences.py
 clicompanionlib/tabs.py
 clicompanionlib/utils.py
 clicompanionlib/view.py
@@ -10,3 +13,8 @@
 data/clicompanion2.config
 data/clicompanion.16.png
 data/clicompanion.64.png
+plugins/clfu.py
+plugins/CommandLineFU.py
+plugins/__init__.py
+plugins/LocalCommandList.py
+

=== modified file 'clicompanion'
--- clicompanion	2012-01-02 00:23:11 +0000
+++ clicompanion	2012-01-08 10:37:24 +0000
@@ -25,13 +25,12 @@
 
 
 parser = OptionParser(usage="%prog [-f] [-q]", version="%prog 1.1")
-parser.add_option("-f", "--file", dest="filename",
-                  help="Write report to FILE", metavar="FILE")
+parser.add_option("-f", "--file", dest="conffile",
+                  help="Configuration file to use.", metavar="FILE")
 parser.add_option("-c", "--cheatsheet", dest="cheatsheet",
                   help="Read cheatsheet from FILE", metavar="FILE")
-parser.add_option("-q", "--quiet",
-                  action="store_false", dest="verbose", default=True,
-                  help="Don't print status messages to stdout")
+parser.add_option("-d", "--debug", dest="debug", action='store_true',
+                  default=False, help="Print debug messages",)
 
 (options, args) = parser.parse_args()
 

=== modified file 'clicompanionlib/__init__.py'
--- clicompanionlib/__init__.py	2010-11-30 16:03:59 +0000
+++ clicompanionlib/__init__.py	2012-01-08 10:37:24 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# clicompanion.py - commandline tool.
+# __init__.py
 #
 # Copyright 2010 Duane Hinnen, Kenny Meyer
 #

=== modified file 'clicompanionlib/config.py'
--- clicompanionlib/config.py	2012-01-02 00:23:11 +0000
+++ clicompanionlib/config.py	2012-01-08 10:37:24 +0000
@@ -1,9 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# clicompanion.py - commandline tool.
+# config.py - Configuration classes for the clicompanion
 #
-# Copyright 2010 Duane Hinnen
+# Copyright 2012 David Caro <[e-mail]>
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -18,246 +18,323 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 #
+# This file has the CLIConfig class definition, and the CLIConfigView, the
+# first is the main configuration model of the progran, where all the config
+# is stored and processed to be correct, also sets up all the required
+# configuration (default sections and keybindings) if they are not set.
+#
+# The CLIConfigViewer, is something similar to a view in MySQL, is an object
+# that has the same (almos all) methods than the normal CLIConfig, but only
+# shows a part of it, used to allow the plugins to handle their own
+# configurations (a prefix will be added, like the 'profiles::' prefix or the
+# name of the plugin that stores the config).
+
+
 import os
 import ConfigParser
-import clicompanionlib.utils as utils
+import collections
+import gtk
+import pango
+import clicompanionlib.utils as cc_utils
 from clicompanionlib.utils import dbg
-import collections
 
-CHEATSHEET = os.path.expanduser("~/.clicompanion2")
 CONFIGDIR = os.path.expanduser("~/.config/clicompanion/")
 CONFIGFILE = os.path.expanduser("~/.config/clicompanion/config")
 CONFIG_ORIG = "/etc/clicompanion.d/clicompanion2.config"
-DEFAULTS = { "scrollb": '500',
-             "colorf": '#FFFFFF',
-             "colorb": '#000000',
-             "encoding": 'UTF-8',
-             "debug": 'False'}
-
-## To avoid parsing the config file each time, we store the loaded config here
-CONFIG = None
-
-def create_config(conffile=CONFIGFILE):
-    global CONFIG
-    config = CONFIG
-    configdir = conffile.rsplit(os.sep,1)[0]
-    if not os.path.exists(configdir):
-        try:
-            os.makedirs(configdir)
-        except Exception, e:
-            print _('Unable to create config at dir %s (%s)')%(configdir,e)
-            return False
-    # reuse the config if able
-    if not config:
-        config = ConfigParser.SafeConfigParser(DEFAULTS)
-        # set a number of parameters
-        if os.path.isfile(conffile):
-            config.read([conffile])
-        else:
-            config.add_section("terminal")
-            for option, value in DEFAULTS.items():
-                config.set("terminal", option, value)
-        CONFIG = config
-    # Writing our configuration file
-    save_config(config, conffile)
-    print _("INFO: Created config file at %s.")%conffile
-    return config
-        
-
-def get_config_copy(config=None):
-    global CONFIG
-    if not config:
-        config = CONFIG
-    new_cfg = ConfigParser.SafeConfigParser(DEFAULTS)
-    for section in config.sections():
-        new_cfg.add_section(section)
-        for option in config.options(section):
-            new_cfg.set(section, option, config.get(section, option))
-    return new_cfg
-    
-
-def get_config(conffile=CONFIGFILE, confdir=CONFIGDIR):
-    global CONFIG
-    config = CONFIG
-    if not config:
-        dbg('Loading new config')
-        if not os.path.isfile(conffile):
-            config = create_config(conffile)
-        config = ConfigParser.SafeConfigParser(DEFAULTS)
-        config.add_section("terminal")
-        config.read([conffile])
-        CONFIG = config
-    else:
-        dbg('Reusing already loaded config')
-    return config
-
-
-def save_config(config, conffile=CONFIGFILE):
-    global CONFIG
-    dbg('Saving conffile at %s'%conffile)
-    with open(CONFIGFILE, 'wb') as f:
-        config.write(f)
-    CONFIG = config
-
-class Cheatsheet:
-    '''
-    comtainer class for the cheatsheet
-
-    Example of usage:
-    >>> c = config.Cheatsheet()
-    >>> c.load('/home/cascara/.clicompanion2')
-    >>> c[3]
-    ['uname -a', '', 'What kernel am I running\n']
-    >>> c.file
-    '/home/cascara/.clicompanion2'
-    >>> c[2]=[ 'mycmd', 'userui', 'desc' ]
-    >>> c[2]
-    ['mycmd', 'userui', 'desc']
-    >>> del c[2]
-    >>> c[2]
-    ['ps aux | grep ?', 'search string', 'Search active processes for search string\n']
-    >>> c.insert('cmd2','ui2','desc2',2)
-    >>> c[2]
-    ['cmd2', 'ui2', 'desc2']
-
-    '''
-    def __init__(self):
-        self.file = CHEATSHEET
-        self.commands = []
-
-    def __repr__(self):
-        return 'Config: %s - %s'%(self.file, self.commands)
-    
-    def load(self, cheatfile=None):
-        if not cheatfile:
-            self.file = CHEATSHEET
-            if not os.path.exists(CHEATSHEET):
-                if os.path.exists(CONFIG_ORIG):
-                    os.system ("cp %s %s" % (CONFIG_ORIG, CHEATSHEET))
-                else:
-                    # Oops! Looks like there's no default cheatsheet.
-                    # Then, create an empty cheatsheet.
-                    open(CHEATSHEET, 'w').close()
-        else:
-            self.file = cheatfile
-        try:
-            dbg('Reading cheatsheet from file %s'%self.file)
-            with open(self.file, 'r') as ch_fd:
-                ## try to detect if the line is a old fashines config line
-                ## (separated by ':'), when saved will rewrite it
-                no_tabs = True
-                some_colon = False
-                for line in ch_fd:
-                    line = line.strip()
-                    if not line:
-                        continue
-                    cmd, ui, desc = [ l.strip() for l in line.split('\t',2)] \
-                                        + ['',]*(3-len(line.split('\t',2)))
-                    if ':' in cmd:
-                        some_colon = True
-                    if ui or desc:
-                        no_tabs = False
-                    if cmd and [ cmd, ui, desc ] not in self.commands:
-                        self.commands.append([cmd, ui, desc])
-                        dbg('Adding command %s'%[cmd, ui, desc])
-                if no_tabs and some_colon:
-                    ## None of the commands had tabs, and all had ':' in the 
-                    ## cmd... most probably old config style
-                    print _("Detected old cheatsheet style at")\
-                            +" %s"%self.file+_(", parsing to new one.")
-                    for i in range(len(self.commands)):
-                        cmd, ui, desc = self.commands[i]
-                        cmd, ui, desc = [ l.strip() for l in cmd.split(':',2)] \
-                                        + ['',]*(3-len(cmd.split(':',2)))
-                        self.commands[i] = [cmd, ui, desc]
-                    self.save()
-        except IOError, e:
-            print _("Error while loading cheatfile")+" %s: %s"%(self.file, e)
-
-    def save(self, cheatfile=None):
-        '''
-        Saves the current config to the file cheatfile, or the file that was 
-        loaded.
-        NOTE: It does not overwrite the value self.file, that points to the file 
-        that was loaded
-        '''
-        if not cheatfile and self.file:
-            cheatfile = self.file
-        elif not cheatfile:
-            return False
-        try:
-            with open(cheatfile, 'wb') as ch_fd:
-                for command in self.commands:
-                    ch_fd.write('\t'.join(command)+'\n')
-        except IOError, e:
-            print _("Error writing cheatfile")+" %s: %s"%(cheatfile, e)
-            return False
-        return True
-
-    def __len__(self):
-        return len(self.commands)
-
-    def __getitem__(self, key):
-        return self.commands[key]
-
-    def __setitem__(self, key, value):
-        if not isinstance(value, collections.Iterable) or len(value) < 3:
-            raise ValueError('Value must be a container with three items, but got %s'%value)
-        if key < len(self.commands):
-            self.commands[key]=list(value)
-        else:
+
+
+## All the options (except keybindings) passed as name: (default, test), where
+## test can be one of 'bool', 'str', 'encoding', 'font', or a function to test
+## the value (the function must throw an exception on fail)
+DEFAULTS = {'profile': {"scrollb": ('500', 'int'),
+                         "color_scheme": ("Custom", 'str'),
+                         "colorf": ('#FFFFFF', gtk.gdk.color_parse),
+                         "colorb": ('#000000', gtk.gdk.color_parse),
+                         "use_system_colors": ("False", 'bool'),
+                         "encoding": ('UTF-8', 'encoding'),
+                         "font": (cc_utils.get_system_font(), 'font'),
+                         "use_system_font": ("False", 'bool'),
+                         "use_system_colors": ("False", 'bool'),
+                         "bold_text": ("False", 'bool'),
+                         "antialias": ("True", 'bool'),
+                         "sel_word": (u"-A-Za-z0-9,./?%&#:_", 'str'),
+                         "update_login_records": ("True", 'bool'),
+                        },
+             'general': {"debug": ('False', 'bool'),
+                         "plugins": ('LocalCommandList, CommandLineFU', 'str')
+                        },
+             'LocalCommandList': {"cheatsheet":
+                               (os.path.expanduser("~/.clicompanion2"), 'str'),
+                        },
+             }
+
+## Note that the modifiers must be specified as 'mod1+mod2+key', where the
+## modifiers are 'shift', 'alt','ctrl', in that order (shift+alt+ctrl+key), and
+## that the key pressed is the key affecteed by the modifiers, for example,
+## shift+ctrl+D (not shift+ctrl+d). And the function keys go uppercase (F10).
+DEFAULT_KEY_BINDINGS = {
+        'run_command': 'F4',
+        'add_command': 'F5',
+        'remove_command': 'F6',
+        'edit_command': 'unused',
+        'add_tab': 'F7',
+        'close_tab': 'unused',
+        'toggle_fullscreen': 'F12',
+        'toggle_maximize': 'F11',
+        'toggle_hide_ui': 'F9',
+        }
+
+### funcname : labelname
+## a function with the name funcname and signature void(void) must exist in the
+## main window class, and is the one that will be called when the keybinding is
+## actibated
+KEY_BINDINGS = {
+        'run_command': 'Run command',
+        'add_command': 'Add command',
+        'remove_command': 'Remove command',
+        'edit_command': 'Edit command',
+        'add_tab': 'Add tab',
+        'close_tab': 'Close tab',
+        'toggle_fullscreen': 'Toggle fullscreen',
+        'toggle_maximize': 'Maximize',
+        'toggle_hide_ui': 'Hide UI',
+        }
+
+
+class CLIConfig(ConfigParser.RawConfigParser):
+    def __init__(self, defaults=DEFAULTS, conffile=CONFIGFILE):
+        ConfigParser.RawConfigParser.__init__(self)
+        self.conffile = os.path.abspath(conffile)
+        configdir = self.conffile.rsplit(os.sep, 1)[0]
+        if not os.path.exists(configdir):
             try:
-                self.insert(*value, pos=key)
-            except ValueError, e:
-                raise ValueError('Value must be a container with three items, but got %s'%value)
-
-    def __iter__(self):
-        for command in self.commands:
-            yield command
-
-    def insert(self, cmd, ui, desc, pos=None):
-        if not [cmd, ui, desc] in self.commands:
-            if not pos:
-                self.commands.append([cmd, ui, desc])
-            else:
-                self.commands.insert(pos, [cmd, ui, desc])
-
-    def append(self, cmd, ui, desc):
-        self.insert(cmd, ui, desc)
-
-    def index(self, cmd, ui, value):
-        return self.commands.index([cmd, ui, desc])
-                    
-    def __delitem__(self, key):
-        del self.commands[key]
-    
-    def pop(self, key):
-        return self.commands.pop(key)
-
-    def del_by_value(self, cmd, ui, desc):
-        if [cmd, ui, desc] in self.commands:
-            return self.commands.pop(self.commands.index([cmd, ui, desc]))
-
-    def drag_n_drop(self, cmd1, cmd2, before=True):
-        if cmd1 in self.commands:
-            dbg('Dropping command from inside %s'%'_\t_'.join(cmd1))
-            i1 = self.commands.index(cmd1)
-            del self.commands[i1]
-            if cmd2:
-                i2 = self.commands.index(cmd2)
-                if before:
-                    self.commands.insert(i2, cmd1)
-                else:
-                    self.commands.insert(i2+1, cmd1)
-            else:
-                self.commands.append(cmd1)
-        else:
-            dbg('Dropping command from outside %s'%'_\t_'.join(cmd1))
-            if cmd2:
-                i2 = self.commands.index(cmd2)
-                if before:
-                    self.commands.insert(i2, cmd1)
-                else:
-                    self.commands.insert(i2+1, cmd1)
-            else:
-                self.commands.append(cmd1)
+                os.makedirs(configdir)
+            except Exception, e:
+                print _('Unable to create config at dir %s (%s)') \
+                        % (configdir, e)
+                return False
+        # set a number of default parameters, and fill the missing ones
+        if os.path.isfile(self.conffile):
+            self.read([self.conffile])
+            print _("INFO: Reading config file at %s.") % self.conffile
+        else:
+            print _("INFO: Creating config file at %s.") % self.conffile
+
+        for section in DEFAULTS.keys():
+            fullsection = section + '::default'
+            ## Set default profile options
+            if fullsection not in self.sections():
+                self.add_section(fullsection)
+                for option, optdesc in DEFAULTS[section].items():
+                    value, test = optdesc
+                    self.set(fullsection, option, value)
+        ## Set default keybindings
+        if 'keybindings' not in self.sections():
+            self.add_section("keybindings")
+        for option, value in DEFAULT_KEY_BINDINGS.items():
+            if not self.has_option('keybindings', option):
+                self.set('keybindings', option, value)
+        self.parse()
+        # Writing our configuration file
+        self.save()
+
+    def parse(self):
+        ## clean the default options to avoid seeing options where they are not
+        for option in self.defaults().keys():
+            self.remove_option('DEFAULT', option)
+        ## now parse the rest of sections
+        for section in self.sections():
+            for option in self.options(section):
+                if section == 'keybindings':
+                    if option not in KEY_BINDINGS.keys():
+                        print _("Option %s:%s not recognised, deleting." \
+                                % (section, option))
+                        self.remove_option(section, option)
+                else:
+                    if not '::' in section:
+                        print _("Deleting unrecognzed section %s." % section)
+                        self.remove_section(section)
+                        break
+                    secttype = section.split('::')[0]
+                    if secttype not in DEFAULTS:
+                        print _("Deleting unrecognized section %s." % section)
+                        self.remove_section(section)
+                        break
+                    if option not in DEFAULTS[secttype].keys():
+                        print _("Option %s:%s not recognised, deleting." \
+                                % (section, option))
+                        self.remove_option(section, option)
+                    else:
+                        val = self.get(section, option)
+                        defval, test = DEFAULTS[secttype][option]
+                        try:
+                            if test == 'str':
+                                continue
+                            elif test == 'int':
+                                res = self.getint(section, option)
+                            elif test == 'bool':
+                                res = self.getboolean(section, option)
+                            elif test == 'encoding':
+                                if val.lower() not in [enc.lower()
+                                                       for enc, desc
+                                                       in cc_utils.encodings]:
+                                    raise ValueError(
+                                        _('Option %s is not valid.') % test)
+                            elif test == 'font':
+                                fname, fsize = val.rsplit(' ', 1)
+                                fsize = int(fsize)
+                                cont = gtk.TextView().create_pango_context()
+                                avail_fonts = cont.list_families()
+                                found = False
+                                for font in avail_fonts:
+                                    if fname == font.get_name():
+                                        found = True
+                                        break
+                                if not found:
+                                    raise ValueError(
+                                        _('Option %s is not valid.') % type)
+                            elif callable(test):
+                                res = test(val)
+                                if not res:
+                                    raise Exception
+                            else:
+                                        print _("Wrong specification for "
+                                            "option %s in file %s") \
+                                            % (option, __file__)
+                        except Exception, e:
+                            print (_('ERROR: Wrong config value for %s: %s ') \
+                                    % (option, val) +
+                                    _(',using default one %s.') % defval)
+                            self.set(section, option, defval)
+
+    def set(self, section, option, value):
+        if section == 'DEFAULT':
+            raise ConfigParser.NoSectionError(
+                'Section "DEFAULT" is not allowed. Use section '
+                    '"TYPE::default instead"')
+        else:
+            return ConfigParser.RawConfigParser.set(self, section,
+                                                    option, value)
+
+    def get(self, section, option):
+        if '::' in section:
+            sectiontag = section.split('::')[0]
+            if not self.has_option(section, option):
+                if not self.has_option(sectiontag + '::default', option):
+                    raise ConfigParser.NoOptionError(option, section)
+                return ConfigParser.RawConfigParser.get(self,
+                            sectiontag + '::default', option)
+        elif not self.has_option(section, option):
+            raise ConfigParser.NoOptionError(option, section)
+        return ConfigParser.RawConfigParser.get(self, section, option)
+
+    def get_config_copy(self):
+        new_cfg = CLIConfig(DEFAULTS)
+        for section in self.sections():
+            if section not in new_cfg.sections():
+                new_cfg.add_section(section)
+            for option in self.options(section):
+                new_cfg.set(section, option, self.get(section, option))
+        return new_cfg
+
+    def save(self, conffile=None):
+        if not conffile:
+            conffile = self.conffile
+        dbg('Saving conffile at %s' % conffile)
+        with open(conffile, 'wb') as f:
+            self.write(f)
+
+    def get_plugin_conf(self, plugin):
+        return CLIConfigView(plugin, self)
+
+
+class CLIConfigView():
+    '''
+    This class implements an editable view (hiding unwanted options) of the
+    CLIConfig class, for example, to avoid the plugins editing other options
+    but their own, some methods of the configRaw Parser are not implemented.
+    '''
+    def __init__(self, sectionkey, config):
+        self.key = sectionkey + '::'
+        self._config = config
+
+    def get(self, section, option):
+        if section == 'DEFAULT':
+            section = 'default'
+        if self.key + section not in self._config.sections():
+            raise ConfigParser.NoSectionError(
+                'The section %s does not exist.' % section)
+        return self._config.get(self.key + section, option)
+
+    def getint(self, section, option):
+        return self._config.getint(self.key + section, option)
+
+    def getfloat(self, section, option):
+        return self._config.getfloat(self.key + section, option)
+
+    def getboolean(self, section, option):
+        return self._config.getboolean(self.key + section, option)
+
+    def items(self, section):
+        return self._config.items(self.key + section)
+
+    def write(self, fileobject):
+        pass
+
+    def remove_option(self, section, option):
+        return self._config.remove_option(self.key + section, option)
+
+    def optionxform(self, option):
+        pass
+
+    def set(self, section, option, value):
+        if section == 'DEFAULT':
+            section = 'default'
+        if self.key + section not in self._config.sections():
+            raise ConfigParser.NoSectionError(
+                'The section %s does not exist.' % section)
+        return self._config.set(self.key + section, option, value)
+
+    def add_section(self, section):
+        return self._config.add_section(self.key + section)
+
+    def remove_section(self, section):
+        return self._config.remove_section(self.key + section)
+
+    def sections(self):
+        sections = []
+        for section in self._config.sections():
+            if section.startswith(self.key):
+                sections.append(section.split('::', 1)[1])
+        return sections
+
+    def options(self, section):
+        return self._config.options(self.key + section)
+
+    def defaults(self):
+        return self._config.options(self.key + 'default')
+
+    def has_section(self, section):
+        return self._config.has_section(self.key + section)
+
+    def has_option(self, section, option):
+        return self._config.has_option(self.key + section, option)
+
+    def readfp(self, filedesc, name='<???>'):
+        tempconf = ConfigParser.RawConfigParser()
+        tempconf.readfp(filedesc, name)
+        for option in tempconf.defaults():
+            self.set('DEFAULT', option, tempconf.get('DEFAULT', option))
+        for section in tempconf.sections():
+            if not self.has_section(section):
+                self.add_section(section)
+            for option in tempconf.options():
+                self.set(section, option)
+
+    def read(self, files):
+        for file in files:
+            with open(file, 'r') as fd:
+                self.readfp(fd)
+
+    def save(self):
+        self._config.save()

=== removed file 'clicompanionlib/controller.py'
--- clicompanionlib/controller.py	2012-01-02 00:23:11 +0000
+++ clicompanionlib/controller.py	1970-01-01 00:00:00 +0000
@@ -1,665 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# clicompanion - commandline tool.
-#
-# Copyright 2010 Duane Hinnen, Kenny Meyer
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
-#
-#
-
-import os
-import pygtk
-pygtk.require('2.0')
-import re
-import webbrowser
-import view
-import copy
-import clicompanionlib.tabs
-import clicompanionlib.config as cc_config
-import clicompanionlib.utils  as utils
-from clicompanionlib.utils import get_user_shell, dbg
-
-#if cc_config.get_config().get('terminal','debug') == 'True':
-#    utils.DEBUG = True
-
-# import vte and gtk or print error
-try:
-    import gtk
-except:
-    error = gtk.MessageDialog (None, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
-        _("You need to install the python gtk bindings package 'python-gtk2'"))
-    error.run()
-    sys.exit (1)
-    
-try:
-    import vte
-except:
-    error = gtk.MessageDialog (None, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
-        _("You need to install 'python-vte' the python bindings for libvte."))
-    error.run()
-    sys.exit (1)
-    
-
-
-class Actions(object):
-    ## Info Dialog Box
-    ## if a command needs more info EX: a package name, a path
-    def get_info(self, cmd, ui, desc):
-        dbg('Got command with user input')
-        ## Create Dialog object
-        dialog = gtk.MessageDialog(
-            None,
-            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-            gtk.MESSAGE_QUESTION,
-            gtk.BUTTONS_OK_CANCEL,
-            None)
-
-        # Primary text
-        dialog.set_markup(_("This command requires more information."))
-
-        ## create the text input field
-        entry = gtk.Entry()
-        ## allow the user to press enter to do ok
-        entry.connect("activate", self.responseToDialog, dialog, gtk.RESPONSE_OK)
-
-        ## create a horizontal box to pack the entry and a label
-        hbox = gtk.HBox()
-        hbox.pack_start(gtk.Label(ui+":"), False, 5, 5)
-        hbox.pack_end(entry)
-        ## some secondary text
-        dialog.format_secondary_markup(_("Please provide a "+ui))
-        ## add it and show it
-        dialog.vbox.pack_end(hbox, True, True, 0)
-        dialog.show_all()
-
-        ## Show the dialog
-        response = dialog.run()
-
-        ## user text assigned to a variable
-        text = entry.get_text()
-        user_input = text.split(' ')
-
-        ## The destroy method must be called otherwise the 'Close' button will
-        ## not work.
-        dialog.destroy()
-        if response != gtk.RESPONSE_OK:
-            user_input = None
-        return user_input
-
-    def responseToDialog(self, text, dialog, response):
-        dialog.response(response)
-
-    ## Add command dialog box
-    def add_command(self, mw):
-
-        ## Create Dialog object
-        dialog = gtk.MessageDialog(
-            None,
-            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-            gtk.MESSAGE_QUESTION,
-            gtk.BUTTONS_OK,
-            None)
-
-        ## primaary text
-        dialog.set_markup(_("Add a command to your command list"))
-
-        #create the text input field
-        entry1 = gtk.Entry()
-        entry2 = gtk.Entry()
-        entry3 = gtk.Entry()
-        ## allow the user to press enter to do ok
-        entry1.connect("activate", self.responseToDialog, dialog, gtk.RESPONSE_OK)
-        entry2.connect("activate", self.responseToDialog, dialog, gtk.RESPONSE_OK)
-        entry3.connect("activate", self.responseToDialog, dialog, gtk.RESPONSE_OK)
-
-        ## create three labels
-        hbox1 = gtk.HBox()
-        hbox1.pack_start(gtk.Label(_("Command")), False, 5, 5)
-        hbox1.pack_start(entry1, False, 5, 5)
-
-        hbox1.pack_start(gtk.Label(_("User Input")), False, 5, 5)
-        hbox1.pack_start(entry2, False, 5, 5)
-
-        hbox2 = gtk.HBox()
-        hbox2.pack_start(gtk.Label(_("Description")), False, 5, 5)
-        hbox2.pack_start(entry3, True, 5, 5)
-
-        ## cancel button
-        dialog.add_button(_('Cancel'), gtk.RESPONSE_DELETE_EVENT)
-        ## some secondary text
-        dialog.format_secondary_markup(
-            _("When entering a command use question marks(?) as placeholders if"
-              " user input is required when the command runs. Example: ls "
-              "/any/directory would be entered as, ls ? .For each question "
-              "mark(?) in your command, if any, use the User Input field to "
-              "provide a hint for each variable. Using our example ls ? you "
-              "could put directory as the User Input. Lastly provide a brief "
-              "Description."))
-
-        ## add it and show it
-        dialog.vbox.pack_end(hbox2, True, True, 0)
-        dialog.vbox.pack_end(hbox1, True, True, 0)
-        dialog.show_all()
-        ## Show the dialog
-        result = dialog.run()
-
-        if result == gtk.RESPONSE_OK:
-            ## user text assigned to a variable
-            text1 = entry1.get_text()
-            text2 = entry2.get_text()
-            text3 = entry3.get_text()
-            ## update commandsand sync with screen '''
-            view.CMNDS.append(text1, text2, text3)
-            mw.sync_cmnds()
-            view.CMNDS.save()
-
-        ## The destroy method must be called otherwise the 'Close' button will
-        ## not work.
-        dialog.destroy()
-        #return text
-
-    ## This the edit function
-    def edit_command(self, mw):
-        if not view.ROW:
-            return
-        lst_index = int(view.ROW[0][0])
-        model = mw.treeview.get_model()
-        cmd = ''.join(model[lst_index][0])
-        ui = ''.join(model[lst_index][1])
-        desc = ''.join(model[lst_index][2])
-
-        ## Create Dialog object
-        dialog = gtk.MessageDialog(
-            None,
-            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-            gtk.MESSAGE_QUESTION,
-            gtk.BUTTONS_OK,
-            None)
-
-        # primary text
-        dialog.set_markup(_("Edit a command in your command list"))
-
-        ## create the text input fields
-        entry1 = gtk.Entry()
-        entry1.set_text(cmd)
-        entry2 = gtk.Entry()
-        entry2.set_text(ui)
-        entry3 = gtk.Entry()
-        entry3.set_text(desc)
-        ## allow the user to press enter to do ok
-        entry1.connect("activate", self.responseToDialog, dialog, gtk.RESPONSE_OK)
-
-        ## create three labels
-        hbox1 = gtk.HBox()
-        hbox1.pack_start(gtk.Label(_("Command")), False, 5, 5)
-        hbox1.pack_start(entry1, False, 5, 5)
-
-        hbox1.pack_start(gtk.Label(_("User Input")), False, 5, 5)
-        hbox1.pack_start(entry2, False, 5, 5)
-
-        hbox2 = gtk.HBox()
-        hbox2.pack_start(gtk.Label(_("Description")), False, 5, 5)
-        hbox2.pack_start(entry3, True, 5, 5)
-
-        ## cancel button
-        dialog.add_button(_('Cancel'), gtk.RESPONSE_DELETE_EVENT)
-        ## some secondary text
-        dialog.format_secondary_markup(_("Please provide a command, description, and what type of user variable, if any, is required."))
-
-        ## add it and show it
-        dialog.vbox.pack_end(hbox2, True, True, 0)
-        dialog.vbox.pack_end(hbox1, True, True, 0)
-        dialog.show_all()
-        ## Show the dialog
-        result = dialog.run()
-
-        if result == gtk.RESPONSE_OK:
-            ## user text assigned to a variable
-            cmd = entry1.get_text()
-            ui = entry2.get_text()
-            desc = entry3.get_text()
-
-            if cmd != "":
-                cmd_index = model[lst_index][3]
-                dbg('Got index %d for command at pos %d'%(cmd_index, lst_index))
-                view.CMNDS[cmd_index] = [cmd, ui, desc]
-            mw.sync_cmnds()
-            view.CMNDS.save()
-        ## The destroy method must be called otherwise the 'Close' button will
-        ## not work.
-        dialog.destroy()
-
-
-    ## Remove command from command file and GUI
-    def remove_command(self, mw):
-        if not view.ROW:
-            return
-        ## get selected row
-        lst_index = int(view.ROW[0][0])
-        ## get selected element index, even from search filter
-        model = mw.treeview.get_model()
-        cmd_index = model[lst_index][3]
-        ## delete element from liststore and CMNDS
-        del view.CMNDS[cmd_index]
-        mw.sync_cmnds()
-        ## save changes
-        view.CMNDS.save()
-
-
-    def _filter_commands(self, widget, liststore, treeview):
-        """
-        Show commands matching a given search term.
-        The user should enter a term in the search box and the treeview should
-        only display the rows which contain the search term.
-        Pretty straight-forward.
-        """
-        search_term = widget.get_text().lower()
-        ## If the search term is empty, restore the liststore
-        if search_term == "":
-            view.FILTER = 0
-            treeview.set_model(liststore)
-            return
-
-        view.FILTER = 1
-        ## Create a TreeModelFilter object which provides auxiliary functions for
-        ## filtering data.
-        ## http://www.pygtk.org/pygtk2tutorial/sec-TreeModelSortAndTreeModelFilter.html
-        modelfilter = liststore.filter_new()
-        def search(modelfilter, iter, search_term):
-            try:
-                ## Iterate through every column and row and check if the search
-                ## term is there:
-                if search_term in modelfilter.get_value(iter, 0).lower() or \
-                   search_term in modelfilter.get_value(iter, 1).lower() or \
-                   search_term in modelfilter.get_value(iter, 2).lower() :
-                        return True
-                                         
-            except TypeError:
-                ## Python raises a TypeError if row data doesn't exist. Catch
-                ## that and fail silently.
-                pass
-            except AttributeError:
-                ## Python raises a AttributeError if row data was modified . Catch
-                ## that and fail silently.
-                pass
-        modelfilter.set_visible_func(search, search_term)
-        ## save the old liststore and cmnds
-        treeview.set_model(modelfilter)
-
-    ## send the command to the terminal
-    def run_command(self, mw):
-
-        ## if called without selecting a command from the list return
-        if not view.ROW:
-            return
-        text = ""
-        lst_index = int(view.ROW[0][0]) ## removes everything but number from [5,]
-
-        ## get the current notebook page so the function knows which terminal to run the command in.
-        pagenum = mw.notebook.get_current_page()
-        widget = mw.notebook.get_nth_page(pagenum)
-        page_widget = widget.get_child()
-
-        model = mw.treeview.get_model()
-        cmd = ''.join(model[lst_index][0])
-        ui = ''.join(model[lst_index][1])
-        desc = ''.join(model[lst_index][2])
-            
-        ## find how many ?(user arguments) are in command
-        match = re.findall('\?', cmd) 
-        '''
-        Make sure user arguments were found. Replace ? with something
-        .format can read. This is done so the user can just enter ?, when
-        adding a command where arguments are needed, instead
-        of {0[1]}, {0[1]}, {0[2]}
-        '''    
-        if match == False:
-            pass
-        else:
-            num = len(match)
-            ran = 0
-            new_cmnd = self.replace(cmd, num, ran)
-
-        if len(match) > 0: # command with user input
-            dbg('command with ui')
-            f_cmd = ""
-            while True:
-                try:
-                    ui_text = self.get_info(cmd, ui, desc)
-                    if ui_text == None:
-                        return
-                    dbg('Got ui "%s"'%' '.join(ui_text))
-                    if ''.join(ui_text) == '':
-                        raise IndexError
-                    f_cmd = new_cmnd.format(ui_text)
-                except IndexError, e: 
-                    error = gtk.MessageDialog (None, gtk.DIALOG_MODAL, \
-                        gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
-                        _("You need to enter full input. Space separated."))
-                    error.connect('response', lambda err, *x: err.destroy())
-                    error.run()
-                    continue
-                break
-            page_widget.feed_child(f_cmd+"\n") #send command w/ input
-            page_widget.show()
-            page_widget.grab_focus()
-        else: ## command that has no user input
-            page_widget.feed_child(cmd+"\n") #send command
-            page_widget.show()
-            page_widget.grab_focus()
-            
-    ## replace ? with {0[n]}
-    def replace(self, cmnd, num, ran):
-        replace_cmnd=re.sub('\?', '{0['+str(ran)+']}', cmnd, count=1)
-        cmnd = replace_cmnd
-        ran += 1
-        if ran < num:
-            return self.replace(cmnd, num, ran)    
-        else:
-            pass
-        return cmnd
-        
-    ## open the man page for selected command
-    def man_page(self, notebook):
-        import subprocess as sp
-        import shlex
-        try:
-            row_int = int(view.ROW[0][0]) # removes everything but number from EX: [5,]
-        except IndexError:  
-            ## When user not choose row, when is in filter mode
-            dialog = gtk.MessageDialog(
-                None,
-                gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                gtk.MESSAGE_QUESTION,
-                gtk.BUTTONS_OK,
-                None)
-            dialog.set_markup(_('You must choose a row to view the help'))
-            dialog.show_all()
-            dialog.run()
-            dialog.destroy()     
-            return 
-        ## get the manpage for the command
-        cmnd = view.CMNDS[row_int][0] #CMNDS is where commands are store
-        ## get each command for each pipe, It's not 100 accurate, but good 
-        ## enough (by now)
-        commands = []
-        next_part = True
-        found_sudo = False
-        for part in shlex.split(cmnd):
-            if next_part:
-                if part == 'sudo' and not found_sudo:
-                    found_sudo = True
-                    commands.append('sudo') 
-                else:
-                    if part not in commands:
-                        commands.append(part)
-                    next_part = False
-            else:
-                if part in [ '||', '&&', '&', '|']:
-                    next_part = True
-           
-        notebook = gtk.Notebook()
-        notebook.set_scrollable(True)
-        notebook.popup_enable()
-        notebook.set_properties(group_id=0, tab_vborder=0, tab_hborder=1, tab_pos=gtk.POS_TOP)
-        ## create a tab for each command
-        for command in commands:
-            scrolled_page = gtk.ScrolledWindow()
-            scrolled_page.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-            tab = gtk.HBox()
-            tab_label = gtk.Label(command)
-            tab_label.show()
-            tab.pack_start(tab_label)
-            page = gtk.TextView()
-            page.set_wrap_mode(gtk.WRAP_WORD)
-            page.set_editable(False)
-            page.set_cursor_visible(False)
-            try:
-                manpage = sp.check_output(["man",command])
-            except sp.CalledProcessError, e:
-                manpage =  _('Failed to get manpage for command "%s"\nReason:\n%s')%(
-                        command, e)
-            textbuffer = page.get_buffer()
-            textbuffer.set_text(manpage)
-            scrolled_page.add(page)
-            notebook.append_page(scrolled_page, tab)
-        
-        help_win = gtk.Dialog()
-        help_win.set_title(_("Man page for %s")%cmnd)
-        help_win.vbox.pack_start(notebook, True, True, 0)
-        button = gtk.Button("close")
-        button.connect_object("clicked", lambda self: self.destroy(), help_win)
-        button.set_flags(gtk.CAN_DEFAULT)
-        help_win.action_area.pack_start( button, True, True, 0)
-        button.grab_default()
-        help_win.set_default_size(500,600)
-        help_win.show_all()
-
-
-    @staticmethod
-    def _filter_sudo_from(command):
-        """Filter the sudo from `command`, where `command` is a list.
-        Return the command list with the "sudo" filtered out.
-        """
-        if command[0].startswith("sudo"):
-            del command[0]
-            return command
-        return command
-
-
-    #TODO: Move to menus_buttons
-    def copy_paste(self, vte, event, data=None):
-        if event.button == 3:
-
-            time = event.time
-            ## right-click popup menu Copy
-            popupMenu = gtk.Menu()
-            menuPopup1 = gtk.ImageMenuItem (gtk.STOCK_COPY)
-            popupMenu.add(menuPopup1)
-            menuPopup1.connect('activate', lambda x: vte.copy_clipboard())
-            ## right-click popup menu Paste
-            menuPopup2 = gtk.ImageMenuItem (gtk.STOCK_PASTE)
-            popupMenu.add(menuPopup2)
-            menuPopup2.connect('activate', lambda x: vte.paste_clipboard())
-
-            ## Show popup menu
-            popupMenu.show_all()
-            popupMenu.popup( None, None, None, event.button, time)
-            return True
-        else:
-            pass
-            
-    ## close the window and quit
-    def delete_event(self, widget,  data=None):
-        gtk.main_quit()
-        return False
-    
-    ## Help --> About and Help --> Help menus
-    def about_event(self, widget, data=None):
-        # Create AboutDialog object
-        dialog = gtk.AboutDialog()
-
-        # Add the application name to the dialog
-        dialog.set_name('CLI Companion ')
-
-        # Set the application version
-        dialog.set_version('1.1')
-
-        # Pass a list of authors.  This is then connected to the 'Credits'
-        # button.  When clicked the buttons opens a new window showing
-        # each author on their own line.
-        dialog.set_authors(['Duane Hinnen', 'Kenny Meyer', 'Marcos Vanettai', 'Marek Bardoński'])
-
-        # Add a short comment about the application, this appears below the application
-        # name in the dialog
-        dialog.set_comments(_('This is a CLI Companion program.'))
-
-        # Add license information, this is connected to the 'License' button
-        # and is displayed in a new window.
-        dialog.set_license(_('Distributed under the GNU license. You can see it at <http://www.gnu.org/licenses/>.'))
-
-        # Show the dialog
-        dialog.run()
-
-        # The destroy method must be called otherwise the 'Close' button will
-        # not work.
-        dialog.destroy()
-
-
-    def help_event(self, widget, data=None):
-        webbrowser.open("http://launchpad.net/clicompanion")
-        
-
-    def usage_event(self, widget, data=None):
-        dialog = gtk.Dialog("Usage",
-            None,
-            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-            (gtk.STOCK_CANCEL, gtk.RESPONSE_CLOSE))
-            
-        hbox1 = gtk.HBox()
-        hbox2 = gtk.HBox()
-        hbox21 = gtk.HBox()
-        hbox3 = gtk.HBox()
-        hbox4 = gtk.HBox()
-        hbox5 = gtk.HBox()
-        hbox6 = gtk.HBox()
-
-        hbox1.pack_start(gtk.Label(_("To maximize window, press F11")), False, 5, 5)
-        hbox2.pack_start(gtk.Label(_("To hide UI, press F12")), False, 5, 5)
-        hbox21.pack_start(gtk.Label(_("--------------------")), False, 5, 5)
-        hbox3.pack_start(gtk.Label(_("Run command - F4")), False, 5, 5) 
-        hbox4.pack_start(gtk.Label(_("Add command - F5")), False, 5, 5)        
-        hbox5.pack_start(gtk.Label(_("Remove command - F6")), False, 5, 5) 
-        hbox6.pack_start(gtk.Label(_("Add tab - F7")), False, 5, 5)        
-        
-        dialog.vbox.pack_end(hbox1, True, True, 0)
-        dialog.vbox.pack_end(hbox2, True, True, 0)
-        dialog.vbox.pack_end(hbox21, True, True, 0)
-        dialog.vbox.pack_end(hbox3, True, True, 0)
-        dialog.vbox.pack_end(hbox4, True, True, 0)
-        dialog.vbox.pack_end(hbox5, True, True, 0)
-        dialog.vbox.pack_end(hbox6, True, True, 0)
-        
-        dialog.show_all()
-        
-        result = dialog.run()
-        ## The destroy method must be called otherwise the 'Close' button will
-        ## not work.
-        dialog.destroy()
-        
-        
-    ## File --> Preferences    
-    def changed_cb(self, combobox, config):
-        dbg('Changed encoding')
-        model = combobox.get_model()
-        index = combobox.get_active()
-        if index>=0:
-            text_e = model[index][0]
-            encoding = text_e.split(':',1)[0].strip()
-            dbg('Setting encoding to "%s"'%encoding)
-            config.set("terminal", "encoding", encoding)
-
-        
-    def color_set_fg_cb(self, colorbutton_fg, config, tabs):
-        dbg('Changing fg color')
-        colorf = self.color2hex(colorbutton_fg)
-        config.set("terminal", "colorf", str(colorf))          
-        tabs.update_all_term_config(config)
-
-
-    def color_set_bg_cb(self, colorbutton_bg, config, tabs):
-        dbg('Changing bg color')
-        colorb = self.color2hex(colorbutton_bg)
-        config.set("terminal", "colorb", str(colorb))
-        tabs.update_all_term_config(config)
-        
-        
-    def color2hex(self, widget):
-        """Pull the colour values out of a Gtk ColorPicker widget and return them
-        as 8bit hex values, sinces its default behaviour is to give 16bit values"""
-        widcol = widget.get_color()
-        return('#%02x%02x%02x' % (widcol.red>>8, widcol.green>>8, widcol.blue>>8))
-        
-    def preferences(self, tabs, data=None):
-        '''
-        Preferences window
-        '''
-        dialog = gtk.Dialog(_("User Preferences"),
-            None,
-            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-            (gtk.STOCK_CANCEL, gtk.RESPONSE_CLOSE,
-            gtk.STOCK_OK, gtk.RESPONSE_OK))
-            
-        config = cc_config.get_config_copy()
-           
-        ##create the text input fields
-        entry1 = gtk.Entry()
-        entry1.set_text(config.get('terminal', 'scrollb'))
-        
-        ##combobox for selecting encoding
-        combobox = gtk.combo_box_new_text()
-        i=0
-        for encoding, desc in utils.encodings:
-            combobox.append_text(encoding + ': '+desc)
-            if encoding.strip().upper() == config.get('terminal','encoding').upper():
-                active = i
-            i=i+1
-        combobox.set_active(active)
-        combobox.connect('changed', self.changed_cb, config)
-        
-        ##colorbox for selecting text and background color
-        colorbutton_fg = gtk.ColorButton(
-            gtk.gdk.color_parse(config.get('terminal','colorf')))
-        colorbutton_bg = gtk.ColorButton(
-            gtk.gdk.color_parse(config.get('terminal','colorb')))
-
-        colorbutton_fg.connect('color-set', self.color_set_fg_cb, config, tabs)
-        colorbutton_bg.connect('color-set', self.color_set_bg_cb, config, tabs)
-        
-        ## allow the user to press enter to do ok
-        entry1.connect("activate", self.responseToDialog, dialog, gtk.RESPONSE_OK)
-
-        ## create the labels
-        hbox1 = gtk.HBox()
-        hbox1.pack_start(gtk.Label(_("Scrollback")), False, 5, 5)
-        hbox1.pack_start(entry1, False, 5, 5)
-
-        hbox1.pack_start(gtk.Label(_("Encoding")), False, 5, 5)
-        hbox1.pack_start(combobox, False, 5, 5)
-
-        hbox2 = gtk.HBox()
-        hbox2.pack_start(gtk.Label(_("Font color")), False, 5, 5)
-        hbox2.pack_start(colorbutton_fg, True, 5, 5)
-        
-        hbox2.pack_start(gtk.Label(_("Background color")), False, 5, 5)
-        hbox2.pack_start(colorbutton_bg, True, 5, 5)
-        
-        ## add it and show it
-        dialog.vbox.pack_end(hbox2, True, True, 0)
-        dialog.vbox.pack_end(hbox1, True, True, 0)
-        dialog.show_all()
-
-        result = dialog.run()
-        if result == gtk.RESPONSE_OK:
-            ## user text assigned to a variable
-            text_sb = entry1.get_text()
-            config.set("terminal", "scrollb", text_sb)
-            cc_config.save_config(config)
-        tabs.update_all_term_config()
-
-        ## The destroy method must be called otherwise the 'Close' button will
-        ## not work.
-        dialog.destroy()
-

=== added file 'clicompanionlib/helpers.py'
--- clicompanionlib/helpers.py	1970-01-01 00:00:00 +0000
+++ clicompanionlib/helpers.py	2012-01-08 10:37:24 +0000
@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# helpers.py - Helper dialogs for clicompanion
+#                                                                                                             
+# Copyright 2012 Duane Hinnen, Kenny Meyer, Marcos Vanetta, Marek Bardoński,
+#                David Caro
+#                                                                                                             
+# This program is free software: you can redistribute it and/or modify it       
+# under the terms of the GNU General Public License version 3, as published     
+# by the Free Software Foundation.                                                                            
+#                                                                                                             
+# This program is distributed in the hope that it will be useful, but           
+# WITHOUT ANY WARRANTY; without even the implied warranties of                  
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.               
+#    
+#    
+####
+## This file keeps some popups that are shown across the program execution,
+## that aren't directly related with a class, like the edit comand popup or the
+## about popup, but are too small to be kept in a separate file
+
+import os
+import re
+import pygtk
+pygtk.require('2.0')
+import gtk
+import subprocess as sp
+import shlex
+from clicompanionlib.utils import dbg
+
+
+class ManPage(gtk.Dialog):
+    def __init__(self, cmd):
+        if not cmd:
+            choose_row_error()
+            gtk.Dialog.__init__(self)
+            self.cmd = None
+            return
+        self.cmd = cmd
+        notebook = gtk.Notebook()
+        notebook.set_scrollable(True)
+        notebook.popup_enable()
+        notebook.set_properties(group_id=0, tab_vborder=0,
+                                tab_hborder=1, tab_pos=gtk.POS_TOP)
+        ## create a tab for each command
+        for command in self.get_commands():
+            scrolled_page = gtk.ScrolledWindow()
+            scrolled_page.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+            tab = gtk.HBox()
+            tab_label = gtk.Label(command)
+            tab_label.show()
+            tab.pack_start(tab_label)
+            page = gtk.TextView()
+            page.set_wrap_mode(gtk.WRAP_WORD)
+            page.set_editable(False)
+            page.set_cursor_visible(False)
+            try:
+                manpage = sp.check_output(["man", command])
+            except sp.CalledProcessError, e:
+                manpage = _('Failed to get manpage for command '
+                            '"%s"\nReason:\n%s') % (command, e)
+            textbuffer = page.get_buffer()
+            textbuffer.set_text(manpage)
+            scrolled_page.add(page)
+            notebook.append_page(scrolled_page, tab)
+        self.set_title(_("Man page for %s") % cmd)
+        self.vbox.pack_start(notebook, True, True, 0)
+        button = gtk.Button("close")
+        button.connect_object("clicked", lambda *x: self.destroy(), self)
+        button.set_flags(gtk.CAN_DEFAULT)
+        self.action_area.pack_start(button, True, True, 0)
+        button.grab_default()
+        self.set_default_size(500, 600)
+        self.show_all()
+
+    def run(self):
+        if not self.cmd:
+            return
+        gtk.Dialog.run(self)
+
+    def get_commands(self):
+        commands = []
+        next_part = True
+        found_sudo = False
+        try:
+            for part in shlex.split(self.cmd):
+                if next_part:
+                    if part == 'sudo' and not found_sudo:
+                        found_sudo = True
+                        commands.append('sudo')
+                    else:
+                        if part not in commands:
+                            commands.append(part)
+                        next_part = False
+                else:
+                    if part in ['||', '&&', '&', '|']:
+                        next_part = True
+        except Exception, e:
+            return [self.cmd]
+        return commands
+
+
+def show_about():
+    dialog = gtk.AboutDialog()
+    dialog.set_name('CLI Companion')
+    dialog.set_version('1.1')
+    dialog.set_authors([u'Duane Hinnen', u'Kenny Meyer', u'Marcos Vanettai',
+                        u'Marek Bardoński', u'David Caro'])
+    dialog.set_comments(_('This is a CLI Companion program.'))
+    dialog.set_license(_('Distributed under the GNU license. You can see it at'
+                         '<http://www.gnu.org/licenses/>.'))
+    dialog.run()
+    dialog.destroy()
+
+
+## Some hlper popus like edit command and so
+class CommandInfoWindow(gtk.MessageDialog):
+    def __init__(self, cmd, ui, desc):
+        self.cmd, self.ui, self.desc = cmd, ui, desc
+        gtk.MessageDialog.__init__(self,
+            None,
+            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+            gtk.MESSAGE_QUESTION,
+            gtk.BUTTONS_OK_CANCEL,
+            None)
+        self.set_markup(_("This command requires more information."))
+        ## create the text input field
+        self.entry = gtk.Entry()
+        ## allow the user to press enter to do ok
+        self.entry.connect("activate", lambda *x: self.response(
+                                                    gtk.RESPONSE_OK))
+        ## create a horizontal box to pack the entry and a label
+        hbox = gtk.HBox()
+        hbox.pack_start(gtk.Label(self.ui + ":"), False, 5, 5)
+        hbox.pack_end(self.entry)
+        ## some secondary text
+        self.format_secondary_markup(_("Please provide a " + self.ui))
+        ## add it and show it
+        self.vbox.pack_end(hbox, True, True, 0)
+        self.show_all()
+        ## The destroy method must be called otherwise the 'Close' button will
+        ## not work.
+
+    def run(self):
+        result = False
+        while not result:
+            result = gtk.MessageDialog.run(self)
+            if result == gtk.RESPONSE_OK:
+                ui = self.entry.get_text().strip()
+                dbg('Got ui "%s"' % ui)
+                if not ui:
+                    self.show_error()
+                    result = None
+                try:
+                    cmd = self.cmd.format(ui.split(' '))
+                except:
+                    result = None
+            else:
+                cmd = None
+        self.destroy()
+        return cmd
+
+    def show_error(self):
+        error = gtk.MessageDialog(None, gtk.DIALOG_MODAL, \
+            gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
+            _("You need to enter full input. Space separated."))
+        error.connect('response', lambda *x: error.destroy())
+        error.run()
+
+
+def choose_row_error():
+    dialog = gtk.MessageDialog(
+            None,
+            gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+            gtk.MESSAGE_QUESTION,
+            gtk.BUTTONS_OK,
+            None)
+    dialog.set_markup(_('You must choose a row to view the help'))
+    dialog.show_all()
+    dialog.run()
+    dialog.destroy()

=== modified file 'clicompanionlib/menus_buttons.py'
--- clicompanionlib/menus_buttons.py	2012-01-02 00:23:11 +0000
+++ clicompanionlib/menus_buttons.py	2012-01-08 10:37:24 +0000
@@ -1,7 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# Copyright 2010 Duane Hinnen, Kenny Meyer, Marcos Vanetta
+# menus_buttons.py - Menus and Buttons for the clicompanion
+#
+# Copyright 2010 Duane Hinnen, Kenny Meyer, Marcos Vanetta, David Caro
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -16,199 +18,180 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 #
-#
-# This file contains the menus, buttons, and right clicks
-#
+# This file contains the upper menus (class FileMenu), and the lower buttons
+# (class Buttons) used in the CLI Companion main window
 
 import gtk
-import tabs
-
-
-class FileMenu(object):
-
-    def the_menu(self, mw):
-        actions = mw.actions
-        liststore = mw.liststore
-        tabs = mw.tabs
-        notebook = mw.notebook
+import gobject
+import webbrowser
+import clicompanionlib.helpers as cc_helpers
+
+
+class FileMenu(gtk.MenuBar):
+    __gsignals__ = {
+         'run_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'add_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'remove_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'edit_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'add_tab': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'close_tab': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'preferences': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'quit': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         }
+
+    def __init__(self, config):
+        gtk.MenuBar.__init__(self)
         menu = gtk.Menu()
         #color = gtk.gdk.Color(65555, 62000, 65555)
         #menu.modify_bg(gtk.STATE_NORMAL, color)
-        root_menu = gtk.MenuItem(_("File"))       
+        root_menu = gtk.MenuItem(_("File"))
         root_menu.set_submenu(menu)
- 
-        menu2 = gtk.Menu()       
+
+        menu2 = gtk.Menu()
         #color = gtk.gdk.Color(65555, 62000, 60000)
         #menu2.modify_bg(gtk.STATE_NORMAL, color)
         root_menu2 = gtk.MenuItem(_("Help"))
         root_menu2.set_submenu(menu2)
 
-        ##FILE MENU ##     
+        ##FILE MENU ##
         ## Make 'Run' menu entry
-        menu_item1 = gtk.MenuItem(_("Run Command [F4]"))
+        menu_item1 = gtk.MenuItem(_("Run Command"))
         menu.append(menu_item1)
-        menu_item1.connect("activate", lambda *x: actions.run_command(mw))
+        menu_item1.connect("activate", lambda *x: self.emit('run_command'))
         menu_item1.show()
 
         ## Make 'Add' file menu entry
-        menu_item2 = gtk.MenuItem(_("Add Command [F5]"))
+        menu_item2 = gtk.MenuItem(_("Add Command"))
         menu.append(menu_item2)
-        menu_item2.connect("activate", lambda *x: actions.add_command(mw))
+        menu_item2.connect("activate", lambda *x: self.emit('add_command'))
         menu_item2.show()
-        
+
         ## Make 'Remove' file menu entry
-        menu_item3 = gtk.MenuItem(_("Remove Command [F6]"))
+        menu_item3 = gtk.MenuItem(_("Remove Command"))
         menu.append(menu_item3)
-        menu_item3.connect("activate", lambda *x: actions.remove_command(mw))
+        menu_item3.connect("activate", lambda *x: self.emit('remove_command'))
         menu_item3.show()
-        
+
         ## Make 'Add Tab' file menu entry
-        menu_item4 = gtk.MenuItem(_("Add Tab [F7]"))
-        menu.append(menu_item4)
-        menu_item4.connect("activate", lambda *x: tabs.add_tab(notebook))
-        menu_item4.show()
-        
+        menu_item4 = gtk.MenuItem(_("Add Tab"))
+        menu.append(menu_item4)
+        menu_item4.connect("activate", lambda *x: self.emit('add_tab'))
+        menu_item4.show()
+
+        ## Make 'Close Tab' file menu entry
+        menu_item4 = gtk.MenuItem(_("Close Tab"))
+        menu.append(menu_item4)
+        menu_item4.connect("activate", lambda *x: self.emit('close_tab'))
+        menu_item4.show()
+
         ## Make 'User Preferences' file menu entry
         menu_item5 = gtk.MenuItem(_("Preferences"))
         menu.append(menu_item5)
-        menu_item5.connect("activate", lambda *x: actions.preferences(tabs))
+        menu_item5.connect("activate", lambda *x: self.emit('preferences'))
         menu_item5.show()
 
         ## Make 'Quit' file menu entry
         menu_item6 = gtk.MenuItem(_("Quit"))
         menu.append(menu_item6)
-        menu_item6.connect("activate", actions.delete_event)
+        menu_item6.connect("activate", lambda *x: self.emit('quit'))
         menu_item6.show()
-        
-        
+
         ## HELP MENU ##
         ## Make 'About' file menu entry
         menu_item11 = gtk.MenuItem(_("About"))
         menu2.append(menu_item11)
-        menu_item11.connect("activate", actions.about_event)
+        menu_item11.connect("activate", lambda *x: cc_helpers.show_about())
         menu_item11.show()
 
-        ## Make 'Usage' file menu entry
-        menu_item22 = gtk.MenuItem(_("Usage"))
-        menu2.append(menu_item22)
-        menu_item22.connect("activate", actions.usage_event)
-        menu_item22.show()
-        
         ## Make 'Help' file menu entry
         menu_item22 = gtk.MenuItem(_("Help-online"))
         menu2.append(menu_item22)
-        menu_item22.connect("activate", actions.help_event)
+        menu_item22.connect("activate", lambda *x: webbrowser.open(
+                                        "http://launchpad.net/clicompanion"))
         menu_item22.show()
-       
-        
-
-        menu_bar = gtk.MenuBar()
-        #color = gtk.gdk.Color(60000, 65533, 60000) 
-        #menu_bar.modify_bg(gtk.STATE_NORMAL, color)
-        
-        menu_bar.append (root_menu) ##Menu bar(file)
-        menu_bar.append (root_menu2) ##Menu bar(help)       
-        #menu_bar.show() ##show File Menu # Menu Bar
-        ##Show 'File' Menu
-        #root_menu.show()
-        return menu_bar
-        
-        
-        
-    def buttons(self, mw,  spacing, layout):
-        #button box at bottom of main window
-        frame = gtk.Frame()
+
+        self.append(root_menu)  # Menu bar(file)
+        self.append(root_menu2)  # Menu bar(help)
+        self.show_all()
+
+
+class Buttons(gtk.Frame):
+    __gsignals__ = {
+         'run_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'add_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'remove_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'edit_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'add_tab': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'show_man': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'quit': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         }
+
+    #button box at bottom of main window
+    def __init__(self, spacing, layout):
+        gtk.Frame.__init__(self)
         bbox = gtk.HButtonBox()
         bbox.set_border_width(5)
-        frame.add(bbox)
+        self.add(bbox)
 
         # Set the appearance of the Button Box
-        #color = gtk.gdk.Color(65000, 61000, 61000)
         bbox.set_layout(layout)
         bbox.set_spacing(spacing)
         # Run button
-        buttonRun = gtk.Button('_'+_("Run"))
+        buttonRun = gtk.Button(stock=gtk.STOCK_EXECUTE)
         bbox.add(buttonRun)
-        buttonRun.connect("clicked", lambda *x: mw.actions.run_command(mw))
+        buttonRun.connect("clicked", lambda *x: self.emit('run_command'))
         buttonRun.set_tooltip_text(_("Click to run a highlighted command"))
-        #buttonRun.modify_bg(gtk.STATE_NORMAL, color)        
-        #buttonRun.modify_bg(gtk.STATE_PRELIGHT, color)        
-        #buttonRun.modify_bg(gtk.STATE_INSENSITIVE, color)        
         # Add button
         buttonAdd = gtk.Button(stock=gtk.STOCK_ADD)
         bbox.add(buttonAdd)
-        buttonAdd.connect("clicked", lambda *x: mw.actions.add_command(mw))
-        buttonAdd.set_tooltip_text(_("Click to add a command to your command list"))
-        #buttonAdd.modify_bg(gtk.STATE_NORMAL, color)        
-        #buttonAdd.modify_bg(gtk.STATE_PRELIGHT, color)        
-        #buttonAdd.modify_bg(gtk.STATE_INSENSITIVE, color)
+        buttonAdd.connect("clicked", lambda *x: self.emit('add_command'))
+        buttonAdd.set_tooltip_text(_("Click to add a command to your"
+                                     "command list"))
         # Edit button
-        buttonEdit = gtk.Button('_'+_("Edit"))
+        buttonEdit = gtk.Button(stock=gtk.STOCK_EDIT)
         bbox.add(buttonEdit)
-        buttonEdit.connect("clicked", lambda *x: mw.actions.edit_command(mw))
-        buttonEdit.set_tooltip_text(_("Click to edit a command in your command list"))
-        #buttonEdit.modify_bg(gtk.STATE_NORMAL, color)        
-        #buttonEdit.modify_bg(gtk.STATE_PRELIGHT, color)        
-        #buttonEdit.modify_bg(gtk.STATE_INSENSITIVE, color)
+        buttonEdit.connect("clicked", lambda *x: self.emit('edit_command'))
+        buttonEdit.set_tooltip_text(_("Click to edit a command in your "
+                                      "command list"))
         # Delete button
         buttonDelete = gtk.Button(stock=gtk.STOCK_DELETE)
         bbox.add(buttonDelete)
-        buttonDelete.connect("clicked", lambda *x: mw.actions.remove_command(mw))
-        buttonDelete.set_tooltip_text(_("Click to delete a command in your command list"))
-        #buttonDelete.modify_bg(gtk.STATE_NORMAL, color)        
-        #buttonDelete.modify_bg(gtk.STATE_PRELIGHT, color)        
-        #buttonDelete.modify_bg(gtk.STATE_INSENSITIVE, color)
+        buttonDelete.connect("clicked", lambda *x: self.emit('remove_command'))
+        buttonDelete.set_tooltip_text(_("Click to delete a command in your "
+                                        "command list"))
         #Help Button
         buttonHelp = gtk.Button(stock=gtk.STOCK_HELP)
         bbox.add(buttonHelp)
-        buttonHelp.connect("clicked", lambda *x: mw.actions.man_page(mw.notebook))
-        buttonHelp.set_tooltip_text(_("Click to get help with a command in your command list"))
-        #buttonHelp.modify_bg(gtk.STATE_NORMAL, color)        
-        #buttonHelp.modify_bg(gtk.STATE_PRELIGHT, color)        
-        #buttonHelp.modify_bg(gtk.STATE_INSENSITIVE, color)
+        buttonHelp.connect("clicked", lambda *x: self.emit('show_man'))
+        buttonHelp.set_tooltip_text(_("Click to get help with a command in "
+                                      "your command list"))
+        #AddTab Button
+        button_addtab = gtk.Button(stock=gtk.STOCK_NEW)
+        bbox.add(button_addtab)
+        # Very ugly and nasty hack...
+        box = button_addtab.get_children()[0].get_children()[0]
+        lbl = box.get_children()[1]
+        lbl.set_text(_('Add tab'))
+        button_addtab.connect("clicked", lambda *x: self.emit('add_tab'))
+        button_addtab.set_tooltip_text(_("Click to add a terminal tab"))
         # Cancel button
         buttonCancel = gtk.Button(stock=gtk.STOCK_QUIT)
         bbox.add(buttonCancel)
-        buttonCancel.connect("clicked", mw.actions.delete_event)
+        buttonCancel.connect("clicked", lambda *x: self.emit('quit'))
         buttonCancel.set_tooltip_text(_("Click to quit CLI Companion"))
-        #buttonCancel.modify_bg(gtk.STATE_NORMAL, color)        
-        #buttonCancel.modify_bg(gtk.STATE_PRELIGHT, color)        
-        #buttonCancel.modify_bg(gtk.STATE_INSENSITIVE, color)
-        return frame      
-        
-        
-    #right-click popup menu for the Liststore(command list)
-    def right_click(self, widget, event, mw):
-        if event.button == 3:
-            x = int(event.x)
-            y = int(event.y)
-            time = event.time
-            pthinfo = mw.treeview.get_path_at_pos(x, y)
-            if pthinfo is not None:
-                path, col, cellx, celly = pthinfo
-                mw.treeview.grab_focus()
-                mw.treeview.set_cursor( path, col, 0)
-                
-                # right-click popup menu Apply(run)
-                popupMenu = gtk.Menu()
-                menuPopup1 = gtk.ImageMenuItem (gtk.STOCK_APPLY)
-                popupMenu.add(menuPopup1)
-                menuPopup1.connect("activate", lambda self, *x: mw.actions.run_command(mw))
-                # right-click popup menu Edit        
-                menuPopup2 = gtk.ImageMenuItem (gtk.STOCK_EDIT)
-                popupMenu.add(menuPopup2)
-                menuPopup2.connect("activate", lambda self, *x: mw.actions.edit_command(mw))
-                # right-click popup menu Delete                 
-                menuPopup3 = gtk.ImageMenuItem (gtk.STOCK_DELETE)
-                popupMenu.add(menuPopup3)
-                menuPopup3.connect("activate", lambda self, *x: mw.actions.remove_command(mw))
-                # right-click popup menu Help                
-                menuPopup4 = gtk.ImageMenuItem (gtk.STOCK_HELP)
-                popupMenu.add(menuPopup4)
-                menuPopup4.connect("activate", lambda self, *x: mw.actions.man_page(mw.notebook))
-                # Show popup menu
-                popupMenu.show_all()
-                popupMenu.popup( None, None, None, event.button, time)
-            return True          
-
-
+        self.show_all()

=== added file 'clicompanionlib/plugins.py'
--- clicompanionlib/plugins.py	1970-01-01 00:00:00 +0000
+++ clicompanionlib/plugins.py	2012-01-08 10:37:24 +0000
@@ -0,0 +1,207 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# plugins.py - Plugin related clases for the clicompanion
+#                                                                                                             
+# Copyright 2012 David Caro <[e-mail]>
+#                                                                                                             
+# This program is free software: you can redistribute it and/or modify it       
+# under the terms of the GNU General Public License version 3, as published     
+# by the Free Software Foundation.                                                                            
+#                                                                                                             
+# This program is distributed in the hope that it will be useful, but           
+# WITHOUT ANY WARRANTY; without even the implied warranties of                  
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.               
+#    
+#################################################
+## The plugins
+##
+## Here are defined the PluginLoader class and all the plugin base classes.
+##
+## The PluginLoader class
+## This class handles the loading and handpling of the plugins, it get a
+## directory and a list of the allowed plugins and loads all the allowed
+## plugins that it found on the dir *.py files (a plugin is a class that
+## inherits from the base class Plugin defined in this file).
+##
+## The Plugin class is the base class for all the plugins, if the plugin does
+## not inherit from that class, it will not be loaded.
+##
+## TabPlugin: This is a plugin that will be used as a tab in the upper notebook
+## of the application, like the LocalCommandList o CommandLineFU plugins
+##
+## PluginConfig: this will be the config tab in the preferences for the plugin.
+##
+## About the plugins:
+## The plugins have some attributes that should be set, like the __authors__,
+## and the __info__ attributes, that will be shown in the info page for the
+## plugin, and the __title__ that will be the plugin name shown in the plugins
+## list.
+
+import gobject
+import gtk
+import sys
+import os
+import inspect
+from clicompanionlib.utils import dbg
+
+
+class PluginLoader:
+    def __init__(self):
+        self.plugins = {}
+        self.allowed = []
+
+    def load(self, pluginsdir, allowed):
+        self.allowed = allowed
+        dbg('Allowing only the plugins %s' % allowed.__repr__())
+        sys.path.insert(0, pluginsdir)
+        try:
+            files = os.listdir(pluginsdir)
+        except OSError:
+            sys.path.remove(pluginsdir)
+            return False
+        for plugin in files:
+            pluginpath = os.path.join(pluginsdir, plugin)
+            if not os.path.isfile(pluginpath) or not  plugin[-3:] == '.py':
+                continue
+            dbg('Searching plugin file %s for plugins...' % plugin)
+            try:
+                module = __import__(plugin[:-3], globals(), locals(), [''])
+                for cname, mclass \
+                in inspect.getmembers(module, inspect.isclass):
+                    dbg('  Checking if class %s is a plugin.' % cname)
+                    if issubclass(mclass, Plugin):
+                        if cname not in self.plugins.keys():
+                            dbg('    Found plugin %s' % cname)
+                            self.plugins[cname] = mclass
+                            continue
+            except Exception, ex:
+                print 'Error searching plugin file %s: %s' % (plugin, ex)
+
+    def enable(self, plugins):
+        for plugin in plugins:
+            if plugin not in self.allowed:
+                self.allowed.append(plugin)
+
+    def get_plugins(self, capabilities=None):
+        plugins = []
+        if capabilities == None:
+            return [(pg, cs) for pg, cs in self.plugins.items()
+                        if pg in self.allowed()]
+        for plugin, pclass in self.plugins.items():
+            for capability in pclass.__capabilities__:
+                if capability in capabilities \
+                and plugin in self.allowed:
+                    plugins.append((plugin, pclass))
+                    dbg('Matching plugin %s for %s' % (plugin, capability))
+        return plugins
+
+    def get_plugin_conf(self, plugin):
+        if plugin + 'Config' in self.plugins:
+            return self.plugins[plugin + 'Config']
+
+    def is_enabled(self, plugin):
+        return plugin in self.allowed
+
+    def get_allowed(self):
+        return self.allowed
+
+    def get_disallowed(self):
+        disallowed = []
+        for plugin, pclass in self.plugins.items():
+            if plugin not in self.allowed \
+            and pclass.__capabilities__ != ['Config']:
+                disallowed.append(plugin)
+        return disallowed
+
+    def get_available_plugins(self):
+        return [pg for pg, cl
+                    in self.plugins.items()
+                    if ['Config'] == cl.__capabilities__]
+
+    def get_info(self, plugin):
+        if plugin in self.plugins.keys():
+            return self.plugins[plugin].__info__
+
+    def get_authors(self, plugin):
+        if plugin in self.plugins.keys():
+            return self.plugins[plugin].__authors__
+
+
+## To make all the classe sinherit from this one
+class Plugin(gtk.VBox):
+    def __init__(self):
+        gtk.VBox.__init__(self)
+
+
+class TabPlugin(Plugin):
+    '''
+    Generic Tab plugin that implements all the possible signals.
+    The *command signals are used to interact mainly with the LocalCommandList
+    plugin that handles the locally stored commands.
+    The add_tab is used to add  anew terminal tab.
+    '''
+    __gsignals__ = {
+         'run_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, str, str)),
+         'add_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, str, str)),
+         'remove_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, str, str)),
+         'edit_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, str, str)),
+         'add_tab': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'preferences': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'show_man': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str,)),
+         'quit': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         }
+    __capabilities__ = ['CommandTab']
+    __title__ = ''
+    __authors__ = ''
+    __info__ = ''
+
+    def reload(self):
+        '''
+        This method is called when a signal 'reload' is sent from it's
+        configurator
+        '''
+        pass
+
+    def get_command(self):
+        '''
+        This method is uset to retrieve a command, not sure if it's needed yet
+        '''
+        return None, None, None
+
+    def filter(self, string):
+        '''
+        This function is used to filter the commandslist, usually by the
+        search box
+        '''
+        pass
+
+
+class PluginConfig(Plugin):
+    '''
+    Generic plugin configuration window, to be used in the preferences plugins
+    tab
+    '''
+    __gsignals__ = {
+        ## when emited, this signal forces the reload of it's associated plugin
+        ## to reload the plugin config without having to restart the program
+         'reload': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ())
+         }
+    __capabilities__ = ['Config']
+
+    def __init__(self, config):
+        Plugin.__init__(self)
+        self.config = config

=== added file 'clicompanionlib/preferences.py'
--- clicompanionlib/preferences.py	1970-01-01 00:00:00 +0000
+++ clicompanionlib/preferences.py	2012-01-08 10:37:24 +0000
@@ -0,0 +1,708 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# preferences.py - Preferences dialogs for clicompanion
+#                                                                                                             
+# Copyright 2012 Duane Hinnen, Kenny Meyer, Marcos Vanettai, Marek Bardoński,
+#                David Caro <[e-mail]>
+#                                                                                                             
+# This program is free software: you can redistribute it and/or modify it       
+# under the terms of the GNU General Public License version 3, as published     
+# by the Free Software Foundation.                                                                            
+#                                                                                                             
+# This program is distributed in the hope that it will be useful, but           
+# WITHOUT ANY WARRANTY; without even the implied warranties of                  
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.               
+#    
+############################################
+## The preferences window is a popup that shows all the configuration options
+## allowing the user to change them, also handles the profiles creatin and
+## delete.
+##
+## The main class is the PreferencesWindow, that has all the other packed. Each
+## as a tab inside the preferences window.
+## The other classes are:
+##   - PluginsTab: handles the plugin activation and configuration
+##   - KeybindingsTab: handles the keybindings
+##   - ProfilesTab: The main tab for the profiles setting, this class is a
+##                   notebook with three classes (tabs) packed
+##      - ProfScrollingTab: the scrolling options tab inside the profiles tab
+##      - ProfColorsTab: the colors tab
+##      - ProfGeneralTab: the general setting tab
+##
+## About the profiles: each profile is a configuration section in the config
+## file with the name 'profile::profilename', having always the profile
+## 'profile::default', the will have all the default options (if it is not
+## found, it will be created with the harcoded options inside the code.
+
+import pygtk
+pygtk.require('2.0')
+import gtk
+import gobject
+import clicompanionlib.config as cc_config
+import clicompanionlib.utils as cc_utils
+from clicompanionlib.utils import dbg
+
+COLOR_SCHEMES = {
+        'Grey on Black': ['#aaaaaa', '#000000'],
+        'Black on Yellow': ['#000000', '#ffffdd'],
+        'Black on White': ['#000000', '#ffffff'],
+        'White on Black': ['#ffffff', '#000000'],
+        'Green on Black': ['#00ff00', '#000000'],
+        'Orange on Black': ['#e53c00', '#000000'],
+        'Custom': []
+        }
+
+
+def color2hex(color_16b):
+    """
+    Pull the colour values out of a Gtk ColorPicker widget and return them
+    as 8bit hex values, sinces its default behaviour is to give 16bit values
+    """
+    return('#%02x%02x%02x' % (color_16b.red >> 8,
+                              color_16b.green >> 8,
+                              color_16b.blue >> 8))
+
+
+class ProfGeneralTab(gtk.VBox):
+    def __init__(self, config, profile='default'):
+        gtk.VBox.__init__(self)
+        self.config = config
+        self.profile = profile
+        self.draw_all()
+
+    def draw_all(self):
+        ## 'use_system_font'
+        self.systemfont = gtk.CheckButton(label=_('Use system fixed'
+                                                  'width font'))
+        self.pack_start(self.systemfont, False, False, 8)
+        self.systemfont.set_active(
+                self.config.getboolean('profile::' + self.profile,
+                                       'use_system_font'))
+        self.systemfont.connect('toggled', lambda *x: self.update_font_btn())
+
+        ## 'font'
+        font_box = gtk.HBox()
+        font_box.pack_start(gtk.Label('Font:'), False, False, 8)
+        self.fontbtn = gtk.FontButton(self.config.get('profile::'
+                                            + self.profile, 'font'))
+        font_box.pack_start(self.fontbtn, False, False, 8)
+        self.pack_start(font_box, False, False, 8)
+        ## 'bold_text'
+        self.bold_text = gtk.CheckButton(label=_('Allow bold text'))
+        self.pack_start(self.bold_text, False, False, 8)
+        self.bold_text.set_active(self.config.getboolean('profile::'
+                                                + self.profile, 'bold_text'))
+        ## 'antialias'
+        self.antialias = gtk.CheckButton(label=_('Anti-alias text'))
+        self.pack_start(self.antialias, False, False, 8)
+        self.antialias.set_active(self.config.getboolean('profile::'
+                                                + self.profile, 'antialias'))
+        ## 'sel_word'
+        sel_word_box = gtk.HBox()
+        sel_word_box.pack_start(gtk.Label('Select-by-word characters:'))
+        self.sel_word_text = gtk.Entry()
+        self.sel_word_text.set_text(self.config.get('profile::'
+                                                + self.profile, 'sel_word'))
+        sel_word_box.pack_start(self.sel_word_text, False, False, 0)
+        self.pack_start(sel_word_box, False, False, 8)
+        ## System subsection
+        sys_lbl = gtk.Label()
+        sys_lbl.set_markup('<b>System Configuration</b>')
+        self.pack_start(sys_lbl, False, False, 4)
+        ## 'update_login_records'
+        self.update_login_records = gtk.CheckButton(
+                                        label=_('Update login records'))
+        self.pack_start(self.update_login_records, False, False, 8)
+        self.update_login_records.set_active(
+            self.config.getboolean('profile::' + self.profile,
+                                    'update_login_records'))
+        self.update_font_btn()
+
+    def update_font_btn(self):
+        if self.systemfont.get_active():
+            self.fontbtn.set_sensitive(False)
+        else:
+            self.fontbtn.set_sensitive(True)
+
+    def save_changes(self):
+        if 'profile::' + self.profile in self.config.sections():
+            self.config.set('profile::' + self.profile,
+                'use_system_font', '%s' % self.systemfont.get_active())
+            self.config.set('profile::' + self.profile,
+                'font', '%s' % self.fontbtn.get_font_name())
+            self.config.set('profile::' + self.profile,
+                'bold_text', '%s' % self.bold_text.get_active())
+            self.config.set('profile::' + self.profile,
+                'antialias', '%s' % self.antialias.get_active())
+            self.config.set('profile::' + self.profile,
+                'sel_word', self.sel_word_text.get_text())
+            self.config.set('profile::' + self.profile,
+                'update_login_records',
+                '%s' % self.update_login_records.get_active())
+
+    def set_profile(self, profile='default'):
+        self.save_changes()
+        if profile != self.profile:
+            self.profile = profile
+            self.update()
+            self.show_all()
+
+    def update(self):
+        for child in self.get_children():
+            self.remove(child)
+        self.draw_all()
+
+
+class ProfColorsTab(gtk.VBox):
+    def __init__(self, config, profile='default'):
+        gtk.VBox.__init__(self)
+        self.config = config
+        self.profile = profile
+        self.draw_all()
+
+    def draw_all(self):
+        ## 'use_system_colors'
+        self.systemcols = gtk.CheckButton(
+                            label=_('Use colors from system theme'))
+        self.pack_start(self.systemcols, False, False, 8)
+        self.systemcols.set_active(
+                self.config.getboolean('profile::' + self.profile,
+                                       'use_system_colors'))
+        self.systemcols.connect('toggled', lambda *x: self.update_sys_colors())
+
+        ## 'color_scheme'
+        hbox = gtk.HBox()
+        hbox.pack_start(gtk.Label('Color scheme:'), False, False, 8)
+        self.colsch_combo = gtk.combo_box_new_text()
+        color_scheme = self.config.get('profile::' + self.profile,
+                                        'color_scheme')
+        self.colsch_combo.append_text('Custom')
+        if color_scheme == 'Custom':
+            self.colsch_combo.set_active(0)
+        hbox.pack_start(self.colsch_combo, False, False, 8)
+        i = 0
+        for cs, colors in COLOR_SCHEMES.items():
+            i = i + 1
+            self.colsch_combo.append_text(cs)
+            if color_scheme == cs:
+                self.colsch_combo.set_active(i)
+        self.pack_start(hbox, False, False, 8)
+        self.colsch_combo.connect('changed',
+                lambda *x: self.update_color_btns())
+
+        ## 'colorf'
+        hbox = gtk.HBox()
+        hbox.pack_start(gtk.Label('Font color:'), False, False, 8)
+        self.colorf = gtk.ColorButton()
+        hbox.pack_start(self.colorf, False, False, 8)
+        self.pack_start(hbox, False, False, 8)
+        self.colorf.connect('color-set', lambda *x: self.update_custom_color())
+
+        ## 'colorb'
+        hbox = gtk.HBox()
+        hbox.pack_start(gtk.Label('Background color:'), False, False, 8)
+        self.colorb = gtk.ColorButton()
+        hbox.pack_start(self.colorb, False, False, 8)
+        self.pack_start(hbox, False, False, 8)
+        self.colorb.connect('color-set', lambda *x: self.update_custom_color())
+
+        self.update_sys_colors()
+
+    def update_sys_colors(self):
+        if not self.systemcols.get_active():
+            self.colsch_combo.set_sensitive(True)
+            self.update_color_btns()
+        else:
+            self.colsch_combo.set_sensitive(False)
+            self.update_color_btns()
+            self.colorb.set_sensitive(False)
+            self.colorf.set_sensitive(False)
+
+    def update_color_btns(self):
+        color_scheme = self.colsch_combo.get_active_text()
+        if color_scheme != 'Custom':
+            self.colorb.set_sensitive(False)
+            self.colorf.set_sensitive(False)
+            self.colorf.set_color(gtk.gdk.color_parse(
+                    COLOR_SCHEMES[color_scheme][0]))
+            self.colorb.set_color(gtk.gdk.color_parse(
+                    COLOR_SCHEMES[color_scheme][1]))
+        else:
+            self.colorb.set_sensitive(True)
+            self.colorf.set_sensitive(True)
+            self.colorf.set_color(gtk.gdk.color_parse(
+                    self.config.get('profile::' + self.profile, 'colorf')))
+            self.colorb.set_color(gtk.gdk.color_parse(
+                    self.config.get('profile::' + self.profile, 'colorb')))
+
+    def update_custom_color(self):
+        color_scheme = self.colsch_combo.get_active_text()
+        if color_scheme == 'Custom':
+            self.config.set('profile::' + self.profile, 'colorf',
+                    color2hex(self.colorf.get_color()))
+            self.config.set('profile::' + self.profile, 'colorb',
+                    color2hex(self.colorb.get_color()))
+
+    def save_changes(self):
+        if 'profile::' + self.profile in self.config.sections():
+            self.config.set('profile::' + self.profile, 'use_system_colors',
+                    self.systemcols.get_active().__repr__())
+            self.config.set('profile::' + self.profile, 'color_scheme',
+                    self.colsch_combo.get_active_text())
+            if self.colsch_combo.get_active_text() == 'Custom':
+                self.config.set('profile::' + self.profile, 'colorf',
+                        color2hex(self.colorf.get_color()))
+                self.config.set('profile::' + self.profile, 'colorb',
+                        color2hex(self.colorb.get_color()))
+
+    def set_profile(self, profile='default'):
+        self.save_changes()
+        if profile != self.profile:
+            self.profile = profile
+            self.update()
+            self.show_all()
+
+    def update(self):
+        for child in self.get_children():
+            self.remove(child)
+        self.draw_all()
+
+
+class ProfScrollingTab(gtk.VBox):
+    def __init__(self, config, profile='default'):
+        gtk.VBox.__init__(self)
+        self.config = config
+        self.profile = 'profile::' + profile
+        self.draw_all()
+
+    def draw_all(self):
+        hbox = gtk.HBox()
+        hbox.pack_start(gtk.Label('Number of history lines:'), False, False, 8)
+        self.scrollb_sb = gtk.SpinButton(
+            adjustment=gtk.Adjustment(upper=9999, step_incr=1))
+        self.scrollb_sb.set_wrap(True)
+        self.scrollb_sb.set_numeric(True)
+        self.scrollb_sb.set_value(self.config.getint(self.profile, 'scrollb'))
+        hbox.pack_start(self.scrollb_sb, False, False, 8)
+        self.pack_start(hbox, False, False, 8)
+
+    def set_profile(self, profile='default'):
+        if 'profile::' + profile != self.profile:
+            self.profile = 'profile::' + profile
+            self.update()
+            self.show_all()
+
+    def update(self):
+        for child in self.get_children():
+            self.remove(child)
+        self.draw_all()
+
+    def save_changes(self):
+        if self.profile in self.config.sections():
+            dbg('Setting scrollb to %d' % int(self.scrollb_sb.get_value()))
+            self.config.set(self.profile,
+                    'scrollb',
+                    str(int(self.scrollb_sb.get_value())))
+
+
+class ProfilesTab(gtk.HBox):
+    def __init__(self, config):
+        gtk.HBox.__init__(self)
+        self.config = config
+        self.tabs = []
+        self.gprofs = 0
+
+        vbox = gtk.VBox()
+        self.proflist = gtk.TreeView(gtk.ListStore(str))
+        self.init_proflist()
+        hbox = gtk.HBox()
+        add_btn = gtk.Button()
+        add_btn.add(self.get_img_box('Add', gtk.STOCK_ADD))
+        add_btn.connect('clicked', lambda *x: self.add_profile())
+        del_btn = gtk.Button()
+        del_btn.add(self.get_img_box('Remove', gtk.STOCK_DELETE))
+        del_btn.connect('clicked', lambda *x: self.del_profile())
+        hbox.pack_start(add_btn, False, False, 0)
+        hbox.pack_start(del_btn, False, False, 0)
+
+        vbox.pack_start(self.proflist, True, True, 0)
+        vbox.pack_start(hbox, False, False, 0)
+        self.pack_start(vbox)
+
+        self.tabs.append(('General', ProfGeneralTab(config)))
+        self.tabs.append(('Colors', ProfColorsTab(config)))
+        self.tabs.append(('Scrolling', ProfScrollingTab(config)))
+
+        self.options = gtk.Notebook()
+        for name, tab in self.tabs:
+            self.options.append_page(tab, gtk.Label(_(name)))
+
+        self.proflist.connect('cursor-changed', lambda *x: self.update_tabs())
+        self.pack_start(self.options)
+
+    def get_img_box(self, text, img):
+        box = gtk.HBox()
+        image = gtk.Image()
+        image.set_from_stock(img, gtk.ICON_SIZE_BUTTON)
+        label = gtk.Label(text)
+        box.pack_start(image, False, False, 0)
+        box.pack_start(label, False, False, 0)
+        return box
+
+    def add_text_col(self, colname, n=0):
+        col = gtk.TreeViewColumn()
+        col.set_title(_(colname))
+        self.render = gtk.CellRendererText()
+        self.render.connect('edited',
+                lambda cell, path, text: self.added_profile(path, text))
+        col.pack_start(self.render, expand=True)
+        col.add_attribute(self.render, 'text', n)
+        col.set_resizable(True)
+        col.set_sort_column_id(n)
+        self.proflist.append_column(col)
+
+    def init_proflist(self):
+        self.add_text_col('Profile')
+        model = self.proflist.get_model()
+        for section in self.config.sections():
+            if section.startswith('profile::'):
+                last = model.append((section[9:],))
+                if section == 'profile::default':
+                    self.proflist.set_cursor_on_cell(
+                        model.get_path(last),
+                        self.proflist.get_column(0))
+                self.gprofs += 1
+
+    def update_tabs(self):
+        selection = self.proflist.get_selection()
+        model, iterator = selection.get_selected()
+        if not iterator:
+            return
+        profile = model.get(iterator, 0)[0]
+        for name, tab in self.tabs:
+            if 'profile::' + profile in self.config.sections():
+                tab.set_profile(profile)
+
+    def save_all(self):
+        for name, tab in self.tabs:
+            tab.save_changes()
+
+    def add_profile(self):
+        self.gprofs += 1
+        model = self.proflist.get_model()
+        iterator = model.append(('New Profile %d' % self.gprofs,))
+        self.render.set_property('editable', True)
+        self.proflist.grab_focus()
+        self.proflist.set_cursor_on_cell(model.get_path(iterator),
+                self.proflist.get_column(0),
+                start_editing=True)
+
+    def added_profile(self, path, text):
+        dbg('Added profile %s' % text)
+        if 'profile::' + text in self.config.sections():
+            return
+        model = self.proflist.get_model()
+        model[path][0] = text
+        self.render.set_property('editable', False)
+        self.config.add_section('profile::' + text)
+        self.update_tabs()
+
+    def del_profile(self):
+        selection = self.proflist.get_selection()
+        model, iterator = selection.get_selected()
+        profile = model.get(iterator, 0)[0]
+        if profile != 'default':
+            self.config.remove_section('profile::' + profile)
+            model.remove(iterator)
+
+
+class KeybindingsTab(gtk.VBox):
+    def __init__(self, config):
+        gtk.VBox.__init__(self)
+        self.config = config
+        self.draw_all()
+
+    def draw_all(self):
+        self.labels = []
+        for kb_func, kb_name in cc_config.KEY_BINDINGS.items():
+            hbox = gtk.HBox()
+            lbl = gtk.Label(_(kb_name))
+            self.labels.append(lbl)
+            btn = gtk.Button(self.config.get('keybindings', kb_func))
+            btn.connect('clicked',
+                lambda wg, func: self.get_key(func), kb_func)
+            btn.set_size_request(100, -1)
+            hbox.pack_start(btn, False, False, 8)
+            del_btn = gtk.Button()
+            del_img = gtk.Image()
+            del_img.set_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_BUTTON)
+            del_btn.add(del_img)
+            del_btn.connect('clicked',
+                lambda wg, func: self.get_key(func, 'not used'), kb_func)
+            hbox.pack_start(del_btn, False, False, 8)
+            hbox.pack_start(lbl, True, True, 8)
+            self.pack_start(hbox)
+
+    def update(self):
+        for child in self.children():
+            self.remove(child)
+        self.draw_all()
+        self.show_all()
+
+    def get_key(self, func, key=None):
+        if key != None:
+            self.config.set('keybindings', func, key)
+            self.update()
+            return
+        self.md = gtk.Dialog("Press the new key for '%s'" % func,
+                    None,
+                    gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
+        lbl = gtk.Label('Press a key')
+        self.md.get_content_area().pack_start((lbl), True, True, 0)
+        lbl.set_size_request(100, 100)
+        self.md.connect('key-press-event',
+            lambda w, event: self.key_pressed(func, event, lbl))
+        self.md.connect('key-release-event',
+            lambda w, event: self.key_released(event, lbl))
+        self.md.show_all()
+        self.md.run()
+
+    def key_released(self, event, lbl):
+        keycomb = cc_utils.get_keycomb(event)
+        combname = ''
+        activemods = keycomb.split('+')[:-1]
+        released = keycomb.rsplit('+', 1)[-1]
+        mods = {'shift': 'shift',
+                 'control': 'ctrl',
+                 'alt': 'alt',
+                 'super': 'super'}
+        for mod in mods.keys():
+            if mod in released.lower():
+                if mods[mod] in activemods:
+                    activemods.pop(activemods.index(mods[mod]))
+        combname = '+'.join(activemods) + '+'
+        if combname == '+':
+            combname = 'Press a key'
+        lbl.set_text(combname)
+
+    def key_pressed(self, func, event, lbl):
+        keycomb = cc_utils.get_keycomb(event)
+        if not cc_utils.only_modifier(event):
+            self.md.destroy()
+            self.config.set('keybindings', func, keycomb)
+            self.update()
+        else:
+            combname = ''
+            activemods = keycomb.split('+')[:-1]
+            pressed = keycomb.rsplit('+', 1)[-1]
+            mods = {'shift': 'shift',
+                     'control': 'ctrl',
+                     'alt': 'alt',
+                     'super': 'super'}
+            for mod in mods.keys():
+                if mod in pressed.lower():
+                    if mods[mod] not in activemods:
+                        activemods.append(mods[mod])
+            combname = '+'.join(activemods) + '+'
+            if combname == '+':
+                combname = 'Press a key'
+            lbl.set_text(combname)
+
+    def save_all(self):
+        pass
+
+
+class PluginsTab(gtk.HBox):
+    __gsignals__ = {
+         'changed-plugin': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, ))
+         }
+
+    def __init__(self, config, plugins):
+        gtk.HBox.__init__(self)
+        self.config = config
+        self.plugins = plugins
+
+        self.pluginlist = gtk.TreeView(gtk.ListStore(bool, str))
+        first = self.init_pluginlist()
+        self.pack_start(self.pluginlist, False, False, 8)
+
+        self.infonb = gtk.Notebook()
+        self.generate_infotabs(first)
+        self.pack_start(self.infonb, True, True, 8)
+
+        self.pluginlist.connect('row_activated',
+                lambda *x: self.toggle_plugin())
+        self.pluginlist.connect('cursor-changed',
+                lambda *x: self.update_info())
+
+    def init_pluginlist(self):
+        self.add_cbox_col('Enabled', 0)
+        self.add_text_col('Plugin Name', 1)
+        model = self.pluginlist.get_model()
+        first = None
+        for plugin in self.plugins.get_allowed():
+            if not first:
+                first = plugin
+            model.append((True, plugin))
+        for plugin in self.plugins.get_disallowed():
+            if not first:
+                first = plugin
+            model.append((False, plugin))
+        self.pluginlist.set_cursor((0,))
+        return first
+
+    def add_cbox_col(self, colname, n=0):
+        col = gtk.TreeViewColumn()
+        col.set_title(_(colname))
+        render = gtk.CellRendererToggle()
+        col.pack_start(render, expand=True)
+        col.add_attribute(render, 'active', n)
+        col.set_resizable(True)
+        col.set_sort_column_id(n)
+        self.pluginlist.append_column(col)
+
+    def add_text_col(self, colname, n=0):
+        col = gtk.TreeViewColumn()
+        col.set_title(_(colname))
+        render = gtk.CellRendererText()
+        col.pack_start(render, expand=True)
+        col.add_attribute(render, 'text', n)
+        col.set_resizable(True)
+        col.set_sort_column_id(n)
+        self.pluginlist.append_column(col)
+
+    def toggle_plugin(self):
+        selection = self.pluginlist.get_selection()
+        model, iterator = selection.get_selected()
+        oldvalue, plugin = model.get(iterator, 0, 1)
+        if plugin == 'LocalCommandList':
+            self.show_warning()
+            return
+        model.set(iterator, 0, not oldvalue)
+
+    def generate_infotabs(self, plugin):
+        '''
+        Adds the plugins info and config page (if any) to the plugins info
+        notebook
+        '''
+        confplg = self.plugins.get_plugin_conf(plugin)
+
+        if confplg:
+            conf_tab = confplg(self.config.get_plugin_conf(plugin))
+            self.infonb.append_page(
+                    conf_tab,
+                    gtk.Label(_('Configutarion')))
+            conf_tab.connect('reload',
+                lambda wg, pl: self.emit('changed-plugin', plugin),
+                plugin)
+
+        self.infonb.append_page(self.generate_infopage(plugin),
+                    gtk.Label(_('About')))
+
+    def generate_infopage(self, plugin):
+        '''
+        Generates the plugins info page
+        '''
+        info = self.plugins.get_info(plugin)
+        authors = self.plugins.get_authors(plugin)
+        page = gtk.TextView()
+        page.set_wrap_mode(gtk.WRAP_WORD)
+        page.set_editable(False)
+        buffer = page.get_buffer()
+        scrolled_window = gtk.ScrolledWindow()
+        scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+        scrolled_window.add(page)
+        iter = buffer.get_iter_at_offset(0)
+        buffer.insert(iter, info + '\n\nAuthors:\n' + authors)
+        return scrolled_window
+
+    def update_info(self):
+        selection = self.pluginlist.get_selection()
+        model, iterator = selection.get_selected()
+        enabled, plugin = model.get(iterator, 0, 1)
+        for child in self.infonb.get_children():
+            self.infonb.remove(child)
+        self.generate_infotabs(plugin)
+        self.show_all()
+
+    def save_all(self):
+        newenabled = []
+        model = self.pluginlist.get_model()
+        elem = model.get_iter_first()
+        while elem:
+            enabled, plugin = model.get(elem, 0, 1)
+            if enabled:
+                newenabled.append(plugin)
+            elem = model.iter_next(elem)
+        self.config.set('general::default', 'plugins', ', '.join(newenabled))
+
+    def show_warning(self):
+        dlg = gtk.MessageDialog(
+                     None,
+                     gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+                     gtk.MESSAGE_ERROR,
+                     gtk.BUTTONS_CLOSE,
+                     message_format=_('Can\'t disable "LocalCommandList'))
+        dlg.format_secondary_text(_('The plugin "LocalCommandList is the main'
+            ' plugin for CLI Companion, and can\'t be disalbed, sorry.'))
+        dlg.run()
+        dlg.destroy()
+
+
+class PreferencesWindow(gtk.Dialog):
+    '''
+    Preferences window, the tabs are needed for the preview
+    '''
+    __gsignals__ = {
+         'preview': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, str))
+         }
+
+    def __init__(self, config, plugins):
+        gtk.Dialog.__init__(self, _("User Preferences"),
+                     None,
+                     gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+                     (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
+                      gtk.STOCK_OK, gtk.RESPONSE_OK))
+        self.config = config
+        self.plugins = plugins
+        self.config_bkp = self.config.get_config_copy()
+        self.changed_plugins = []
+
+        mainwdg = self.get_content_area()
+        self.tabs = gtk.Notebook()
+        mainwdg.pack_start(self.tabs, True, True, 0)
+
+        ## profiles
+        proftab = ProfilesTab(config)
+        self.tabs.append_page(proftab, gtk.Label('Profiles'))
+        ## keybindings
+        keybind_tab = KeybindingsTab(config)
+        self.tabs.append_page(keybind_tab, gtk.Label('Keybindings'))
+        ## plugins
+        plug_tab = PluginsTab(config, plugins)
+        plug_tab.connect('changed-plugin',
+            lambda wg, pl: self.mark_changed_plugins(pl))
+        self.tabs.append_page(plug_tab, gtk.Label('Plugins'))
+
+    def mark_changed_plugins(self, plugin):
+        if plugin not in self.changed_plugins:
+            self.changed_plugins.append(plugin)
+
+    def run(self):
+        self.show_all()
+        response = gtk.Dialog.run(self)
+        if response == gtk.RESPONSE_OK:
+            for i in range(self.tabs.get_n_pages()):
+                self.tabs.get_nth_page(i).save_all()
+            config = self.config
+        else:
+            config = None
+        self.destroy()
+        return config, self.changed_plugins

=== modified file 'clicompanionlib/tabs.py'
--- clicompanionlib/tabs.py	2012-01-02 00:23:11 +0000
+++ clicompanionlib/tabs.py	2012-01-08 10:37:24 +0000
@@ -1,6 +1,9 @@
 #!/usr/bin/env python
-#
-# Copyright 2010 Duane Hinnen, Kenny Meyer, Marcos Vanetta
+# -*- coding: utf-8 -*-
+#
+# tabs.py - Terminal tab handling classes for clicompanion
+#
+# Copyright 2010 Duane Hinnen, Kenny Meyer, Marcos Vanetta, David Caro
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -15,6 +18,14 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 #
+# This file contains the classes used to provide the terminals secion of the
+# main window.
+#
+# TerminalTab: This class implements one tab of the terminals notebook, with
+# it's own profile and vte associated.
+#
+# TerminalsNotebook: This class implements the notebook, where the terminals
+# will be added.
 #
 
 import os
@@ -22,157 +33,388 @@
 pygtk.require('2.0')
 import gtk
 import vte
-import clicompanionlib.config as cc_config
-
-from clicompanionlib.utils import get_user_shell, dbg
-import clicompanionlib.controller
-import clicompanionlib.utils as utils
+import re
 import view
-
-
-class Tabs(object):
-    '''
-    add a new terminal in a tab above the current terminal
-    '''
-    def __init__(self):
-        #definition nop - (no of pages) reflects no of terminal tabs left (some may be closed by the user)
-        self.nop = 0
-        #definition gcp - how many pages is visible
+import gobject
+import pango
+import gconf
+from clicompanionlib.utils import dbg
+import clicompanionlib.utils as cc_utils
+import clicompanionlib.helpers as cc_helpers
+import clicompanionlib.preferences as cc_pref
+
+
+class TerminalTab(gtk.ScrolledWindow):
+    __gsignals__ = {
+         'quit': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'add_tab': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'rename': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, )),
+         'preferences': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+    }
+
+    def __init__(self, title, config, profile='default'):
+        gtk.ScrolledWindow.__init__(self)
+        self.config = config
+        self.title = title
+        self.profile = 'profile::' + profile
+        self.vte = vte.Terminal()
+        self.add(self.vte)
+        self.vte.connect("child-exited", lambda *x: self.emit('quit'))
+        self.update_records = self.config.getboolean(self.profile,
+                                        'update_login_records')
+        dbg('Updating login records: ' + self.update_records.__repr__())
+        self.vte.fork_command(cc_utils.shell_lookup(),
+           logutmp=self.update_records,
+           logwtmp=self.update_records,
+           loglastlog=self.update_records)
+        self.vte.connect("button_press_event", self.copy_paste_menu)
+        self.update_config()
+        self.show_all()
+
+    def update_config(self, config=None, preview=False):
+        if not config:
+            config = self.config
+        elif not preview:
+            self.config = config
+        if self.profile not in config.sections():
+            self.profile = 'profile::default'
+            if self.profile not in config.sections():
+                config.add_section(self.profile)
+        dbg(self.profile)
+        dbg(','.join([config.get(self.profile, option)
+                     for option in config.options(self.profile)]))
+
+        ## Scrollback
+        try:
+            config_scrollback = config.getint(self.profile, 'scrollb')
+        except ValueError:
+            print _("WARNING: Invalid value for property '%s', int expected:"
+                    " got '%s', using default '%s'") % (
+                        'scrollb',
+                        config.get(self.profile, 'scrollb'),
+                        config.get('DEFAULT', 'scrollb'))
+            config.set(self.profile, 'scrollb',
+                        config.get('DEFAULT', 'scrollb'))
+            config_scrollback = config.getint('DEFAULT', 'scrollb')
+        self.vte.set_scrollback_lines(config_scrollback)
+
+        color = ('#2e3436:#cc0000:#4e9a06:#c4a000:#3465a4:#75507b:#06989a:'
+                '#d3d7cf:#555753:#ef2929:#8ae234:#fce94f:#729fcf:#ad7fa8:'
+                '#34e2e2:#eeeeec')
+        colors = color.split(':')
+        palette = []
+        for color in colors:
+            if color:
+                palette.append(gtk.gdk.color_parse(color))
+
+        #### Colors
+        if config.getboolean(self.profile, 'use_system_colors'):
+            config_color_fore = self.vte.get_style().text[gtk.STATE_NORMAL]
+            config_color_back = self.vte.get_style().base[gtk.STATE_NORMAL]
+        else:
+            color_scheme = config.get(self.profile, 'color_scheme')
+            if color_scheme != 'Custom':
+                fgcolor, bgcolor = cc_pref.COLOR_SCHEMES[color_scheme]
+            else:
+                fgcolor = config.get(self.profile, 'colorf')
+                bgcolor = config.get(self.profile, 'colorb')
+
+            try:
+                config_color_fore = gtk.gdk.color_parse(fgcolor)
+            except ValueError, e:
+                print _("WARNING: Invalid value for property '%s':"
+                        " got '%s', using default '%s'.") % (
+                            'colorf',
+                            fgcolor,
+                            config.get('DEFAULT', 'colorf'))
+                config.set(self.profile, 'colorf',
+                            config.get('DEFAULT', 'colorf'))
+                config_color_fore = gtk.gdk.color_parse(config.get('DEFAULT',
+                                                            'colorf'))
+
+            try:
+                config_color_back = gtk.gdk.color_parse(bgcolor)
+            except ValueError, e:
+                print _("WARNING: Invalid value for property '%s':"
+                        " got '%s', using default '%s'.") % (
+                            'colorb',
+                            bgcolor,
+                            config.get('DEFAULT', 'colorb'))
+                config.set(self.profile, 'colorb',
+                        config.get('DEFAULT', 'colorb'))
+                config_color_back = gtk.gdk.color_parse(config.get('DEFAULT',
+                                                        'colorb'))
+        self.vte.set_colors(config_color_fore, config_color_back, palette)
+
+        ### Encoding
+        config_encoding = config.get(self.profile, 'encoding')
+        if config_encoding.upper() not in [enc.upper()
+                                          for enc, desc
+                                          in cc_utils.encodings]:
+            print _("WARNING: Invalid value for property '%s':"
+                    " got '%s', using default '%s'") \
+                    % ('encoding', config_encoding,
+                        config.get('DEFAULT', 'encoding'))
+            config.set(self.profile, 'encoding',
+                        config.get('DEFAULT', 'encoding'))
+            config_encoding = config.get('DEFAULT', 'encoding')
+        self.vte.set_encoding(config_encoding)
+
+        ## Font
+        if config.getboolean(self.profile, 'use_system_font'):
+            fontname = cc_utils.get_system_font(
+                        lambda *x: self.update_config())
+        else:
+            fontname = config.get(self.profile, 'font')
+        font = pango.FontDescription(fontname)
+        if not font or not fontname:
+            print _("WARNING: Invalid value for property '%s':"
+                    " got '%s', using default '%s'") % (
+                        'font',
+                        fontname,
+                        cc_utils.get_system_font())
+            config.set('DEFAULT', 'font', c_utils.get_system_font())
+            fontname = config.get('DEFAULT', 'font')
+        font = pango.FontDescription(fontname)
+        if font:
+            self.vte.set_font_full(font,
+                                  config.getboolean(self.profile, 'antialias'))
+
+        update_records = config.getboolean(self.profile,
+                                           'update_login_records')
+        if update_records != self.update_records:
+            if not preview:
+                self.update_records = update_records
+            dbg('Updating login records: ' + update_records.__repr__())
+            self.vte.feed('\n\r')
+            self.vte.fork_command(cc_utils.shell_lookup(),
+               logutmp=update_records,
+               logwtmp=update_records,
+               loglastlog=update_records)
+
+        self.vte.set_allow_bold(config.getboolean(self.profile, 'bold_text'))
+        self.vte.set_word_chars(config.get(self.profile, 'sel_word'))
+
+    def copy_paste_menu(self, vte, event):
+        if event.button == 3:
+            time = event.time
+            ## right-click popup menu Copy
+            popupMenu = gtk.Menu()
+            menuPopup1 = gtk.ImageMenuItem(gtk.STOCK_COPY)
+            popupMenu.add(menuPopup1)
+            menuPopup1.connect('activate', lambda x: vte.copy_clipboard())
+            ## right-click popup menu Paste
+            menuPopup2 = gtk.ImageMenuItem(gtk.STOCK_PASTE)
+            popupMenu.add(menuPopup2)
+            menuPopup2.connect('activate', lambda x: vte.paste_clipboard())
+            ## right-click popup menu Rename
+            menuPopup3 = gtk.ImageMenuItem(gtk.STOCK_EDIT)
+            menuPopup3.set_label(_('Rename'))
+            popupMenu.add(menuPopup3)
+            menuPopup3.connect('activate', lambda x: self.rename())
+            ## right-click popup menu Add Tab
+            menuPopup3 = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
+            menuPopup3.set_label(_('Configure'))
+            popupMenu.add(menuPopup3)
+            menuPopup3.connect('activate', lambda x: self.emit('preferences'))
+            ## right-click popup menu Add Tab
+            menuPopup3 = gtk.ImageMenuItem(gtk.STOCK_ADD)
+            menuPopup3.set_label(_('Add tab'))
+            popupMenu.add(menuPopup3)
+            menuPopup3.connect('activate', lambda x: self.emit('add_tab'))
+            ## right-click popup menu Profiles
+            menuit_prof = gtk.MenuItem()
+            menuit_prof.set_label(_('Profiles'))
+            submenu_prof = gtk.Menu()
+            menuit_prof.set_submenu(submenu_prof)
+            popupMenu.add(menuit_prof)
+            for section in self.config.sections():
+                if section.startswith('profile::'):
+                    subitem = gtk.MenuItem()
+                    subitem.set_label(_(section[9:]))
+                    submenu_prof.add(subitem)
+                    subitem.connect('activate',
+                        lambda wg, *x: self.change_profile(
+                            wg.get_label()))
+            ## right-click popup menu Close Tab
+            menuPopup3 = gtk.ImageMenuItem(gtk.STOCK_CLOSE)
+            menuPopup3.set_label(_('Close tab'))
+            popupMenu.add(menuPopup3)
+            menuPopup3.connect('activate', lambda x: self.emit('quit'))
+            ## Show popup menu
+            popupMenu.show_all()
+            popupMenu.popup(None, None, None, event.button, time)
+            return True
+
+    def rename(self):
+        dlg = gtk.Dialog("Enter the new name",
+                   None,
+                   gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+                   (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
+                    gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
+        entry = gtk.Entry()
+        entry.connect("activate", lambda *x: dlg.response(gtk.RESPONSE_ACCEPT))
+        entry.set_text(self.title)
+        dlg.vbox.pack_start(entry)
+        dlg.show_all()
+        response = dlg.run()
+        if response == gtk.RESPONSE_ACCEPT:
+            text = entry.get_text()
+            self.emit('rename', text)
+        dlg.destroy()
+
+    def run_command(self, cmd, ui, desc):
+        if not cmd:
+            dbg('Empty command... doing nothing')
+            return
+        '''
+        Make sure user arguments were found. Replace ? with something
+        .format can read. This is done so the user can just enter ?, when
+        adding a command where arguments are needed, instead
+        of {0[1]}, {0[1]}, {0[2]}
+        '''
+        ## find how many ?(user arguments) are in command
+        match = re.findall('\?', cmd)
+        if match:
+            num = len(match)
+            ran = 0
+            new_cmd = cc_utils.replace(cmd, num, ran)
+
+        if len(match) > 0:  # command with user input
+            dbg('command with ui')
+            cmd_info_win = cc_helpers.CommandInfoWindow(new_cmd, ui, desc)
+            cmd = cmd_info_win.run()
+            if cmd == None:
+                return
+        self.vte.feed_child(cmd + "\n")  # send command
+        self.show()
+        self.grab_focus()
+
+    def change_profile(self, profile):
+        dbg(profile)
+        self.profile = 'profile::' + profile
+        self.update_config()
+
+
+class TerminalsNotebook(gtk.Notebook):
+    __gsignals__ = {
+         'quit': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'preferences': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+    }
+
+    def __init__(self, config):
+        gtk.Notebook.__init__(self)
+        #definition gcp - global page count, how many pages have been created
         self.gcp = 0
-
-    def add_tab(self, notebook):
+        self.global_config = config
+        ## The "Add Tab" tab
+        add_tab_button = gtk.Button("+")
+        ## tooltip for "Add Tab" tab
+        add_tab_button.set_tooltip_text(_("Click to add another tab"))
+        ## create first tab
+        self.append_page(gtk.Label(""), add_tab_button)
+        add_tab_button.connect("clicked", lambda *x: self.add_tab())
+        self.set_size_request(700, 120)
+
+    def focus(self):
+        num = self.get_current_page()
+        self.get_nth_page(num).vte.grab_focus()
+
+    def add_tab(self, title=None):
         dbg('Adding a new tab')
-        _vte = vte.Terminal()
-        if view.NETBOOKMODE == 1:
-            _vte.set_size_request(700, 120)
-        else:
-		    _vte.set_size_request(700, 220) 
-       
-        _vte.connect("child-exited", lambda term: gtk.main_quit())
-        _vte.fork_command(get_user_shell()) # Get the user's default shell
-        
-        self.update_term_config(_vte)
-
-        vte_tab = gtk.ScrolledWindow()
-        vte_tab.add(_vte)
-        #notebook.set_show_tabs(True)
-        #notebook.set_show_border(True)
-        
-        self.nop += 1
         self.gcp += 1
-        pagenum = ('Tab %d') % self.gcp
-        if self.nop > 1:
+        if title == None:
+            title = 'Tab %d' % self.gcp
+
+        newtab = TerminalTab(title, self.global_config)
+
+        if self.get_n_pages() > 1:
             dbg('More than one tab, showing them.')
-            view.MainWindow.notebook.set_show_tabs(True)
+            self.set_show_tabs(True)
+        label = self.create_tab_label(title, newtab)
+        self.insert_page(newtab, label, self.get_n_pages() - 1)
+        self.set_current_page(self.get_n_pages() - 2)
+        self.set_scrollable(True)
+        # signal handler for tab
+        newtab.connect("quit", lambda *x: self.quit_tab(newtab))
+        newtab.connect("add_tab", lambda *x: self.add_tab())
+        newtab.connect("preferences", lambda *x: self.emit('preferences'))
+        newtab.connect("rename",
+                lambda wg, text: self.rename_tab(newtab, text))
+        self.focus()
+        return newtab
+
+    def create_tab_label(self, title, tab):
+        ## Create the tab's labe with button
         box = gtk.HBox()
-        label = gtk.Label(pagenum)
+        label = gtk.Label(title)
         box.pack_start(label, True, True)
-        
-        
         ## x image for tab close button
-        close_image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
+        close_image = gtk.image_new_from_stock(gtk.STOCK_CLOSE,
+                                               gtk.ICON_SIZE_MENU)
         ## close button
         closebtn = gtk.Button()
         closebtn.set_relief(gtk.RELIEF_NONE)
         closebtn.set_focus_on_click(True)
-
         closebtn.add(close_image)
         ## put button in a box and show box
         box.pack_end(closebtn, False, False)
         box.show_all()
-
-        view.MainWindow.notebook.prepend_page(vte_tab, box) # add tab
-        view.MainWindow.notebook.set_scrollable(True)
-        actions = clicompanionlib.controller.Actions()
-        _vte.connect("button_press_event", actions.copy_paste, None)
-        vte_tab.grab_focus()
-        # signal handler for tab
-        closebtn.connect("clicked", lambda *x: self.close_tab(vte_tab, notebook))
-                
-        vte_tab.show_all()
-
-        return vte_tab
-
+        closebtn.connect("clicked", lambda *x: self.close_tab(tab))
+        return box
+
+    def rename_tab(self, tab, newname):
+        dbg('Renaming tab to %s' % newname)
+        label = self.create_tab_label(newname, tab)
+        self.set_tab_label(tab, label)
+        self.focus()
 
     ## Remove a page from the notebook
-    def close_tab(self, vte_tab, notebook):
+    def close_tab(self, tab):
         ## get the page number of the tab we wanted to close
-        pagenum = view.MainWindow.notebook.page_num(vte_tab)
+        pagenum = self.page_num(tab)
         ## and close it
-        view.MainWindow.notebook.remove_page(pagenum)
-        self.nop -= 1
-        if self.nop <= 1:
-            view.MainWindow.notebook.set_show_tabs(False)
-        
-        # check if the focus does not go to the last page (ie with only a + sign)
-        if view.MainWindow.notebook.get_current_page() == self.nop:
-            view.MainWindow.notebook.prev_page()
-        
+        self.remove_page(pagenum)
+        if self.get_n_pages() < 3:
+            self.set_show_tabs(False)
+
+        # check if the focus does not go to the last page (ie with only a +
+        # sign)
+        if self.get_current_page() == self.get_n_pages() - 1:
+            self.prev_page()
+        if self.get_n_pages() != 1:
+            self.focus()
+
+    def quit_tab(self, tab=None):
+        if not tab:
+            tab = self.get_nth_page(self.get_current_page())
+        self.close_tab(tab)
+        if self.get_n_pages() == 1:
+            self.emit('quit')
+
+    def run_command(self, cmd, ui, desc):
+        ## get the current notebook page so the function knows which terminal
+        ## to run the command in.
+        pagenum = self.get_current_page()
+        page = self.get_nth_page(pagenum)
+        page.run_command(cmd, ui, desc)
+        self.focus()
+
     def update_all_term_config(self, config=None):
-        for pagenum in range(view.MainWindow.notebook.get_n_pages()):
-            page = view.MainWindow.notebook.get_nth_page(pagenum)
-            dbg(page)
-            if isinstance(page, gtk.ScrolledWindow):
-                for grandson in page.get_children():
-                    dbg(grandson)
-                    if isinstance(grandson,vte.Terminal):
-                        self.update_term_config(grandson, config)
-        
-    def update_term_config(self, _vte, config=None):
+        self.global_config = config
+        for pagenum in range(self.get_n_pages()):
+            page = self.get_nth_page(pagenum)
+            if isinstance(page, TerminalTab):
+                self.update_term_config(page, config)
+
+    def update_term_config(self, tab, config=None):
         ##set terminal preferences from conig file data
         if not config:
-            config = cc_config.get_config()
-        try:
-            config_scrollback = config.getint('terminal', 'scrollb')
-        except ValueError:
-            print _("WARNING: Invalid value for property 'terminal', int expected:"
-                    " got '%s', using default '%s'")%(
-                        config.get('terminal', 'scrollb'),
-                        config.get('DEFAULT', 'scrollb'))
-            config.set('terminal','scrollb',config.get('DEFAULT', 'scrollb'))
-            config_scrollback = config.getint('DEFAULT', 'scrollb')
-        _vte.set_scrollback_lines(config_scrollback)
-        
-        color = '#2e3436:#cc0000:#4e9a06:#c4a000:#3465a4:#75507b:#06989a:#d3d7cf:#555753:#ef2929:#8ae234:#fce94f:#729fcf:#ad7fa8:#34e2e2:#eeeeec'
-        colors = color.split(':')
-        palette = []
-        for color in colors:
-            if color:
-                palette.append(gtk.gdk.color_parse(color))
-        
-        try:
-            config_color_fore = gtk.gdk.color_parse(config.get('terminal', 'colorf'))
-        except ValueError, e:
-            print _("WARNING: Invalid value for property '%s':"
-                    " got '%s', using default '%s'.")%(
-                        'colorf',
-                        config.get('terminal', 'colorf'),
-                        config.get('DEFAULT', 'colorf'))
-            config.set('terminal','colorf',config.get('DEFAULT', 'colorf'))
-            config_color_fore = gtk.gdk.color_parse(config.get('DEFAULT', 'colorf'))
-
-        try:
-            config_color_back = gtk.gdk.color_parse(config.get('terminal', 'colorb'))
-        except ValueError, e:
-            print _("WARNING: Invalid value for property '%s':"
-                    " got '%s', using default '%s'.")%(
-                        'colorb',
-                        config.get('terminal', 'colorb'),
-                        config.get('DEFAULT', 'colorb'))
-            config.set('terminal','colorb',config.get('DEFAULT', 'colorb'))
-            config_color_back = gtk.gdk.color_parse(config.get('DEFAULT', 'colorb'))
-        _vte.set_colors(config_color_fore, config_color_back, palette)
-        
-        config_encoding = config.get('terminal', 'encoding')
-        if config_encoding.upper() not in [ enc.upper() for enc, desc in utils.encodings]:
-            print _("WARNING: Invalid value for property '%s':"
-                    " got '%s', using default '%s'")%(
-                        'encoding',
-                        config_encoding,
-                        config.get('DEFAULT', 'encoding'))
-            config.set('terminal','encoding',config.get('DEFAULT', 'encoding'))
-            config_encoding = config.get('DEFAULT', 'encoding')
-        _vte.set_encoding(config_encoding)
-
-
-        
+            config = self.global_config
+        tab.update_config(config)

=== modified file 'clicompanionlib/utils.py'
--- clicompanionlib/utils.py	2012-01-02 00:23:11 +0000
+++ clicompanionlib/utils.py	2012-01-08 10:37:24 +0000
@@ -1,9 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# clicompanion.py - commandline tool.
+# utils.py - Some helpful functions for clicompanion
 #
-# Copyright 2010 Duane Hinnen, Kenny Meyer, Marcos Vanetta
+# Copyright 2010 Duane Hinnen, Kenny Meyer, Marcos Vanetta, David Caro
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -18,17 +18,19 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 #
-
-"""
-A collection of useful functions.
-"""
-
-import getpass
+# In this file are implemented some functions that do not need any clicompanion
+# class and can somehow be useful in more than one module.
+
 import os
-import sys 
-import gtk 
-import pwd 
+import sys
+import gtk
+import pwd
 import inspect
+import re
+try:
+    import gconf
+except ImportError:
+    pass
 
 
 ## set to True if you want to see more logs
@@ -37,95 +39,97 @@
 DEBUGCLASSES = []
 DEBUGMETHODS = []
 
+gconf_cli = None
+
 ## list gotten from terminator (https://launchpad.net/terminator)
 encodings = [
     ["ISO-8859-1", _("Western")],
     ["ISO-8859-2", _("Central European")],
-    ["ISO-8859-3", _("South European") ],
-    ["ISO-8859-4", _("Baltic") ],
-    ["ISO-8859-5", _("Cyrillic") ],
-    ["ISO-8859-6", _("Arabic") ],
-    ["ISO-8859-7", _("Greek") ],
-    ["ISO-8859-8", _("Hebrew Visual") ],
-    ["ISO-8859-8-I", _("Hebrew") ],
-    ["ISO-8859-9", _("Turkish") ],
-    ["ISO-8859-10", _("Nordic") ],
-    ["ISO-8859-13", _("Baltic") ],
-    ["ISO-8859-14", _("Celtic") ],
-    ["ISO-8859-15", _("Western") ],
-    ["ISO-8859-16", _("Romanian") ],
-    #    ["UTF-7", _("Unicode") ],
-    ["UTF-8", _("Unicode") ],
-    #    ["UTF-16", _("Unicode") ],
-    #    ["UCS-2", _("Unicode") ],
-    #    ["UCS-4", _("Unicode") ],
-    ["ARMSCII-8", _("Armenian") ],
-    ["BIG5", _("Chinese Traditional") ],
-    ["BIG5-HKSCS", _("Chinese Traditional") ],
-    ["CP866", _("Cyrillic/Russian") ],
-    ["EUC-JP", _("Japanese") ],
-    ["EUC-KR", _("Korean") ],
-    ["EUC-TW", _("Chinese Traditional") ],
-    ["GB18030", _("Chinese Simplified") ],
-    ["GB2312", _("Chinese Simplified") ],
-    ["GBK", _("Chinese Simplified") ],
-    ["GEORGIAN-PS", _("Georgian") ],
-    ["HZ", _("Chinese Simplified") ],
-    ["IBM850", _("Western") ],
-    ["IBM852", _("Central European") ],
-    ["IBM855", _("Cyrillic") ],
-    ["IBM857", _("Turkish") ],
-    ["IBM862", _("Hebrew") ],
-    ["IBM864", _("Arabic") ],
-    ["ISO-2022-JP", _("Japanese") ],
-    ["ISO-2022-KR", _("Korean") ],
-    ["EUC-TW", _("Chinese Traditional") ],
-    ["GB18030", _("Chinese Simplified") ],
-    ["GB2312", _("Chinese Simplified") ],
-    ["GBK", _("Chinese Simplified") ],
-    ["GEORGIAN-PS", _("Georgian") ],
-    ["HZ", _("Chinese Simplified") ],
-    ["IBM850", _("Western") ],
-    ["IBM852", _("Central European") ],
-    ["IBM855", _("Cyrillic") ],
-    ["IBM857", _("Turkish") ],
-    ["IBM862", _("Hebrew") ],
-    ["IBM864", _("Arabic") ],
-    ["ISO-2022-JP", _("Japanese") ],
-    ["ISO-2022-KR", _("Korean") ],
-    ["ISO-IR-111", _("Cyrillic") ],
-    #    ["JOHAB", _("Korean") ],
-    ["KOI8-R", _("Cyrillic") ],
-    ["KOI8-U", _("Cyrillic/Ukrainian") ],
-    ["MAC_ARABIC", _("Arabic") ],
-    ["MAC_CE", _("Central European") ],
-    ["MAC_CROATIAN", _("Croatian") ],
-    ["MAC-CYRILLIC", _("Cyrillic") ],
-    ["MAC_DEVANAGARI", _("Hindi") ],
-    ["MAC_FARSI", _("Persian") ],
-    ["MAC_GREEK", _("Greek") ],
-    ["MAC_GUJARATI", _("Gujarati") ],
-    ["MAC_GURMUKHI", _("Gurmukhi") ],
-    ["MAC_HEBREW", _("Hebrew") ],
-    ["MAC_ICELANDIC", _("Icelandic") ],
-    ["MAC_ROMAN", _("Western") ],
-    ["MAC_ROMANIAN", _("Romanian") ],
-    ["MAC_TURKISH", _("Turkish") ],
-    ["MAC_UKRAINIAN", _("Cyrillic/Ukrainian") ],
-    ["SHIFT-JIS", _("Japanese") ],
-    ["TCVN", _("Vietnamese") ],
-    ["TIS-620", _("Thai") ],
-    ["UHC", _("Korean") ],
-    ["VISCII", _("Vietnamese") ],
-    ["WINDOWS-1250", _("Central European") ],
-    ["WINDOWS-1251", _("Cyrillic") ],
-    ["WINDOWS-1252", _("Western") ],
-    ["WINDOWS-1253", _("Greek") ],
-    ["WINDOWS-1254", _("Turkish") ],
-    ["WINDOWS-1255", _("Hebrew") ],
-    ["WINDOWS-1256", _("Arabic") ],
-    ["WINDOWS-1257", _("Baltic") ],
-    ["WINDOWS-1258", _("Vietnamese") ]
+    ["ISO-8859-3", _("South European")],
+    ["ISO-8859-4", _("Baltic")],
+    ["ISO-8859-5", _("Cyrillic")],
+    ["ISO-8859-6", _("Arabic")],
+    ["ISO-8859-7", _("Greek")],
+    ["ISO-8859-8", _("Hebrew Visual")],
+    ["ISO-8859-8-I", _("Hebrew")],
+    ["ISO-8859-9", _("Turkish")],
+    ["ISO-8859-10", _("Nordic")],
+    ["ISO-8859-13", _("Baltic")],
+    ["ISO-8859-14", _("Celtic")],
+    ["ISO-8859-15", _("Western")],
+    ["ISO-8859-16", _("Romanian")],
+    #    ["UTF-7", _("Unicode")],
+    ["UTF-8", _("Unicode")],
+    #    ["UTF-16", _("Unicode")],
+    #    ["UCS-2", _("Unicode")],
+    #    ["UCS-4", _("Unicode")],
+    ["ARMSCII-8", _("Armenian")],
+    ["BIG5", _("Chinese Traditional")],
+    ["BIG5-HKSCS", _("Chinese Traditional")],
+    ["CP866", _("Cyrillic/Russian")],
+    ["EUC-JP", _("Japanese")],
+    ["EUC-KR", _("Korean")],
+    ["EUC-TW", _("Chinese Traditional")],
+    ["GB18030", _("Chinese Simplified")],
+    ["GB2312", _("Chinese Simplified")],
+    ["GBK", _("Chinese Simplified")],
+    ["GEORGIAN-PS", _("Georgian")],
+    ["HZ", _("Chinese Simplified")],
+    ["IBM850", _("Western")],
+    ["IBM852", _("Central European")],
+    ["IBM855", _("Cyrillic")],
+    ["IBM857", _("Turkish")],
+    ["IBM862", _("Hebrew")],
+    ["IBM864", _("Arabic")],
+    ["ISO-2022-JP", _("Japanese")],
+    ["ISO-2022-KR", _("Korean")],
+    ["EUC-TW", _("Chinese Traditional")],
+    ["GB18030", _("Chinese Simplified")],
+    ["GB2312", _("Chinese Simplified")],
+    ["GBK", _("Chinese Simplified")],
+    ["GEORGIAN-PS", _("Georgian")],
+    ["HZ", _("Chinese Simplified")],
+    ["IBM850", _("Western")],
+    ["IBM852", _("Central European")],
+    ["IBM855", _("Cyrillic")],
+    ["IBM857", _("Turkish")],
+    ["IBM862", _("Hebrew")],
+    ["IBM864", _("Arabic")],
+    ["ISO-2022-JP", _("Japanese")],
+    ["ISO-2022-KR", _("Korean")],
+    ["ISO-IR-111", _("Cyrillic")],
+    #    ["JOHAB", _("Korean")],
+    ["KOI8-R", _("Cyrillic")],
+    ["KOI8-U", _("Cyrillic/Ukrainian")],
+    ["MAC_ARABIC", _("Arabic")],
+    ["MAC_CE", _("Central European")],
+    ["MAC_CROATIAN", _("Croatian")],
+    ["MAC-CYRILLIC", _("Cyrillic")],
+    ["MAC_DEVANAGARI", _("Hindi")],
+    ["MAC_FARSI", _("Persian")],
+    ["MAC_GREEK", _("Greek")],
+    ["MAC_GUJARATI", _("Gujarati")],
+    ["MAC_GURMUKHI", _("Gurmukhi")],
+    ["MAC_HEBREW", _("Hebrew")],
+    ["MAC_ICELANDIC", _("Icelandic")],
+    ["MAC_ROMAN", _("Western")],
+    ["MAC_ROMANIAN", _("Romanian")],
+    ["MAC_TURKISH", _("Turkish")],
+    ["MAC_UKRAINIAN", _("Cyrillic/Ukrainian")],
+    ["SHIFT-JIS", _("Japanese")],
+    ["TCVN", _("Vietnamese")],
+    ["TIS-620", _("Thai")],
+    ["UHC", _("Korean")],
+    ["VISCII", _("Vietnamese")],
+    ["WINDOWS-1250", _("Central European")],
+    ["WINDOWS-1251", _("Cyrillic")],
+    ["WINDOWS-1252", _("Western")],
+    ["WINDOWS-1253", _("Greek")],
+    ["WINDOWS-1254", _("Turkish")],
+    ["WINDOWS-1255", _("Hebrew")],
+    ["WINDOWS-1256", _("Arabic")],
+    ["WINDOWS-1257", _("Baltic")],
+    ["WINDOWS-1258", _("Vietnamese")]
     ]
 
 
@@ -135,8 +139,9 @@
         method = None
         for stackitem in stack:
             parent_frame = stackitem[0]
-            names, varargs, keywords, local_vars = inspect.getargvalues(parent_frame)
-            ## little trick to get the second stackline method, in case we do 
+            names, varargs, keywords, local_vars = \
+                        inspect.getargvalues(parent_frame)
+            ## little trick to get the second stackline method, in case we do
             ## not find self
             if not method and method != None:
                 method = stackitem[3]
@@ -163,37 +168,88 @@
         if DEBUGMETHODS != [] and method not in DEBUGMETHODS:
             return
         try:
-            print >> sys.stderr, "%s::%s: %s%s" % (classname, method, log, extra)
+            print >> sys.stderr, "%s::%s: %s%s" % (classname, method,
+                                                    log, extra)
         except IOError:
             pass
-    
-
-#TODO: Move this to controller.py
-def get_user_shell():
-    """Get the user's shell defined in /etc/passwd ."""
-    data = None
+
+
+def shell_lookup():
+    """Find an appropriate shell for the user
+    Function copied from the terminator project source code
+    www.launchpad.net/terminator"""
     try:
-        # Read out the data in /etc/passwd
-        with open('/etc/passwd') as f:
-            data = f.readlines()
-    except e:
-        print "Something unexpected happened!"
-        raise e
-
-    for i in data:
-        tmp = i.split(":")
-        # Check for the entry of the currently logged in user
-        if tmp[0] == getpass.getuser(): 
-            # Columns are separated by colons, so split each column.
-            # Sample /etc/passwd entry for a user:
-            # 
-            #  jorge:x:1001:1002:,,,:/home/jorge:/bin/bash
-            #
-            # The last column is relevant for us.
-            # Don't forget to strip the newline at the end of the string!
-            return i.split(":")[-1:][0].strip('\n')
-
+        usershell = pwd.getpwuid(os.getuid())[6]
+    except KeyError:
+        usershell = None
+    shells = [os.getenv('SHELL'), usershell, 'bash',
+            'zsh', 'tcsh', 'ksh', 'csh', 'sh']
+
+    for shell in shells:
+        if shell is None:
+            continue
+        elif os.path.isfile(shell):
+            dbg('Found shell %s' % (shell))
+            return shell
+        else:
+            rshell = path_lookup(shell)
+            if rshell is not None:
+                dbg('Found shell %s at %s' % (shell, rshell))
+                return rshell
+    dbg('Unable to locate a shell')
+
+
+## replace ? with {0[n]}
+def replace(cmnd, num, ran):
+    while ran < num:
+        replace_cmnd = re.sub('\?', '{0[' + str(ran) + ']}', cmnd, count=1)
+        cmnd = replace_cmnd
+        ran += 1
+    return cmnd
+
+
+def get_system_font(callback=None):
+    """Look up the system font"""
+    global gconf_cli
+    if 'gconf' not in globals():
+        return 'Monospace 10'
+    else:
+        if not gconf_cli:
+            gconf_cli = gconf.client_get_default()
+        value = gconf_cli.get(
+                    '/desktop/gnome/interface/monospace_font_name')
+        system_font = value.get_string()
+        if callback:
+            gconf_cli.notify_add(
+                        '/desktop/gnome/interface/monospace_font_name',
+                        callback)
+        return system_font
+
+
+## WARNING: the altgr key is detected as a normal key
+def get_keycomb(event):
+    keyname = gtk.gdk.keyval_name(event.keyval)
+    if event.state & gtk.gdk.CONTROL_MASK:
+        keyname = 'ctrl+' + keyname
+    if event.state & gtk.gdk.MOD1_MASK:
+        keyname = 'alt+' + keyname
+    if event.state & gtk.gdk.SHIFT_MASK:
+        keyname = 'shift+' + keyname
+    return keyname
+
+
+## WARNING: the altgr key is detected as shift
+def only_modifier(event):
+    key = gtk.gdk.keyval_name(event.keyval)
+    return 'shift' in key.lower() \
+        or 'control' in key.lower() \
+        or 'super' in key.lower() \
+        or 'alt' in key.lower()
+
+
+### Singleton implementation (kind of)
 class Borg:
     __shared_state = {}
+
     def __init__(self):
         self.__dict__ = self.__shared_state

=== modified file 'clicompanionlib/view.py'
--- clicompanionlib/view.py	2012-01-02 00:23:11 +0000
+++ clicompanionlib/view.py	2012-01-08 10:37:24 +0000
@@ -1,9 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-# clicompanion.py - commandline tool.
+# view.py - Main window for the clicompanon
 #
-# Copyright 2010 Duane Hinnen, Kenny Meyer
+# Copyright 2010 Duane Hinnen, Kenny Meyer, David Caro
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -17,45 +17,47 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
-
-
+# This file is where the main window is defined, depends on all the modules of
+# the clicompanion libraries.
+#
+# Also holds the class that implements the commands notebook (the upper
+# notebook), where all the tab plugins will be added (like LocalCommandList and
+# CommandLineFU)
+
+
+import os
 import pygtk
 pygtk.require('2.0')
-import os
+import gobject
+import webbrowser
 
 # import vte and gtk or print error
 try:
     import gtk
 except:
-    error = gtk.MessageDialog (None, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
-        _("You need to install the python gtk bindings package 'python-gtk2'"))
-    error.run()
-    sys.exit (1)
-    
+    ## do not use gtk, just print
+    print _("You need to install the python gtk bindings package"
+            "'python-gtk2'")
+    sys.exit(1)
+
 try:
     import vte
 except:
-    error = gtk.MessageDialog (None, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
+    error = gtk.MessageDialog(None, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR,
+        gtk.BUTTONS_OK,
         _("You need to install 'python-vte' the python bindings for libvte."))
     error.run()
-    sys.exit (1)
-    
-import clicompanionlib.menus_buttons
-import clicompanionlib.controller
-from clicompanionlib.utils import get_user_shell , Borg, dbg
-import clicompanionlib.tabs
-import clicompanionlib.utils as utils
+    sys.exit(1)
+
+import clicompanionlib.menus_buttons as cc_menus_buttons
+import clicompanionlib.tabs as cc_tabs
+import clicompanionlib.utils as cc_utils
+from clicompanionlib.utils import dbg
 import clicompanionlib.config as cc_config
-
-
-## Changed two->three columns
-CMNDS = cc_config.Cheatsheet() 
-## will hold the commands. Actually the first three columns
-## note that this commands list will not change with searchers and filters, 
-## instead, when adding a command to the liststore, we will add also the index 
-## of the command in the CMND list
-
-ROW = '0' ## holds the currently selected row
+import clicompanionlib.helpers as cc_helpers
+import clicompanionlib.plugins as cc_plugins
+import clicompanionlib.preferences as cc_pref
+
 TARGETS = [
     ('MY_TREE_MODEL_ROW', gtk.TARGET_SAME_WIDGET, 0),
     ('text/plain', 0, 1),
@@ -63,250 +65,180 @@
     ('STRING', 0, 3),
     ]
 
-FILTER = 0
-NETBOOKMODE = 0
-HIDEUI = 0
-FULLSCREEN = 0
-
-menu_search_hbox = ''
-button_box = ''
-
-
-class MainWindow(Borg):
-    window = gtk.Window(gtk.WINDOW_TOPLEVEL) 
-    #color = gtk.gdk.Color(60000, 65533, 60000)
-    #window.modify_bg(gtk.STATE_NORMAL, color)
-    liststore = gtk.ListStore(str, str, str, int)	
-    treeview = gtk.TreeView()
-    expander = gtk.Expander()
-    scrolledwindow = gtk.ScrolledWindow()
-    notebook = gtk.Notebook()
-
-    screen = gtk.gdk.display_get_default().get_default_screen()
-    screen_size = screen.get_monitor_geometry(0)
-    height =  screen.get_height() ## screen height ##
-    global NETBOOKMODE
-    if height < 750:
-		NETBOOKMODE = 1
-
-
-    def sync_cmnds(self, rld=False):
-        global CMNDS
-        dbg('syncing commands')
-        if rld:
-            ## reload the commands list from the file
-            CMNDS.load()
-        self.liststore.clear()
-        ## Store also the index of the command in the CMNDS list
-        i = 0
-        for cmd, ui, desc in CMNDS:
-            self.liststore.append((cmd, ui, desc, i))
-            i = i +1
-
-    
-    #liststore in a scrolled window in an expander
-    def expanded_cb(self, expander, params, window, search_box):
-        if expander.get_expanded():
-
-            # Activate the search box when expanded
-            search_box.set_sensitive(True)
-        else:
-            # De-activate the search box when not expanded
-            self.search_box.set_sensitive(False)
-            expander.set_expanded(False)
-            #expander.remove(expander.child)
-            ##reset the size of the window to its original one
-            window.resize(1, 1)
-        return  
-        
-
-    # close the window and quit
-    def delete_event(self, widget,  data=None):
-        gtk.main_quit()
-        return False
-        
-    def key_clicked(self, widget, event):
-        actions = clicompanionlib.controller.Actions()
-        global HIDEUI
-        global FULLSCREEN
-        global menu_search_hbox
-        global button_box
-        keyname = gtk.gdk.keyval_name(event.keyval).upper()
-        if keyname == "F12":
-            HIDEUI = 1 - HIDEUI
-        if HIDEUI == 1:
-            self.treeview.hide_all()
-            self.expander.hide_all()
-            self.scrolledwindow.hide_all()
-            menu_search_hbox.hide_all()
-            button_box.hide_all()
-        else:
-            self.treeview.show_all()
-            self.expander.show_all()
-            self.scrolledwindow.show_all()
-            menu_search_hbox.show_all()
-            button_box.show_all()
-        if keyname == "F11":
-            FULLSCREEN = 1 - FULLSCREEN
-        if FULLSCREEN == 1:
-            pwin = button_box.get_window()
-            pwin.fullscreen()
-        else: 
-            pwin = button_box.get_window()
-            pwin.unfullscreen()
-        if keyname == "F4":
-			actions.run_command(self)
-        if keyname == "F5":
-			actions.add_command(self)
-        if keyname == "F6":
-			actions.remove_command(self)
-        if keyname == "F7":
-			self.tabs.add_tab(self)
-  
-    def __init__(self):
-        #import pdb  ##debug
-        #pdb.set_trace() ##debug
-        
-        ##For now TERM is hardcoded to xterm because of a change
-        ##in libvte in Ubuntu Maverick
-        os.putenv('TERM', 'xterm')
-
-
-        ## style to reduce padding around tabs
-        ## TODO: Find a better place for this? 
-    	gtk.rc_parse_string ("style \"tab-close-button-style\"\n"
-		     "{\n"
-		       "GtkWidget::focus-padding = 0\n"
-		       "GtkWidget::focus-line-width = 0\n"
-		       "xthickness = 0\n"
-		       "ythickness = 0\n"
-		     "}\n"
-		     "widget \"*.tab-close-button\" style \"tab-close-button-style\"");
-        
-        ## Create UI widgets
-
-        self.notebook.set_show_tabs(0)
-
-        ##attach the style to the widget
-        self.notebook.set_name ("tab-close-button")
-
-        ## set sizes and borders
-        global NETBOOKMODE
-        if NETBOOKMODE == 1:
-            self.scrolledwindow.set_size_request(700, 200)
-            self.window.set_default_size(700, 500)
-        else:
-            self.scrolledwindow.set_size_request(700, 220)
-            self.window.set_default_size(700, 625)
-        self.window.set_border_width(10)
-        ## Sets the position of the window relative to the screen
-        self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
-        ## Allow user to resize window
-        self.window.set_resizable(True)
-        
-        ## set Window title and icon
-        self.window.set_title("CLI Companion")
-        icon = gtk.gdk.pixbuf_new_from_file("/usr/share/pixmaps/clicompanion.16.png")
-        self.window.set_icon(icon)
-	   
-        # sync liststore with commands
-        self.sync_cmnds()
-        
-        ## set renderer and colors
-        #color2 = gtk.gdk.Color(5000,5000,65000)
-        renderer = gtk.CellRendererText()
-        #renderer.set_property("cell-background-gdk", color)
-        #renderer.set_property("foreground-gdk", color2)
-        
-        ## create the TreeViewColumns to display the data
-        self.treeview.columns = [None]*3
-        self.treeview.columns[0] = gtk.TreeViewColumn(_('Command'), renderer)
-        self.treeview.columns[1] = gtk.TreeViewColumn(_('User Input'), renderer)
-        self.treeview.columns[2] = gtk.TreeViewColumn(_('Description'), renderer)     
-        
-        for n in range(3):
-            ## add columns to treeview
-            self.treeview.append_column(self.treeview.columns[n])
-            ## create a CellRenderers to render the data
-            self.treeview.columns[n].cell = gtk.CellRendererText()
-            #self.treeview.columns[n].cell.set_property("cell-background-gdk", color)
-            #self.treeview.columns[n].cell.set_property("foreground-gdk", color2)
-            ## add the cells to the columns
-            self.treeview.columns[n].pack_start(self.treeview.columns[n].cell,
-                                                True)
-            ## set the cell attributes to the appropriate liststore column
-            self.treeview.columns[n].set_attributes(
-                    self.treeview.columns[n].cell, text=n)   
-            self.treeview.columns[n].set_resizable(True)  
-        
-        ''' set treeview model and put treeview in the scrolled window
-        and the scrolled window in the expander. '''
-        self.treeview.set_model(self.liststore)
-        self.treeview.set_reorderable(True)
-        self.scrolledwindow.add(self.treeview)
-        
-        self.expander.add(self.scrolledwindow)
-        #self.window.show_all()
-
-        ## instantiate tabs
-        self.tabs = clicompanionlib.tabs.Tabs()
-        ## instantiate controller.Actions, where all the button actions are
-        self.actions = clicompanionlib.controller.Actions()
+
+class CommandsNotebook(gtk.Notebook):
+    '''
+    This is the notebook where the commands list and the commandlinefu commands
+    are displayed
+    '''
+    ### We need a way to tell the main window that a command must be runned on
+    ## the selected terminal tab
+    __gsignals__ = {
+         'run_command': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, str, str)),
+         'add_tab': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'preferences': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         'show_man': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             (str, )),
+         'quit': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
+                             ()),
+         }
+
+    def __init__(self, config, pluginloader):
+        self.config = config
+        self.pluginloader = pluginloader
+        gtk.Notebook.__init__(self)
+        self.loaded_plugins = {}
+        self.draw_all()
+
+    def draw_all(self):
+        ## Load the needed LocalCommandList plugin
+        if 'LocalCommandList' not in self.pluginloader.plugins.keys():
+            print _("ERROR: LocalCommandList plugin is needed for the "
+                    "execution of CLI Companion, please retore the plugin or "
+                    "reinstall.")
+            self.emit('quit')
+        else:
+            self.commandstab = self.pluginloader.plugins['LocalCommandList'](
+                    self.config.get_plugin_conf('LocalCommandList'))
+        for pname, pclass in self.pluginloader.get_plugins('CommandTab'):
+            if pname == 'LocalCommandList':
+                tab = self.commandstab
+            else:
+                tab = pclass(self.config.get_plugin_conf('LocalCommandList'))
+            self.append_tab(tab, pname)
+
+    def append_tab(self, tab, pname):
+        ## save the tab related to the plugin name
+        self.loaded_plugins[pname] = tab
+        self.append_page(tab, gtk.Label(tab.__title__ or pname))
+        ##All the available signals for the plugins
+        tab.connect('run_command',
+                lambda wg, *args: self.run_command(*args))
+        tab.connect('add_command',
+                lambda wg, *args: self.commandstab.add_command(*args))
+        tab.connect('remove_command',
+                lambda wg, *args: self.remove_command(*args))
+        tab.connect('edit_command',
+                lambda wg, *args: self.edit_command(*args))
+        tab.connect('add_tab',
+                lambda wg, *args: self.emit('add_tab', *args))
+        tab.connect('preferences',
+                lambda wg, *args: self.emit('preferences', *args))
+        tab.connect('show_man',
+                lambda wg, *args: self.emit('show_man', *args))
+        tab.connect('quit',
+                lambda wg, *args: self.emit('quit', *args))
+
+    def filter(self, filter_str, pagenum=None):
+        if pagenum == None:
+            pagenum = self.get_current_page()
+        page = self.get_nth_page(pagenum)
+        dbg('filtering by %s' % filter_str)
+        page.filter(filter_str)
+
+    def set_netbook(netbookmode=False):
+        if netbookmode:
+            self.set_size_request(700, 200)
+        else:
+            self.set_size_request(700, 220)
+
+    def get_command(self):
+        pagenum = self.get_current_page()
+        page = self.get_nth_page(pagenum)
+        return page.get_command()
+
+    def run_command(self, cmd=None, ui=None, desc=None):
+        if cmd == None:
+            cmd, ui, desc = self.get_command()
+        if cmd:
+            dbg('running command %s' % cmd)
+            self.emit('run_command', cmd, ui, desc)
+
+    def add_command(self):
+        if self.get_current_page() == 0:
+            self.commandstab.add_command()
+        else:
+            command = self.get_command()
+            if command[0] != None:
+                self.commandstab.add_command(*command)
+            else:
+                self.commandstab.add_command()
+
+    def remove_command(self):
+        if self.get_current_page() == 0:
+            self.commandstab.remove_command()
+
+    def edit_command(self):
+        if self.get_current_page() == 0:
+            self.commandstab.edit_command()
+        else:
+            command = self.get_command()
+            if command[0] != None:
+                self.commandstab.add_command(*command)
+
+    def update(self, config=None, force=None):
+        if config:
+            self.config = config
+        newplugins = self.pluginloader.get_plugins('CommandTab')
+        for plugin in self.loaded_plugins.keys():
+            if plugin not in [ name for name, cl in newplugins]:
+                dbg('Disabling plugin %s' % plugin)
+                self.remove_page(self.page_num(self.loaded_plugins[plugin]))
+                self.loaded_plugins.pop(plugin)
+        for pname, pclass in newplugins:
+            if pname not in self.loaded_plugins.keys():
+                dbg('Adding new selected plugin %s' % pname)
+                self.append_tab(
+                    pclass(self.config.get_plugin_conf('LocalCommandList')),
+                    pname)
+        for plugin in force:
+            if plugin in self.loaded_plugins:
+                dbg('Reloading plugin %s' % plugin)
+                self.loaded_plugins[plugin].reload(
+                        self.config.get_plugin_conf(plugin))
+        self.show_all()
+
+
+class MainWindow(gtk.Window):
+    def __init__(self, config):
+        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
+        ###############
+        ### Some state variables
+        self.hiddenui = False
+        self.maximized = False
+        self.filtered = False
+        self.fullscr = False
+
+        self.config = config
+
+        self.load_plugins()
+
+        ## two sections, the menus and search box and the expander with the
+        ## commands notebook and in the botom, the terminals notebook
+
+        ## set various parameters on the main window (size, etc)
+        self.init_config()
+        self.term_notebook = cc_tabs.TerminalsNotebook(self.config)
+
+        ###########################
+        #### Here we create the commands notebook for the expander
+        self.cmd_notebook = CommandsNotebook(config, self.pluginloader)
+
+        ## Create the menus and the searchbox
+        ## hbox for menu and search Entry
+        self.menu_search_hbox = gtk.HBox(False)
+
+        #### The menus
         ## instantiate 'File' and 'Help' Drop Down Menu [menus_buttons.py]
-        bar = clicompanionlib.menus_buttons.FileMenu()
-        menu_bar = bar.the_menu(self)
-        
-
-        ## get row of a selection
-        def mark_selected(self, treeselection):
-            global ROW
-            (model, pathlist) = treeselection.get_selected_rows()
-            ROW = pathlist
-            
-            
-        ## double click to run a command    
-        def treeview_clicked(widget, path, column):
-            self.actions.run_command(self)
-
-
-        ## press enter to run a command                   
-        def treeview_button(widget, event):
-            keyname = gtk.gdk.keyval_name(event.keyval).upper()
-            dbg('Key %s pressed'%keyname)
-            if event.type == gtk.gdk.KEY_PRESS:
-                if keyname == 'RETURN':
-                    self.actions.run_command(self)
-                    
-                    
-
-        selection = self.treeview.get_selection()
-        #selection.set_mode(gtk.SELECTION_SINGLE)
-        ## open with top command selected
-        selection.select_path(0) 
-        selection.connect("changed", mark_selected, selection)
-        ## double-click
-        self.treeview.connect("row-activated", treeview_clicked)
-        #press enter to run command
-        self.treeview.connect("key-press-event", treeview_button)
-                
-        global menu_search_hbox
-        
-        ## The search section
-        search_label = gtk.Label(_("Search:"))
-        search_label.set_alignment(xalign=-1, yalign=0)
-        self.search_box = gtk.Entry()
-        self.search_box.connect("changed", self.actions._filter_commands, self.liststore, self.treeview)
-        ## search box tooltip
-        self.search_box.set_tooltip_text(_("Search your list of commands"))
-        ## Set the search box sensitive OFF at program start, because
-        ## expander is not unfolded by default
-        self.search_box.set_sensitive(False)
-        ## hbox for menu and search Entry
-        menu_search_hbox = gtk.HBox(False)
-        menu_search_hbox.pack_end(self.search_box, True)
-        menu_search_hbox.pack_end(search_label, False, False, 10)
-        menu_search_hbox.pack_start(menu_bar, True)
-
+        menu_bar = cc_menus_buttons.FileMenu(self.config)
+        self.menu_search_hbox.pack_start(menu_bar, True)
+
+        #### the expander
+        self.expander = gtk.Expander()
+        self.menu_search_hbox.pack_end(self.expander, False, False, 0)
         ## expander title
         expander_hbox = gtk.HBox()
         image = gtk.Image()
@@ -314,70 +246,286 @@
         label = gtk.Label(_('Command List'))
         ## tooltip for the label of the expander
         expander_hbox.set_tooltip_text(_("Click to show/hide command list"))
-        
         ## add expander widget to hbox
         expander_hbox.pack_start(image, False, False)
         expander_hbox.pack_start(label, True, False)
         self.expander.set_label_widget(expander_hbox)
+        self.expander.set_expanded(True)
+
+        #### The search box
+        self.search_hbox = gtk.HBox()
+        #### the search label
+        search_label = gtk.Label(_("Search:"))
+        search_label.set_alignment(xalign=-1, yalign=0)
+        self.search_box = gtk.Entry()
+        self.search_box.connect("changed",
+                lambda wg, *x: self.cmd_notebook.filter(wg.get_text()))
+        ## search box tooltip
+        self.search_box.set_tooltip_text(_("Search your list of commands"))
+        self.search_hbox.pack_start(search_label, False, False, 8)
+        self.search_hbox.pack_end(self.search_box, True)
+        self.menu_search_hbox.pack_end(self.search_hbox, True)
+
+        ############################
+        ## and now the terminals notebook
+        self.term_notebook.set_show_tabs(0)
+        ##attach the style to the widget
+        self.term_notebook.set_name("tab-close-button")
 
         ## Add the first tab with the Terminal
-        self.tabs.add_tab(self.notebook)
-        self.notebook.set_tab_pos(2)
+        self.term_notebook.add_tab()
 
-        ## The "Add Tab" tab
-        add_tab_button = gtk.Button("+")
-        ## tooltip for "Add Tab" tab
-        add_tab_button.set_tooltip_text(_("Click to add another tab"))
-        ## create first tab
-        self.notebook.append_page(gtk.Label(""), add_tab_button)
-        
-        global button_box
         ## buttons at bottom of main window [menus_buttons.py]
-        button_box = bar.buttons(self, 10, gtk.BUTTONBOX_END)
+        self.button_box = cc_menus_buttons.Buttons(10, gtk.BUTTONBOX_END)
 
+        ## pack everything
         ## vbox for search, notebook, buttonbar
-        vbox = gtk.VBox()
-        self.window.add(vbox)
         ## pack everytyhing in the vbox
-        #self.vbox.pack_start(menu_bar, False, False,  0) ##menuBar
-        vbox.pack_start(menu_search_hbox, False, False, 5)
-        vbox.pack_start(self.expander, False, False, 5)
-        vbox.pack_start(self.notebook, True, True, 5)
-        vbox.pack_start(button_box, False, False, 5)
-        
+        h_vbox = gtk.VBox()
+        h_vbox.pack_start(self.menu_search_hbox, False, False, 5)
+        h_vbox.pack_start(self.cmd_notebook, True, True, 5)
+        self.l_vbox = gtk.VBox()
+        self.l_vbox.pack_start(self.term_notebook, True, True, 0)
+        self.l_vbox.pack_start(self.button_box, False, False, 0)
+
+        ## Pack it in a vpant bo allow the user to resize
+        self.vpane = gtk.VPaned()
+        self.vpane.pack1(h_vbox, True, False)
+        self.vpane.pack2(self.l_vbox, True, True)
+        self.add(self.vpane)
+
         ## signals
-        self.expander.connect('notify::expanded', self.expanded_cb, self.window, self.search_box)
-        self.window.connect("delete_event", self.delete_event)
-        self.window.connect("key-press-event", self.key_clicked)
-        add_tab_button.connect("clicked", lambda *x: self.tabs.add_tab(self.notebook))
+        self.cmd_notebook.connect('run_command',
+            lambda wdg, *args: self.term_notebook.run_command(*args))
+        self.cmd_notebook.connect('show_man',
+                lambda wgt, cmd: cc_helpers.ManPage(cmd).run())
+        self.cmd_notebook.connect('quit', lambda *x: gtk.main_quit())
+        self.term_notebook.connect('quit', lambda *x: gtk.main_quit())
+        self.term_notebook.connect('preferences', lambda *x: self.edit_pref())
+        self.expander.connect('notify::expanded',
+                lambda *x: self.expanded_cb())
+        self.connect("delete_event", self.delete_event)
+        self.connect("key-press-event", self.key_clicked)
+        menu_bar.connect('quit', lambda *x: gtk.main_quit())
+        menu_bar.connect('run_command',
+                lambda *x: self.cmd_notebook.run_command())
+        menu_bar.connect('add_command',
+                lambda *x: self.cmd_notebook.add_command())
+        menu_bar.connect('edit_command',
+                lambda *x: self.cmd_notebook.edit_command())
+        menu_bar.connect('remove_command',
+                lambda *x: self.cmd_notebook.remove_command())
+        menu_bar.connect('preferences', lambda *x: self.edit_pref())
+        menu_bar.connect('add_tab', lambda *x: self.term_notebook.add_tab())
+        menu_bar.connect('close_tab', lambda *x: self.term_notebook.quit_tab())
+        self.button_box.connect('quit', lambda *x: gtk.main_quit())
+        self.button_box.connect('run_command',
+                lambda *x: self.cmd_notebook.run_command())
+        self.button_box.connect('add_command',
+                lambda *x: self.cmd_notebook.add_command())
+        self.button_box.connect('edit_command',
+                lambda *x: self.cmd_notebook.edit_command())
+        self.button_box.connect('remove_command',
+                lambda *x: self.cmd_notebook.remove_command())
+        self.button_box.connect('show_man',
+                lambda *x: cc_helpers.ManPage(
+                    self.cmd_notebook.get_command()[0]).run())
+        self.button_box.connect('add_tab',
+                lambda *x: self.term_notebook.add_tab())
         ## right click menu event capture
-        self.treeview.connect("button_press_event", bar.right_click, self)
-
         # Allow enable drag and drop of rows including row move
-        self.treeview.enable_model_drag_source( gtk.gdk.BUTTON1_MASK,
-                                                TARGETS,
-                                                gtk.gdk.ACTION_DEFAULT |
-                                                gtk.gdk.ACTION_COPY)
-        self.treeview.enable_model_drag_dest(TARGETS,
-                                                gtk.gdk.ACTION_DEFAULT)
-
-        self.treeview.connect ("drag_data_get", self.drag_data_get_event)
-        self.treeview.connect ("drag_data_received", self.drag_data_received_event)
-        self.treeview.connect("drag_drop", self.on_drag_drop )
-
-
-        #self.vte.grab_focus()
-        self.window.show_all()
-        return
-
+#        self.treeview.enable_model_drag_source( gtk.gdk.BUTTON1_MASK,
+#                                                TARGETS,
+#                                                gtk.gdk.ACTION_DEFAULT |
+#                                                gtk.gdk.ACTION_COPY)
+#        self.treeview.enable_model_drag_dest(TARGETS,
+#                                                gtk.gdk.ACTION_DEFAULT)
+#
+#        self.treeview.connect ("drag_data_get", self.drag_data_get_event)
+#        self.treeview.connect ("drag_data_received",
+#                self.drag_data_received_event)
+#        self.treeview.connect("drag_drop", self.on_drag_drop )
+
+        ## show everything
+        self.show_all()
+        ## set the focus on the terminal
+        self.term_notebook.focus()
+        return
+
+    def load_plugins(self):
+        self.pluginloader = cc_plugins.PluginLoader()
+        self.reload_plugins()
+
+    def reload_plugins(self):
+        (head, _tail) = os.path.split(cc_plugins.__file__)
+        pluginspath = os.path.join(head.rsplit(os.sep, 1)[0], 'plugins')
+        allowed = [plg.strip() for plg in self.config.get('general::default',
+                                                        'plugins').split(',')]
+        dbg('Allowed plugins: %s' % allowed.__repr__())
+        self.pluginloader.load(pluginspath, allowed)
+
+    def expanded_cb(self):
+        #liststore in a scrolled window in an expander
+        if self.expander.get_expanded():
+            self.search_hbox.show_all()
+            self.cmd_notebook.show_all()
+            self.cmd_notebook.set_current_page(self.currentpage)
+            self.button_box.show_all()
+            self.vpane.set_position(self.currentpos)
+        else:
+            self.currentpage = self.cmd_notebook.get_current_page()
+            self.currentpos = self.vpane.get_position()
+            self.cmd_notebook.hide_all()
+            self.search_hbox.hide_all()
+            self.button_box.hide_all()
+            self.vpane.set_position(0)
+        return
+
+    def init_config(self):
+        ## Set the netbookmode if needed
+        screen = gtk.gdk.display_get_default().get_default_screen()
+        height = screen.get_height()
+        if height < 750:
+            self.cmd_notebook.set_netbook(True)
+            self.set_default_size(700, 500)
+        else:
+            self.set_default_size(700, 625)
+        self.set_border_width(5)
+        ## Sets the position of the window relative to the screen
+        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
+        ## Allow user to resize window
+        self.set_resizable(True)
+
+        ## set Window title and icon
+        self.set_title("CLI Companion")
+        icon = gtk.gdk.pixbuf_new_from_file(
+                "/usr/share/pixmaps/clicompanion.16.png")
+        self.set_icon(icon)
+
+        ##For now TERM is hardcoded to xterm because of a change
+        ##in libvte in Ubuntu Maverick
+        os.putenv('TERM', 'xterm')
+
+        ## style to reduce padding around tabs
+        ## TODO: Find a better place for this?
+        gtk.rc_parse_string("style \"tab-close-button-style\"\n"
+             "{\n"
+               "GtkWidget::focus-padding = 0\n"
+               "GtkWidget::focus-line-width = 0\n"
+               "xthickness = 0\n"
+               "ythickness = 0\n"
+             "}\n"
+             "widget \"*.tab-close-button\" style \"tab-close-button-style\"")
+
+    def edit_pref(self):
+        pref_win = cc_pref.PreferencesWindow(
+            self.config.get_config_copy(), self.pluginloader)
+        newconfig, changed_plugins = pref_win.run()
+        if newconfig:
+            self.config = newconfig
+            self.config.save()
+            dbg(', '.join([self.config.get('profile::default', opt)
+                    for opt in self.config.options('profile::default')]))
+        self.reload_plugins()
+        self.term_notebook.update_all_term_config(self.config)
+        self.cmd_notebook.update(self.config, changed_plugins)
+
+    def delete_event(self, widget,  data=None):
+        # close the window and quit
+        gtk.main_quit()
+        return False
+
+    def key_pressed(self, event):
+        keyname = cc_utils.get_keycomb(event)
+        if keyname in cc_pref.KEY_BINDINGS.keys():
+            key, func = cc_pref.KEY_BINDINGS[keyname]
+
+    def key_clicked(self, widget, event):
+        if cc_utils.only_modifier(event):
+            return
+        keycomb = cc_utils.get_keycomb(event)
+        for func in cc_config.KEY_BINDINGS.keys():
+            if keycomb == self.config.get('keybindings', func):
+                getattr(self, func)()
+                ## this is to stop sending the keypress to the widgets
+                return True
+
+    def run_command(self):
+        self.cmd_notebook.run_command()
+
+    def add_command(self):
+        self.cmd_notebook.add_command()
+
+    def remove_command(self):
+        self.cmd_notebook.remove_command()
+
+    def edit_command(self):
+        self.cmd_notebook.edit_command()
+
+    def add_tab(self):
+        self.term_notebook.add_tab()
+
+    def close_tab(self):
+        self.term_notebook.quit_tab()
+
+    def toggle_hide_ui(self):
+        if self.hiddenui:
+            self.show_ui()
+        else:
+            self.hide_ui()
+
+    def hide_ui(self):
+        if self.hiddenui:
+            return
+        dbg('Hide UI')
+        self.l_vbox.remove(self.term_notebook)
+        self.remove(self.vpane)
+        self.add(self.term_notebook)
+        self.hiddenui = True
+
+    def show_ui(self):
+        if not self.hiddenui:
+            return
+        dbg('Show UI')
+        self.remove(self.term_notebook)
+        btns = self.l_vbox.get_children()[0]
+        self.l_vbox.remove(btns)
+        self.l_vbox.pack_start(self.term_notebook, True, True, 0)
+        self.l_vbox.pack_start(btns, False, False, 0)
+        self.add(self.vpane)
+        self.hiddenui = False
+
+    def toggle_maximize(self):
+        if not self.maximized:
+            self.maximize()
+        else:
+            self.unmaximize()
+        self.maximized = not self.maximized
+
+    def toggle_fullscreen(self):
+        '''
+        Maximize and hide everything, or unmaximize and unhide if it was on
+        fullscren mode
+        '''
+        if not self.fullscr:
+            self.hide_ui()
+            self.fullscreen()
+            self.set_border_width(0)
+        else:
+            self.show_ui()
+            self.unfullscreen()
+            self.set_border_width(5)
+        self.fullscr = not self.fullscr
+
+    ### TODO: pass these functions to the LocalCommandList class
     def on_drag_drop(self, treeview, *x):
         '''
         Stop the signal when in search mode
         '''
-        if FILTER:
+        if self.FILTER:
             treeview.stop_emission('drag_drop')
 
-    def drag_data_get_event(self, treeview, context, selection, target_id, 
+    def drag_data_get_event(self, treeview, context, selection, target_id,
                             etime):
         """
         Executed on dragging
@@ -387,20 +535,19 @@
         data = model.get(iter, 0, 1, 2)
         selection.set(selection.target, 8, '\t'.join(data))
 
-    def drag_data_received_event(self, treeview, context, x, y, selection, info,
-                            etime):
+    def drag_data_received_event(self, treeview, context, x, y, selection,
+            info, etime):
         """
         Executed when dropping.
         """
         global CMNDS
-        global FILTER
         ## if we are in a search, do nothing
-        if FILTER == 1:
+        if self.FILTER == 1:
             return
         model = treeview.get_model()
         ## get the destination
         drop_info = treeview.get_dest_row_at_pos(x, y)
-        if drop_info: 
+        if drop_info:
             path, position = drop_info
             iter = model.get_iter(path)
             dest = list(model.get(iter, 0, 1, 2))
@@ -408,21 +555,23 @@
         ## parse all the incoming commands
         for data in selection.data.split('\n'):
             # if we got an empty line skip it
-            if not data.replace('\r',''): continue
+            if not data.replace('\r', ''):
+                continue
             # format the incoming string
-            orig = data.replace('\r','').split('\t',2)
-            orig = [ fld.strip() for fld in orig ]
+            orig = data.replace('\r', '').split('\t', 2)
+            orig = [fld.strip() for fld in orig]
             # fill the empty fields
-            if len(orig) < 3: orig = orig + ('',)*(3-len(orig))
-            dbg('Got drop of command %s'%'_\t_'.join(orig))
+            if len(orig) < 3:
+                orig = orig + ('', ) * (3 - len(orig))
+            dbg('Got drop of command %s' % '_\t_'.join(orig))
 
             if drop_info:
                 if (position == gtk.TREE_VIEW_DROP_BEFORE
                         or position == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE):
-                    dbg('\t to before dest %s'%'_\t_'.join(dest))
+                    dbg('\t to before dest %s' % '_\t_'.join(dest))
                     CMNDS.drag_n_drop(orig, dest, before=True)
                 else:
-                    dbg('\t to after dest %s'%'_\t_'.join(dest))
+                    dbg('\t to after dest %s' % '_\t_'.join(dest))
                     CMNDS.drag_n_drop(orig, dest, before=False)
             else:
                 dbg('\t to the end')
@@ -431,19 +580,21 @@
             context.finish(True, True, etime)
         self.sync_cmnds()
         CMNDS.save()
-        
+
     def main(self):
         try:
             gtk.main()
         except KeyboardInterrupt:
             pass
-        
-def run( options=None ):
-    ##create the config file
-    config = cc_config.create_config()
-    if config.get('terminal','debug') == 'True':
-        utils.DEBUG = True
-    CMNDS.load(options and options.cheatsheet or None)
-    dbg('Loaded commands %s'%CMNDS)
-    main_window = MainWindow()
+
+
+def run(options=None):
+    if options and options.conffile:
+        config = cc_config.CLIConfig(conffile)
+    else:
+        config = cc_config.CLIConfig()
+    if config.get('general::default', 'debug') == 'True' or options.debug:
+        cc_utils.DEBUG = True
+    main_window = MainWindow(
+                config=config)
     main_window.main()

=== added directory 'plugins'
=== added file 'plugins/CommandLineFU.py'
--- plugins/CommandLineFU.py	1970-01-01 00:00:00 +0000
+++ plugins/CommandLineFU.py	2012-01-08 10:37:24 +0000
@@ -0,0 +1,282 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# CommandLineFu.py - CommandlineFU commands plugin for CLI Comapnion
+#
+# Copyright 2012 David Caro <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
+#
+
+
+import os
+import pygtk
+pygtk.require('2.0')
+import gobject
+import webbrowser
+
+try:
+    import gtk
+except:
+    ## do not use gtk, just print
+    print _("You need to install the python gtk bindings package"
+            "'python-gtk2'")
+    sys.exit(1)
+
+from clicompanionlib.utils import dbg
+import clfu as cc_clf
+import clicompanionlib.plugins as plugins
+
+
+class CommandLineFU(plugins.TabPlugin):
+    '''
+    Tab with all the commandlinefu commands and search options
+    '''
+    __authors__ = 'David Caro <[e-mail]>'
+    __info__ = ('This plugin crates a tab on the commands list that allows you'
+        ' to search commands on the CommandlineFU website '
+        '(www.commandlinefu.com).')
+    __title__ = 'CommandlineFU Commands'
+
+    def __init__(self, config):
+        plugins.TabPlugin.__init__(self)
+        self.config = config
+        self.clfu = cc_clf.CLFu()
+        self.pages = []
+        ## las_search will store the params of the last search
+        self.lastsearch = []
+
+        ## box for commands tags and timerange comboboxes, and refresh
+        hbox = gtk.HBox()
+        self.pack_start(hbox, False, False, 0)
+
+        ## combobox for selecting command tag
+        self.tags_box = gtk.combo_box_new_text()
+        self.tags_box.append_text('Update')
+        self.tags_box.append_text('None')
+        self.tags_box.set_active(1)
+        self.tags_box.connect('changed', lambda *x: self.populate_tags())
+        hbox.pack_start(gtk.Label(_('Tag:')), False, False, 0)
+        hbox.pack_start(self.tags_box, False, False, 0)
+
+        ## time range combobox
+        self.trange_box = gtk.combo_box_new_text()
+        ## populate time ranges, no http call needed
+        for timerange in self.clfu.get_timeranges():
+            self.trange_box.append_text(timerange)
+        self.trange_box.set_active(0)
+        hbox.pack_start(gtk.Label(_('From:')), False, False, 0)
+        hbox.pack_start(self.trange_box, False, False, 0)
+
+        ## refresh button
+        refresh_btn = gtk.Button("Search")
+        refresh_btn.connect("clicked", lambda *x: self.populate())
+        hbox.pack_start(refresh_btn, False, False, 0)
+
+        ## add the commands list
+        sw = gtk.ScrolledWindow()
+        self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, gtk.gdk.Pixbuf,
+                                str, str, int, str)
+        self.treeview = gtk.TreeView(gtk.TreeModelSort(self.liststore))
+        sw.add(self.treeview)
+        #self.treeview.set_reorderable(True)
+        self.treeview.connect('row-activated', self.clicked)
+        self.treeview.connect("button_press_event", self.right_click)
+        self.init_cols()
+        self.pack_start(sw, True, True, 0)
+
+        ## Get more button
+        self.more_btn = gtk.Button("Get more!")
+        self.more_btn.connect("clicked",
+                lambda *x: self.populate(next_page=True))
+        hbox.pack_start(self.more_btn, False, False, 0)
+        self.more_btn.set_sensitive(False)
+
+        ## Show everything
+        self.show_all()
+
+    def add_pixbuf_col(self, colname, n=0):
+        col = gtk.TreeViewColumn()
+        col.set_title(colname)
+        render_pixbuf = gtk.CellRendererPixbuf()
+        col.pack_start(render_pixbuf, expand=True)
+        col.add_attribute(render_pixbuf, 'pixbuf', n)
+        col.set_resizable(True)
+        self.treeview.append_column(col)
+
+    def add_text_col(self, colname, n=0):
+        col = gtk.TreeViewColumn()
+        col.set_title(_(colname))
+        render = gtk.CellRendererText()
+        col.pack_start(render, expand=True)
+        col.add_attribute(render, 'text', n)
+        col.set_resizable(True)
+        col.set_sort_column_id(n)
+        self.treeview.append_column(col)
+
+    def init_cols(self):
+        self.add_pixbuf_col('', 0)
+        self.add_pixbuf_col('', 1)
+        self.add_text_col('Command', 2)
+        self.add_text_col('Summary', 3)
+        self.add_text_col('Votes', 4)
+
+    def populate_tags(self):
+        dbg('Poulating clf tags')
+        tag = self.tags_box.get_active_text()
+        if tag == "Update":
+            self.tags_box.set_model(gtk.ListStore(str))
+            self.tags_box.append_text('Update')
+            self.tags_box.append_text('None')
+            ## populate commands tags
+            for tag, tagid in self.clfu.get_tags():
+                self.tags_box.append_text(tag)
+            self.tags_box.set_active(1)
+
+    def populate(self, next_page=False, filter_str=''):
+        '''
+        populate the widgets with the info from the commandlinefu website
+        '''
+        ## get the filter params, the saved ones if it's a next page request or
+        ## the new ones if it's  anew search
+        self.liststore.clear()
+        if next_page:
+            tag, timerange, filter_str = self.lastsearch
+            page = len(self.pages)
+        else:
+            tag = self.tags_box.get_active_text()
+            timerange = self.trange_box.get_active_text()
+            self.lastsearch = tag, timerange, filter_str
+            page = 0
+            self.pages = []
+        ## get new commands page
+        if tag != 'None':
+            commands = self.clfu.tag(tag=tag, timerange=timerange, page=page)
+        elif filter_str != '':
+            commands = self.clfu.search(filter_str, timerange=timerange,
+                                page=page)
+        else:
+            commands = self.clfu.browse(timerange=timerange, page=page)
+        ## if there were no results, do avoid requesting more pages, show the
+        ## user that there are no more pages
+        self.more_btn.set_sensitive(True)
+        if not commands or len(commands) < 25:
+            self.more_btn.set_sensitive(False)
+        ## append it to the revious pages if any
+        self.pages.append(commands)
+        ## filter and show all the commands
+        for page in self.pages:
+            for command in page:
+                if filter_str != '':
+                    if filter_str not in command['command'] \
+                    and filter_str not in command['summary']:
+                        continue
+                add_btn = self.treeview.render_icon(stock_id=gtk.STOCK_ADD,
+                                 size=gtk.ICON_SIZE_SMALL_TOOLBAR)
+                link_btn = self.treeview.render_icon(stock_id=gtk.STOCK_INFO,
+                                 size=gtk.ICON_SIZE_SMALL_TOOLBAR)
+                self.liststore.append((add_btn, link_btn,
+                        command['command'], command['summary'],
+                        int(command['votes']), command['url']))
+
+    def filter(self, search_term):
+        """
+        Show commands matching a given search term.
+        The user should enter a term in the search box and the treeview should
+        only display the rows which contain the search term.
+        No reordering allowed when filtering.
+        """
+        ## If the search term is empty, and we change filtering state
+        ## restore the liststore, else do nothing
+        if search_term == "":
+            if self.filtering:
+                dbg("Uniltering...")
+                self.filtering = False
+                self.treeview.set_model(gtk.TreeModelSort(self.liststore))
+            return
+        dbg("Filtering...")
+        self.filtering = True
+        modelfilter = self.liststore.filter_new()
+
+        def search(model, iter, search_term):
+            cmd, desc = model.get(iter, 2, 3)
+            if search_term in ('%s %s' % (cmd, desc)).lower():
+                    return True
+        modelfilter.set_visible_func(search, search_term)
+        self.treeview.set_model(gtk.TreeModelSort(modelfilter))
+
+    def clicked(self, treeview, path, column):
+        treeselection = treeview.get_selection()
+        model, iter = treeselection.get_selected()
+        data = model.get(iter, 2, 3, 4, 5)
+        if column == treeview.get_column(0):
+            dbg('Adding command %s, %s, %s' % (data[0], '', data[1]))
+            self.emit('add_command', data[0], '', data[1])
+        elif column == treeview.get_column(1):
+            webbrowser.open(data[3])
+        else:
+            self.emit('run_command', data[0], '', data[1])
+
+    def get_command(self, withurl=False):
+        treeselection = self.treeview.get_selection()
+        model, iter = treeselection.get_selected()
+        if not iter:
+            return None, None, None
+        cmd, desc, url = model.get(iter, 2, 3, 5)
+        if not withurl:
+            return cmd, '', desc
+        return cmd, '', desc, url
+
+
+    #right-click popup menu for the Liststore(command list)
+    def right_click(self, widget, event):
+        if event.button == 3:
+            x = int(event.x)
+            y = int(event.y)
+            time = event.time
+            row = self.treeview.get_path_at_pos(x, y)
+            if row:
+                path, col, x, y = row
+            if row:
+                popupMenu = gtk.Menu()
+                self.treeview.grab_focus()
+                self.treeview.set_cursor(path, col, 0)
+                data = self.get_command(withurl=True)
+                if data[0] == None:
+                    return
+                # right-click popup menu Apply(run)
+                menuPopup1 = gtk.ImageMenuItem(gtk.STOCK_APPLY)
+                popupMenu.add(menuPopup1)
+                menuPopup1.connect("activate",
+                    lambda *x: self.emit('run_command', *data[:-1]))
+                # right-click popup menu AddToLocal
+                menuPopup2 = gtk.ImageMenuItem(gtk.STOCK_ADD)
+                popupMenu.add(menuPopup2)
+                menuPopup2.connect("activate",
+                    lambda *x: self.emit('add_command', *data[:-1]))
+                # right-click popup menu Help
+                menuPopup4 = gtk.ImageMenuItem(gtk.STOCK_HELP)
+                popupMenu.add(menuPopup4)
+                menuPopup4.connect("activate",
+                    lambda *x: self.emit('show_man', data[0]))
+                # right-click popup menu Online Help
+                menuPopup4 = gtk.ImageMenuItem(gtk.STOCK_INFO)
+                box = menuPopup4.get_children()[0]
+                box.set_label(_('Show online info'))
+                popupMenu.add(menuPopup4)
+                menuPopup4.connect("activate",
+                    lambda wg, url: webbrowser.open(url), data[3])
+                # Show popup menu
+                popupMenu.show_all()
+                popupMenu.popup(None, None, None, event.button, time)
+                return True

=== added file 'plugins/LocalCommandList.py'
--- plugins/LocalCommandList.py	1970-01-01 00:00:00 +0000
+++ plugins/LocalCommandList.py	2012-01-08 10:37:24 +0000
@@ -0,0 +1,710 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# LocalCommandList.py - Plugin for handling locally stored commands
+#
+# Copyright 2010 Duane Hinnen, Kenny Meyer, David Caro
+#                                               <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
+#
+
+
+import os
+import pygtk
+pygtk.require('2.0')
+import gobject
+
+try:
+    import gtk
+except:
+    ## do not use gtk, just print
+    print _("You need to install the python gtk bindings package"
+             "'python-gtk2'")
+    sys.exit(1)
+
+## we should try to absolutely detach it from the clicompanion libs someday
+from clicompanionlib.utils import dbg
+import clicompanionlib.plugins as plugins
+
+## Targets for the Drag and Drop
+TARGETS = [
+    ('MY_TREE_MODEL_ROW', gtk.TARGET_SAME_WIDGET, 0),
+    ('text/plain', 0, 1),
+    ('TEXT', 0, 2),
+    ('STRING', 0, 3),
+    ]
+
+
+class LocalCommandList(plugins.TabPlugin):
+    '''
+    Tab with the list of local stored commands, the ponly signals that should
+    get emited (right now) are the run_command and show_man. The other can be
+    processed inhouse
+    '''
+    __authors__ = ('Duane Hinnen\n'
+                   'Kenny Meyer\n'
+                   'Marcos Vanettai\n'
+                   'Marek Bardoński\n'
+                   'David Caro <[e-mail]>\n')
+    __info__ = ('This is the main plugin for the CLI Companion, the one that '
+                'handles the locally stored commands.')
+    __title__ = 'Local Commands'
+
+    def __init__(self, config):
+        self.config = config
+        plugins.TabPlugin.__init__(self)
+        self.treeview = gtk.TreeView()
+        self.filtering = False
+        ## command, user input, description, and index in cmnds array
+        self.liststore = gtk.ListStore(str, str, str, int)
+        ## Load the given commands file
+        self.cmnds = Cheatsheet(
+                self.config.get('default', 'cheatsheet'))
+        ## will hold the commands. Actually the first three columns
+        ## note that this commands list will not change with searchers nor
+        ## filters, instead, when adding a command to the liststore, we will
+        ## add also the index of the command in the cmnds array as another
+        ## field
+        self.sync_cmnds(rld=True)
+        self.treeview.set_model(DummySort(self.liststore))
+
+        ### Only show the three firs columns
+        ## create the TreeViewColumns to display the data
+        self.add_text_col('Command', 0)
+        self.add_text_col('User Input', 1)
+        self.add_text_col('Description', 2)
+        self.treeview.set_tooltip_column(2)
+        self.treeview.set_reorderable(True)
+        ## open with top command selected
+        selection = self.treeview.get_selection()
+        selection.select_path(0)
+        selection.set_mode(gtk.SELECTION_SINGLE)
+        ### double-click
+        self.treeview.connect("row-activated", self.event_clicked)
+        ##press enter to run command
+        self.treeview.connect("key-press-event",
+                lambda wg, event: self.event_key_pressed(event))
+        ## Right click event
+        self.treeview.connect("button_press_event", self.right_click)
+        # Allow enable drag and drop of rows including row move
+        self.treeview.enable_model_drag_source( gtk.gdk.BUTTON1_MASK,
+                                                TARGETS,
+                                                gtk.gdk.ACTION_DEFAULT |
+                                                gtk.gdk.ACTION_COPY)
+        self.treeview.enable_model_drag_dest(TARGETS,
+                                                gtk.gdk.ACTION_DEFAULT)
+
+        self.treeview.connect ("drag_data_get", self.drag_data_get_event)