# -*- coding: utf-8 -*-
## File gui.py
## This file is part of pyArq-Presupuestos.
##
## Copyright (C) 2010 Miguel Ángel Bárcena Rodríguez
##                         <miguelangel@obraencurso.es>
##
## pyArq-Presupuestos is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## pyArq-Presupuestos is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program.  If not, see <http://www.gnu.org/licenses/>.
##

"""Gui module

The MainWindow class contain the toplevel WINDOW,
this window have a notebook with a page for each budget.
Each budget or notebook page is showed by the Page class, this class contain
the main widget showed in a page notebook.
The main widget can show the budget information in several panes.
This panes are ordened in gtk.Paned represented for the class Paned which can
have 2 viewes represented for the View class or other gtk.Paned that have other
viewes or more gtk.Paned.
The view can have diferente type of widgets to show the budget information.
The DecompositionList class show the decompositon list information of a record
The Measure class show de measure information of a record
The TextWindow class show the long description of a record
The Sheet class class show the sheet of condition information of a record

The views can send signal to the others.
All the viewes ordered in panes can be or not be connected to the others,
if there are connecteded to the others when the user change the active code in
one of the panes the active code change in the others.

"""
# TODO: Config file

# Standar Modules
import os
import time
import pygtk
pygtk.require('2.0')
import gtk
import gobject
import weakref

# pyArq-Presupuestos Modules
from Gtk import importFiebdc
from Generic import base
from Generic import fiebdc
from Generic import durusdatabase
from Generic import utils
from Generic import globals
from Generic import openwith

# Load default icon
if os.path.exists(globals.getAppPath("ICON")):
    icon = gtk.gdk.pixbuf_new_from_file(globals.getAppPath("ICON"))
    gtk.window_set_default_icon_list(icon)
else:
    print utils.mapping(_("The icon file does not exist. '$1'"),
          (globals.getAppPath("ICON"),))

# Autodetect desktop
if globals.desktop["autodetect"] is True:
    openwith.autodetect_desktop()
    print utils.mapping(_("pyArq-Presupuestos running on $1"),
                        (globals.desktop["desktop"],))

class MainWindow(object):
    """gui.MainWindow:
    
    Description:
        Creates and shows the main window.
        This is the interface base class.
    Constructor:
        gui.MainWindow(): Returns the newly created main window instance
    Ancestry:
    +-- object
      +-- MainWindow
    Atributes:
        "window": Main window widget ("gtk.Window" object)
        "__budget_temp_list": Temporal list of budgets
        "__budget_list": List of budgets ("base.Budget" objects)
        "__page_list": List of pages ("Page" object)
        "__notebook": Notebook widget ("gtk.Notebook" object)
        "__general_action_group": the "General" action group
    Methods:
        __init__(self)
        _main(self)
        _addBudget(self, budget)
        _appendPage(self)
        _testBudgetList(self)
        _menuitemImportFiebdc(self, widget)
        _menuitemImportPriceDatabase(self, widget)
        _menuitemOpenPriceDatabase(self, widget)
        _menuitemOpen
        _menuitemClose(self, widget)
        _menuitemText(self, widget)
        _delete_event(self, widget, event)
        _destroy(self, widget)
    """
    # TODO:* Can choose open budget in new window
    # TODO:* gtk.Action for menu and toolbar
    # TODO:* Can choose show more than one notebook in the same window or
    # TODO:  can show basedata notebook in a side pane
    __ui = '''<ui>
    <menubar name="MenuBar">
      <menu action="File">
        <menuitem action="ImportFiebdc"/>
        <menuitem action="Close"/>
      </menu>
      <menu action="View">
        <menuitem action="Text"/>
      </menu>
      <menu action="Test">
        <menuitem action="ImportFiebdcPriceDatabase"/>
        <menuitem action="OpenPriceDatabase"/>
      </menu>
    </menubar>
    <toolbar name="ToolBar">
      <toolitem action="ImportFiebdc"/>
      <separator/>
      <toolitem action="Close"/>
      <separator name="sep1"/>
    </toolbar>
    </ui>'''

    def __init__(self):
        """def __init__(self)
        
        Initialize the atributes "__budget_list" and "__page_list" without data.
        Creates the widgets "window" and "__notebook".
        """
        self.__budget_temp_list = []
        self.__budget_list = []
        self.__page_list = []
        # Main window
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_default_size(771, 570)
        self.window.set_title("Presupuestos")
        self.window.set_border_width(0)
        self.window.connect("destroy", self._destroy)
        self.window.connect("delete_event", self._delete_event)
        # Vertical box
        _vbox1 = gtk.VBox(False, 0)
        self.window.add(_vbox1)
        _vbox1.show()
        #Uimanager
        _uimanager = gtk.UIManager()
        _accelgroup = _uimanager.get_accel_group()
        self.window.add_accel_group(_accelgroup)
        _general_action_group = gtk.ActionGroup("General")
        self.__general_action_group = _general_action_group
        _general_action_group.add_actions(
            [("File", None, _("_File"), None),
             ("ImportFiebdc", gtk.STOCK_OPEN, _('_Import Fiebdc'), "", 'NPI',
                self._menuitemImportFiebdc),
             ("Close", gtk.STOCK_CLOSE, _("_Close"), None, 'NPI',
                self._menuitemClose),
             ("View", None, _("_View")),
             ("Text", None, _("_Text"), None, 'NPI',
                self._menuitemText),
             ("Test", None, _("_Test")),
             ('ImportFiebdcPriceDatabase', gtk.STOCK_OPEN,
                _("Import Fiebdc _price database"), "", "NPI",
                self._menuitemImportPriceDatabase ),
             ("OpenPriceDatabase", gtk.STOCK_OPEN, _('_Open price database'),
                "", 'NPI', self._menuitemOpenPriceDatabase),
            ])
        _uimanager.insert_action_group(_general_action_group, 0)
        _uimanager.add_ui_from_string(self.__ui)
        _menu_bar = _uimanager.get_widget("/MenuBar")
        _vbox1.pack_start(_menu_bar, False, False, 0)
        _toolbar = _uimanager.get_widget("/ToolBar")
        _toolbar.get_settings().set_long_property("gtk-toolbar-icon-size",
            gtk.ICON_SIZE_SMALL_TOOLBAR, "pyArq-Presupuestos:toolbar")
        _vbox1.pack_start(_toolbar, False, False, 0)
        # Notebook
        self.__notebook = gtk.Notebook()
        _vbox1.pack_start(self.__notebook, True, True, 0)
        self.__notebook.set_tab_pos(gtk.POS_TOP)
        self.__notebook.set_show_tabs(True)
        self.__notebook.set_show_border(True)
        self.__notebook.set_scrollable(True)
        self.__notebook.show()
        self._main()
        
    def _main(self):
        """def main(self)
        
        Shows window and starts the GTK+ event processing loop.
        """
        self.window.show()
        gtk.main()
        
    def _addBudget(self, budget):
        """def _addBudget(self, budget)
        
        budget: "base.Budget" object
        
        Appends a budget in the "__budget_list"
        """
        if budget != None:
            _budget = budget
            if _budget in self.__budget_temp_list:
                self.__budget_temp_list.remove(_budget)
            self.__budget_list.append(_budget)

    def _appendPage(self):
        """def _appendPage(self)
        
        Creates a new page (instance of "Page class") from the last budget in
        __budget_list, appends this page in the "__page_list" and shows the
        page widget in the notebook widget.
        """
        _last_budget = self.__budget_list[-1]
        _page = Page(_last_budget)
        self.__notebook.append_page(_page.widget, _page.title)
        self.__page_list.append(_page)

    def _testBudgetList2(self):
        """def _testBudgetList2(self)
        
        Test if the number of budgets ("__budget_list") is greater
        than the number of pages ("__page_list"), if it is greater 
        appendPage method is called to create a page to show the new budget
        and save the budget in a durus file.
        """
        if len(self.__budget_list) > len(self.__page_list):
            self._appendPage()
            #-# in test mode
            # TODO: It must be in a thread
            _last_budget = self.__budget_list[-1]
            _path = globals.getHomePath("DURUS-DATABASE")
            _file_whit_path_bc3 = _last_budget.filename
            _filename_bc3 = _file_whit_path_bc3.split("/")[-1]
            _filename = _filename_bc3.split(".")[-2]
            _file = _path + _filename + ".durus"
            print utils.mapping(_("Saving file: $1"), (_file,))
            _time = time.time()
            _durus_file = durusdatabase.DurusFile(_file,True)
            _durus_file.setBudget(_last_budget)
            _durus_file.close()
            print utils.mapping(_("Saving time: $1 seconds"),
                  (("%.2f" %(time.time()-_time) ),))
            #-#
            return False
        return True

    def _menuitemImportFiebdc(self, widget):
        """def _menuitemImportFiebdc(self, widget)
        
        widget: the widget where the event is emitted from
        Callback to open a budget file.
        Inits a timeout to test if a budgets is appended to "__budget_list"
        calling _testBudgetList method if it is true.
        
        Creates and shows a window to open a budget file.
        """
        _budget = base.Budget()
        self.__budget_temp_list.append(_budget)
        _budget_file = fiebdc.Read()
        _read_method = _budget_file.readFile
        _filename = "file"
        _exit_method = _budget_file.cancel
        _file_window = importFiebdc.FileSelectionWindow(self,
            _read_method, _budget, _filename, _exit_method)

    def _menuitemImportPriceDatabase(self, widget):
        """def _menuitemImportPriceDatabase(self, widget)
        
        widget: the widget where the event is emitted from
        Callback to open a budget file.
        Inits a timeout to test if a budgets is appended to "__budget_list"
        calling _testBudgetList method if it is true.
        
        Creates and shows a window to open a budget file.
        """
        #TODO: change timeout, it is deprecated
        #TODO: the .durus file must be direted saved
        gobject.timeout_add(100, self._testBudgetList2)
        _budget = base.Budget()
        self.__budget_temp_list.append(_budget)
        _budget_file = fiebdc.Read()
        _read_method = _budget_file.readFile
        _filename = "file"
        _exit_method = _budget_file.cancel
        _file_window = importFiebdc.FileSelectionWindow(self,
            _read_method, _budget, _filename, _exit_method)

    def _menuitemOpenPriceDatabase(self, widget):
        """def _menuitemImportPriceDatabase(self, widget)
        
        widget: the widget where the event is emitted from
        Callback to open a budget file.
        Inits a timeout to test if a budgets is appended to "__budget_list"
        calling _testBudgetList method if it is true.
        
        Creates and shows a window to open a budget file.
        """
        _openDialog = OpenDurusDatabase(self._OpenDurusDatabase)
        _openDialog.main()

    def _OpenDurusDatabase(self, file):
        """def _menuitemImportFiebdc(self, widget)
        
        widget: the widget where the event is emitted from
        
        Callback to open a budget file from a durus file.
        """
        _file = file
        print utils.mapping(_("Loading file: $1:"), (_file,))
        _time = time.time()
        _durus_file = durusdatabase.DurusFile(_file,False)
        _budget = _durus_file.getBudget()
        _durus_file.close()
        print utils.mapping(("Loadig time: $1 seconds"),
             (("%.2f" %(time.time()-_time)),))
        self.__budget_list.append(_budget)
        _page = Page(_budget)
        self.__notebook.append_page(_page.widget, _page.title)
        self.__page_list.append(_page)

    def _menuitemClose(self, widget):
        """def _menuitemClose(self, widget)
        
        widget: the widget where the event is emitted from
        
        Callback to close a budget file.
        """
        _page_num = self.__notebook.get_current_page()
        if _page_num == -1:
            return
        _page = self.__page_list.pop(_page_num)
        if isinstance(_page, Page):
            #not loading budget
            self.__budget_list.pop(_page_num)
        _page.clear()
        self.__notebook.remove_page(_page_num)

    def _menuitemText(self, widget):
        """_menuitemText(self, widget)
        
        widget: the widget where the event is emitted from
        
        Creates and shows a window showing text description
        using a instance of TextWindow class.
        """
        _page_num = self.__notebook.get_current_page()
        if _page_num == -1:
            return
        _budget = self.__budget_list[_page_num]
        _page = self.__page_list[_page_num]
        _code = _page.getActiveCode()
        _concepto = _budget.getRecord(_code)
        _text = _concepto.text
        _window = TextWindow(_code, _text)
        _window.main()

    def _delete_event(self, widget, event):
        """_delete_event(self, widget, event)
        
        widget: the widget where the event is emitted from
        event: the "gtk.gdk.Event"
        
        Method connected to "delete_event" signal of main window widget
        This signal is emitted when a user press the close titlebar button.
        It Returns True so the signal "destroy" is emitted.
        """
        for _page in self.__page_list:
            _page.clear()
        return False # -> destroy

    def _destroy(self, widget):
        """_destroy(self, widget)
        
        widget: the widget where the event is emitted from
        Method connected to "destroy" signal of main window widget
        
        This signal is emited when the method connected to "delete_event"
        signal returns True or when the program call the destroy() method of
        the gtk.Window widget.
        The window is closed and the GTK+ event processing loop is ended.
        """
        gtk.main_quit()

    def getNotebook(self):
        return self.__notebook
    def getPageList(self):
        return self.__page_list
    def getBudgetList(self):
        return self.__budget_list

class EmptyPage(object):
    """
    """
    def __init__(self, mainWindow, readFileMethod, budget, filename,
                 cancelMethod):
        """def __init__(self, mainWindow, readFileMethod, budget, filename,
                        cancelMethod)
        
        """
        self.__mainWindow = mainWindow
        self.__readFileMethod = readFileMethod
        self.__budget = budget
        self.__filename = filename
        self.__cancelMethod = cancelMethod
        self.__children = None
        self.__cancel = [False, False]
        self.__progress = 0.0
        self.__widget = gtk.VBox()
        self.__main_item = None
        self.__widget.show()
        self.__throbber = gtk.Image()
        self.__throbber.set_from_file(globals.getAppPath("THROBBER-ICON"))
        self.__throbber.show()
        self.__animationThobber = gtk.gdk.PixbufAnimation(
                                  globals.getAppPath("THROBBER-GIF"))
        self.__quietThobber = self.__throbber.get_pixbuf()
        self.__budget_icon = gtk.gdk.pixbuf_new_from_file_at_size(
                             globals.getAppPath("BUDGET-ICON"), 16, 16)
        _filename = os.path.basename(filename)
        _rootfilename = os.path.splitext(_filename)[0]
        if not _rootfilename == "":
            _filename = _rootfilename
        _titleLabel = gtk.Label(_filename)
        _titleLabel.show()
        self.__title = gtk.HBox()
        self.__title.add(self.__throbber)
        self.__title.add(_titleLabel)
        self.__statusbar = gtk.Statusbar()
        self.__statuscontext = self.__statusbar.get_context_id("Statusbar")
        self.__statusbar.show()
        _align = gtk.Alignment(0.5, 0.5, 0, 0)
        _iconVbox = gtk.VBox()
        _pyArqIcon = gtk.Image()
        _pyArqIcon.set_from_file(globals.getAppPath("PYARQ-ICON"))
        _pyArqIcon.show()
        _iconVbox.pack_start(_pyArqIcon, True, True, 0)
        _link = gtk.LinkButton("http://pyarq.obraencurso.es",
                               "http://pyarq.obraencurso.es")
        _iconVbox.pack_start(_link, True, True, 0)
        _link.show()
        _iconVbox.show()
        _align.add(_iconVbox)
        _align.show()
        self.__widget.pack_start(_align, True, True, 0)
        _progressframe = gtk.Frame()
        _progressframe.set_shadow_type(gtk.SHADOW_IN)
        _progressframe.show()
        self.__progress_bar = gtk.ProgressBar()
        self.__progress_bar.show()
        _progressframe.add(self.__progress_bar)
        self.__statusbar.pack_start(_progressframe, False, False, 0)
        self.__widget.pack_end(self.__statusbar, False, True, 0)
        self.__main_item = None

    def run(self):
        self.__statusbar.push(self.__statuscontext, _("Time: 0s"))
        self.__throbber.set_from_animation(self.__animationThobber)
        self._launchChildren()
        self._launchTimeout()

    def progress(self, percent):
        _progress = str(int(round(100 * percent,0)))
        self.__progress = percent

    def stopLoading(self):
        self.__throbber.set_from_pixbuf(self.__budget_icon)
        self.__progress_bar.hide()
        self.__statusbar.pop(self.__statuscontext)

    def _launchChildren(self):
        """_launchChildren(self)
        
        Launch the thread to read the file
        """
        if self.__children is None:
            self.__children = importFiebdc.Thread(self, self.__mainWindow,
                self.__readFileMethod, self.__budget, self.__filename,
                self.__cancelMethod)
            self.__children.start()

    def _launchTimeout(self):
        """def _launchTimeout(self)
        
        Launch the timeouts: 
            1- update progress bar
            2- update time label
            3- If the other timetouts are stoped the window is closed
        """
        gobject.timeout_add(500, self._updateProgressBar)
        gobject.timeout_add(1000, self._updateLabel, time.time())
        self.__cancel = [False, False]
        gobject.timeout_add(1000, self._autoClose)

    def _updateProgressBar(self):
        """def _updateProgressBar(self)
        
        update progress bar in a timeout
        If the thread end or is canceled the timeout is stoped
        """
        if  self.__children is None or self.__children.isCanceled() == True:
            self.__cancel[0] = True
            return False
        else:
            self.__progress_bar.set_fraction(self.__progress)
            _text = "%s%%" %str(int(round(100 * self.__progress,0)))
            self.__progress_bar.set_text(_text)
            return True

    def _updateLabel(self, _time):
        """def _updateProgressBar(self)
        
        update time label in a timeout
        If the thread end or is canceled the timeout is stoped
        """
        if  self.__children is None or self.__children.isCanceled() == True:
            self.__cancel[1] = True
            return False
        else:
            _time = time.time() - _time
            _text = utils.mapping(_("Time: $1"), ("%.0f" %_time,))
            self.__statusbar.pop(self.__statuscontext)
            self.__statusbar.push(self.__statuscontext, _text)
            return True

    def _autoClose(self):
        """def _updateProgressBar(self)
        
        If the time label and progress bar timeouts are stoped the window is 
        closed and ist tiemeout is stoped
        """
        if self.__cancel == [ True, True ]:
            return False
        else:
            return True

    def closeWindow(self):
        """def closeWindow(self)
        
        Sets the __children atribute to None
        This causes that the timeouts is ended.
        This method is called from thread when it is finished
        TODO: it must called threadFinished or somethig
        """
        self.__children = None
        self.stopLoading()
        _page = Page(self.__budget)
        _children = self.__widget.get_children()
        for _child in _children:
            self.__widget.remove(_child)
        self.__widget.pack_start(_page.widget, True, True, 0)
        _noteBook = self.__mainWindow.getNotebook()
        _pageIndex = _noteBook.page_num(self.__widget)
        self.__mainWindow.getPageList()[_pageIndex] = _page
    def threadCanceled(self):
        """def threadCanceled(self)
        
        Sets the __children atribute to None
        This causes that the timeouts is ended.
        This method is called from thread when is canceled
        TODO: it must called threadFinished or somethig
        """
        self.__children = None
        self.stopLoading()

    def clear(self):
        """def clear(self)
        
        Cancel thread
        """
        self.__children.cancel()
        
    def getWidget(self):
        """def getWidget(self)
        
        Return de main widget to show in the page
        """
        return self.__widget

    def getTitle(self):
        """def getTtle(self)
        
        Return the title of the page, a gtk.Label objetc
        """
        return self.__title

    widget = property(getWidget, None, None,
                      "Main widget showed in the pane")
    title = property(getTitle, None, None,
                      "Page Title")

class Page(object):
    """gui.Page:
    
    Description:
    It creates and shows a page in the notebook from a budget object.
    The page can show the budget information in several panes ordered
    according to "panes_list" information.
    Constructor:
        gui.Page(budget, active_code=None):
        budget: budget to be showed in this page (base.Budget object)
        active_code: the code of the active record 
        Returns the newly created Page instance
    Ancestry:
    +-- object
      +-- Page
    Atributes:
        "budget": Read-Write. Budget to show in the page. (base.obra object)
        "panes_list": Read. info list for create the panes
            ej: [ "v", pane1, pane2 ] , [ "h", pane1, pane2 ]
                [ "v", [ "h", pane1, pane2 ], [ "h", pane1, pane2 ] ]
            pane types:
                * "DecompositionList": its creates a "DecompositionList" object 
                * "RecordDescription" : its creates a "Description" objetc
                * "Measure": its creates a "Measure" objetc
                * "FileView": its creates a "FileView" objet
                * "CompanyView": its creates a "CompanyView" object
        "widget": Read. Notebook page Widget. (a gtk.VBox instance)
        "title": Read. Notebook page title (gtk.Label object)
        "__active_path_record": The active path record
        "__main_item": main item in the page, can be a View object or a Paned 
            object
    Methods:
        __init__(self, budget=None, active_code=None)
        propagateMessageFrom(self, message, path, arg=None)
        sendMessageTo(self, pane, message, path, arg=None)
        clear(self)
        getItem(self,path)
        setMainItem(self, item)
        itemsFactory(self, list_paned, path=(0,))
        setActivePathRecord(self, path_record)
        getTitle(self)
        getWidget(self)
        setBudget(self, budget)
        getBudget(self)
        getPanesList(self)
    """
    # TODO:  * The panes can be ordered as the user wishes 
    # TODO:  * Panes in windows
    # TODO:  * pane types
    # TODO:      * General budget properties (is better a dialog?)

    def __init__(self, budget, path_record=(0,)):
        """def __init__(self, budget=None, active_code=None)
        
        budget: "base.Budget" object
        active_code: the code of the active record
        Sets the atributes
            * __panes_list: info to create the panes
            * budget (base.Budget object)
            * active_code
        """
        #TODO: __panes_list should come from config file...
        self.__widget = gtk.VBox()
        self.__panes_list = [ "v", "DecompositionList", [ "v", "Measure",
            "RecordDescription" ]]
        self.__main_item = None
        self.setBudget(budget)
        self.setActivePathRecord(path_record)
        self.__widget.show()

    def propagateMessageFrom(self, message, path, arg=None):
        """def propagateMessageFrom(self, message, path, arg=None)
        
        message: string message
        path: tuple that represents the pane path which emits the message
        arg: arguments for the message
             if message is "change_active" arg is the path record
        
        The panes are connectted to this method to send messages to other panes
        """
        _budget = self.__budget
        if message == "change_active" and _budget.hasPath(arg):
            self.sendMessageTo(self.__main_item, message, path, arg)
        elif message == "autoclose":
            self._closeItem(path)
        elif message == "split h":
            self._splitItem(path, "h")
        elif message == "split v":
            self._splitItem(path, "v")
            
    def sendMessageTo(self, pane, message, path, arg=None):
        """def sendMessageTo(self, pane,message, path, arg=None)
        pane: the receiver pane
        message: string message
        path: tuple that represents the pane path which emits the message
        arg: arguments for the message
        
        Sends a message to a pane
        """
        if not pane.path == path:
            pane.runMessage(message, path, arg)

    def clear(self):
        """def clear(self)
        
        Clear atributes
        """
        self.propagateMessageFrom("clear", (0,))
        
        del self.__budget
        del self.__panes_list
        del self.__widget
        del self.__title
        del self.__active_path_record
        del self.__main_item

    def getItem(self,path):
        """def getItem(self, path
        
        Return the item whith the path "path", it can return a Paned instance
        or a View instance
        """
        _item = self.__main_item
        if len(path) == 1:
            return _item
        else:
            return _item.getItem(path[1:])

    def setMainItem(self, item):
        """setMainItem(self,item)
        
        Sets a new main item in the page
        """
        if not self.__main_item is None:
            _old_main_widget = self.__main_item.widget
            self.__widget.remove(_old_main_widget)
        self.__main_item = item
        _main_widget = self.__main_item.widget
        _main_widget.show()
        self.__widget.pack_start(_main_widget, True, True, 0)

    def _splitItem(self, path, orientation):
        """_splitItem(self, path, orientation)
        
        Splits the item that is identifies by the path and the orientation
        """
        _item = self.getItem(path)
        _parent = self.getItem(path[:-1])
        _item.setPath(path+ (0,))
        _item_clone0 = _item.getClone(path + (0,))
        _item_clone1 = _item.getClone(path + (1,))
        _paned = Paned(orientation, path, _item_clone0, _item_clone1)
        if len(path) > 1:
            _parent.setItem(path[-1], [_paned])
        else:
            self.setMainItem(_paned)
        
    def _closeItem(self, path):
        """_closeItem(self, path)
        
        Closes the item that is identifies by the path
        """
        _item = self.getItem(path)
        if len(path) > 1:
            # There are more than one item
            _parent = self.getItem(path[:-1])
            _brothers = [ _brother for _brother in _parent]
            _brothers.remove(_item)
            _brother = _brothers[0]
            
            _parent.widget.remove(_brother.widget)
            _brother.path = path[:-1]
            if len(path) > 2:
                _grandparent = self.getItem(path[:-2])
                _grandparent.setItem(path[-2], [_brother])
                _parent.widget.destroy()
                _parent.clear()
                _item.clear()
            else:
                _grandparent = self
                _grandparent.setMainItem(_brother)
                _parent.widget.destroy()
                _parent.clear()
                _item.clear()
        else:
            # Thre is only one item in the page, it can not be closed
            pass

    def itemsFactory(self, list_paned, path=(0,)):
        """def itemsFactory(self, list_paned, path(0,))
        
        list_paned: list in "__panes_list" format
            [ "v" or "h", panel1_type, panel2_type]
            which contains the info for create the widgets. 
            panel types:
                * "DecompositionList"
                * "RecordDescription"
                * "Measure"
                * "Sheet of Conditions"
                * "FileView"
                * "CompanyView"
        path: tuple that represents the item path in the page
        
        Creates the items and widgets and returns the main item
        """
        if not isinstance(list_paned , list):
            raise ValueError, _("The value must be a list")
        if list_paned[0] == "v" or  list_paned[0] == "h":
            if len(list_paned) != 3:
                raise ValueError, _("Incorrect len")
            if not isinstance(list_paned[1],list):
                list_paned[1] = [list_paned[1]]
            if not isinstance(list_paned[2],list):
                list_paned[2] = [list_paned[2]]
            _item1 = self.itemsFactory(list_paned[1],path + (0,))
            _item2 = self.itemsFactory(list_paned[2],path + (1,)) 
            _item = Paned(list_paned[0], path, _item1, _item2)
        elif list_paned[0] == "DecompositionList":
            _item = View( "DecompositionList", self.__budget,
                weakref.ref(self), path, self.__active_path_record)
        elif list_paned[0] == "RecordDescription":
            _item = View( "RecordDescription", self.__budget,weakref.ref(self),
                path, self.__active_path_record)
        elif list_paned[0] == "Measure":
            _item = View( "Measure", self.__budget, weakref.ref(self), path,
                self.__active_path_record)
        elif list_paned[0] == "Sheet of Conditions":
            _item  = Sheet(sef.__budget, weakref.ref(self), path,
                self.__active_path_record)
        elif list_paned[0] == "FileView":
            _item  = FileView(sef.__budget, weakref.ref(self), path,
                self.__active_path_record)
        elif list_paned[0] == "CompanyView":
            _item  = CompanyView(sef.__budget, weakref.ref(self), path,
                self.__active_path_record)
        else:
            _item = None
            raise ValueError, utils.mapping(_("Incorrect item $1"),
                  (str(list_paned[0]),))
        return _item

    def setActivePathRecord(self, path_record):
        """def setActivePathRecord(self, path_record)
        
        path_record: the active record path
        
        Sets the active record path
        """
        if self.__budget.hasPath(path_record):
            self.__active_path_record = path_record
        else:
            raise ValueError, utils.mapping(_("The budget does not have the "\
                  "path record: $1"), (str(path_record),))

    def getTitle(self):
        """def getTtle(self)
        
        Return the title of the page, a gtk.Label objetc
        """
        return self.__title
    
    def getWidget(self):
        """def getWidget(self)
        
        Return de main widget to show in the pane
        """
        return self.__widget
    
    def setBudget(self, budget):
        """def setBudget(self, budget)
        
        budget: a base.Budget object
        
        Sets the budget and the active code atributes,
        creates the page title and the widgets in the pane and
        shows the main widget.
        """
        if budget is None:
            self.clear()
            return
        self.__budget = budget
        self.setActivePathRecord((0,))
        ## Todo: change page title
        self.__title = gtk.Label(self.__budget.getCode(
                       self.__active_path_record))
        _panes_list = self.__panes_list
        self.__main_item = self.itemsFactory(_panes_list)
        _main_widget = self.__main_item.getWidget()
        _main_widget.show()
        self.__widget.pack_start(_main_widget, True, True, 0)

    def getBudget(self):
        """def getBudget(self)
        
        Return de budget, a "base.Budget" object.
        """
        return self.__budget
    
    def getPanesList(self):
        """def getPanesList(self)
        
        Return the panes list, info list for create the panes.
        """
        return self.__panes_list
    
    budget = property(getBudget, setBudget, None,
                      "Budget to show, base.Budget object")
    widget = property(getWidget, None, None,
                      "Main widget showed in the pane")
    title = property(getTitle, None, None,
                      "Page Title")
    panes_list = property(getPanesList, None, None,
                      "Info list for create the panes")

class View(object):
    """gui.View:
    
    Description:
        It creates a view to show the budget info
    Constructor:
        View(view_type, budget, wr_page, path, active_path_record)
    Ancestry:
    +-- object
      +-- Paned
    Atributes:
        "path": the tuple that identifies the view in the main notebook page
        "widget": the main gtk widget to show in a view object,
            a gtk.VBox object
        "__view_type": the object type to show
            * DecompositionList
            * Description
            * Measure
            * Sheet of conditions
            * FileView
            * CompanyView
        "__wr_page": weak reference to the page where the view must be showed
        "__budget": the budget to show
        "__view ": the object to show:
            * DecompositionList object
            * Description object
            * Measure object
            * Sheet object
            * FileView object
            * Comapany View
        "__connected": boolean value, True means that the View object sends and
            receives signals from/to others views
        "__connected_button": a button to switch __connected True or False
    Methods:
        __init__(self)
        getItem(self, path)
        _closeItem(self, close_button)
        _change_combo(self, combobox)
        propagateMessgeFrom(self, message, path, arg=None)
        runMessage(self, message, path, arg=None)
        getWidget(self)
        getPath(self)
        setPath(self)
        getClone(self, newpath)
        clear(self)
    """
    def __init__(self, view_type, budget, wr_page, path, active_path_record):

        """def __init__(self, view_type, budget, wr_page, path,
                        active_path_record)
        view_type: the object type to show
            * DecompositionList
            * Description
            * Measure
            * Sheet
            * FileView
            * CompanyView
        budget: the budget to show
        wr_page: weak reference to the page where the view must be showed
        path: the position or path of the view in the page notebook
        active_path_record: the record path that must be showed
        
        Creates and shows a new view
        """
        self.__active_path_record = active_path_record
        self.__view_type = view_type
        self.__wr_page = wr_page
        self.__budget = budget
        self.__path = path
        self.__connected = True
        # view_type liststore
        _liststore = gtk.ListStore(str)
        _liststore.append([_("Decomposition")]) #0
        _liststore.append([_("Description")]) #1
        _liststore.append([_("Measure")]) #2
        _liststore.append([_("Sheet of Conditions")]) #3
        _liststore.append([_("Files")]) #4
        _liststore.append([_("Companies")]) #5
        _combobox = gtk.ComboBox(_liststore)
        _cell = gtk.CellRendererText()
        _combobox.pack_start(_cell, True)
        _combobox.add_attribute(_cell, 'text', 0)
        _vbox = gtk.VBox()
        _vbox.show()
        _toolitem = gtk.ToolItem()
        _toolitem.set_expand(True)
        _toolitem.add(_vbox)
        _toolitem.show()
        self.__widget = gtk.Toolbar()
        self.__widget.insert(_toolitem, 0)
        _hbox = gtk.HBox()
        if view_type == "DecompositionList":
            self.__view = DecompositionList(budget, weakref.ref(self),
                          path, active_path_record)
            _combobox.set_active(0)
            _view_icon = gtk.Image()
            _view_icon.set_from_file(globals.getAppPath("DECOMPOSITION-ICON"))
        elif view_type == "RecordDescription":
            self.__view = Description(budget, weakref.ref(self),
                          path, active_path_record)
            _combobox.set_active(1)
            _view_icon = gtk.Image()
            _view_icon.set_from_file(globals.getAppPath("DESCRIPTION-ICON"))
        elif view_type == "Measure":
            self.__view = Measure(budget, weakref.ref(self),
                          path, active_path_record)
            _combobox.set_active(2)
            _view_icon = gtk.Image()
            _view_icon.set_from_file(globals.getAppPath("MEASURE-ICON"))
        elif view_type == "Sheet of Conditions":
            self.__view = Sheet(budget, weakref.ref(self),
                          path, active_path_record)
            _combobox.set_active(3)
            _view_icon = gtk.Image()
            _view_icon.set_from_file(globals.getAppPath("SHEET-ICON"))
        elif view_type == "FileView":
            self.__view = FileView(budget, weakref.ref(self),
                          path, active_path_record)
            _combobox.set_active(4)
            _view_icon = gtk.Image()
            _view_icon.set_from_file(globals.getAppPath("SHEET-ICON"))
        elif view_type == "CompanyView":
            self.__view = CompanyView(budget, weakref.ref(self), path,
                          active_path_record)
            _combobox.set_active(5)
            _view_icon = gtk.Image()
            _view_icon.set_from_file(globals.getAppPath("SHEET-ICON"))
            
        else:
            raise ValueError, _(utils.mapping("Invalid type of View: $1",
                  view_type))
        _view_icon.show()
        _combobox.connect("changed", self._change_combo)
        _combobox.show()
        _vbox.pack_start(_hbox,False)
        _vbox.pack_start(self.__view.widget, True, True)
        _hbox.pack_start(_view_icon, False, False,0)
        _hbox.pack_start(_combobox, False, False,0)
        _invisible = gtk.HBox()
        _invisible.show()
        _hbox.pack_start(_invisible, True, False,0)
        _icon_menu = gtk.Image()
        _icon_menu.set_from_file(globals.getAppPath("MENU-ICON"))
        _icon_menu.show()
        _menu_button = gtk.ToolButton()
        _menu_button.set_icon_widget(_icon_menu)
        _menu_button.connect("clicked", self._menu_view)
        _menu_button.show()
        _icon_connected = gtk.Image()
        _icon_connected.set_from_file(globals.getAppPath("CONNECTED-ICON"))
        _icon_connected.show()
        _hbox.pack_start(_menu_button, False, False, 0)
        self.__connected_button = gtk.ToolButton()
        self.__connected_button.set_icon_widget(_icon_connected)
        self.__connected_button.connect("clicked", self._connected)
        self.__connected_button.show()
        _hbox.pack_start(self.__connected_button, False, False, 0)
        _icon_close = gtk.Image()
        _icon_close.set_from_file(globals.getAppPath("CLOSE-ICON"))
        _icon_close.show()
        _close_button = gtk.ToolButton()
        _close_button.set_icon_widget(_icon_close)
        _close_button.connect("clicked", self._closeItem)
        _close_button.show()
        _hbox.pack_start(_close_button, False, False, 0)
        _hbox.show()
        self.__widget.show()

    def getItem(self, path):
        """def getItem(self, path)
        
        Return itself.
        """
        return self

    def _closeItem(self, close_button):
        """_closeItem(self, widget)
        
        Method connected to the "clicked" signal of the _close_button widget
        Send the "autoclose" message to the page to close this view
        """
        self.propagateMessageFrom( "autoclose", self.__path)

    def _change_combo(self, combobox):
        """_change_combo(self, combobox)
        
        Method connected to the "changed" signal of the _combobox widget
        It changes the view type to the type selected in the combobox
        """
        _index = combobox.get_active()
        _budget = self.__view.budget
        _wr_page = self.__view.page
        _path = self.__view.path
        _path_record = self.__view.active_path_record
        _toolitem = self.__widget.get_nth_item(0)
        _vbox= _toolitem.get_children()[0]
        _hbox = _vbox.get_children()[0]
        _combobox = _hbox.get_children()[1]
        _hbox.remove(_combobox)
        _invisible = _hbox.get_children()[1]
        _hbox.remove(_invisible)
        _menu_button = _hbox.get_children()[1]
        _hbox.remove(_menu_button)
        _connected_button = _hbox.get_children()[1]
        _hbox.remove(_connected_button)
        _close_button = _hbox.get_children()[1]
        _hbox.remove(_close_button)
        _vbox.remove(self.__view.widget)
        _vbox.remove(_hbox)
        _hbox.destroy()
        _view_icon = gtk.Image()
        if _index == 0:
            self.__view = DecompositionList(_budget, _wr_page, _path,
                          _path_record)
                        
            _view_icon.set_from_file(globals.getAppPath("DECOMPOSITION-ICON"))
            self.__view_type = "DecompositionList"
        elif _index == 1:
            self.__view = Description(_budget, _wr_page, _path,
                         _path_record)
            _view_icon.set_from_file(globals.getAppPath("DESCRIPTION-ICON"))
            self.__view_type = "RecordDescription"
        elif _index == 2:
            self.__view = Measure(_budget, _wr_page, _path,
                         _path_record)
            _view_icon.set_from_file(globals.getAppPath("MEASURE-ICON"))
            self.__view_type = "Measure"
        elif _index == 3:
            self.__view = Sheet(_budget, _wr_page, _path,
                         _path_record)
            _view_icon.set_from_file(globals.getAppPath("SHEET-ICON"))
            self.__view_type = "Sheet of Conditions"
        elif _index == 4:
            self.__view = FileView(_budget, _wr_page, _path,
                         _path_record)
            _view_icon.set_from_file(globals.getAppPath("SHEET-ICON"))
            self.__view_type = "FileView"
        elif _index == 5:
            self.__view = CompanyView(_budget, _wr_page, _path,
                          _path_record)
            _view_icon.set_from_file(globals.getAppPath("SHEET-ICON"))
            self.__view_type = "CompanyView"
        _view_icon.show()
        _hbox = gtk.HBox()
        _hbox.pack_start(_view_icon, False, False,0)
        _hbox.pack_start(_combobox, False, False,0)
        _hbox.pack_start(_invisible, True, False,0)
        _hbox.pack_start(_menu_button, False, False, 0)
        _hbox.pack_start(_connected_button, False, False, 0)
        _hbox.pack_start(_close_button, False, False, 0)
        _hbox.show()
        _vbox.pack_start(_hbox, False, False, 0)
        _vbox.pack_start(self.__view.widget, True, True, 0)

    def _menu_view(self, widget):
        """_menu_view(self, widget)
        
        Method connected to the "clicked" signal of the __connected_button
        It shows a popup menu with some options
        """
        _menu_view = gtk.Menu()
        _item_leftright = gtk.MenuItem("Split View Left/Right")
        _menu_view.append(_item_leftright)
        _item_leftright.connect_object("activate", self._split_view, "h")
        _item_leftright.show()
        _item_topbottom = gtk.MenuItem("Split View Top/Bottom")
        _menu_view.append(_item_topbottom)
        _item_topbottom.connect_object("activate", self._split_view, "v")
        _item_topbottom.show()
        _item_close = gtk.MenuItem("close view")
        _menu_view.append(_item_close)
        _item_close.connect_object("activate", self._closeItem, None)
        _item_close.show()
        _menu_view.popup(None, None, None, 0, 0)
        
    def _split_view(self, orientation):
        """_menu_view(self, orientation)
        
        orientation: orientation split, "h" or "v"
        
        Method connected to the "activate" signal of the _item_leftright and
        _item_topbottom menu items.
        It sends the "split" message to the page to splits the view in the
        specified orientation
        """
        self.propagateMessageFrom( "split " + orientation, self.__path)

    def _connected(self, widget):
        """_connected(self, widget)
        
        Method connected to the "clicked" signal of the _menu_button
        It changes the __connected atribute to True or False, if the 
        _connected atribute is False the view do not send and receive messages
        to/from others views
        """
        if self.__connected:
            _icon = gtk.Image()
            _icon.set_from_file(globals.getAppPath("DISCONNECTED-ICON"))
            _icon.show()
            self.__connected_button.set_icon_widget(_icon)
            self.__connected = False
        else:
            _icon = gtk.Image()
            _icon.set_from_file(globals.getAppPath("CONNECTED-ICON"))
            _icon.show()
            self.__connected_button.set_icon_widget(_icon)
            self.__connected = True

    def propagateMessageFrom(self, message, path, arg=None):
        """def propagateMessageFrom(self, message, path, arg=None)
        
        message: string message
        path: tuple that represents the pane path which emits the message
        arg: arguments for the message
        The panes are connectted to this method to send messages to other panes
        """
        if self.__connected or message == "autoclose" or \
           message == "split h" or message == "split v":
            self.__wr_page().propagateMessageFrom(message, path, arg)

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        path: tuple that identifies the pane in the notebook page
        arg: tuple whit two items:
            0: record path in the budget
            1: record code
        This method receives a message and executes its corresponding action
        """
        if self.__connected:
            self.__view.runMessage(message, path, arg)
            if message == "change_active":
                if self.__budget.hasPath(arg):
                    _path_record = arg
                    self.__active_path_record = _path_record

    def getWidget(self):
        """def getWidget(self)
        
        Return de pane widget
        """
        return self.__widget

    def getPath(self):
        """def getPath(self)
        
        return the tuple that identifies the pane in the notebook page
        """
        return self.__view.path

    def setPath(self, path):
        """def setPath(self)
        
        set the tuple that identifies the pane in the notebook page
        """
        self.__path = path
        self.__view.path = path

    def getClone(self, new_path):
        """getClone(self, new_path)
        
        new_path: the path that identifies the clone view in the page
        
        return a clone of itself
        """
        return View(self.__view_type, self.__budget, self.__wr_page,
                       new_path, self.__active_path_record)

    def clear(self):
        """clear(self)
        
        Clear the intance atributes
        """
        del self.__wr_page
        del self.__budget
        del self.__path
        del self.__widget
        del self.__view
        del self.__connected
        del self.__connected_button
    
    path = property(getPath, setPath, None,
        "path that identifies the item in the notebook page")
    widget = property(getWidget, None, None, "View widget")

class Paned(object):
    """gui.Paned:
    
    Description:
    It creates and shows gtk.Hpaned or gtk.Vpaned to show in page budget
    Constructor:
        Paned(orientation, widget1, widget2)
        orientation: The orientation of the pane separator, can be "v" or "h"
        widget1: the top or left pane widget
        widget2: the botton or right pane widget
        Returns the newly created Paned instance
    Ancestry:
    +-- object
      +-- Paned
    Atributes:
        "widget": Pane widget("gtk.VPaned" or "gtk.HPaned" object)
        "__orientation": The orientation of de gtk.Paned, can be "v" or "h"
        "__items": list of items showed in the paned, its can be View or Paned
            instances
        "__path": the paned path in the page
    Methods:
        __init__(self)
        __getitem__(self, item)
        getClone(self, new_path)
        getItem(self, path)
        runMessage(self, messge, path, arg=None)
        getWidget(self)
        {get/set}Path
        clear(self)
    """
    # TODO:  *control the position paned separator. Now is always 200 pixels
    # TODO:     can be with a float(0.0-1.0) aspect ratio
    # TODO:          0.0 no space for widget1
    # TODO:          1.0 all the space for widget1
    # TODO:  *control the position pane separator when the size of the window
    # TODO:     change with the same ascpect ratio

    def __init__(self, orientation, path, item1, item2):
        """def __init__(self, oritentation, path, item1, item2)
        
        orientation: The orientation of de gtk.Paned, can be "v" or "h"
        path: the paned path in the page
        item1: the top or left pane object
        item2: the bottom or right pane object
        
        Creates and shows a new gtk.Paned
        """
        self.__orientation = orientation
        if not isinstance(item1.widget, gtk.Widget) or \
           not isinstance(item2.widget, gtk.Widget):
            raise ValueError, _("The item must be a widget object.")
        if orientation == "v":
            self.__widget = gtk.VPaned()
        elif orientation == "h":
            self.__widget = gtk.HPaned()
        else:
            raise ValueError, _("Invalid orientation.")
        self.__widget.pack1(item1.widget,True,False)
        self.__widget.pack2(item2.widget,True,False)
        self.__widget.set_position(200)
        self.__widget.show()
        self.__items = [item1, item2]
        self.__path = path

    def __getitem__(self, item):
        """__getitem__(self, item)
        
        Called to implement evaluation of self[key].
        The accepted keys should be integers 0 or 1.
        """
        return self.__items[item]

    def getClone(self, new_path):
        """getClone(self, new_path)
        
        Return a clone Paned instance with the path new_path
        """
        return Paned(self.__orientation, new_path,
                     self.__items[0].getClone(new_path + (0,)),
                     self.__items[1].getClone(new_path + (1,)))

    def getItem(self,path):
        """def getItem(self, path)
        
        Return the item whith the specified path.
        """
        _item = self.__items[path[0]]
        if len(path) == 1:
            return _item
        else:
            return _item.getItem(path[1:])
        
    def setItem(self, path, item_list):
        """def setItem(self, path, item_list)
        
        Sets the first item in the item_list whith the especified path and
        remove the old item in this position.
        """
        item = item_list[0]
        if path == 0 or path == 1:
            _old_item = self.__items[path]
            self.__widget.remove(_old_item.widget)
            self.__items[path] = item
            if path == 0:
                self.__widget.pack1(item.widget,True,False)
            else:
                self.__widget.pack2(item.widget,True,False)
            return True
        return False

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, page_path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        page_path: tuple that identifies the pane in the notebook page
        arg: arguments
        
        This method receives a message and send this to the items of the paned
        """
        for _item in self.__items:
            if not _item.path == path:
                _item.runMessage(message, path, arg)

    def getWidget(self):
        """def getWidget(self)
        
        Return de gtk.Paned widget
        """
        return self.__widget

    def getPath(self):
        """def getPath(self)
        
        Return de Paned path in the notebook page
        """
        return self.__path
    
    def setPath(self, path):
        """def setPath(self)
        
        sets the tuple that identifies the pane in the notebook page
        """
        self.__path = path
        self.__items[0].path = path + (0,)
        self.__items[1].path = path + (1,)
    
    def clear(self):
        del self.__widget
        del self.__orientation
        del self.__items
        del self.__path

    widget = property(getWidget, None, None, "gtk.Paned widget")
    path = property(getPath, setPath, None, "Pane path in the notebook page")

class TreeView(object):
    """gui.Treeviev:
    
    Description:
        It creates the columns in a treeview, is the base class for 
        DescompositionList and Measure classes 
    Constructor:
        TreView(args)
        args: list of tuples, the tuple items are:
            0.type:
                * index column
                * float column
                * text column
                * calculated column
                * calculated text
                * type column
            1. clicked method
            2. width
            3. text color
            4. backgruound colors
            5. model column index
    Ancestry:
    +-- object
      +-- TreeView
    Atributes:
        "columns": list of columns (gtk.TreeViewColumn isntances)
    Methods:
        __init__(self)
        __getitem__(self, item)
        createColumn(self, args)
        createTextBaseColumn(self,args)
        createBaseColumn(self,args)
    """

    def __init__(self, args):
        """__init__(self, args)
        
        args: list of tuples, the tuple items are:
            0.type:
                * index column
                * float column
                * text column
                * calculated column
                * Calculated text
                * type column
            1. clicked method
            2. width
            3. text color
            4. backgruound colors
            5. model column index
        
        Create the columns form the args info calling creatheColumn to create
        each column
        """
        self.columns = [ self.createColumn(arg) for arg in args ]
        self.columns.append(self.createColumn(("END",)))
    
    def createColumn(self, args):
        """createColumn(self, args)
        
        args: tuple with the args
            0.type:
                * index column
                * float column
                * text column
                * calculated column
                * calculated text
                * type column
            1. clicked method
            2. width
            3. text color
            4. backgruound colors
            5. model column index
        
        Return a column created whith the arg info
        """
        if args[0] == "INDEX":
            _index_column = self.createBaseColumn(args)
            _text_index_cell = gtk.CellRendererText()
            _text_index_cell.set_property('foreground-gdk',
                gtk.gdk.color_parse(globals.color["TEXT"]))
            _pixbuf_index_cell = gtk.CellRendererPixbuf()
            _arrow_icon = gtk.gdk.pixbuf_new_from_file(
                globals.getAppPath("ARROW-ICON"))
            _pixbuf_index_cell.set_property("pixbuf", _arrow_icon)
            _index_column.pack_start(_text_index_cell, True)
            _index_column.pack_start(_pixbuf_index_cell, True)
            _index_column.set_cell_data_func(_text_index_cell,
                self.colorCell,
                [gtk.gdk.color_parse(globals.color["INDEX-UNEVEN"]),
                gtk.gdk.color_parse(globals.color["INDEX-EVEN"])])
            return _index_column
        elif args[0] == "TEXT":
            _column, _cell = self.createTextBaseColumn(args)
            _column.add_attribute(_cell, 'text', args[5])
            return _column
        elif args[0] == "FLOAT":
            _column, _cell = self.createTextBaseColumn(args)
            _column.add_attribute(_cell, 'text', args[5])
            _column.get_cell_renderers()[0].set_property('xalign', 1.0)
            return _column
        elif args[0] == "CALCULATED":
            _column, cell = self.createTextBaseColumn(args)
            _column.get_cell_renderers()[0].set_property('xalign', 1.0)
            return _column
        elif args[0] == "CALCULATEDTEXT":
            _column, cell = self.createTextBaseColumn(args)
            return _column
        elif args[0] == "TYPE":
            _column = self.createBaseColumn(args)
            _type_cell1 = gtk.CellRendererPixbuf()
            _type_cell2 = gtk.CellRendererText()
            _type_cell2.set_property('foreground-gdk', args[3])
            _column.pack_start(_type_cell1, True)
            _column.pack_start(_type_cell2, True)
            _column.add_attribute(_type_cell2, 'text', args[5])
            _column.set_cell_data_func(_type_cell1,
                self.colorCell, args[4])
            _column.set_cell_data_func(_type_cell2,
                self.colorCell, args[4])
            return _column
        elif args[0] == "PIXBUF":
            _column = self.createBaseColumn(args)
            _type_cell1 = gtk.CellRendererPixbuf()
            _column.pack_start(_type_cell1, True)
            _column.set_cell_data_func(_type_cell1,
                self.colorCell, args[4])
            return _column
        elif args[0] == "END":
            _end_column = gtk.TreeViewColumn()
            _end_column.set_clickable(False)
            _end_cell = gtk.CellRendererText()
            _end_cell.set_property('cell-background-gdk',
                gtk.gdk.color_parse(globals.color["UNEVEN"]))
            _end_column.pack_start(_end_cell, True)
            return _end_column
        return None

    def createTextBaseColumn(self,args):
        """createTextBaseColumn(self,args)
        
        args: tuple with the args
            0.type:
                * float column
                * text column
                * calculated column
                * calculated text
            1. clicked method
            2. width
            3. text color
            4. backgruound colors
            5. model column index
        
        Return a column and its CellREndererText
        """
        _column = self.createBaseColumn(args)
        _cell = gtk.CellRendererText()
        _cell.set_property('foreground-gdk', args[3])
        _column.pack_start(_cell, True)
        _column.set_cell_data_func(_cell, self.colorCell, args[4])
        return _column, _cell

    def createBaseColumn(self,args):
        """createBaseColumn(self,args)
        
        args: tuple with the args
            0.type:
                * index column
                * float column
                * text column
                * calculated column
                * calculated text column
                * type column
            1. clicked method
            2. width
            3. text color
            4. backgruound colors
            5. model column index
        
        Return a column
        """
        _column = gtk.TreeViewColumn()
        _column.set_clickable(True)
        _column.connect("clicked", args[1])
        _column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        _column.set_fixed_width(args[2])
        _column.set_resizable(True)
        return _column

class DecompositionList(TreeView):
    """gui.DecompositionList:
    
    Description:
        Class to show a budget Decomposition List
    Constructor:
        DecompositionList(budget, page, path)
        budget: budget showed ("base.Budget" object)
        page: weak reference from Page instance which creates this class
        path: tuple that represents the view path in the Page
        Returns the newly created DecompositionList instance
    Ancestry:
    +-- object
      +-- TreeView
        +-- DecompositionList
    Atributes:
        "budget": Budget to show, base.obra instance.
        "widget or __scrolled_window": Window that contains the table,
            (gtk.ScrolledWindow)
        "path": Pane page identifier
        "page": weak reference from Page instance which creates this class
        "__active_color": background color of the active cell, a
            gtk.gdk.Color object
        "__chapter_background_colors": background colors of the Code
            column cells when there is a chapter record,
            list of gtk.gdk.Color objects [even cell, uneven cell]
        "__methond_message": Method to send messages to the page
        "__liststore": list model which store the list data
            (gtk.ListStore object)
        "__treeview": widget for displaying decomposition lists (gtk.TreeView)
        "__index_column": Index column (gtk.TreeViewColumn object)
        "__code_column": Record code column (gtk.TreeViewColumn)
        "__unit_column": Unit of measure column (gtk.TreeViewColumn)
        "__description_column": record's short description column 
            (gtk.TreeViewColumn)
        "__measure_column": Measure column (gtk.TreeViewColumn)
        "__price_column": Price column (gtk.TreeViewColumn)
        "__amount_column": Amount column(gtk.TreeViewColumn)
        "__end_column": End empty column (gtk.TreeViewColumn)
        "__treeselection": active selection
        "__selection_control": state of the selection control (True/False)
        "__cursor": cursor position in the table
    Methods:
        __init__(self, budget)
        treeviewCursorChanged(self, treeview)
        treeviewClickedEvent(self, widget, event)
        treeviewKeyPressEvent(self, widget, event)
        moveCursor(self, treeview, step, count)
        controlSelection(self, selection)
        selectAll(self, column)
        setColumnsHeaders(self)
        setListstoreValues(self, puntero, treeiter=None)
        colorCell(self, column, cell_renderer, tree_model, iter, lcolor)
        _claculateAmount(self, row_path, tree_model)
        showParentRecord(self, column)
        showMessageRecord(self, camino,_code):
        showRowRecord(self, treeview, path, column)
        runMessage(self, messagem path, arg=None)
        _clear(self)
        getWidget(self)
        {get/set}Path
        {get/seg}Page
        getBudget(self)
        getActivePathRecord(self)
    """

    def __init__(self, budget, page, path, path_record=(0,)):
        """def __init__(self, budget, page, path)
        
        budget: budget showed ("base.Budget" object)
        page: weak reference from Page instance which creates this class
        path: tuple that represents the path of the List in the Page
        
        Sets the init atributes
        Creates the init list values in self.__liststore from the budget 
            showing the top record descomposition
        Creates the list in self.__treeview
            * Creates the columns and cell
            * Sets te the column headers values
            * Sets the selection properties
            * Connects the events
        """
        # TODO: to group all columns in a dicctionary
        # Budget
        if not isinstance(budget, base.Budget):
            raise ValueError, _("Argument must be a Budget object")
        self.__budget = budget
        self.__page = page
        self.__path = path
        # ListStore
        self.__liststore = gtk.ListStore(object
            #, int, int, str, str, str, str, str,str
            )
        if path_record is None:
            print _("DecompositionList.__init__: Record path can not be None")
            path_record = (0,)
        self.__active_path_record = path_record
        self.setListstoreValues(self.__active_path_record)
        # Treeview
        self.__treeview = gtk.TreeView(self.__liststore)
        self.__treeview.set_enable_search(False)
        self.__treeview.set_reorderable(False)
        self.__treeview.set_headers_clickable(True)
        self.__treeview.show()
        # Scrolled_window
        self.__scrolled_window = gtk.ScrolledWindow()
        self.__scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
                                        gtk.POLICY_AUTOMATIC)
        self.__scrolled_window.add(self.__treeview)
        # colors
        _text_color = gtk.gdk.color_parse(globals.color["TEXT"])
        _background_color = [
            gtk.gdk.color_parse(globals.color["UNEVEN"]),
            gtk.gdk.color_parse(globals.color["EVEN"])]
        self.__chapter_background_colors = [
            gtk.gdk.color_parse(globals.color["CHAPTER-UNEVEN"]),
            gtk.gdk.color_parse(globals.color["CHAPTER-EVEN"])]
        super(DecompositionList,self).__init__(
            [("INDEX",self.selectAll,42),
            ("CALCULATEDTEXT", self.showParentRecord, 
             gtk.Label("A"*10).size_request()[0] +10,
             _text_color, _background_color),
            ("PIXBUF", self.showParentRecord, 26, _text_color,
             _background_color),
            ("CALCULATEDTEXT", self.showParentRecord,
            gtk.Label(_("a"*4)).size_request()[0] +10,
            _text_color, _background_color),
            ("CALCULATEDTEXT", self.showParentRecord,
            gtk.Label("a"*30).size_request()[0] +10,
            _text_color, _background_color),
            ("CALCULATED", self.showParentRecord,
            gtk.Label("a"*10).size_request()[0] +10,
            _text_color, _background_color),
            ("CALCULATED", self.showParentRecord,
            gtk.Label("a"*10).size_request()[0] +10,
            _text_color, _background_color),
            ("CALCULATED", self.showParentRecord,
            gtk.Label("a"*10).size_request()[0] +10,
            gtk.gdk.color_parse(globals.color["CALCULATED-TEXT"]),
            _background_color),
            ])
        self.__index_column = self.columns[0]
        self.__code_column = self.columns[1]
        self.__type_column = self.columns[2]
        self.__unit_column = self.columns[3]
        self.__description_column = self.columns[4]
        self.__measure_column = self.columns[5]
        self.__price_column = self.columns[6]
        self.__amount_column = self.columns[7]
        self.__end_column = self.columns[8]
        # Index column
        self.__treeview.append_column(self.__index_column)
        # Code column
        self.__treeview.append_column(self.__code_column)
        # Type column
        self.__treeview.append_column(self.__type_column)
        self.chapter_icon = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("CHAPTER-ICON"))
        self.unit_icon  = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("UNIT-ICON") )
        self.material_icon  = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("MATERIAL-ICON") )
        self.machinery_icon = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("MACHINERY-ICON"))
        self.labourforce_icon = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("LABOURFORCE-ICON"))
        self.__type_column.get_cell_renderers()[0].set_property("pixbuf",
            self.labourforce_icon)
        
        # Unit column
        self.__treeview.append_column(self.__unit_column)
        # Description column
        self.__treeview.append_column(self.__description_column)
        # Measure Column
        self.__treeview.append_column(self.__measure_column)
        # Price column
        self.__treeview.append_column(self.__price_column)
        # Amount column
        self.__treeview.append_column(self.__amount_column)
        # End Column
        self.__treeview.append_column(self.__end_column)
        # Connect
        self.__treeview.connect("row-activated", self.showRowRecord)
        self.__treeview.connect("move-cursor", self.moveCursor)
        self.__treeview.connect("key-press-event", self.treeviewKeyPressEvent)
        self.__treeview.connect("button-press-event", self.treeviewClickedEvent)
        self.__treeview.connect("cursor-changed", self.treeviewCursorChanged)
        # control selection
        self.__treeselection = self.__treeview.get_selection()
        self.__treeselection.set_mode(gtk.SELECTION_MULTIPLE)
        self.__treeselection.set_select_function(self.controlSelection)
        self.__selection_control = True
        if len(self.__liststore) > 0:
            self.__treeview.set_cursor_on_cell((0,),self.__unit_column,
                self.__unit_column.get_cell_renderers()[0],True)
        self.__treeview.grab_focus()
        self.__cursor = self.__treeview.get_cursor()
        # Show
        self.setColumnsHeaders()
        self.__scrolled_window.show()

    def treeviewCursorChanged(self, treeview):
        """def treeviewCursorChanged(self, treeview)
        
        treeview: treewiew widget
        Method connected to "cursor-changed" signal
        The "cursor-changed" signal is emitted when the cursor moves or is set
        Sets the new cursor position in self.__cursor, it is used to avoid 
        unnecessary changes in cursor position.
        """
        event = gtk.get_current_event()
        (_cursor_path, _column) = treeview.get_cursor()
        if event is None or event.type !=  gtk.gdk.BUTTON_RELEASE:
            if not _column is self.__index_column:
                self.__cursor = treeview.get_cursor()
    
    def treeviewClickedEvent(self, widget, event):
        """def treeviewClickedEvent(self, widget, event)
        
        widget: treewiew widget
        event: clicked event
        Method connected to "button-press-event" signal
        The "button-press-event" signal is emitted when a mouse button is
        pressed.
        Returns TRUE to stop other handlers from being invoked for the event.
        Returns FALSE to propagate the event further.
        
        The events in end column are ignored.
        If the user click in a row of the index column the cursor is moved to
        this row but not to the index column
        """
        if event.button == 1:
            path_at_pos = self.__treeview.get_path_at_pos(int(event.x),
                                                        int(event.y))
            if not path_at_pos is None: 
                _path_cursor, _column, _x, _y = path_at_pos
                if _column == self.columns[-1]:
                    return True
                if _column is self.columns[0]:
                    self.__cursor[0] == _path_cursor
        return False

    def treeviewKeyPressEvent(self, widget, event):
        """def treeviewKeyPressEvent(self, widget, event)
        
        widget: treewiew widget
        event: Key Press event
        Method connected to "key-press-event" signal
        The "key-press-event" signal is emitted when the user presses a key
        on the keyboard.
        Returns :TRUE to stop other handlers from being invoked for the event.
        Returns :FALSE to propagate the event further.
        
        If the user press the right cursor button and the cursor is in the
        amount column or pres the left cursor button and the cursor is
        in the code column the event is estoped, else the event is propagated. 
        """
        (_cursor_path, _column) = self.__treeview.get_cursor()
        if (event.keyval == gtk.keysyms.Right \
            and _column == self.columns[-2]) \
            or (event.keyval == gtk.keysyms.Left \
            and _column == self.columns[1]):
            return True
        return False

    def moveCursor(self, treeview, step, count):
        """def treeviewKeyPressEvent(self, widget, event)
        
        treeview: the treeview that received the signal
        step: the movement step size
        count: the number of steps to take
        
        Method connected to "move-cursor" signal
        The "move-cursor" signal is emitted when the user moves the cursor
        using the Right, Left, Up or Down arrow keys or the Page Up,
        Page Down, Home and End keys.
        
        Returns :TRUE if the signal was handled.
        """
        return False

    def controlSelection(self, selection):
        """def controlSelection(self, selection)
        
        selection: treeselection
        
        Method connected to set_selection_function() 
        This method is called before any node is selected or unselected,
        giving some control over which nodes are selected.
        The selection function should return TRUE if the state
        of the node may be toggled, and FALSE if the state of the node should
        be left unchanged.
        
        The selection only run if the user click in the index column, else
        the previous selection is erased.
        """
        _column = self.__treeview.get_cursor()[1]
        if _column is self.columns[0] \
            or self.__selection_control == False:
            return True
        else:
            self.__selection_control = False
            self.__treeselection.unselect_all()
            self.__selection_control = True
            return False

    def selectAll(self, column):
        """def selectAll(self, column)
        
        column: index column
        Method connected to "clicked" event in the index column
        If the user clickes in the index column header selecs or deselects 
        all rows
        """
        (_model, _pathlist) = self.__treeselection.get_selected_rows()
        # it avoid to set cursor in the index column
        self.__treeview.set_cursor(self.__cursor[0], self.__cursor[1])
        self.__selection_control = False
        if len(_pathlist) == 0:
            # select all
            self.__treeselection.select_all()
        else:
            # unselect all
            self.__treeselection.unselect_all()
        self.__selection_control = True

    def setColumnsHeaders(self):
        """def setColumnsHeaders(self)
        
        Sets the headers column values
        """
        _path_record = self.__active_path_record
        _number = _path_record[-1]
        _budget = self.__budget
        _code = _budget.getCode(_path_record)
        _decomposition = _budget.getDecomposition(_path_record)
        _stryield = _budget.getStrYield(_decomposition.budgetMeasures[0],
                                        _budget.getRecord(_code).recordType)
        _record = _budget.getRecord(_code)
        _unit = _record.unit
        _description = _record.summary
        _price = _budget.getStrPriceFromRecord(self.budget.getActiveTitle(),
                                               _record)
        # TODO: round to decimal places in amount
        _amount = float(_stryield) * float(_price)
        if len(_path_record) == 1: # root record
            _amount = _price
        else:
            _parent_code = self.budget.getCode(self.__active_path_record[:-1])
            _parent_record = self.__budget.getRecord(_parent_code)
            _amount = _budget.getStrAmount(self.__active_path_record)
        
        self.__code_column.set_title(_("Code") + chr(10) + "[" + _code + "]")
        self.__unit_column.set_title(_("Unit") + chr(10) + "[" + _unit + "]")
        self.__description_column.set_title(
           _("Description") + chr(10) + "[" + _description + "]")
        self.__measure_column.set_title(
            _("Measure") + chr(10) + "[" + _stryield + "]")
        self.__price_column.set_title(
            _("Price") + chr(10) + "[" + _price + "]")
        self.__amount_column.set_title(
            _("Amount") + chr(10) + "[" + str(_amount) + "]")

        
    def setListstoreValues(self, path_record):
        """def setListstoreValues(self, path_record)
        
        path_record: Record path in the budget
        Sets the liststore record values from a path record
        """
        self.__liststore.clear()
        _budget = self.__budget
        if not _budget.hasPath(path_record):
            raise ValueError, _("Invalid path")
        else:
            _parent_code = _budget.getCode(path_record)
            for N,_code in enumerate(_budget.getchildren(_parent_code)):
                _decomposition = _budget.getNDecomposition(_parent_code, N)
                _record = _budget.getRecord(_code)
                _values = [_record,
                           #_record.hierarchy,
                           #_record.type,
                           #_record.subtype,
                           #_code,
                           #_record.unit,
                           #_record.summary,
                           #_decomposition.yield_,
                           #_decomposition.budget[0].yield_,
                           #_record.prices[_budget.getActiveTitle()].prices]
                           #_record.getPrice(_budget.getActiveTitle())
                           ]
                _treeiter = self.__liststore.append(_values)

    def colorCell(self, column, cell_renderer, tree_model, iter, lcolor):
        """def colorCell(self, column, cell_renderer, tree_model, iter, lcolor)
        
        column: the gtk.TreeViewColumn in the treeview
        cell_renderer: a gtk.CellRenderer
        tree_model: the gtk.TreeModel
        iter: gtk.TreeIter pointing at the row
        lcolor: list with 2 gtk colors for even and uneven record
        
        Method connected to "set_cell_data_func" of many column
        The set_cell_data_func() method sets the data function (or method) 
        to use for the column gtk.CellRenderer specified by cell_renderer.
        This function (or method) is used instead of the standard attribute
        mappings for setting the column values, and should set the attributes
        of the cell renderer as appropriate. func may be None to remove the
        current data function. The signature of func is:
        -def celldatafunction(column, cell, model, iter, user_data)
        -def celldatamethod(self, column, cell, model, iter, user_data)
        where column is the gtk.TreeViewColumn in the treeview, cell is the
        gtk.CellRenderer for column, model is the gtk.TreeModel for the
        treeview and iter is the gtk.TreeIter pointing at the row.
        
        The method sets cell background color and text for all columns.
        """
        _row_path = tree_model.get_path(iter)
        _number = _row_path[-1]
        _record = tree_model[_row_path][0]
        if column is self.__index_column:
            cell_renderer.set_property('text', str(_number + 1))
            self.__index_column.get_cell_renderers()[1].set_property(
                'cell-background-gdk', lcolor[_number % 2])
        elif column is self.__code_column:
            # if the record is a chapter
            if tree_model.get_value(iter, 0).recordType.hierarchy == 1: 
                lcolor = self.__chapter_background_colors
            _code = _record.code
            cell_renderer.set_property('text', _code)
        elif column is self.__unit_column:
            _unit = _record.unit
            cell_renderer.set_property('text', _unit)
        elif column is self.__description_column:
            _summary = _record.summary
            cell_renderer.set_property('text', _summary)
        elif column is self.__measure_column:
            _parent_code = self.budget.getCode(self.__active_path_record)
            _parent_record = self.__budget.getRecord(_parent_code)
            _decomposition = _parent_record.children[_number]
            _stryield = self.__budget.getStrYield(
                _decomposition.budgetMeasures[0], _parent_record.recordType)
            cell_renderer.set_property('text', _stryield)
        elif column is self.__price_column:
            _price = self.budget.getStrPriceFromRecord(
                       self.budget.getActiveTitle(), _record)
            cell_renderer.set_property('text', _price)
        elif column is self.__amount_column:
            _parent_code = self.budget.getCode(self.__active_path_record)
            _parent_record = self.__budget.getRecord(_parent_code)
            _amount = self.budget.getStrAmount(
                        self.__active_path_record + (_number,))
            cell_renderer.set_property('text', str(_amount))
        elif column is self.__type_column:
            _hierarchy = tree_model[_row_path][0].recordType.hierarchy
            _type = tree_model[_row_path][0].recordType.type
            _subtype = tree_model[_row_path][0].recordType.subtype
            if _hierarchy == 1:
                cell_renderer.set_property("pixbuf",self.chapter_icon)
            else:
                if _type == 0:
                    cell_renderer.set_property("pixbuf",self.unit_icon)
                elif _type == 1:
                    cell_renderer.set_property("pixbuf",
                        self.labourforce_icon)
                elif _type == 2:
                    cell_renderer.set_property("pixbuf",
                        self.machinery_icon)
                else:
                    cell_renderer.set_property("pixbuf",self.material_icon)
        if self.__treeview.get_cursor() == (_row_path,column):
            cell_renderer.set_property('cell-background-gdk',
                gtk.gdk.color_parse(globals.color["ACTIVE"]))
        else:
            cell_renderer.set_property('cell-background-gdk',
                lcolor[_number % 2])

    def showParentRecord(self, column):
        """def showParentRecord(self, column)
        
        column: the column that is clicked
        Method connected to "clicked" event of many columns
        Show the parent record
        """
        _budget = self.__budget
        if len(self.__active_path_record) == 1:
            # The active record is the root record
            # This avoid to move the cursor to the clicked column
            self.__treeview.set_cursor(self.__cursor[0], self.__cursor[1])
        else:
            _path_record = self.__active_path_record[:-1]
            _parent = self.__active_path_record[-1]
            self.__active_path_record = _path_record
            self.setColumnsHeaders()
            self.setListstoreValues(self.__active_path_record)
            arg = ( _path_record )
            _page = self.__page()
            _page.propagateMessageFrom("change_active", self.__path, arg)
            self.__treeview.set_cursor(_parent, self.__cursor[1])
            self.__cursor = self.__treeview.get_cursor()

    def showMessageRecord(self, record_path):
        """def showMessageRecord(self, record_path)
        
        record_path: the path of  the record to show
        Method connected to "change_active" message
        Show the record especified in the "change_active" message
        """
        _budget = self.__budget
        self.__active_path_record = record_path
        self.setColumnsHeaders()
        self.setListstoreValues(self.__active_path_record)
        self.__treeview.set_cursor((0,))

    def showRowRecord(self, treeview, treeview_path, column):
        """def showRowRecord(self, treeview, treeview_path, column)
        
        treeview: treview to show
        treeview_path: the path of the record to show
        code: the code of the record to show
        
        Method connected to "row-activated" event
        The "row-activated" signal is emitted when the row_activated() method
        is called or the user double clicks a treeview row.
        "row-activated" is also emitted when a non-editable row is selected
        and one of the keys: Space, Shift+Space, Return or Enter is pressed.
        Show the especified record
        """
        if not (column is self.__end_column) and \
           not (column is self.__index_column):
            _budget = self.__budget
            _model = treeview.get_model()
            _iter = _model.get_iter(treeview_path)
            _code = _model.get_value(_iter, 0).code
            #_code = _model.get_value(_iter, 4)
            _path_record = self.__active_path_record + treeview_path
            if self.__budget.hasPath(_path_record):
                # if this record path is valid
                self.__active_path_record = _path_record
                self.setColumnsHeaders()
                self.setListstoreValues(self.__active_path_record)
                self.__treeview.set_cursor((0,))
                _arg = ( _path_record )
                _page = self.__page()
                _page.propagateMessageFrom("change_active", self.__path,
                                       _arg )

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        path: tuple that identifies the pane in the notebook page
        arg: tuple whit two items:
            0: record path in the budget
            1: record code
        This method receives a message and executes its corresponding action
        """
        _budget = self.__budget
        if message == "change_active":
            if _budget.hasPath(arg):
                _path_record = arg
                self.showMessageRecord( _path_record)
        elif message == "clear":
            self._clear()

    def _clear(self):
        """def _clear(self)
        
        it deletes the __budget value
        this would not be necessary if there were not circular references,
        which are pending to fix
        """
        del self.__budget 

    def getWidget(self):
        """def getWidget(self)
        
        return the main widget (gtk.ScrolledWindow)
        """
        return self.__scrolled_window

    def getPath(self):
        """def getPath(self)
        
        return the tuple that identifies the pane in the notebook page
        """
        return self.__path

    def setPath(self, path):
        """def setPath(self)
        
        sets the tuple that identifies the pane in the notebook page
        """
        self.__path = path

    def getPage(self):
        """def getPage(self)
        
        return the Page
        """
        return self.__page

    def setPage(self,page):
        """def setPage(self)
        
        set the Page
        """
        self.__page = page

    def getBudget(self):
        """def getBudget(self)
        
        return the Budget objet
        """
        return self.__budget

    def getActivePathRecord(self):
        """def getActivePathRecord(self)
        
        return the Active Path Record
        """
        return self.__active_path_record

    widget = property(getWidget, None, None,
        "Pane configuration list")
    path = property(getPath, setPath, None,
        "path that identifie the item in the page notebook")
    page = property(getPage, setPage, None,
        "weak reference from Page instance which creates this class")
    budget =  property(getBudget, None, None,
        "Budget object")
    active_path_record =  property(getActivePathRecord, None, None,
        "Active path record")

class Measure(TreeView):
    """gui.Measure:
    
    Description:
        Class to show a Measure List
    Constructor:
        Measure(budget, page, path)
        budget: budget showed ("base.Budget" object)
        page: weak reference from Page instance which creates this class
        path: tuple that represents the path of the List in the Page
        Returns the newly created DecompositionList instance
    Ancestry:
    +-- object
      +-- TreeView
        +-- DecompositionList
    Atributes:
        "budget": Budget to show, base.obra instance.
        "__active_path_record": path of the active record in the budget
        "widget or __scrolled_window": Window that contains the table,
            (gtk.ScrolledWindow)
        "path": Pane page identifier
        "page": weak reference from Page instance which creates this class
        "__active_color": The background color of the active cell as a
            gtk.gdk.Color object
        "__chapter_background_colors": The background colors of the Code
            column cells when there is a chapter record
            as a list of gtk.gdk.Color objects [even cell, uneven cell]
        "__methond_message": Method to send messages to the page
        "__liststore": list model which store the list data
            (gtk.ListStore object)
        "__treeview": widget for displaying decomposition lists (gtk.TreeView)
        "__index_column": Index column (gtk.TreeViewColumn object)
        "__code_column": Record code column (gtk.TreeViewColumn)
        "__unit_column": Unit of measure column (gtk.TreeViewColumn)
        "__description_column": record's short description column 
            (gtk.TreeViewColumn)
        "__measure_column": Measure column (gtk.TreeViewColumn)
        "__price_column": Price column (gtk.TreeViewColumn)
        "__amount_column": Amount column(gtk.TreeViewColumn)
        "__end_column": End empty column (gtk.TreeViewColumn)
        "__treeselection": active selection
        "__selection_control": state of the selection control (True/False)
        "__cursor": Situation of the cursor in the table
    Methods:
        __init__(self, budget, page, path, path_record=(0,))
        setListstoreValues(self, path_record)
        setColumnsHeaders(self)
        controlSelection(self, selection)
        showMessageRecord(self, record_path)
        treeviewCursorChanged(self, treeview)
        moveCursor(self, treeview, step, count)
        treeviewClickedEvent(self, widget, event)
        treeviewKeyPressEvent(self, widget, event)
        runMessage(self, message, path, arg=None)
        selectAll(self, column)
        colorCell(self, column, cell_renderer, tree_model, iter, lcolor)
        _clear(self)
        getWidget(self)
        {get/set}Path
        {get/set}Page
        getBudget(self)
        getActivePathRecord(self)
    """

    def __init__(self, budget, page, path, path_record=(0,)):
        """def __init__(self, budget, page, path, path_record=(0,))
        
        budget: budget: budget showed ("base.Budget" object)
        page: weak reference from Page instance which creates this class
        path: tuple that represents the path of the List in the Page
        path_record: path of the active record in the budget
        
        Sets the init atributes
        Creates the init list values in self.__liststore from the budget 
            showing the top record from the record with path path_record
        Creates the list in self.__treeview
            * Creates the columns and cell
            * Sets te the column headers values
            * Sets the selection properties
            * Connects the events
        """
        # Seting init args
        if not isinstance(budget, base.Budget):
            raise ValueError, _("Argument must be a Budget object")
        self.__budget = budget
        self.__page = page
        self.__path = path
        if not isinstance(path_record, tuple):
            print _("Record path must be a tuple")
            path_record = (0,)
        self.__active_path_record = path_record
        # ListStore
        self.__liststore = gtk.ListStore(object)
        self.setListstoreValues(self.__active_path_record)
        # Treeview
        self.__treeview = gtk.TreeView(self.__liststore)
        self.__treeview.set_enable_search(False)
        self.__treeview.set_reorderable(False)
        self.__treeview.set_headers_clickable(True)
        self.__treeview.show()
        # Scrolled_window
        self.__scrolled_window = gtk.ScrolledWindow()
        self.__scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
            gtk.POLICY_AUTOMATIC)
        self.__scrolled_window.add(self.__treeview)
        # colors
        _text_color = gtk.gdk.color_parse(globals.color["TEXT"])
        _calculated_text =gtk.gdk.color_parse(globals.color["CALCULATED-TEXT"])
        _background_color = [
            gtk.gdk.color_parse(globals.color["UNEVEN"]),
            gtk.gdk.color_parse(globals.color["EVEN"])]
        self.__chapter_background_colors = [
            gtk.gdk.color_parse(globals.color["CHAPTER-UNEVEN"]),
            gtk.gdk.color_parse(globals.color["CHAPTER-EVEN"])]
        super(Measure,self).__init__(
            [("INDEX",self.selectAll,42),
            ("PIXBUF", self.passMethod,
             gtk.Label("A"*4).size_request()[0] +10,
             _text_color, _background_color),
            ("CALCULATEDTEXT", self.passMethod, 
             gtk.Label("A"*12).size_request()[0] +10,
             _text_color, _background_color),
            ("CALCULATED", self.passMethod, 
             gtk.Label("A"*5).size_request()[0] +10,
             _text_color, _background_color),
            ("CALCULATED", self.passMethod, 
             gtk.Label("A"*7).size_request()[0] +10,
             _text_color, _background_color),
            ("CALCULATED", self.passMethod, 
             gtk.Label("A"*7).size_request()[0] +10,
             _text_color, _background_color),
            ("CALCULATED", self.passMethod, 
             gtk.Label("A"*7).size_request()[0] +10,
             _text_color, _background_color),
            ("CALCULATEDTEXT", self.passMethod, 
             gtk.Label("A"*12).size_request()[0] +10,
             _text_color, _background_color),
            ("CALCULATED", self.passMethod, 
             gtk.Label("A"*7).size_request()[0] +10,
             _calculated_text, _background_color),
            ("CALCULATED", self.passMethod, 
             gtk.Label("A"*7).size_request()[0] +10,
             _calculated_text, _background_color),
            ])
        self.__index_column = self.columns[0]
        self.__linetype_column = self.columns[1]
        self.__comment_column = self.columns[2]
        self.__units_column = self.columns[3]
        self.__length_column = self.columns[4]
        self.__width_column = self.columns[5]
        self.__height_column = self.columns[6]
        self.__formula_column = self.columns[7]
        self.__parcial_column = self.columns[8]
        self.__subtotal_column = self.columns[9]
        self.__end_column = self.columns[10]
        # Index column
        self.__treeview.append_column(self.__index_column)
        # Linetype column
        self.__treeview.append_column(self.__linetype_column)
        self.calculatedline_icon = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("CALCULATEDLINE-ICON"))
        self.normalline_icon  = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("NORMALLINE-ICON") )
        self.parcialline_icon  = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("PARCIALLINE-ICON") )
        self.acumulatedline_icon = gtk.gdk.pixbuf_new_from_file(
            globals.getAppPath("ACUMULATEDLINE-ICON"))
        # Comment column
        self.__treeview.append_column(self.__comment_column)
        # Units column
        self.__treeview.append_column(self.__units_column)
        # Length column
        self.__treeview.append_column(self.__length_column)
        # Width_column
        self.__treeview.append_column(self.__width_column)
        # Height column
        self.__treeview.append_column(self.__height_column)
        # Formula column
        self.__treeview.append_column(self.__formula_column)
        # Parcial column
        self.__treeview.append_column(self.__parcial_column)
        # Subtotal column
        self.__treeview.append_column(self.__subtotal_column)
        # End Column
        self.__treeview.append_column(self.__end_column)
        # Connect
        self.__treeview.connect("move-cursor", self.moveCursor)
        self.__treeview.connect("key-press-event", self.treeviewKeyPressEvent)
        self.__treeview.connect("button-press-event", self.treeviewClickedEvent)
        self.__treeview.connect("cursor-changed", self.treeviewCursorChanged)
        # control selection
        self.__treeselection = self.__treeview.get_selection()
        self.__treeselection.set_mode(gtk.SELECTION_MULTIPLE)
        self.__treeselection.set_select_function(self.controlSelection)
        self.__selection_control = True
        self.__treeview.set_cursor_on_cell((1,), self.columns[1],
            self.columns[1].get_cell_renderers()[0],True)
        self.__treeview.grab_focus()
        self.__cursor = self.__treeview.get_cursor()
        # Show
        self.setColumnsHeaders()
        self.__scrolled_window.show()
    
    def passMethod(self, args):
        pass

    def setListstoreValues(self, path_record):
        """def setListstoreValues(self, path_record)
        
        path_record: Record path in the budget
        Sets the liststore record values from a path record
        """
        self.__liststore.clear()
        _budget = self.__budget
        if not _budget.hasPath(path_record):
            raise ValueError, _("Invalid path")
        else:
            _measure = _budget.getMeasure(path_record)
            if isinstance(_measure, base.Measure):
                _lines = _measure.lines
                for _line in _lines:
                    _values = [
                        _line,
##                        _line.type,
##                        _line.comment,
##                        _line.units,
##                        _line.length,
##                        _line.width,
##                        _line.height
                        ]
                    _treeiter = self.__liststore.append(_values)
            else:
                raise ValueError, utils.mapping(_("measure must be a Measure "\
                      "object. Type: $1"), (type(_measure),))
    def setColumnsHeaders(self):
        """def setColumnsHeaders(self)
        
        Sets the headers column values
        """
        _measure = self.__budget.getMeasure(self.__active_path_record)
        _DS = self.__budget.getDecimals("DS")
        _total = _measure.measure
        _total_str = ("%." + str(_DS) + "f" ) % _total
        self.columns[1].set_title(_("Type"))  # Σ parcial Σ total
        self.columns[2].set_title(_("Comment"))
        self.columns[3].set_title(_("N\n(a)"))
        self.columns[4].set_title(_("Length\n(b)"))
        self.columns[5].set_title(_("Width\n(c)"))
        self.columns[6].set_title(_("Height\n(d)"))
        self.columns[7].set_title(_("Formula"))
        self.columns[8].set_title(_("Parcial\n[%s]" % _total_str))
        self.columns[9].set_title(_("Subtotal"))
    def controlSelection(self, selection):
        """def controlSelection(self, selection)
        
        selection: treeselection
        
        Method connected to set_selection_function() 
        This method is called before any node is selected or unselected,
        giving some control over which nodes are selected.
        The selection function should return TRUE if the state
        of the node may be toggled, and FALSE if the state of the node should
        be left unchanged.
        
        The selection only run if the user click in the index column, else
        the previous selection is erased.
        """
        _column = self.__treeview.get_cursor()[1]
        if _column is self.columns[0] \
            or self.__selection_control == False:
            return True
        else:
            self.__selection_control = False
            self.__treeselection.unselect_all()
            self.__selection_control = True
            return False 

    def showMessageRecord(self, record_path):
        """def showMessageRecord(self, record_path)
        
        record_path: the path of the record to show
        Method connected to "change_active" message
        Show the record especified in the "change_active" message
        """
        _budget = self.__budget
        self.__active_path_record = record_path
        self.setColumnsHeaders()
        self.setListstoreValues(self.__active_path_record)
        self.__treeview.set_cursor((0,))

    def treeviewCursorChanged(self, treeview):
        """def treeviewCursorChanged(self, treeview)
        
        treeview: treewiew widget
        Method connected to "cursor-changed" signal
        The "cursor-changed" signal is emitted when the cursor moves or is set
        Sets the new cursor position in self.__cursor, it is used to avoid 
        unnecessary changes in cursor position.
        """
        event = gtk.get_current_event()
        (_cursor_path, _column) = treeview.get_cursor()
        if event is None or event.type !=  gtk.gdk.BUTTON_RELEASE:
            if not _column is self.__index_column:
                self.__cursor = treeview.get_cursor()

    def moveCursor(self, treeview, step, count):
        """def treeviewKeyPressEvent(self, widget, event)
        
        treeview: the treeview that received the signal
        step: the movement step size
        count: the number of steps to take
        
        Method connected to "move-cursor" signal
        The "move-cursor" signal is emitted when the user moves the cursor
        using the Right, Left, Up or Down arrow keys or the Page Up,
        Page Down, Home and End keys.
        
        Returns :TRUE if the signal was handled.
        """
        return False

    def treeviewClickedEvent(self, widget, event):
        """def treeviewClickedEvent(self, widget, event)
        
        widget: treewiew widget
        event: clicked event
        Method connected to "button-press-event" signal
        The "button-press-event" signal is emitted when a mouse button is
        pressed.
        Returns TRUE to stop other handlers from being invoked for the event.
        Returns FALSE to propagate the event further.
        
        The events in end column are ignored.
        If the user click in a row of the index column the cursor is moved to
        this row but not to the index column
        """
        if event.button == 1:
            path_at_pos = self.__treeview.get_path_at_pos(int(event.x),
                                                        int(event.y))
            if not path_at_pos is None: 
                _path_cursor, _column, _x, _y = path_at_pos
                if _column == self.columns[-1]:
                    return True
                if _column is self.columns[0]:
                    self.__cursor[0] == _path_cursor
        return False

    def treeviewKeyPressEvent(self, widget, event):
        """def treeviewKeyPressEvent(self, widget, event)
        
        widget: treewiew widget
        event: Key Press event
        Method connected to "key-press-event" signal
        The "key-press-event" signal is emitted when the user presses a key
        on the keyboard.
        Returns :TRUE to stop other handlers from being invoked for the event.
        Returns :FALSE to propagate the event further.
        
        If the user press the right cursor button and the cursor is in the
        amount column or pres the left cursor button and the cursor is
        in the code column the event is estoped, else the event is propagated. 
        """
        (_cursor_path, _column) = self.__treeview.get_cursor()
        if (event.keyval == gtk.keysyms.Right \
            and _column == self.columns[-2]) \
            or (event.keyval == gtk.keysyms.Left \
            and _column == self.columns[1]):
            return True
        return False

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        path: tuple that identifies the pane in the notebook page
        arg: tuple whit two items:
            0: record path in the budget
            1: record code
        This method receives a message and executes its corresponding action
        """
        _budget = self.__budget
        if message == "change_active":
            if _budget.hasPath(arg):
                _path_record = arg
                self.showMessageRecord( _path_record)
        elif message == "clear":
            self._clear()

    def selectAll(self, column):
        """def selectAll(self, column)
        
        column: index column
        Method connected to "clicked" event in the index column
        If the user clickes in the index column header selecs or deselects 
        all rows
        """
        (_model, _pathlist) = self.__treeselection.get_selected_rows()
        # it avoid to set cursor in the index column
        self.__treeview.set_cursor(self.__cursor[0], self.__cursor[1])
        self.__selection_control = False
        if len(_pathlist) == 0:
            # select all
            self.__treeselection.select_all()
        else:
            # unselect all
            self.__treeselection.unselect_all()
        self.__selection_control = True

    def colorCell(self, column, cell_renderer, tree_model, iter, lcolor):
        """def colorCell(self, column, cell_renderer, tree_model, iter, lcolor)
        
        column: the gtk.TreeViewColumn in the treeview
        cell_renderer: a gtk.CellRenderer
        tree_model: the gtk.TreeModel
        iter: gtk.TreeIter pointing at the row
        lcolor: list with 2 gtk colors for even and uneven record
        
        Method connected to "set_cell_data_func" of many column
        The set_cell_data_func() method sets the data function (or method) 
        to use for the column gtk.CellRenderer specified by cell_renderer.
        This function (or method) is used instead of the standard attribute
        mappings for setting the column values, and should set the attributes
        of the cell renderer as appropriate. func may be None to remove the
        current data function. The signature of func is:
        -def celldatafunction(column, cell, model, iter, user_data)
        -def celldatamethod(self, column, cell, model, iter, user_data)
        where column is the gtk.TreeViewColumn in the treeview, cell is the
        gtk.CellRenderer for column, model is the gtk.TreeModel for the
        treeview and iter is the gtk.TreeIter pointing at the row.
        
        The method sets cell background color for all columns
        and text for index and amount columns.
        """
        _row_path = tree_model.get_path(iter)
        _number = _row_path[-1]
        if column is self.__index_column:
            cell_renderer.set_property('text', str(_number + 1))
            self.__index_column.get_cell_renderers()[1].set_property(
                'cell-background-gdk', lcolor[_number % 2])
        elif column is self.__linetype_column:
            _measure = tree_model[_row_path][0]
            _type = _measure.lineType
            if _type == 0:
                cell_renderer.set_property("pixbuf",self.normalline_icon)
            elif _type == 1:
                cell_renderer.set_property("pixbuf",self.parcialline_icon)
            elif _type == 2:
                cell_renderer.set_property("pixbuf",
                        self.acumulatedline_icon)
            else: #elif _type == 3:
                cell_renderer.set_property("pixbuf",
                        self.calculatedline_icon)
                
        elif column is self.__comment_column:
            _measure = tree_model[_row_path][0]
            _comment = str(_measure.comment)
            cell_renderer.set_property('text', _comment)
        elif column is self.__units_column:
            _measure = tree_model[_row_path][0]
            _units = _measure.units
            if isinstance(_units, float):
                _DN = self.__budget.getDecimals("DN")
                _units = ("%." + str(_DN) + "f" ) % _units
            cell_renderer.set_property('text', _units)
        elif column is self.__length_column:
            _measure = tree_model[_row_path][0]
            _length = _measure.length
            if isinstance(_length, float):
                _DD = self.__budget.getDecimals("DD")
                _length = ("%." + str(_DD) + "f" ) % _length
            cell_renderer.set_property('text', _length)
        elif column is self.__width_column:
            _measure = tree_model[_row_path][0]
            _width = _measure.width
            if isinstance(_width, float):
                _DD = self.__budget.getDecimals("DD")
                _width = ("%." + str(_DD) + "f" ) % _width
            cell_renderer.set_property('text', _width)
        elif column is self.__height_column:
            _measure = tree_model[_row_path][0]
            _height = _measure.height
            if isinstance(_height, float):
                _DD = self.__budget.getDecimals("DD")
                _height = ("%." + str(_DD) + "f" ) % _height
            cell_renderer.set_property('text', _height)
        elif column is self.__formula_column:
            _measure = tree_model[_row_path][0]
            _formula = _measure.formula
            cell_renderer.set_property('text', _formula)
        elif column is self.__parcial_column:
            _measure_line = tree_model[_row_path][0]
            _parcial = _measure_line.parcial
            _type = _measure_line.lineType
            if _type == 1 or _type == 2:
                _parcial = ""
            else:
                if isinstance(_parcial, float):
                    _DS = self.__budget.getDecimals("DS")
                    _parcial = ("%." + str(_DS) + "f" ) % _parcial
            cell_renderer.set_property('text', _parcial)
        elif column is self.__subtotal_column:
            _measure_line = tree_model[_row_path][0]
            _type = _measure_line.lineType
            if _type == 1 or _type == 2:
                if _type == 1:
                    _color = gtk.gdk.color_parse(
                               globals.color["SUBTOTAL-PARCIAL"])
                    _subtotal = _measure_line.parcial_subtotal
                else: #elif _type == 2:
                    _color = gtk.gdk.color_parse(globals.color["SUBTOTAL"])
                    _subtotal = _measure_line.acumulated_subtotal
                lcolor = [_color, _color]
                if isinstance(_subtotal, float):
                    _DS = self.__budget.getDecimals("DS")
                    _subtotal= ("%." + str(_DS) + "f" ) % _subtotal
                cell_renderer.set_property('text', _subtotal)
            else:
                cell_renderer.set_property('text', "")

        if self.__treeview.get_cursor() == (_row_path,column):
            cell_renderer.set_property('cell-background-gdk',
                gtk.gdk.color_parse(globals.color["ACTIVE"]))
        else:
            cell_renderer.set_property('cell-background-gdk',
                lcolor[_number % 2])

    def _clear(self):
        """def _clear(self)
        
        it deletes the __budget value
        this would not be necessary if there were not circular references,
        which are pending to fix
        """
        del self.__budget

    def getWidget(self):
        """def getWidget(self)
        
        return the main widget (gtk.ScrolledWindow)
        """
        return self.__scrolled_window

    def getPath(self):
        """def getPath(self)
        
        return the tuple that identifies the pane in the notebook page
        """
        return self.__path

    def setPath(self, path):
        """def setPath(self)
        
        sets the tuple that identifies the pane in the notebook page
        """
        self.__path = path
    def getPage(self):
        """def getPage(self)
        
        return the Page
        """
        return self.__page

    def setPage(self,page):
        """def setPage(self)
        
        set the Page
        """
        self.__page = page

    def getBudget(self):
        """def getBudget(self)
        
        return the Budget objet
        """
        return self.__budget

    def getActivePathRecord(self):
        """def getActivePathRecord(self)
        
        return the Active Path Record
        """
        return self.__active_path_record

    widget = property(getWidget, None, None,
        "Pane configuration list")
    path = property(getPath, setPath, None,
        "Path that identifies the item in the page notebook")
    page = property(getPage, setPage, None,
        "Weak reference from Page instance which creates this class")
    budget =  property(getBudget, None, None,
        "Budget object")
    active_path_record =  property(getActivePathRecord, None, None,
        "Active Code")

class Description(object):
    """gui.Description
    
    Description:
        Class to show a description text of a record in a pane
    Constructor:
        Description(budget, code)
        budget: budget
        code: code record
    Ancestry:
    +-- object
      +-- Description
    Atributes:
        "widget": the main widget (gtk.ScrolledWindow object)
        "path": the tuple that identifies the pane in the notebook page
            TODO
        "budget": The budget (base.obra objetc)
        "active_code": The active code of the record
        "__textbuffer": The textbuffer of the textview that contain
            the record text.
        "__label": The gtk.label with the title of the pane
    Methods:
        __init__(self, budget, code)
        setActiveCode(self, code)
        runMessage(self, message, nt, arg=None)
        _clear(self)
        getWidget(self)
        {get/set}Path
        {get/seg}Page
        getBudget(self)
        getActviCode(self)
    """
    # TODO: make standar: "DecompositonList and Description"
    def __init__(self, budget, page, path, path_record=(0,)):
        """def __init__(self, budget, page, path, path_record=(0,))
        
        budget: the budget (base.obra object)
        page: weak reference from Page instance which creates this class
        path: the path position of the description in the page
        path_record: the path of the active record
        
        Creates an shows the scroledwindow that contain the description text
        of the record to be showed in a pane.
        """
        self.__budget = budget
        self.__page = page
        self.__path = path
        self.__active_path_record = path_record
        _budget = budget
        _text = _budget.getRecord(self.__budget.getCode(
                self.__active_path_record)).text
        _scrollwindow = gtk.ScrolledWindow()
        _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC,
                                 gtk.POLICY_AUTOMATIC)
        _textview = gtk.TextView()
        _textview.set_wrap_mode(gtk.WRAP_WORD)
        self.__textbuffer = _textview.get_buffer()
        self.__textbuffer.set_text(_text)
        _textview.show()
        _hbox = gtk.HBox()
        _hbox.pack_start(_textview, True, True, 5)
        _hbox.show()
        _vbox = gtk.VBox()
        self.__label = gtk.Label(utils.mapping(_("Description text of the "\
                     "record $1"), (self.__budget.getCode(
                    self.__active_path_record),)))
        self.__label.set_alignment(0, 0)
        self.__label.show()
        _vbox.pack_start(self.__label, False, False, 5)
        _vbox.pack_start(_hbox, True, True, 5)
        _vbox.show()
        _scrollwindow.add_with_viewport(_vbox)
        _scrollwindow.show()
        self.__widget = _scrollwindow


    def setActivePathRecord(self, path_record):
        """def setActivePathRecord(self, path_record))
        
        path_record: active path record
        Set the new path code to show its description text.
        """
        _budget = self.__budget
        self.__active_path_record = path_record
        _code = _budget.getCode(self.__active_path_record)
        self.__label.set_text(utils.mapping(_("Description text of the record "\
            "$1"), (_code,)))
        _text = _budget.getRecord(_code).text
        self.__textbuffer.set_text(_text)

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        path: tuple that identifies the pane in the notebook page
        arg: tuple whit two items:
            0: record path in the budget
            1: record code
        This method receives a message and executes its corresponding action
        """
        _budget = self.__budget
        if message == "change_active":
            if _budget.hasPath(arg):
                self.setActivePathRecord(arg)
        elif message == "clear":
            self._clear()

    def _clear(self):
        """def _clear(self)
        
        Delete all instance atributes
        """
        del self.__widget
        del self.__path
        del self.__budget
        del self.__active_code
        del self.__textbuffer
        del self.__label

    def getWidget(self):
        """def getWidget(self)
        
        return the main widget (gtk.ScrolledWindow)
        """
        return self.__widget

    def getPath(self):
        """def getPath(self)
        
        return the tuple that identifies the pane in the notebook page
        """
        return self.__path

    def setPath(self, path):
        """def setPath(self)
        
        sets the tuple that identifies the pane in the notebook page
        """
        self.__path = path

    def getPage(self):
        """def getPage(self)
        
        return the weak reference from Page instance
        """
        return self.__page

    def setPage(self, page):
        """def setPage(self)
        
        set the weak reference from Page instance
        """
        self.__page = page

    def getBudget(self):
        """def getBudget(self)
        
        return the budget object
        """
        return self.__budget

    def getActivePathRecord(self):
        """def getActivePathRecord(self)
        
        return the Active Path Record
        """
        return self.__active_path_record

    path = property(getPath, setPath, None,
        "Path that identifie the item in the page notebook")
    widget = property(getWidget, None, None,
        "The main widget (gtk.ScrolledWindow)")
    page = property(getPage, setPage, None,
        "Weak reference from Page instance which creates this class")
    budget = property(getBudget, None, None,
        "Budget object")
    active_path_record = property(getActivePathRecord, None, None,
        "Active Path Record")

class Sheet(object):
    """gui.Sheet
    
    Description:
        Class to show a sheeet of conditions text of a record in a pane
    Constructor:
        Sheet(budget, code)
        budget: budget object
        code: code record
    Ancestry:
    +-- object
      +-- Sheet
    Atributes:
        "widget": the main widget (gtk.ScrolledWindow object)
        "path": the tuple that identifies the pane in the notebook page
        "budget": The budget (base.obra objetc)
        "active_path_record": The active path record
        "page": weak reference from Page instance which creates this class

        "__textbuffer": The textbuffer of the textview that contain
            the record text.
        "__label": The gtk.label with the title of the pane
        "__field_liststore": the field liststore
        "__field_treeview": the field treeview
        "__field_selection": the field selected in field treview
        "__section_liststore": the section liststore
        "__section_treeview": the section treeview
        "__section_selection": the section selected in the section treeview
    Methods:
        __init__(self, budget, code)
        setFields(self)
        setSection(self)
        setText(self)
        field_controlSelection(self, selection)
        section_controlSelection(self, selection)
        runMessage(self, message, nt, arg=None)
        _clear(self)
        getWidget(self)
        {get/set}Path
        {get/set}Page
        getBudget(self)
        getActviPathRecord(self)
    """
    def __init__(self, budget, page, path, path_record=(0,)):
        """def __init__(self, budget, page, path, path_record=(0,))
        
        budget: the budget (base.obra object)
        page: weak reference from Page instance which creates this class
        path: the path position of the description in the page
        path_record: the path of the active record
        Creates an shows the scroledwindow that contain the description text
        of the record to be showed in a pane.
        """
        self.__budget = budget
        self.__page = page
        self.__path = path
        self.__active_path_record = path_record
        _budget = budget
        
        _main_box = gtk.VBox()
        
        self.__label = gtk.Label(utils.mapping(_("Sheet of Conditions of the "\
                       "record $1"), (self.__budget.getCode(
                       self.__active_path_record),)))
        self.__label.set_alignment(0, 0)
        self.__label.show()
        
        _frame = gtk.Frame()
        _frame.set_shadow_type(gtk.SHADOW_IN)
        _frame_box = gtk.VBox()
        _list_box = gtk.HBox()
        
        self.__field_liststore = gtk.ListStore(str, str)
        self.__field_treeview = gtk.TreeView(self.__field_liststore)
        _field_treeselection = self.__field_treeview.get_selection()
        _field_treeselection.set_mode(gtk.SELECTION_SINGLE)
        self.__field_selection = None
        _field_treeselection.set_select_function(
            self.field_controlSelection)
        self.__field_treeview.show()
        _fieldcode_cell = gtk.CellRendererText()
        _field_column = gtk.TreeViewColumn(_("Field"))
        _field_column.pack_start(_fieldcode_cell, False)
        _field_cell = gtk.CellRendererText()
        _field_column.pack_end(_field_cell, True)
        _field_column.add_attribute(_fieldcode_cell, "text", 0)
        _field_column.add_attribute(_field_cell, "text", 1)
        self.__field_treeview.append_column(_field_column)
        _field_scrollwindow = gtk.ScrolledWindow()
        _field_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC,
                                 gtk.POLICY_AUTOMATIC)
        _field_scrollwindow.add(self.__field_treeview)
        _field_scrollwindow.show()
        
        self.__section_liststore = gtk.ListStore(str, str)
        self.__section_treeview = gtk.TreeView(self.__section_liststore)
        _section_treeselection = self.__section_treeview.get_selection()
        _section_treeselection.set_mode(gtk.SELECTION_SINGLE)
        self.__section_selection = None
        _section_treeselection.set_select_function(
            self.section_controlSelection)
        self.__section_treeview.show()
        _sectioncode_cell = gtk.CellRendererText()
        _section_column = gtk.TreeViewColumn(_("Section"))
        _section_column.pack_start(_sectioncode_cell, False)
        _section_column.add_attribute(_sectioncode_cell, "text", 0)
        _section_cell = gtk.CellRendererText()
        _section_column.pack_end(_section_cell, True)
        _section_column.add_attribute(_section_cell, "text", 1)
        self.__section_treeview.append_column(_section_column)
        _section_scrollwindow = gtk.ScrolledWindow()
        _section_scrollwindow.set_policy(gtk.POLICY_AUTOMATIC,
                                 gtk.POLICY_AUTOMATIC)
        _section_scrollwindow.add(self.__section_treeview)
        _section_scrollwindow.show()
        
        _list_box.pack_start(_field_scrollwindow, True, True, 5)
        _list_box.pack_start(_section_scrollwindow, True, True, 5)
        _list_box.show()
        
        _scrollwindow = gtk.ScrolledWindow()
        _scrollwindow.set_policy(gtk.POLICY_AUTOMATIC,
                                 gtk.POLICY_AUTOMATIC)
        _textview = gtk.TextView()
        _textview.set_wrap_mode(gtk.WRAP_WORD)
        self.__textbuffer = _textview.get_buffer()
        _textview.show()
        _hbox = gtk.HBox()
        _hbox.pack_start(_textview, True, True, 5)
        _hbox.show()
        
        _frame_box.pack_start(self.__label, False, False, 5)
        _frame_box.pack_start(_list_box, False, False, 5)
        _frame_box.show()
        _frame.add(_frame_box)
        _frame.show()
        _main_box.pack_start(_frame, False)
        

        _vbox = gtk.VBox()
        _vbox.pack_start(_hbox, True, True, 5)
        _vbox.show()
        _main_box.pack_start(_scrollwindow, True, True, 5)
        _main_box.show()
        
        _scrollwindow.add_with_viewport(_vbox)
        _scrollwindow.show()
        self.__widget = _main_box
        
        self.setFields()

    def setFields(self):
        """setFields(self)
        
        Set the fields items in the field treeview
        """
        _record = self.__budget.getRecord(self.__budget.getCode(
                  self.__active_path_record))
        _sheet = _record.getSheet()
        _field_list = _sheet.getFields()
        self.__field_liststore.clear()
        for _field in _field_list:
            _field_text = self.__budget.getSheetField(_field)
            _iter = self.__field_liststore.append([_field, _field_text])
        _treeselection = self.__field_treeview.get_selection()
        _treeselection.select_path(0)

    def setSection(self):
        """setSection(self)
        
        Set the section items in the section treeview
        """
        self.__section_liststore.clear()
        if not self.__field_selection is None:
            _record = self.__budget.getRecord(self.__budget.getCode(
                  self.__active_path_record))
            _sheet = _record.getSheet()
            _section_list = _sheet.getSections(self.__field_selection)
            for _section in _section_list:
                _section_text = self.__budget.getSheetSection(_section)
                _iter = self.__section_liststore.append([_section, _section_text])
            _treeselection = self.__section_treeview.get_selection()
            _treeselection.select_path(0)

    def setText(self):
        """setText(self)
        
        Set the text in the textview
        """
        if not self.__section_selection is None and\
           not self.__field_selection is None:
            _record = self.__budget.getRecord(self.__budget.getCode(
                  self.__active_path_record))
            _sheet = _record.getSheet()
            _paragraph_code = _sheet.getParagraph(self.__field_selection,
                                                  self.__section_selection)
            _paragraph = self.__budget.getSheetParagraph(_paragraph_code)
            self.__textbuffer.set_text(_paragraph)
        else:
            self.__textbuffer.set_text("")

    def field_controlSelection(self, selection):
        """def controlSelection(self, selection)
        
        selection: treeselection
        
        Method connected to set_selection_function() in field treeview
        This method is called before any node is selected or unselected,
        giving some control over which nodes are selected.
        The selection function should return TRUE if the state
        of the node may be toggled, and FALSE if the state of the node should
        be left unchanged.
        
        When a user select a row in the field treeview the section treeview is
        reloaded to show the sections of this field and already the text sheet.
        """
        _treeiter = self.__field_liststore.get_iter(selection)
        self.__field_selection = self.__field_liststore.get_value(_treeiter, 0)
        self.setSection()
        return True

    def section_controlSelection(self, selection):
        """def controlSelection(self, selection)
        
        selection: treeselection
        
        Method connected to set_selection_function() in sector treeview
        This method is called before any node is selected or unselected,
        giving some control over which nodes are selected.
        The selection function should return TRUE if the state
        of the node may be toggled, and FALSE if the state of the node should
        be left unchanged.
        
        When a user select a row in the field treeview the text sheet for this
        section in showed
        """
        _treeiter = self.__section_liststore.get_iter(selection)
        self.__section_selection = self.__section_liststore.get_value(_treeiter, 0)
        self.setText()
        return True

    def setActivePathRecord(self, path_record):
        """def setActivePathRecord(self, path_record))
        
        path_record: active path record
        
        Set the new path code to show its sheet of condition text.
        """
        self.__field_selection = None
        self.__field_liststore.clear()
        self.__section_selection = None
        self.__section_liststore.clear()
        self.__textbuffer.set_text("")
        _budget = self.__budget
        self.__active_path_record = path_record
        _code = _budget.getCode(self.__active_path_record)
        self.__label.set_text(utils.mapping(_("Sheet2 of Conditions of the "\
                     "record $1"), (_code,)))
        self.setFields()

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        path: tuple that identifies the pane in the notebook page
        arg: tuple whit two items:
            0: record path in the budget
            1: record code
        This method receives a message and executes its corresponding action
        """
        _budget = self.__budget
        if message == "change_active":
            if _budget.hasPath(arg):
                self.setActivePathRecord(arg)
        elif message == "clear":
            self._clear()

    def _clear(self):
        """def _clear(self)
        
        Deletes all the instance atributes
        """
        del self.__page
        del self.__widget
        del self.__path
        del self.__budget
        del self.__active_code
        del self.__textbuffer
        del self.__label
        del self.__textbuffer
        del self.__label
        del self.__field_liststore
        del self.__field_treeview
        del self.__field_selection
        del self.__section_liststore
        del self.__section_treeview
        del self.__section_selection

    def getWidget(self):
        """def getWidget(self)
        
        return the main widget (gtk.ScrolledWindow)
        """
        return self.__widget

    def getPath(self):
        """def getPath(self)
        
        return the tuple that identifies the pane in the notebook page
        """
        return self.__page

    def setPath(self, path):
        """def setPath(self)
        
        sets the tuple that identifies the pane in the notebook page
        """
        self.__path = path

    def getPage(self):
        """def getPage(self)
        
        return the weak reference from Page instance
        """
        return self.__page

    def setPage(self, page):
        """def setPage(self)
        
        set the weak reference from Page instance
        """
        self.__page = page

    def getBudget(self):
        """def getBudget(self)
        
        return the budget object
        """
        return self.__budget

    def getActivePathRecord(self):
        """def getActivePathRecord(self)
        
        return the Active Path Record
        """
        return self.__active_path_record

    path = property(getPath, setPath, None,
        "Path that identifie the item in the page notebook")
    widget = property(getWidget, None, None,
                      "Lista de configuracion de vistas")
    page = property(getPage, setPage, None,
        "Weak reference from Page instance which creates this class")
    budget = property(getBudget, None, None,
        "Budget object")
    active_path_record = property(getActivePathRecord, None, None,
        "Active Path Record")

class FileView(object):
    """gui.FileView
    
    Description:
        Class to show the file icons of a record in a pane
    Constructor:
        Description(budget, code)
        budget: budget
        code: code record
    Ancestry:
    +-- object
      +-- Description
    Atributes:
        "widget": the main widget (gtk.ScrolledWindow object)
        "__icon_box": the box that contains the icon
        "path": the tuple that identifies the pane in the notebook page
        "budget": The budget (base.obra objetc)
        "active_code": The active code of the record
    Methods:
        __init__(self, budget, code)
        setActiveCode(self, code)
        runMessage(self, message, nt, arg=None)
        _clear(self)
        getWidget(self)
        {get/set}Path
        {get/seg}Page
        getBudget(self)
        getActviCode(self)
    """

    def __init__(self, budget, page, path, path_record=(0,)):
        """def __init__(self, budget, page, path, path_record=(0,))
        
        budget: the budget (base.obra object)
        page: weak reference from Page instance which creates this class
        path: the path position of the description in the page
        path_record: the path of the active record
        
        Creates an shows the scroledwindow that contain icon files
        of the record to be showed in a pane.
        """
        self.__budget = budget
        self.__page = page
        self.__path = path
        self.__active_path_record = path_record
        self.__active_code = budget.getCode(self.__active_path_record)
        _budget = budget
        _record = self.__budget.getRecord(self.__budget.getCode(
                    self.__active_path_record))
                    
        self.__icon_box = self.getIconBox(_record)
        _scrollwindow = gtk.ScrolledWindow()
        _scrollwindow.set_policy(gtk.POLICY_ALWAYS,
                                 gtk.POLICY_NEVER)
        
        self.__icon_box.show()
        _scrollwindow.add_with_viewport(self.__icon_box)
        _scrollwindow.show()
        self.__widget = _scrollwindow

    def getIconBox(self, record):
        """getIconBox(self, record)
        
        record: the active record object
        
        Creates and returns the box whith te icon files of the active record.
        """
        ## TODO: add others filetypes: avi, pdf, ppt...
        _files = record.getFiles()
        _hbox = gtk.HBox()
        _frame = gtk.Frame()
        _frame.set_shadow_type(gtk.SHADOW_IN)
        for _file in _files:
            _path = os.path.dirname(self.__budget.filename)
            _file_path = os.path.join(_path, _file.name)
            _filetype = utils.getFiletype(_file_path)
            _box = gtk.VBox()
            if _filetype == "image":
                _event_box = gtk.EventBox()
                try:
                    _image_pixbuf = gtk.gdk.pixbuf_new_from_file(_file_path)
                    _image_pixbuf = _image_pixbuf.scale_simple(64, 64,
                                    gtk.gdk.INTERP_BILINEAR)
                except:
                    _image_pixbuf = gtk.gdk.pixbuf_new_from_file(
                                    globals.getAppPath("IMAGE-ICON"))
                    _image_pixbuf = _image_pixbuf.scale_simple(64, 64,
                                    gtk.gdk.INTERP_BILINEAR)
                _image_icon = gtk.Image()
                _image_icon.set_from_pixbuf(_image_pixbuf)
                _image_icon.show()
                _event_box.add(_image_icon) 
                _box.pack_start(_event_box, False, False, 5)
                _event_box.connect("button-press-event", self.launchFile,
                                   "image", _file_path)
                _event_box.show()
                
            elif _filetype == "dxf":
                _event_box = gtk.EventBox()
                _dxf_icon = gtk.Image()
                _dxf_pixbuf = gtk.gdk.pixbuf_new_from_file(
                                    globals.getAppPath("DXF-ICON"))
                _dxf_pixbuf = _dxf_pixbuf.scale_simple(64, 64,
                              gtk.gdk.INTERP_BILINEAR)
                _dxf_icon.set_from_pixbuf(_dxf_pixbuf)
                _dxf_icon.show()
                _event_box.add(_dxf_icon)
                _box.pack_start(_event_box, False, False, 5)
                _event_box.connect("button-press-event", self.launchFile, 
                                   "dxf", _file_path)
                _event_box.show()
            _label_event_box = gtk.EventBox()
            _label = gtk.Label(_file.name)
            _label_event_box.add(_label)
            _label_event_box.show()
            _label.show()
            _box.pack_start(_label_event_box, False, False, 5)
            _box.show()
            _hbox.pack_start(_box, False, False, 5)
        _hbox.show()
        _frame.add(_hbox)
        return _frame

    def launchFile(self, widget, event, kind, file_path):
        """launchFile(self, widget, event, kind, file_path)
        
        widget: the widget that emit the signal
        event: the event that emit the signal
        king: kind of file
        file_path: the path file to be launch
        
        Launch the file if a double click emit the signal.
        Method connected to "button-press-event" signal in images event box
        """
        if event.type is gtk.gdk._2BUTTON_PRESS:
            openwith.launch_file(kind, file_path)

    def setActivePathRecord(self, path_record):
        """def setActivePathRecord(self, path_record))
        
        path_record: active path record
        Set the new path code to show its description text.
        """
        _budget = self.__budget
        self.__active_path_record = path_record
        _code = _budget.getCode(self.__active_path_record)
        _record = self.__budget.getRecord(_code)
        self.__icon_box.destroy()
        self.__icon_box =  self.getIconBox(_record)
        self.__icon_box.show()
        self.__widget.add_with_viewport(self.__icon_box)

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        path: tuple that identifies the pane in the notebook page
        arg: tuple whit two items:
            0: record path in the budget
            1: record code
        This method receives a message and executes its corresponding action
        """
        _budget = self.__budget
        if message == "change_active":
            if _budget.hasPath(arg):
                self.setActivePathRecord(arg)
        elif message == "clear":
            self._clear()

    def _clear(self):
        """def _clear(self)
        
        Delete all instance atributes
        """
        del self.__hbox
        del self.__widget
        del self.__path
        del self.__budget
        del self.__active_code

    def getWidget(self):
        """def getWidget(self)
        
        return the main widget (gtk.ScrolledWindow)
        """
        return self.__widget

    def getPath(self):
        """def getPath(self)
        
        return the tuple that identifies the pane in the notebook page
        """
        return self.__path

    def setPath(self, path):
        """def setPath(self)
        
        sets the tuple that identifies the pane in the notebook page
        """
        self.__path = path

    def getPage(self):
        """def getPage(self)
        
        return the weak reference from Page instance
        """
        return self.__page

    def setPage(self, page):
        """def setPage(self)
        
        set the weak reference from Page instance
        """
        self.__page = page

    def getBudget(self):
        """def getBudget(self)
        
        return the budget object
        """
        return self.__budget

    def getActivePathRecord(self):
        """def getActivePathRecord(self)
        
        return the Active Path Record
        """
        return self.__active_path_record

    path = property(getPath, setPath, None,
        "Path that identifie the item in the page notebook")
    widget = property(getWidget, None, None,
        "The main widget (gtk.ScrolledWindow)")
    page = property(getPage, setPage, None,
        "Weak reference from Page instance which creates this class")
    budget = property(getBudget, None, None,
        "Budget object")
    active_path_record = property(getActivePathRecord, None, None,
        "Active Path Record")


class TextWindow(object):
    """gui.TextWindow
    
    Description:
        Class to show a description text of a record in a new gtk window
    Constructor:
        TextWindow(code, text)
        code: code of the record
        text: description text of the record
    Ancestry:
    +-- object
      +-- TextWindow
    Atributes:
    Methods:
        __init__(self, code, text)
        main(self)
        destroy(self, widget)
    """

    def __init__(self, code, text):
        """def __init__(self, code, text)
        
        code: code of the record
        text: description text of the record
        Creates an shows the window.
        """
        _window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        _window.set_resizable(True)
        _window.set_default_size(700, 300)
        _window.set_title(utils.mapping(_("$1 text"), (code,)))
        _window.set_border_width(0)
        _box1 = gtk.VBox(False, 0)
        _window.add(_box1)
        _box1.show()
        _sw = gtk.ScrolledWindow()
        _sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        _textview = gtk.TextView()
        _textview.set_wrap_mode(gtk.WRAP_WORD)
        _textbuffer = _textview.get_buffer()
        _sw.add(_textview)
        _sw.show()
        _textview.show()
        _box1.pack_start(_sw)
        _textbuffer.set_text(text)
        _window.connect("destroy", self.destroy)
        _window.show()

    def main(self):
        """def main(self) 
        
        Starts the GTK+ event processing loop.
        """
        gtk.main()

    def destroy(self, widget):
        """destroy(self, widget)
        widget: the widget where the event is emitted from
        Method connected to "destroy" signal of window widget
        This signal is emited when the method connected to "delete_event"
        signal returns True or when the program call the destroy() method of
        the gtk.Window widget.
        The window is closed and the GTK+ event processing loop is ended.
        """
        gtk.main_quit()

class CompanyView(object):
    """gui.CompanyView:
    
    Description:
        Class to show the company records of a budget
    Constructor:
        CompanyView(budget, page, path)
        budget: budget showed ("base.Budget" object)
        page: weak reference from Page instance which creates this class
        path: tuple that represents the path of the List in the Page
        Returns the newly created CompanyView instance
    Ancestry:
    +-- object
      +-- CompanyView
    Atributes:
        "budget": Budget to show, base.obra instance.
        "active_path_record"
        "widget": Window that contains the main widget,
            (gtk.ScrolledWindow)
        "path": Pane page identifier
        "page": weak reference from Page instance which creates this class
        "__methond_message": Method to send messages to the page
    Methods:
        __init__(self, budget, page, path, path_record=(0,))
        runMessage(self, message, path, arg=None)
        _clear(self)
        getWidget(self)
        {get/set}Path
        {get/set}Page
        getBudget(self)
        getActivePathRecord(self)
    """

    def __init__(self, budget, page, path, path_record=(0,)):
        """def __init__(self, budget, page, path, path_record=(0,))
        
        budget: budget: budget showed ("base.Budget" object)
        page: weak reference from Page instance which creates this class
        path: tuple that represents the path of the List in the Page
        path_record: path of the active record in the budget
        
        Sets the init atributes
        Creates the 

        """
        self.__selection = None
        # Seting init args
        if not isinstance(budget, base.Budget):
            raise ValueError, _("Argument must be a Budget object")
        self.__budget = budget
        self.__page = page
        self.__path = path
        self.__active_path_record = path_record
        # HVox
        self.__hbox = gtk.HPaned()
        self.__hbox.set_position(230)
        # TreeStore
        self.__treestore = gtk.TreeStore(str, str)
        self.setTreeStoreValues()
        # Select Treeview
        self.__select_treeview = gtk.TreeView(self.__treestore)
        self.__select_treeview.set_enable_search(False)
        self.__select_treeview.set_reorderable(False)
        self.__select_treeview.set_headers_visible(False)
        self.__select_treeview.show()
        # Scrolled_window
        self.__scrolled_window = gtk.ScrolledWindow()
        self.__scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
            gtk.POLICY_AUTOMATIC)
        self.__scrolled_window.add(self.__select_treeview)
        # colors
        _text_color = gtk.gdk.color_parse(globals.color["TEXT"])
        _background_color = [
            gtk.gdk.color_parse(globals.color["UNEVEN"]),
            gtk.gdk.color_parse(globals.color["EVEN"])]
        self.__code_column = gtk.TreeViewColumn()
        self.__code_column.set_clickable(True)
        self.__code_column.set_fixed_width(200)
        _code_cell = gtk.CellRendererText()
        _code_cell.set_property('foreground-gdk', _text_color)
        self.__code_column.pack_start(_code_cell, True)
        self.__code_column.add_attribute(_code_cell, 'text', 0)
        _summary_cell = gtk.CellRendererText()
        _summary_cell.set_property('foreground-gdk', _text_color)
        self.__code_column.pack_start(_summary_cell, True)
        self.__code_column.add_attribute(_summary_cell, 'text', 1)
        # Index column
        self.__select_treeview.append_column(self.__code_column)
        # control selection
        self.__treeselection = self.__select_treeview.get_selection()
        self.__treeselection.set_mode(gtk.SELECTION_SINGLE)
        self.__treeselection.set_select_function(self.controlSelection)
        # Show
        self.setColumnsHeaders()
        self.__scrolled_window.show()
        # Option View
        self.__option_View = OptionView("")
        # Selection
        self.__select_treeview.set_cursor((0,), None, False)
        self.__select_treeview.grab_focus()
        #
        self.__hbox.add1(self.__scrolled_window)
        self.__hbox.add2(self.__option_View.widget)
        self.__hbox.show()
        self.__widget = self.__hbox

    def setOptions(self, type):
        if type == "company":
            _options = [("code", _("Code"), "string",
                         _("""Code that define the company""")),
                        ("summary", _("Summary"), "string",
                         _("""Summary of the company name""")),
                        ("name", _("Name"), "string",
                         _("""Complete name""")),
                        ("cif", _("CIF"), "string",
                         _("""Fiscal identifier number""")),
                        ("web", _("Web"), "string",
                         _("""Company web page""")),
                        ("email", _("Email"), "string",
                         _("""Company email""")),
                        ]
            self.__option_View.setOptions(_options)
        elif type == "office":
            _options = [("type", _("Type"), "string",
                         _("""Type of Office:
                           C: Central office
                           D: Local office
                           R: Performer""")),
                        ("subname", _("Name"), "string",
                         _("Office name")),
                        ("address", _("Address"), "string",""),
                        ("postal code", _("Postal code"), "string",""),
                        ("town", _("Town"), "string",""),
                        ("province", _("Province"), "string",""),
                        ("country", _("Country"), "string",""),
                        ("phone", _("Phone"), "list",
                         _("Phone numbers of the office")),
                        ("fax", _("Fax"), "list",
                         _("Fax numbers of the office")),
                        ("contact person", _("Contact person"), "string",
                         _("Contact persons in the office")),
                       ]
            self.__option_View.setOptions(_options)
        else:
            print _("Unknow Option Type")
    def setOptionValues(self, company_key):
        self.__option_View.setValues(_values)

    def setTreeStoreValues(self):
        """def setListstoreValues(self)
        
        Sets the treestore values from  the budget
        """
        _budget = self.__budget
        _company_keys = _budget.getCompanyKeys()
        for _company_key in _company_keys:
            _company = _budget.getCompany(_company_key)
            _values = [_company_key, _company.summary]
            _treeiter = self.__treestore.append(None, _values)
            _offices = _company.offices
            for _office in _offices:
                # TODO: Test offices
                _values = [_office.officeType, _office.subname]
                self.__treestore.append(_treeiter, _values)

    def setColumnsHeaders(self):
        """def setColumnsHeaders(self)
        
        Sets the headers column values
        """
        #self.columns[1].set_title(_("Type"))  # Σ parcial Σ total
        #self.columns[2].set_title(_("Comment"))
        #self.columns[3].set_title(_("N"))
        #self.columns[4].set_title(_("Length"))
        #self.columns[5].set_title(_("Width"))
        #self.columns[6].set_title(_("Height"))
        pass

    def controlSelection(self, selection):
        """def controlSelection(self, selection)
        
        selection: selection
        
        Method connected to set_selection_function() 
        This method is called before any node is selected or unselected,
        giving some control over which nodes are selected.
        The selection function should return TRUE if the state
        of the node may be toggled, and FALSE if the state of the node should
        be left unchanged.
        
        The selection changes the company/office in the option treeview
        """
        if len(selection) == 1:
            # The selection is a company
            _company_key = self.__treestore[selection][0]
            _company = self.__budget.getCompany(_company_key)
            _selection = "company"
            _values = _company.values
        else:
            # The selection is a office
            _company_key = self.__treestore[selection[:1]][0]
            _company = self.__budget.getCompany(_company_key)
            _selection = "office"
            _office = _company.offices[selection[1]]
            _values = _office.values
        if not self.__selection == _selection:
            self.__selection = _selection
            self.setOptions(_selection)
        self.__option_View.setValues(_values)

        return True

    def showMessageRecord(self, record_path):
        """def showMessageRecord(self, record_path)
        
        record_path: the path of the record to show
        Method connected to "change_active" message
        Show the record especified in the "change_active" message
        """
        self.__active_path_record = record_path

    def runMessage(self, message, path, arg=None):
        """def runMessage(self, message, path, arg=None)
        
        message: the message type
            "change_active": change the active record
            "clear": clear instance
        path: tuple that identifies the pane in the notebook page
        arg: tuple whit two items:
            0: record path in the budget
            1: record code
        This method receives a message and executes its corresponding action
        """
        _budget = self.__budget
        if message == "change_active":
            if _budget.hasPath(arg):
                _path_record = arg
                self.showMessageRecord( _path_record)
            pass
        elif message == "clear":
            self._clear()

    def colorCell(self, column, cell_renderer, tree_model, iter, lcolor):
        """def colorCell(self, column, cell_renderer, tree_model, iter, lcolor)
        
        column: the gtk.TreeViewColumn in the treeview
        cell_renderer: a gtk.CellRenderer
        tree_model: the gtk.TreeModel
        iter: gtk.TreeIter pointing at the row
        lcolor: list with 2 gtk colors for even and uneven record
        
        Method connected to "set_cell_data_func" of many column
        The set_cell_data_func() method sets the data function (or method) 
        to use for the column gtk.CellRenderer specified by cell_renderer.
        This function (or method) is used instead of the standard attribute
        mappings for setting the column values, and should set the attributes
        of the cell renderer as appropriate. func may be None to remove the
        current data function. The signature of func is:
        -def celldatafunction(column, cell, model, iter, user_data)
        -def celldatamethod(self, column, cell, model, iter, user_data)
        where column is the gtk.TreeViewColumn in the treeview, cell is the
        gtk.CellRenderer for column, model is the gtk.TreeModel for the
        treeview and iter is the gtk.TreeIter pointing at the row.
        
        The method sets cell background color for all columns
        and text for index and amount columns.
        """
        _row_path = tree_model.get_path(iter)
        _number = _row_path[-1]
        if column is self.__index_column:
            cell_renderer.set_property('text', str(_number + 1))
            self.__index_column.get_cell_renderers()[1].set_property(
                'cell-background-gdk', lcolor[_number % 2])
        if self.__treeview.get_cursor() == (_row_path,column):
            cell_renderer.set_property('cell-background-gdk',
                gtk.gdk.color_parse(globals.color["ACTIVE"]))
        else:
            cell_renderer.set_property('cell-background-gdk',
                lcolor[_number % 2])

    def _clear(self):
        """def _clear(self)
        
        it deletes the __budget value
        this would not be necessary if there were not circular references,
        which are pending to fix
        """
        del self.__budget

    def getWidget(self):
        """def getWidget(self)
        
        return the main widget (gtk.ScrolledWindow)
        """
        return self.__widget

    def getPath(self):
        """def getPath(self)
        
        return the tuple that identifies the pane in the notebook page
        """
        return self.__path

    def setPath(self, path):
        """def setPath(self)
        
        sets the tuple that identifies the pane in the notebook page
        """
        self.__path = path
    def getPage(self):
        """def getPage(self)
        
        return the Page
        """
        return self.__page

    def setPage(self,page):
        """def setPage(self)
        
        set the Page
        """
        self.__page = page

    def getBudget(self):
        """def getBudget(self)
        
        return the Budget objet
        """
        return self.__budget
    
    def getActivePathRecord(self):
        """def getActivePathRecord(self)
        
        return the Active Path Record
        """
        return self.__active_path_record
    
    active_path_record =  property(getActivePathRecord, None, None,
        "Active path record")
    widget = property(getWidget, None, None,
        "main widget")
    path = property(getPath, setPath, None,
        "Path that identifies the item in the page notebook")
    page = property(getPage, setPage, None,
        "Weak reference from Page instance which creates this class")
    budget =  property(getBudget, None, None,
        "Budget object")


class OptionView(object):
    """gui.OptionView:
    
    Description:
        It creates a treeview whith the column "Option Name" "Value"
        and "Type" to show and edit Options
    Constructor:
        OptionView(option_list)
        option_list: list of options
            (option_name, type)
    Ancestry:
    +-- object
      +-- OptionView
    Atributes:
        "__liststore"
        "__treeview"
        "__option_column"
        "__value_column"
        "__type_column"
        "__treeselection"
        "__widget": Main windget
        "__option_list"
        "__option_dict"
        "__description_label"
        "option_types"
        "widget": __widget
    Methods:
        __init__(self, option_list)
        createColumn(self, args)
        createTextBaseColumn(self,args)
        createBaseColumn(self,args)
    """

    def __init__(self, option_list):
        """__init__(self, option_list)
        
        """
        self.__option_dict = {}
        self.__option_list = []
        self.option_types = {"boolean" : _("Boolean"),
                             "integer": _("Integer"),
                             "string":  _("Text"),
                             "color" : _("Color"),
                             "list" : _("List")}
        # ListStore
        self.__liststore = gtk.ListStore(str, str, str, str, str)
        # Treeview
        self.__treeview = gtk.TreeView(self.__liststore)
        self.__treeview.set_enable_search(False)
        self.__treeview.set_reorderable(False)
        self.__treeview.set_headers_clickable(False)
        # vbox
        _vbox = gtk.VBox()
        # Scrolled_window
        _scrolled_window = gtk.ScrolledWindow()
        _scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
                                        gtk.POLICY_AUTOMATIC)
        _scrolled_window.add(self.__treeview)
        _scrolled_window.show()
        _vbox.pack_start(_scrolled_window)
        # colors
        _text_color = gtk.gdk.color_parse(globals.color["TEXT"])
        _background_color = [
            gtk.gdk.color_parse(globals.color["UNEVEN"]),
            gtk.gdk.color_parse(globals.color["EVEN"])]
        # Option Column
        self.__option_column = gtk.TreeViewColumn()
        self.__option_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        self.__option_column.set_fixed_width(150)
        self.__option_column.set_resizable(True)
        _option_cell = gtk.CellRendererText()
        _option_cell.set_property('foreground-gdk', _text_color)
        self.__option_column.pack_start(_option_cell, True)
        self.__option_column.set_cell_data_func(_option_cell, self.colorCell,
                                                _background_color)
        self.__option_column.set_title(_("Option name"))
        self.__option_column.add_attribute(_option_cell, 'text', 1)
        self.__treeview.append_column(self.__option_column)
        # Value Column
        self.__value_column = gtk.TreeViewColumn()
        self.__value_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        self.__value_column.set_fixed_width(275)
        self.__value_column.set_resizable(True)
        _value_cell = gtk.CellRendererText()
        _value_cell.set_property('foreground-gdk', _text_color)
        self.__value_column.pack_start(_value_cell, True)
        self.__value_column.set_cell_data_func(_value_cell, self.colorCell,
                                               _background_color)
        self.__value_column.set_title(_("Value"))
        self.__value_column.add_attribute(_value_cell, 'text', 2)
        self.__treeview.append_column(self.__value_column)
        # Type Column
        self.__type_column = gtk.TreeViewColumn()
        self.__type_column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        self.__type_column.set_fixed_width(70)
        self.__type_column.set_resizable(True)
        _type_cell = gtk.CellRendererText()
        _type_cell.set_property('foreground-gdk', _text_color)
        self.__type_column.pack_start(_type_cell, True)
        self.__type_column.set_cell_data_func(_type_cell, self.colorCell,
                                               _background_color)
        self.__type_column.set_title(_("Type"))
        self.__treeview.append_column(self.__type_column)
        # End Column
        _end_column = gtk.TreeViewColumn()
        _end_column.set_clickable(False)
        _end_cell = gtk.CellRendererText()
        _end_cell.set_property('cell-background-gdk',
            gtk.gdk.color_parse(globals.color["UNEVEN"]))
        _end_column.pack_start(_end_cell, True)
        self.__treeview.append_column(_end_column)
        # Connect
        self.__treeview.connect("key-press-event", self.treeviewKeyPressEvent)
        self.__treeview.connect("button-press-event", self.treeviewClickedEvent)
        # control selection
        self.__treeselection = self.__treeview.get_selection()
        self.__treeselection.set_mode(gtk.SELECTION_MULTIPLE)
        self.__treeselection.set_select_function(self.controlSelection)
        # labels
        _frame = gtk.Frame()
        _frame.set_shadow_type(gtk.SHADOW_OUT)
        _vbox2 = gtk.VBox()
        _frame.add(_vbox2)
        _alignement = gtk.Alignment(xalign=0, yalign=0, xscale=0, yscale=0)
        _alignement.set_padding(0, 0, 12, 0)
        _label = gtk.Label()
        _label.set_markup("<b>" + _("Description:") + "</b>")
        _label.show()
        _alignement.add(_label)
        _alignement.show()
        _alignement2 = gtk.Alignment(xalign=0, yalign=0, xscale=0, yscale=0)
        _alignement2.set_padding(0, 0, 24, 0)
        self.__description_label  = gtk.Label()
        self.__description_label.show()
        _alignement2.add(self.__description_label)
        _alignement2.show()
        _vbox2.pack_start(_alignement, False)
        _vbox2.pack_start(_alignement2, False)
        _vbox2.show()
        _frame.show()
        _vbox.pack_start(_frame, False)
        # Show
        self.__treeview.show()
        _vbox.show()
        self.__widget = _vbox

    def treeviewKeyPressEvent(self, widget, event):
        """def treeviewKeyPressEvent(self, widget, event)
        
        widget: treewiew widget
        event: Key Press event
        Method connected to "key-press-event" signal
        The "key-press-event" signal is emitted when the user presses a key
        on the keyboard.
        Returns :TRUE to stop other handlers from being invoked for the event.
        Returns :FALSE to propagate the event further.
        
        If the user press the right cursor button and the cursor is in the
        value column or pres the left cursor button and the cursor is
        in the value column the event is estoped, else the event is propagated. 
        """
        (_cursor_path, _column) = self.__treeview.get_cursor()
        if (event.keyval == gtk.keysyms.Right \
           and _column == self.__value_column) \
           or (event.keyval == gtk.keysyms.Left \
           and _column == self.__value_column):
            return True
        else:
            _description = self.__liststore[_cursor_path][4]
            self.__description_label.set_text(_description)
            return False

    def treeviewClickedEvent(self, widget, event):
        """def treeviewClickedEvent(self, widget, event)
        
        widget: treewiew widget
        event: clicked event
        Method connected to "button-press-event" signal
        The "button-press-event" signal is emitted when a mouse button is
        pressed.
        Returns TRUE to stop other handlers from being invoked for the event.
        Returns FALSE to propagate the event further.
        
        The cursos is moved to value column.
        """
        path_at_pos = self.__treeview.get_path_at_pos(int(event.x),
                                                      int(event.y))
        if not path_at_pos is None:
            _path_cursor, _column, _x, _y = path_at_pos
            _description = self.__liststore[_path_cursor][4]
            self.__description_label.set_text(_description)
            if _column == self.__value_column:
                return False
            else:
                self.__treeview.set_cursor(_path_cursor,self.__value_column,
                                           True)
                self.__treeview.grab_focus()
                return True
        return True
    
    def controlSelection(self, selection):
        """def controlSelection(self, selection)
        
        selection: treeselection
        
        Method connected to set_selection_function() 
        This method is called before any node is selected or unselected,
        giving some control over which nodes are selected.
        The selection function should return TRUE if the state
        of the node may be toggled, and FALSE if the state of the node should
        be left unchanged.
        
        Return False so none row is selected
        """
        return False


    def colorCell(self, column, cell_renderer, tree_model, iter, lcolor):
        """def colorCell(self, column, cell_renderer, tree_model, iter, lcolor)
        
        column: the gtk.TreeViewColumn in the treeview
        cell_renderer: a gtk.CellRenderer
        tree_model: the gtk.TreeModel
        iter: gtk.TreeIter pointing at the row
        lcolor: list with 2 gtk colors for even and uneven record
        
        Method connected to "set_cell_data_func" of the column
        The set_cell_data_func() method sets the data function (or method) 
        to use for the column gtk.CellRenderer specified by cell_renderer.
        This function (or method) is used instead of the standard attribute
        mappings for setting the column values, and should set the attributes
        of the cell renderer as appropriate. func may be None to remove the
        current data function. The signature of func is:
        -def celldatafunction(column, cell, model, iter, user_data)
        -def celldatamethod(self, column, cell, model, iter, user_data)
        where column is the gtk.TreeViewColumn in the treeview, cell is the
        gtk.CellRenderer for column, model is the gtk.TreeModel for the
        treeview and iter is the gtk.TreeIter pointing at the row.
        
        The method sets cell background color for all columns
        and text for type column.
        """
        _row_path = tree_model.get_path(iter)
        _number = _row_path[-1]
        if self.__treeview.get_cursor() == (_row_path,column):
            cell_renderer.set_property('cell-background-gdk',
                gtk.gdk.color_parse(globals.color["ACTIVE"]))
        else:
            cell_renderer.set_property('cell-background-gdk',
                lcolor[_number % 2])
        if column is self.__type_column:
            _type = self.option_types[tree_model[_row_path][3]]
            cell_renderer.set_property('text', _type)

    def setOptions(self, option_list):
        """setOptions(self, option_list)
        
        option_list: list of tuples
            (option, option name, type)
            option: option identifier
            option name: a string with the option name
            Description: a string with the option description
            type: can be "boolean"
                         "integer"
                         "string"
                         "color"
        Sets the Options in the treeview rows
        """
        self.__option_dict = {}
        self.__option_list = []
        self.__liststore.clear()
        if isinstance(option_list, list):
            for _option in option_list:
                if isinstance(_option, tuple) and len(_option) == 4:
                    _option_key = _option[0]
                    _option_name = _option[1]
                    _option_type = _option[2]
                    _option_description = _option[3]
                    if isinstance(_option_key, str) and \
                       (isinstance(_option_name, str) or\
                       isinstance(_option_name, unicode))and \
                       _option_type in self.option_types.keys():
                        self.__liststore.append([_option_key, _option_name, "",
                            _option_type, _option_description])
                        self.__option_dict[_option_key] = [_option_name, "",
                            _option_type, _option_description]
                        self.__option_list.append(_option_key)
                    else:
                        print _("Option values must be strings")
                else:
                    print _("Option must be a tuple with 4 items")
        else:
            print _("Option list must be a list")
            return
    def setValues(self, values):
        """setValues(self, values)
        
        values: dictionary {option : value}

        Sets the Options values
        """
        if isinstance(values, dict):
            for _option, _value in values.iteritems():
                if _option in self.__option_dict:
                    _type = self.__option_dict[_option][2]
                    if _type == "boolean":
                        if isinstance(_value, bool):
                            _num = self.__option_list.index(_option)
                            _iter = self.__liststore.get_iter((_num,))
                            self.__liststore.set_value(_iter, 2, _value)
                            self.__option_dict[_option][1] = _value
                        else:
                            print _("Icorrect type, must be boolean")
                    elif _type == "integer":
                        try:
                            _value = int(_value)
                        except ValueError:
                            print _("Icorrect type, must be integer")
                        else:
                            _num = self.__option_list.index(_option)
                            _iter = self.__liststore.get_iter((_num,))
                            self.__liststore.set_value(_iter, 2, _value)
                            self.__option_dict[_option][1] = _value
                    elif _type == "string":
                        if isinstance(_value, str):
                            _num = self.__option_list.index(_option)
                            _iter = self.__liststore.get_iter((_num,))
                            self.__liststore.set_value(_iter, 2, _value)
                            self.__option_dict[_option][1] = _value
                        else:
                            print _("Icorrect type, must be string")
                    elif _type == "list":
                        if isinstance(_value, list):
                            _num = self.__option_list.index(_option)
                            _iter = self.__liststore.get_iter((_num,))
                            _str_value = ""
                            for _item_value in _value:
                                _str_value = _str_value + _item_value + ","
                            if _str_value[-1] == ",":
                                _str_value = _str_value[:-1]
                            self.__liststore.set_value(_iter, 2, _str_value)
                            self.__option_dict[_option][1] = _value
                        else:
                            print _("Icorrect type, must be list")
                    elif _type == "color":
                        if isinstance(_value, str):
                            try:
                                _color = gtk.gdk.color_parse(_value)
                            except ValueError:
                                print _("Icorrect type, must be a parseable " \
                                        "color")
                            else:
                                _num = self.__option_list.index(_option)
                                _iter = self.__liststore.get_iter((_num,))
                                self.__liststore.set_value(_iter, 2, _value)
                                self.__option_dict[_option][1] = _value
                    else:
                        print _("Type must be boolean, integer, string or "\
                                "color")
                else:
                    print _("Value must be in the option dict")
        else:
            print _("Values must be a dict")
        self.__treeview.set_cursor((0),self.__value_column, False)
        self.__treeview.grab_focus()
        (_cursor_path, _column) = self.__treeview.get_cursor()
        _description = self.__liststore[_cursor_path][4]
        self.__description_label.set_text(_description)

    def getWidget(self):
        """def getWidget(self)
        
        return the main widget (gtk.ScrolledWindow)
        """
        return self.__widget
    widget = property(getWidget, None, None,
        "The main widget (gtk.ScrolledWindow)")


class OpenDurusDatabase(object):
    """gui.OpenFiebdc
    
    Description:
        Class to show a dialog to open a durus price database
    Constructor:
       OpenDurusDatabase()
    Ancestry:
    +-- object
      +-- OpenDurusDatabase
    Atributes:
        "_openMethod": The method to open the file
        "__file": the filename to open
        "__window": the File Selection window
    Methods:
        __init__(self)
        setActiveCode(self, code)
    """
    def __init__(self, openMethod):
        self.__openMethod = openMethod
        self.__file = None
        self.__window = gtk.FileSelection("Abrir Archivo")
        self.__window.connect("destroy", self.destroy)
        self.__window.ok_button.connect("clicked", self._openFile)
        self.__window.cancel_button.connect("clicked", 
            lambda w: self.__window.destroy())
        self.__window.set_filename(globals.getHomePath("DURUS-DATABASE"))
        self.__window.show()

    def destroy(self, widget):
        gtk.main_quit()

    def main(self):
        gtk.main()

    def _openFile(self, w):
        self.__file = self.__window.get_filename()
        _filename = os.path.basename(self.__file)
        _filename_list = _filename.split(".")
        _filename_ext = _filename_list[-1]
        if _filename == "":
            print _("No file selected")
        elif len(_filename_list) < 2 or _filename_ext != "durus":
            print _("The filename must have durus extension")
        else:
            try:
                self.__openMethod(self.__window.get_filename())
                self.__window.destroy()
            except IOError:
                print utils.mapping("IOError, $1", (self.__file,))