root/branch/k0p/umitInterfaceEditor/Profile.py @ 1358

# Copyright (C) 2005 Insecure.Com LLC.
#
# Author: Luis A. Bastiao Silva <luis.kop@gmail.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA


import gtk 

import sys
# Testing at devel 
from os.path import split, join

from umitCore.Paths import Path
#Path.set_umit_conf(join(split(__file__)[0], 'config', 'umit.conf'))
#END DEV TEST
options = Path.options
profile_editor = Path.profile_editor
#XXX This path is too wrong 
#sys.path.append("selectborder")
from umitInterfaceEditor.selectborder.WrapperWidgets import NotebookLabel, SpecialHBox

from higwidgets.higscrollers import HIGScrolledWindow
from higwidgets.hignotebooks import HIGNotebook
from higwidgets.higlabels import HIGSectionLabel, HIGEntryLabel

from umitCore.NmapCommand import CommandConstructor
from umitCore.UmitConf import Profile, CommandProfile
from umitGUI.OptionBuilder import *
from higwidgets.higboxes import HIGVBox
from umitCore.Logging import log
from umitCore.I18N import _
from higwidgets.higtables import HIGTable
import gobject



TARGET_STRING = 0
TARGET_ROOTWIN = 1

target = [
    ('STRING', 0, TARGET_STRING),
    ('text/plain', 0, TARGET_STRING),
    ('application/x-rootwin-drop', 0, TARGET_ROOTWIN)
]

#Global variables 
SPACE_TABLE = 6



# XXX : Should be put in other file to using by OptionBuilder too 
type_mapping = { 
    "str": OptionEntry,
    "int": OptionIntSpin,
    "float": OptionFloatSpin,
    "level": OptionLevelSpin, 
    "path": OptionFile,
    "interface": OptionInterface, 
    "scriptlist": OptionScriptList
    }


from ProfileCore import ProfileCore, ProfileOption
from Command import Command, TwiceCommand, command_manager
from Tools import ToolBarInterface

#TODO :
'''
The list and dictionarie with the widgets of NotebookEditable with numbers
of the pages should be a class to manage better the pages
'''


class CommandAddRemoveLabel(TwiceCommand, Command):
    ''' 
    Add or Remove Label from Title pages of NotebookEditable 
    ###
    trik : state is a inicial value if it is remove or add.
    '''
    def __init__(self, widget, text, state):
        TwiceCommand.__init__(self, state)
        Command.__init__(self, _('Add Label'))
        self._widget = widget
        self._text = text 
        
    
    def _add_label(self):
        self._widget.unload_voidplace()
        self._widget.set_text(self._text) 
        log.debug('Adding label')
    _execute_1 = _add_label
    def _remove_label(self):
        self._widget.voidplace()
        log.debug('Removing label, Adding Void Place')
    _execute_2 = _remove_label


class CommandAddRemoveVoidplace(TwiceCommand, Command):
    '''
    Add or Remove A voidplace on the Editor-Mode 
    
    '''
    def __init__(self, table, widget, coords, state): 
        TwiceCommand.__init__(self, state)
        Command.__init__(self, _('Add/Remove Voidplace'))
        self._table = table.get_table()
        
        self._widget = widget
        self._x,self._y = coords[widget]  
        #self._spacing = self._table.get_row_spacing(self._x)
        self._spacing = SPACE_TABLE
    def _add(self):
        if self._widget.is_voidplace():
            self._widget.show_voidplace()
        
        #self._widget.do_draw()
        self._widget.show()     
        #self._table.attach(self._widget, 0,2,self._x,self._y)
        self._table.set_row_spacing(self._x,self._spacing)
        #self._widget.do_voidplace()
        #self._widget.do_voidplace()

        log.debug('CommandVoidplace: add voidplace')
        
    _execute_1 = _add 
    def _remove(self):
        
        if self._widget != None and self._widget.is_voidplace():
            log.debug('CommandVoidplace: remove voidplace')
            self._widget.hide_voidplace()
            self._widget.set_select(False)
            self._widget.hide()
            self._table.set_row_spacing(self._x,0)
            
            #self._widget.unload_voidplace()
            #self._table.remove(self._widget)
            
    _execute_2 = _remove
    


class CommandVoidPlaceAttach(TwiceCommand, Command):
    '''
    Add a new widget (voidplace) at the last position 
    
    '''
    def __init__(self,table, widget, coords, state):
        self._last = table.get_last()
        self._box = table
        x, y = coords[self._last] 
        coords[widget] = [x  +1 , y+1]
        TwiceCommand.__init__(self, state)
        Command.__init__(self, _('Add/Remove Voidplace'))
        self._table = table.get_table()
        self._box.set_last(widget)
        self._widget = widget
        self._x,self._y = coords[widget]  
        self._coords = coords
        #self._spacing = self._table.get_row_spacing(x-1)
        self._spacing = SPACE_TABLE
    def _attach(self):
        self._table.resize(self._y, 2)
        log.debug('<<< Attach Add Voidplace')
        self._table.set_row_spacing(self._x,self._spacing)

        self._table.attach(self._widget, 0, 2, self._x, self._y)
        self._widget.show_all()
        self._widget.do_voidplace()
        

        
        
    _execute_1 = _attach
    def _unattach(self):
        #if self._widget != None and self._widget.is_voidplace():
            #log.debug('<<< remove voidplace unattach')
            #self._widget.hide_voidplace()
            #self._widget.set_select(False)
            #self._widget.hide()
            #self._table.set_row_spacing(self._x,0)
        self._widget.unload_voidplace()
        self._table.remove(self._widget)
        del self._coords[self._widget]
    _execute_2 = _unattach


class CommandPageNotebook(TwiceCommand, Command):
    '''
    Add Page at Notebook or Remove
    '''
    def __init__(self, notebook, page, number, profilecore, state):
        TwiceCommand.__init__(self, state)
        Command.__init__(self, _('Add/Remove Page'))
        self._notebook = notebook
        self._page = page
        self._number = number
        self._profilecore = profilecore
    def _create_label(self):
        pass
    
    def _add_page(self):
        label = self._create_label()
        self._notebook.insert_page(self._page, label, self._number)
        
    _execute_1 = _add_page
    def _remove_page(self):
        self._notebook.remove_page(self._number)
    
    _execute_2 = _remove_page
    
class CommandMovePage(TwiceCommand, Command):
    '''
    move page
    '''
    def __init__(self, notebook, number,profilecore, state):
        '''
        @param number: number of num pages to move ; default should be 1
        @type number: Integer
        '''
        
        TwiceCommand.__init__(self, state)
        Command.__init__(self, _('Move Page'))
        self._notebook = notebook
        self._page = self._notebook.get_nth_page(self._notebook.get_current_page())
        self._number = number
        self._profilecore = profilecore
    def _move_left(self):
        log.debug("move left")
        self._notebook.reorder_child(self._page,self._notebook.get_current_page()-self._number )
        name = self._page.get_name()
        if name != None :
            self._profilecore.move_section_left(name)
        
        
    _execute_1 = _move_left
    def _move_right(self):
        log.debug("move right")
        self._notebook.reorder_child(self._page,self._notebook.get_current_page()+self._number )
        name = self._page.get_name()
        if name != None :
            self._profilecore.move_section_right(name)
    _execute_2 = _move_right



class CommandMove(TwiceCommand, Command):
    '''
    Move items to down or up
    #Trick: 
    - Add other colums to save row and do a swap. Use a temporary widget. 
    '''
    def __init__(self, widget_container, widget, coords , profilecore,  state):
        TwiceCommand.__init__(self, state)
        Command.__init__(self, _('Move item'))
        self._parent = widget_container
        self._section_name = widget_container.get_name()
        self._table = widget_container.get_table()
        self._move = widget
        self._coords = coords
        self._profilecore = profilecore
        self._x, self._y = self._coords[widget]
        self._name = widget.get_name()
        
        
        
    def _determine_child(self, list, num): 
        result = None 
        x, y = self._coords[self._move]
        x = x + num 
        y = y + num 
        for i in list : 
            x_tmp, y_tmp = self._coords[i]
            if x_tmp == x and y_tmp == y  :
                result= i
                break 
        return result
    def _get_next(self):
         
        childs = self._table.get_children()
        return self._determine_child(childs, 1)
    def _get_prev(self): 
        
        childs = self._table.get_children()
        childs.reverse()
        return self._determine_child(childs,-1) 
    def _swap(self, widget1, widget2):
        x1, y1 = self._coords[widget1]
        x2, y2 = self._coords[widget2]
        list_vp = []
        if widget1.is_voidplace():
            widget1.unload_voidplace()
            list_vp.append(widget1)
            
        if widget2.is_voidplace():
            list_vp.append(widget2)
            widget2.unload_voidplace()

        
        widget1.set_select(False)
        widget2.set_select(False)
        w_tmp = gtk.Label('tmp')
        self._table.attach(w_tmp, 1,2, x1, y1)
        self._table.remove(widget1)
        self._table.attach(widget1, 0,2, x2, y2)
        self._table.remove(widget2)
        self._table.attach(widget2, 0,2, x1, y1)
        self._table.remove(w_tmp)
        
        self._coords[widget1] = [x2, y2]
        self._coords[widget2] = [x1,y1]
        #self._move = widget2
        for i in list_vp:
            i.do_voidplace()
            #i.do_resize_voidplace()
            
            
    def _move_up(self):
        
        widget_swap = self._get_prev()
        self._profilecore.move_option_up(self._section_name, 
                                         self._name,
                                         widget_swap.get_name())
        self._swap(self._move, widget_swap)
        #widget_swap.do_resize_voidplace()
        self._parent.send_signal()
        self._move.do_draw()
        log.debug('<<< Moving item up')
    _execute_1 = _move_up
    
    def _move_down(self):
        
        widget_swap = self._get_next()
        self._profilecore.move_option_down(self._section_name, 
                                           self._name, 
                                           widget_swap.get_name())
        self._swap( widget_swap, self._move)
        #x, y = self._coords[widget_swap]
        #self._move.set_select(False)
        #widget_swap.set_select(False)

        #w_tmp = gtk.Label('tmp')
        #self._table.attach(w_tmp, 1,2, x, y)
        #self._table.remove(widget_swap)
        #self._table.attach(widget_swap, 0,2, self._x, self._x+1)
        #self._table.remove(self._move)
        
        #self._table.attach(self._move, 0,2, x, y)
        #self._table.remove(w_tmp)
        
        #self._coords[widget_swap] = [self._x, self._y]
        #self._coords[self._move] = [x,y]
        self._parent.send_signal()
        self._move.do_draw()
        log.debug('<<< Moving item down')
        
    _execute_2 = _move_down


class CommandAddRemoveOption(TwiceCommand, Command):
    ''' 
    Add or Remove Option from BoxEditable 
    ###
    trik : state is a inicial value if it is remove or add.
    '''
    def __init__(self, widget_container, widget_option, state):
        TwiceCommand.__init__(self, state)
        Command.__init__(self, _('Add/Remove Option'))
        self._widget = widget_container
        self._widget_option = widget_option
        
    
    def _add_option(self):
        
        widget_option = self._widget_option
        widget = self._widget
        childs = widget.get_children()
        widget.remove(childs[0])
        widget.unload_voidplace()
        for k in widget_option:
            widget.pack_start(k)
        #widget_option.show() # XXX - may be need 
        
        log.debug('Adding option')
    _execute_1 = _add_option
    def _remove_option(self):
        
        widget = self._widget
        childs = widget.get_children()
        for i in childs:
            widget.remove(i)
        t = gtk.Label('-')
        t.set_size_request(-1, 23)
        t.show()
        
        widget.pack_start(t)
        widget.do_voidplace()
        log.debug('Removing option, Adding Void Place')
    _execute_2 = _remove_option


class BoxEditable(HIGVBox):
    def __init__(self, section_name, profile, listoptions, notebook_parent):
        """
        A Box Editable contains a options of each tab
        @param section_name: section name <tab>
        @type section_name: str 
        @param profile: A class that view and modify xml file 
        @type profile: ProfileCore
        """
            
        HIGVBox.__init__(self)
        self._coords = {}
        self._parent = notebook_parent
        self._last = None 
        #Profile Core do a manage at profile_editor.xml file 
        self._profilecore = None 
        
        self._profile = profile
        self._listoptions = listoptions
        self._table = HIGTable()
        self._section_name = section_name
        self._options = self._profile.get_section(section_name)
        self._table.set_border_width(3)
        c = self.get_colormap()
        color = c.alloc_color(0,0,0)   
        self._table.modify_fg(gtk.STATE_NORMAL,color )
        self._fill_table()
        
        box_tmp = HIGVBox()
        box_tmp.pack_start(self._table, False, False)
        self._sw = HIGScrolledWindow()
        #self._sw.set_size_request(400,200)
        vp = gtk.Viewport()
        vp.add(box_tmp)
        vp.set_shadow_type(gtk.SHADOW_NONE)
        self._sw.add(vp)
        self.pack_start(self._sw, True, True)
        self._old_selected = None 
        self._x = 0
        self._y = 0 
        
        
        self.connect('button-press-event', self._bp)
    #Private API 
    def _bp(self, widget,event):
        pass
            

    def _fill_table(self):
        k = 0
        for i in self._options:
            t = SpecialHBox()
            type = i.get_type()
            if type== 'option_check':
                
                name_option = i.get_option()
                hint = self._listoptions.get_hint(name_option)
                tmp_widget = OptionCheckIcon(i.get_label(),name_option,hint)
                t.pack_start(tmp_widget)
                arg_type = self._listoptions.get_arg_type(name_option)
                if arg_type!= '':
                    additional = type_mapping[arg_type]()
                    t.pack_start(additional)
                
            elif type == 'option_list': 
                eventbox = gtk.EventBox()
                label = HIGEntryLabel(i.get_label())
                
                eventbox.add(label)
                tmp_widget = OptionList()
                for j in i.get_option_list():
                    d = {}
                    d['name'] = j 
                    tmp_widget.append(d)
                t.pack_start(eventbox)          
                t.pack_start(tmp_widget)
                #t.drag_source_set(gtk.gdk.BUTTON1_MASK |
                                                  #gtk.gdk.BUTTON3_MASK,
                                                  #target, 
                                                  #gtk.gdk.ACTION_COPY |
                                                  #gtk.gdk.ACTION_MOVE)
                #t.connect('drag_data_get', self.source_drag_data_get)
            
            #XXX : I think that is very important ( I only comment to get focus)
            t.set_flags( t.flags() |  gtk.CAN_FOCUS)
            t.connect('button-press-event', self._button_press_event)
            t.connect('key-press-event', self._key_press_event)
            t.set_name(i.get_label())
            t.connect('drag_data_received', self.drag_received)
            t.drag_dest_set(gtk.DEST_DEFAULT_ALL, target[:-1],
                                gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
            
            self._table.attach(t, 0,2, k,k+1)
            self._coords[t] = [k, k+1]
            self._x = k 
            self._y = k+1
            k =k +1
            self._last = t 
        
    
        
    def _key_press_event(self, widget, event):
        print "key pressed"
        _keyval = gtk.gdk.keyval_name(event.keyval)
        if _keyval == "Delete" and self._old_selected!=None :
            if not widget.is_voidplace(): 
                # remove widgets like checkbuttons or others and put voidplace
                childs = widget.get_children()
                cmd = CommandAddRemoveOption(widget,childs, False)
                widget.set_select(False)
                command_manager.add_command(cmd)
                log.debug(' Remove Widgets like CheckButtons or others and put voidplace')
                
            else:
                # remove voidplace and delete the widget from table/box
                #XXX 
                cmd = CommandAddRemoveVoidplace(self, 
                                                widget, self._coords, False)
                #widget.unload_voidplace()
                command_manager.add_command(cmd)
                log.debug('Remove voidplace and delete the widget from table')
                
        #self._table.remove(widget)
        #childs = self._table.get_children()
        #for i in childs:
            #if i.is_voidplace():
                #i.do_resize_voidplace()
    def _button_press_event(self,widget, event):
        widget.set_select(True) 
        self._parent.select(False)
        if widget == self._old_selected :
            log.debug('Do nothing')
            if widget.is_voidplace():
                widget.do_draw()
            widget.grab_focus()
            return 
        widget.do_draw()
        if self._old_selected != None:
            self._old_selected.set_select(False)
        log.debug('drawing')
        self._old_selected = widget
        widget.grab_focus()
        self._parent.emit('changed', 'Options', self._parent.get_current_page())

    #Public API 
    def get_name(self):
        return self._section_name
    
    def can_move_up(self):
        
        widget = self._old_selected
        x = 0 
        if widget!= None :
            x,y = self._coords[widget]
        return x != 0
    def can_move_down(self):
        
        widget = self._old_selected
        y = len(self._coords)
        if widget!= None :
            x,y = self._coords[widget]
        return y != (len(self._coords))
    def send_signal(self):
        self._parent.emit('changed', 'Options', self._parent.get_current_page())
    def add_voidplace(self, position):
        # Create SpecialHBox with Voidplace
        t = SpecialHBox()
        e = gtk.EventBox()
        label = gtk.Label('-')
        label.set_size_request(-1, 23)
        e.add(label)
        t.pack_start(e)
        t.set_flags( t.flags() |  gtk.CAN_FOCUS)
        t.connect('button-press-event', self._button_press_event)
        t.connect('key-press-event', self._key_press_event)
        t.connect('drag_data_received', self.drag_received)
        t.drag_dest_set(gtk.DEST_DEFAULT_ALL, target[:-1],
                            gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
        cmd = CommandVoidPlaceAttach(self, t, self._coords, True)
        command_manager.add_command(cmd)
        
        #if position == -1 : 
            #x, y = self._x,self._y 
            #self._table.attach()
        #else:
            ## Choose the position 
            #pass
    
    def move_item_down(self):
        '''
        Move selected item to down
        '''
        assert self.can_move_down()
        
        cmd = CommandMove(self, self._old_selected, self._coords, self._profilecore, False)
        command_manager.add_command(cmd)
        self.send_signal()
    def move_item_up(self):
        '''
        Move selected item to up
        '''
        assert self.can_move_up()
        
        cmd = CommandMove(self, self._old_selected, self._coords, self._profilecore, True)
        command_manager.add_command(cmd)
        self.send_signal()
    
    
    def set_profile_core(self, profile_core):
        self._profilecore = profile_core
    
    def option_builder(self, option_name, type):
        '''
        construct a widget with the name of the option
        @return: A widget
        @rtype: Widget like OptionCheck or others 
        '''
        result = []
        hint = self._listoptions.get_hint(option_name)
        #label, option_name, hint
        tmp_widget = OptionCheckIcon(option_name,option_name,hint) 
        result.append(tmp_widget)
        arg_type = self._listoptions.get_arg_type(option_name)
        if arg_type!= '':
            additional = type_mapping[arg_type]()
            result.append(additional)
        return result
        
        
        
        
    def _is_widget(self, name):
        return name[0:3] == '_wid'

    def drag_received(self,w, context, x, y, data, info, time):
        print "drag received"
        option_name = data.data
        if self._is_widget(option_name) or not  w.is_voidplace():
            return
        
        arg_type = self._listoptions.get_arg_type(data.data)
        widgets = self.option_builder(option_name, arg_type)
        
        #Remove child 
        childs = w.get_children()
        w.remove(childs[0])
        #Add
        for child in widgets:
            #t = gtk.Label('fsck')
            w.pack_start(child)
            child.show_all()
        
        w.unload_voidplace()
    def get_table(self):
        return self._table
    def set_last(self, last):
        self._last = last
    def get_last(self):
        return self._last
    def source_drag_data_get(self, btn, context, selection_data, info, time):
        selection_data.set(selection_data.target, 8, "I'm Data!")    

class NotebookEditable(HIGNotebook):
    '''
    Editable Notebook to Edit Profile Editor
    '''
    __gsignals__ = {
        'changed':  (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, 
                     (gobject.TYPE_STRING,object))
    }
    def __init__(self, listoption, profilecore):
        self._listoption = listoption
        HIGNotebook.__init__(self)
        self.sections_widgets = {}
        self.sections_widgets_list = []
        self.connect('key-press-event', self.on_key_press)
        self.connect_after('switch-page', self.on_switch_page)
        self._old_select = None 
        self._profilecore = profilecore
        
        self._page_in = 0

    def save(self):
        self._profilecore.write_file(profile_editor)
    def reset(self):
        pass
    
    def load_data(self):
        self.profile = CommandProfile()
        options_used = {}
        
        self.constructor = CommandConstructor(options_used)
        self.options = ProfileCore(profile_editor)  
        i = 0
        for tab in self.options.groups:
            self.create_tab(tab, self.options.section_names[tab], 
                            self.options.tabs[tab], i)
            i = i+1 
    def create_tab(self, tab_name, section_name, tab, number):
        box = BoxEditable(tab_name, self.options, self._listoption, self)
        box.set_profile_core(self._profilecore)
        label = NotebookLabel(tab_name)
        #eventbox = gtk.EventBox()

        #eventbox.add(label)
        label.set_flags( label.flags() |  gtk.CAN_FOCUS) 
        label.connect('key-press-event', self.on_key_press)
        label.connect('button-press-event', self.on_button_press)  

        
        label.connect('drag_data_received', self.label_drag_data_received)
        label.drag_dest_set(gtk.DEST_DEFAULT_ALL, target[:-1],
                            gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
        #eventbox.show_all()
        label.show_all()
        self.sections_widgets[label] = number
        self.sections_widgets_list.append(label)
        self.append_page(box, label)
        #self.set_tab_reorderable(label, True)
    
    def select(self, value):
        if self._old_select!=None:
            self._old_select.set_select(value)
            self._old_select=None
    
    def on_button_press(self, widget, event):
        log.debug('Button press on Notebook')
        if self._old_select != None:
            self._old_select.set_select(False)
        widget.set_select(True)
        self._old_select = widget
        
        self.set_current_page(self.sections_widgets[widget])
        #XXX - this focus owns drag-n-drop received :( 
        #widget.grab_focus()
        self._page_in = self.get_current_page()
        log.debug('<<< Setting page %s'%self._page_in)
        return True
    def put_on_page(self):
        log.debug('<<< Put on page %s'%self._page_in)
        self.set_current_page(self._page_in)
    def on_switch_page(self, widget, event, page):
        self.grab_focus()
        self.emit('changed','Sections', page)
    def on_key_press(self, widget, event):
        _keyval = gtk.gdk.keyval_name(event.keyval)
        log.debug('Key press event on NotebookEditable')
        if self._old_select==None:
            return

        if _keyval == "Delete" :
            if self._old_select.is_voidplace():
                self._old_select.unload_voidplace()
                label_tmp =self.get_tab_label(self.get_nth_page(
                    self.get_current_page()))
                num = self.sections_widgets[label_tmp]
                del self.sections_widgets[label_tmp]
                for i in range(num, len(self.sections_widgets)):
                    print i
                    widget_tmp = self.sections_widgets_list[i+1]
                    self.sections_widgets[widget_tmp] = self.sections_widgets[widget_tmp] - 1 
                
                self.sections_widgets_list.pop(num)
                self.remove_page(self.get_current_page())
                

                
            else: 
                cmd = CommandAddRemoveLabel(self._old_select, 
                                            self._old_select.get_text(), False)
                command_manager.add_command(cmd)
        #else: 
            #self._old_select.unload_voidplace()
    def label_drag_data_received(self, w, context, x, y, data, info, time):
        print "received"

        if data and data.format == 8:
            print 'Received "%s" in label' % data.data
            context.finish(True, False, time)
            cmd = CommandAddRemoveLabel(self._old_select, 'New Label', True)
            command_manager.add_command(cmd)
            
        #else:
        #    context.finish(False, False, time)
        
    def can_move_right(self):
        n = self.get_n_pages()
        current = self.get_current_page()
        return (n-1) != (current)
    def can_move_left(self):    
        current = self.get_current_page()
        return current!= 0
    def move_right(self):
        cmd = CommandMovePage(self, 1, self._profilecore, False)
        command_manager.add_command(cmd)
        self.emit('changed','Sections', None)
    def move_left(self):
        cmd = CommandMovePage(self, 1, self._profilecore, True)
        command_manager.add_command(cmd)
        self.emit('changed','Sections', None)
            
    
    
class ProfileEdit(gtk.HBox):
    
    def __init__(self, listoption):
        gtk.HBox.__init__(self)
        self._toolbar = ToolBarInterface()
        self._proprieties = None 
        self._notebook_tools = None 
        #MAIN SCROLLED
        self._scroolledmain = HIGScrolledWindow()
        #NOTEBOOKEDITABLE :
        self._profilecore = ProfileCore(profile_editor)
        self.notebook = NotebookEditable(listoption, self._profilecore)
        self._toolbar.set_notebook(self.notebook)
        self.notebook.connect_after('changed', self.update_toolbar)
        self.notebook.load_data()
        self.pack_start(self._toolbar.get_toolbar(), False, True,0)
        self.pack_start(self._scroolledmain, True, True)
        self._scroolledmain.add_with_viewport(self.notebook)
        self.show_all()
    def get_profilecore(self):
        return self._profilecore
    def set_notebook(self, notebook):
        self._notebook_tools = notebook
    def set_proprieties(self, proprieties):
        self._proprieties = proprieties
        proprieties.disable_all()
    def update_toolbar(self, action, others, page):
        #print action
        #print others
        #print page
        boxeditable = self.get_box_editable()
        self._toolbar.set_box_editable(boxeditable)
        self._toolbar.update_toolbar()
        
        #Update Proprieties box
        if self._notebook_tools != None: 
            self._notebook_tools.set_current_page(2)
        
        if boxeditable._old_selected!= None :
            #SpecialHBox - Item
            self._proprieties.set_boxeditable(boxeditable)
            self._proprieties.set_item(boxeditable._old_selected)
            
            log.debug('<<< SpecialHBox Item update')
        elif self.notebook._old_select!= None:
            #Notebook_Label
            self._proprieties.set_notebooklabel(self.notebook._old_select)
            log.debug('<<< NotebookLabel update')
    
    def get_box_editable(self):
        current_page = self.notebook.get_current_page()
        current_box = self.notebook.get_nth_page(current_page)
        return current_box
    
    def save(self):
        self._profilecore.write_file(profile_editor)
        log.debug('<<< Saving to file %s ' % profile_editor)
    
    def create_events(self):
        #....
        pass