#!/usr/bin/env python
try: 
        import gconf 
except: 
        from gnome import gconf
import gtk
import pygtk
import os
import re
from copy import deepcopy

import osso
import hildon

osso_c = osso.Context("dbus-scripts-settings", "1.1", False)

filename = "/etc/dbus-scripts.d/dbus-scripts-settings"
comment_characters = ['#', ';']
config_seperator = '\n'
conf=[]
hr=[]
gconf_client = gconf.client_get_default ()

system_events = [
    ['Offline mode', ['*', '*', 'com.nokia.mce.signal', '*', 'flight']],
    ['Normal mode', ['*', '*', 'com.nokia.mce.signal', '*', 'normal']],
    ['Keyboard slide', ['*', '*', 'org.freedesktop.Hal.Device', 'Condition', 'ButtonPressed', 'cover']],
    ['Power button', ['*', '*', 'org.freedesktop.Hal.Device', 'Condition', 'ButtonPressed', 'power']],
    ['Home button', ['*', '*', 'com.nokia.mce.signal', 'sig_home_key_pressed_ind']],
    ['Device locked', ['*', '*', 'com.nokia.mce.signal', 'tklock_mode_ind', 'locked']],
    ['Device unlocked', ['*', '*', 'com.nokia.mce.signal', 'tklock_mode_ind', 'unlocked']],
    ['Display on', ['*', '*', 'com.nokia.mce.signal', 'display_status_ind', 'on']],
    ['Display dimmed', ['*', '*', 'com.nokia.mce.signal', 'display_status_ind', 'dimmed']],
    ['Display off', ['*', '*', 'com.nokia.mce.signal', 'display_status_ind', 'on']],
    ['System inactive', ['*', '*', 'com.nokia.mce.signal', 'system_inactivity_ind']],
    ['Save unsaved data', ['*', '*', 'com.nokia.mce.signal', 'save_unsaved_data_ind']],
    ['Charger charging on', ['*', '*', 'com.nokia.bme.signal', 'charger_charging_on']],
    ['Charger charging off', ['*', '*', 'com.nokia.bme.signal', 'charger_charging_off']],
    ['Charger charging failed', ['*', '*', 'com.nokia.bme.signal', 'charger_charging_failed']],
    ['Charger connected', ['*', '*', 'com.nokia.bme.signal', 'charger_connected']],
    ['Charger disconnected', ['*', '*', 'com.nokia.bme.signal', 'charger_disconnected']],
    ['Battery full', ['*', '*', 'com.nokia.bme.signal', 'battery_full']],
    ['Battery low', ['*', '*', 'com.nokia.bme.signal', 'battery_low']],
    ['Battery empty', ['*', '*', 'com.nokia.bme.signal', 'battery_empty']],
    ['USB event', ['*', '*', 'org.freedesktop.Hal.Device', 'Condition', 'ButtonPressed', 'usb.cable']], 
    ['FS mounted', ['*', '*', 'org.kernel.kevent', 'mount']],
    ['FS unmounted', ['*', '*', 'org.kernel.kevent', 'umount']],
    ['Headset event', ['*', '*', 'org.freedesktop.Hal.Device', 'Condition', 'ButtonPressed', 'connection']],
]

class dssettings(hildon.Program):

    def __init__(self):
        self.btaddr_regex = re.compile("^[0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2}:[0-9A-F]{2}$")
        hildon.Program.__init__(self)

        self.main_window = hildon.Window()
        self.main_window.connect("destroy", self.destroy_main)
        self.add_window(self.main_window)

# Read settings file
        try:
            self.file = open(filename)
            self.raw = self.file.read().strip()
            self.temp = self.raw.split(config_seperator)
            self.temp = [line for line in self.temp if line]
            desc=""
            disabled=0
            for item in self.temp:
                it=str(item.strip())
                if it[0:2] == "#:":
                    desc = it[2:]
                elif it[0:2] == "#%":
                    it = it[2:]
                    disabled=1
                if it[0] not in comment_characters:
                    conf.append([desc,item.split(),disabled])
                    desc=""
                    disabled=0
        except IOError:
            temp=1

        self.conf_to_hr()
# End read settings file

        vbox = gtk.VBox(False, 0)
        self.main_window.add(vbox)
        vbox.show()

        self.model = gtk.ListStore(str, str, str, str, str, str, str, str)
        self.treeview = gtk.TreeView(self.model)
        #self.treeview.connect("row-activated", self.list_handler)
        self.sender_column = gtk.TreeViewColumn('sender')
        self.dest_column = gtk.TreeViewColumn('dest')
        self.interface_column = gtk.TreeViewColumn('interface')
        self.member_column = gtk.TreeViewColumn('member')
        self.extra_column = gtk.TreeViewColumn('extra')
        self.command_column = gtk.TreeViewColumn('Command')

        self.treeview.append_column(self.sender_column)
        self.treeview.append_column(self.dest_column)
        self.treeview.append_column(self.interface_column)
        self.treeview.append_column(self.member_column)
        self.treeview.append_column(self.extra_column)
        self.treeview.append_column(self.command_column)

        self.sender_cell = gtk.CellRendererText()
        self.dest_cell = gtk.CellRendererText()
        self.interface_cell = gtk.CellRendererText()
        self.member_cell = gtk.CellRendererText()
        self.extra_cell = gtk.CellRendererText()
        self.command_cell = gtk.CellRendererText()

        self.sender_column.pack_start(self.sender_cell)
        self.dest_column.pack_start(self.dest_cell)
        self.interface_column.pack_start(self.interface_cell)
        self.member_column.pack_start(self.member_cell)
        self.extra_column.pack_start(self.extra_cell)
        self.command_column.pack_start(self.command_cell)

        i=0
        self.command_column.add_attribute(self.command_cell, 'text', i)
        i=i+1
        self.sender_column.add_attribute(self.sender_cell, 'text', i)
        i=i+1
        self.dest_column.add_attribute(self.dest_cell, 'text', i)
        i=i+1
        self.interface_column.add_attribute(self.interface_cell, 'text', i)
        i=i+1
        self.member_column.add_attribute(self.member_cell, 'text', i)
        i=i+1
        self.extra_column.add_attribute(self.extra_cell, 'text', i)
        i=i+1
        self.treeview.set_headers_visible(True)
        
        list_win = gtk.ScrolledWindow()
        list_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        list_win.add_with_viewport(self.treeview)

        vbox.pack_start(list_win)

        self.button_box1 = gtk.HBox()
        self.button_box2 = gtk.HBox()
        self.add_bt_button = gtk.Button("Add BT")
        self.add_bt_button.connect("clicked", self.add_bt_command_dialog)
        self.add_conn_button = gtk.Button("Add Connection")
        self.add_conn_button.connect("clicked", self.add_conn_command_dialog)
        self.add_sys_button = gtk.Button("Add System event")
        self.add_sys_button.connect("clicked", self.add_sys_command_dialog)
        self.add_raw_button = gtk.Button("Add Raw")
        self.add_raw_button.connect("clicked", self.add_raw_command_dialog)
        self.delete_button = gtk.Button("Delete")
        self.delete_button.connect("clicked", self.on_delete_button)
        self.save_button = gtk.Button("Save")
        self.save_button.connect("clicked", self.on_save_button)
        self.close_button = gtk.Button("Close")
        self.close_button.connect("clicked", self.destroy_main)
        self.button_box1.pack_start(self.add_bt_button, padding=10)
        self.button_box1.pack_start(self.add_conn_button, padding=10)
        self.button_box1.pack_start(self.add_sys_button, padding=10)
        self.button_box1.pack_start(self.add_raw_button, padding=10)
        self.button_box2.pack_start(self.delete_button)
        self.button_box2.pack_start(self.save_button)
        self.button_box2.pack_start(self.close_button)
        vbox.pack_start(self.button_box1)
        vbox.pack_start(self.button_box2)

        self.list_commands()

    def on_save_button(self, widget, data=None):
        
        try:
                os.system("sudo /usr/bin/dbus-scripts-helper 2")
                self.file = open(filename,"w")
                self.file.write("# This file was generated by dbus-scripts-settings\n")
                self.file.write("# If you edit it by hand you might confuse the program,\n")
                self.file.write("# and you might lose your changes next time the program runs.\n\n")
                for line in conf:
                        if line[0] <> "":
                                self.file.write("#:" + line[0] + '\n')
                        if len(line)>=3 and line[2] == 1:
                                self.file.write("#%")
                        self.file.write(' '.join(line[1])+'\n\n')
                self.file.close()
                os.system("sudo /usr/sbin/invoke-rc.d dbus-scripts restart")
        except IOError:
                temp=1

    def bt_addr_to_name(self, a):
        if not self.btaddr_regex.match(a):
            return a
        self.devices = gconf_client.get_list("/system/bluetooth/devices", gconf.VALUE_STRING)
        if a in self.devices:
            return gconf_client.get_string("/system/bluetooth/device/"+a+"/name")
        return a

    def bt_name_to_addr(self, n):
        if self.btaddr_regex.match(n):
            return n
        self.devices = gconf_client.get_list("/system/bluetooth/devices", gconf.VALUE_STRING)
        for item in self.devices:
            if gconf_client.get_string("/system/bluetooth/device/"+item+"/name") == n:
                return item
        return n

    def conn_uuid_to_name(self, u):
        return gconf_client.get_string("/system/osso/connectivity/IAP"+u+"/name")

    def conn_name_to_uuid(self, n):
        self.conns = gconf_client.all_dirs("/system/osso/connectivity/IAP")
        for item in self.conns:
            if gconf_client.get_string(item+"/name") == n:
                return item[5]
        return n

    def add_hr_line(self, line):
        if line[0] == "BT":
            conf.append([line[2], [line[1], "*", "*", "org.bluez.Adapter", 
            ["RemoteDeviceConnected", "RemoteDeviceDisconnected", "*"][line[3]], self.bt_name_to_addr(line[4])]]);
        if line[0] == "CONN":
            conf.append([line[2], [line[1], "*", "*", "com.nokia.icd", "*",
            self.conn_name_to_uuid(line[4]), "*", ["CONNECTED", "IDLE", "*"][line[3]]]]);
        if line[0] == "SYS":
            conf.append([line[2], [line[1]]+ system_events[[x[0] for x in system_events].index(line[3])][1]])
        if line[0] == "RAW":
            conf.append([line[2], [line[1]] + line[3:]])

    def conf_to_hr(self):
        del hr[:]
        for l in conf:
            if l[1][1:] in [x[1] for x in system_events]:
                hr.append(["SYS", l[1][0], l[0]] + l[1][1:])
            elif l[1][1:5] == ["*", "*", "com.nokia.icd", "*"] and l[1][6]=="*" and l[1][7] in ["CONNECTED", "IDLE", "*"]:
                hr.append(["CONN", l[1][0], l[0], ["CONNECTED", "IDLE", "*"].index(l[1][7]), self.conn_uuid_to_name(l[1][5])])
            elif l[1][1:4] == ["*", "*", "org.bluez.Adapter"] and l[1][4] in ["RemoteDeviceConnected", "RemoteDeviceDisconnected", "*"]:
                hr.append(["BT", l[1][0], l[0], ["RemoteDeviceConnected", "RemoteDeviceDisconnected", "*"].index(l[1][4]), self.bt_addr_to_name(l[1][5])])
            else:
                hr.append(["RAW", l[1][0], l[0]] + l[1][1:])

    def run(self):
        self.main_window.show_all()
        gtk.main()

# ADD System event -----------------------------------------------------------

    def add_sys_command_dialog(self, widget, data=None):
        self.add_sys_dialog = gtk.Dialog()
        self.info_label = gtk.Label("Add new command\n")
        self.connection_label = gtk.Label("Event:")
        self.desc_label = gtk.Label("Description:")
        self.command_label = gtk.Label("Command:")
        
        self.connection_entry = gtk.combo_box_new_text()
        self.desc_entry = gtk.Entry()
        self.command_entry = gtk.Entry()

        for item in system_events:
                self.connection_entry.append_text(item[0])
        self.connection_entry.set_active(0)

        self.add_sys_dialog.vbox.pack_start(self.connection_label)
        self.add_sys_dialog.vbox.pack_start(self.connection_entry)
        self.add_sys_dialog.vbox.pack_start(self.desc_label)
        self.add_sys_dialog.vbox.pack_start(self.desc_entry)
        self.add_sys_dialog.vbox.pack_start(self.command_label)
        self.add_sys_dialog.vbox.pack_start(self.command_entry)

        button_box = gtk.HBox()
        add_sys_button = gtk.Button("Add")
        add_sys_button.connect("clicked", self.on_add_sys_button)
        close_button = gtk.Button("Close")
        close_button.connect("clicked", self.add_sys_dialog_destroy)
        button_box.pack_start(add_sys_button)
        button_box.pack_start(close_button)

        self.add_sys_dialog.vbox.pack_start(button_box)
        self.add_sys_dialog.show_all()

    def on_add_sys_button(self, widget, data=None):
        input_ok = True
        desc = self.desc_entry.get_text()
        command = self.command_entry.get_text()

        if len(desc) == 0 or len(command) == 0:
            input_ok = False

        if input_ok:
            self.add_sys_command(self.connection_entry.get_active(), desc, command)
            self.add_sys_dialog.destroy()
        else:
            self.error_dialog = gtk.Dialog()
            self.error_dialog.vbox.pack_start(gtk.Label("Something is wrong with your input.\nPossible reasons:\n- You did not fill all fields"))
            close_button = gtk.Button("Close")
            close_button.connect("clicked", self.error_dialog_destroy)
            self.error_dialog.vbox.pack_start(close_button)
            self.error_dialog.show_all()

    def add_sys_command(self, event, desc, command):
        self.add_hr_line(["SYS", command, desc, system_events[event][0]])
#        conf.append([desc, [command]+ system_events[event][1]] );
        self.list_commands()

    def error_dialog_destroy(self, widget, data=None):
        self.error_dialog.destroy()

    def add_sys_dialog_destroy(self, widget, data=None):
        self.add_sys_dialog.destroy()

# ADD System event  -----------------------------------------------------------



# ADD RAW -----------------------------------------------------------

    def add_raw_command_dialog(self, widget, data=None):
        self.add_raw_dialog = gtk.Dialog()
        self.info_label = gtk.Label("Add new command\n")
        self.sender_label = gtk.Label("Sender:")
        self.dest_label = gtk.Label("Dest:")
        self.int_label = gtk.Label("Interface:")
        self.member_label = gtk.Label("Member:")
        self.extra_label = gtk.Label("Extra parameters:")
        self.desc_label = gtk.Label("Description:")
        self.command_label = gtk.Label("Command:")
        
        self.sender_entry = gtk.Entry()
        self.dest_entry = gtk.Entry()
        self.int_entry = gtk.Entry()
        self.member_entry = gtk.Entry()
        self.extra_entry = gtk.Entry()
        self.desc_entry = gtk.Entry()
        self.command_entry = gtk.Entry()

        self.add_raw_dialog.vbox.pack_start(self.sender_label)
        self.add_raw_dialog.vbox.pack_start(self.sender_entry)
        self.add_raw_dialog.vbox.pack_start(self.dest_label)
        self.add_raw_dialog.vbox.pack_start(self.dest_entry)
        self.add_raw_dialog.vbox.pack_start(self.int_label)
        self.add_raw_dialog.vbox.pack_start(self.int_entry)
        self.add_raw_dialog.vbox.pack_start(self.member_label)
        self.add_raw_dialog.vbox.pack_start(self.member_entry)
        self.add_raw_dialog.vbox.pack_start(self.extra_label)
        self.add_raw_dialog.vbox.pack_start(self.extra_entry)
        self.add_raw_dialog.vbox.pack_start(self.desc_label)
        self.add_raw_dialog.vbox.pack_start(self.desc_entry)
        self.add_raw_dialog.vbox.pack_start(self.command_label)
        self.add_raw_dialog.vbox.pack_start(self.command_entry)

        button_box = gtk.HBox()
        add_raw_button = gtk.Button("Add")
        add_raw_button.connect("clicked", self.on_add_raw_button)
        close_button = gtk.Button("Close")
        close_button.connect("clicked", self.add_raw_dialog_destroy)
        button_box.pack_start(add_raw_button)
        button_box.pack_start(close_button)

        self.add_raw_dialog.vbox.pack_start(button_box)
        self.add_raw_dialog.show_all()

    def on_add_raw_button(self, widget, data=None):
        input_ok = True
        sender = self.sender_entry.get_text()
        dest = self.dest_entry.get_text()
        int = self.int_entry.get_text()
        member = self.member_entry.get_text()
        extra = self.extra_entry.get_text()
        desc = self.desc_entry.get_text()
        command = self.command_entry.get_text()

        if len(dest) == 0:
                dest = "*"
        if len(sender) == 0:
                sender = "*"
        if len(desc) == 0 or len(command) == 0:
            input_ok = False

        if input_ok:
            self.add_raw_command(desc, command, sender, dest, int, member, extra)
            self.add_raw_dialog.destroy()
        else:
            self.error_dialog = gtk.Dialog()
            self.error_dialog.vbox.pack_start(gtk.Label("Something is wrong with your input.\nPossible reasons:\n- You did not fill all fields correctly"))
            close_button = gtk.Button("Close")
            close_button.connect("clicked", self.error_dialog_destroy)
            self.error_dialog.vbox.pack_start(close_button)
            self.error_dialog.show_all()

    def add_raw_command(self, desc, command, sender, dest, int, member, extra):
        self.add_hr_line(["RAW", command, desc, sender, dest, int, member, extra])
#        conf.append([desc, [command, sender, dest, int, member, extra]]);
        self.list_commands()

    def error_dialog_destroy(self, widget, data=None):
        self.error_dialog.destroy()

    def add_raw_dialog_destroy(self, widget, data=None):
        self.add_raw_dialog.destroy()

# ADD RAW  -----------------------------------------------------------




# ADD Connection -----------------------------------------------------------

    def add_conn_command_dialog(self, widget, data=None):
        self.add_conn_dialog = gtk.Dialog()
        self.info_label = gtk.Label("Add new command\n")
        self.connection_label = gtk.Label("Connection:")
        self.desc_label = gtk.Label("Description:")
        self.command_label = gtk.Label("Command:")
        
        self.connection_entry = gtk.combo_box_new_text()
        self.desc_entry = gtk.Entry()
        self.command_entry = gtk.Entry()

        self.conns = gconf_client.all_dirs("/system/osso/connectivity/IAP")
        self.connection_entry.append_text("Any network")
        for item in self.conns:
                self.connection_entry.append_text(gconf_client.get_string(item+"/name"))
        self.connection_entry.set_active(0)

        self.connection_combobox = gtk.combo_box_new_text()
        self.connection_combobox.append_text("on connect")
        self.connection_combobox.append_text("on disconnect")
        self.connection_combobox.append_text("both")
        self.connection_combobox.set_active(0)

        self.add_conn_dialog.vbox.pack_start(self.connection_label)
        self.add_conn_dialog.vbox.pack_start(self.connection_entry)
        self.add_conn_dialog.vbox.pack_start(self.desc_label)
        self.add_conn_dialog.vbox.pack_start(self.desc_entry)
        self.add_conn_dialog.vbox.pack_start(self.command_label)
        self.add_conn_dialog.vbox.pack_start(self.connection_combobox)
        self.add_conn_dialog.vbox.pack_start(self.command_entry)

        button_box = gtk.HBox()
        add_conn_button = gtk.Button("Add")
        add_conn_button.connect("clicked", self.on_add_conn_button)
        close_button = gtk.Button("Close")
        close_button.connect("clicked", self.add_conn_dialog_destroy)
        button_box.pack_start(add_conn_button)
        button_box.pack_start(close_button)

        self.add_conn_dialog.vbox.pack_start(button_box)
        self.add_conn_dialog.show_all()

    def on_add_conn_button(self, widget, data=None):
        input_ok = True
        if self.connection_entry.get_active() == 0:
                connection = "*"
        else:
                connection = self.conns[self.connection_entry.get_active()-1].split('/')[5]
        desc = self.desc_entry.get_text()
        command = self.command_entry.get_text()

        index = self.connection_combobox.get_active()
        table = index
#        table=["CONNECTED", "IDLE", "*"][index]

        if len(desc) == 0 or len(command) == 0:
            input_ok = False

        if input_ok:
            self.add_conn_command(connection, desc, command, table)
            self.add_conn_dialog.destroy()
        else:
            self.error_dialog = gtk.Dialog()
            self.error_dialog.vbox.pack_start(gtk.Label("Something is wrong with your input.\nPossible reasons:\n- You did not fill all fields"))
            close_button = gtk.Button("Close")
            close_button.connect("clicked", self.error_dialog_destroy)
            self.error_dialog.vbox.pack_start(close_button)
            self.error_dialog.show_all()

    def add_conn_command(self, connection, desc, command, table):
        self.add_hr_line(["CONN", command, desc, table, connection])
#        conf.append([desc, [command, "*", "*", "com.nokia.icd", "*", connection + " * " + table]]);
        self.list_commands()

    def error_dialog_destroy(self, widget, data=None):
        self.error_dialog.destroy()

    def add_conn_dialog_destroy(self, widget, data=None):
        self.add_conn_dialog.destroy()

# ADD Connection  -----------------------------------------------------------



# ADD BT -----------------------------------------------------------

    def add_bt_command_dialog(self, widget, data=None):
        self.add_bt_dialog = gtk.Dialog()
        self.info_label = gtk.Label("Add new command\n")
        self.btaddr_label = gtk.Label("Device adress:")
        self.desc_label = gtk.Label("Description:")
        self.command_label = gtk.Label("Command:")
        
        self.btaddr_entry = gtk.combo_box_entry_new_text()
        self.desc_entry = gtk.Entry()
        self.command_entry = gtk.Entry()

        self.devices = gconf_client.get_list("/system/bluetooth/devices", gconf.VALUE_STRING)
        for item in self.devices:
            self.btaddr_entry.append_text(item+ " (" + gconf_client.get_string("/system/bluetooth/device/"+item+"/name")+")")

        self.connection_combobox = gtk.combo_box_new_text()
        self.connection_combobox.append_text("on connect")
        self.connection_combobox.append_text("on disconnect")
        self.connection_combobox.append_text("both")
        self.connection_combobox.set_active(0)

        self.add_bt_dialog.vbox.pack_start(self.btaddr_label)
        self.add_bt_dialog.vbox.pack_start(self.btaddr_entry)
        self.add_bt_dialog.vbox.pack_start(self.desc_label)
        self.add_bt_dialog.vbox.pack_start(self.desc_entry)
        self.add_bt_dialog.vbox.pack_start(self.command_label)
        self.add_bt_dialog.vbox.pack_start(self.connection_combobox)
        self.add_bt_dialog.vbox.pack_start(self.command_entry)

        button_box = gtk.HBox()
        add_bt_button = gtk.Button("Add")
        add_bt_button.connect("clicked", self.on_add_bt_button)
        close_button = gtk.Button("Close")
        close_button.connect("clicked", self.add_bt_dialog_destroy)
        button_box.pack_start(add_bt_button)
        button_box.pack_start(close_button)

        self.add_bt_dialog.vbox.pack_start(button_box)
        self.add_bt_dialog.show_all()



    def on_add_bt_button(self, widget, data=None):
        input_ok = True
        btaddr = self.btaddr_entry.get_active_text().split(" ")[0]
        desc = self.desc_entry.get_text()
        command = self.command_entry.get_text()

        index = self.connection_combobox.get_active()
        table=index
#        table=["RemoteDeviceConnected", "RemoteDeviceDisconnected", "*"][index]

        if not self.btaddr_regex.match(btaddr):
            input_ok = False

        if len(desc) == 0 or len(command) == 0:
            input_ok = False

        if input_ok:
            self.add_bt_command(btaddr, desc, command, table)
            self.add_bt_dialog.destroy()
        else:
            self.error_dialog = gtk.Dialog()
            self.error_dialog.vbox.pack_start(gtk.Label("Something is wrong with your input.\nPossible reasons:\n- Bluetooth address has a wrong format\n- You did not fill all fields"))
            close_button = gtk.Button("Close")
            close_button.connect("clicked", self.error_dialog_destroy)
            self.error_dialog.vbox.pack_start(close_button)
            self.error_dialog.show_all()

    def add_bt_command(self, btaddr, desc, command, table):
        self.add_hr_line(["BT", command, desc, table, btaddr])
#        conf.append([desc, [command, "*", "*", "org.bluez.Adapter", table, btaddr]]);
        self.list_commands()

    def error_dialog_destroy(self, widget, data=None):
        self.error_dialog.destroy()

    def add_bt_dialog_destroy(self, widget, data=None):
        self.add_bt_dialog.destroy()


# ADD BT -----------------------------------------------------------


    def on_delete_button(self, widget, data=None):
        selected = self.treeview.get_selection()
        if len(selected.get_selected_rows())>1 and len(selected.get_selected_rows()[1])>0:
                index = selected.get_selected_rows()[1][0]
                if index and index[0]>=0 and index[0]<len(conf):
                        del conf[index[0]]
                        self.list_commands()

    def list_commands(self):
        self.model.clear()
        self.conf_to_hr()

        self.command_list = deepcopy(conf)
        
        for c in self.command_list:
                while len(c[1])<8:
                        c[1].append("")
        for c in self.command_list:
                if len(c[1]) > 8:
                        c[1][7] = ' '.join(c[1][7:])
                        del(c[1][8:])
        for c in self.command_list:
                self.model.append(c[1])

    def destroy_main(self, widget, data=None):
        gtk.main_quit()

if __name__ == "__main__":
    app = dssettings()
    app.run()
