Changeset 765

Timestamp:

06/02/07 13:00:08 (6 years ago)

Author:

boltrix

Message:

Merged the changes sent by Max, and fixed a bug related to his fix. Also, fixed a bug on setup.py which were installing the docs in the wrong place.

Location:

trunk

Files:

• setup.py (modified) (1 diff)
• umitCore/NmapCommand.py (modified) (2 diffs)
• umitCore/NmapParser.py (modified) (31 diffs)
• umitCore/UmitConf.py (modified) (4 diffs)
• umitGUI/OptionBuilder.py (modified) (4 diffs)
• umitGUI/ProfileEditor.py (modified) (7 diffs)
• umitGUI/Wizard.py (modified) (5 diffs)

trunk/setup.py

@@ -226 +226 @@
         parser.set(sec, "config_file", config_file)
         parser.set(sec, "config_dir", install_config_dir)
-        parser.set(sec, "docs_dir", os.path.join(install_config_dir, docs_dir))
+        parser.set(sec, "docs_dir", os.path.join(self.install_data, docs_dir))
         parser.set(sec, "pixmaps_dir", os.path.join(self.install_data, pixmaps_dir))
         parser.set(sec, "icons_dir", os.path.join(self.install_data, icons_dir))

trunk/umitCore/NmapCommand.py

@@ -263 +263 @@
 
 class CommandConstructor:
-    def __init__(self, profile=None):
+    def __init__(self, options = {}):
+        self.options = {}
         self.option_profile = NmapOptions(option_xml)
-        self.options = {}
+        for k, v in options.items():
+            self.add_option(k, v, False) # TODO: check this place further
 
     def add_option(self, option_name, args=[], level=False):
-        option = self.option_profile.get_option(option_name)
-
-        if type(args) in StringTypes:
-            args = [args]
-
-        if level:
-            self.options[option_name] = (option['option']+' ')*level
-        elif args:
-            args = tuple (args)
-            self.options[option_name] = option['option'] % args[0]
-        else:
-            self.options[option_name] = option['option']
+        self.options[option_name] = (args, level)
+        
 
     def remove_option(self, option_name):
@@ -287 +279 @@
     def get_command(self, target):
         splited = ['%s' % nmap_command_path]
-        for option in self.options.values():
-            splited.append(option)
-
+
+        for option_name in self.options:
+            option = self.option_profile.get_option(option_name)
+            args, level = self.options[option_name]
+
+            if type(args) in StringTypes:
+                args = [args]
+
+            if level:
+                splited.append((option['option']+' ')*level)
+            elif args:
+                args = tuple (args)
+                splited.append(option['option'] % args[0])
+            else:
+                splited.append(option['option'])
+            
         splited.append(target)
         return ' '.join(splited)
 
-    def __remove_double_space(self, command):
-        while re.findall('(  )', command):
-            command = command.replace('  ', ' ')
-        return command
-
+    def get_options(self):
+        return dict([(k, v[0]) for k, v in self.options.items()])
+    
 class CommandThread(threading.Thread):
     def __init__(self, command):

trunk/umitCore/NmapParser.py

@@ -355 +355 @@
                 break
         else:
-            raise Exception("Comment could not be saved! Host not found at NmapParser!")
+            raise Exception("Comment could not be saved! Host not \
+found at NmapParser!")
 
     def get_host_comment(self, host_id):
@@ -362 +363 @@
                 return host.comment
         else:
-            raise Exception("Comment could not be saved! Host not found at NmapParser!")
+            raise Exception("Comment could not be saved! Host not \
+found at NmapParser!")
 
     def get_profile(self):
@@ -404 +406 @@
         if (type(options) == type([])) or (type(options) in StringTypes):
             self.nmap['nmaprun']['options'] = options
+        elif type(options) == type({}):
+            self.nmap['nmaprun']['options'] = options.keys()
         else:
             raise Exception("Profile option error: wrong argument format! \
@@ -498 +502 @@
             self.nmap['nmaprun']['start'] = date
         else:
-            raise Exception("Wrong date format. Date should be saved in epoch format!")
+            raise Exception("Wrong date format. Date should be saved \
+in epoch format!")
     
     def get_openned_ports(self):
@@ -526 +531 @@
     def get_formated_date(self):
         date = self.get_date()
-        return "%s %s, %s - %s:%s" % (months[date[1]], str(date[2]), str(date[0]),
-                                      str(date[3]).zfill(2), str(date[4]).zfill(2))
+        return "%s %s, %s - %s:%s" % (months[date[1]], 
+                                      str(date[2]), 
+                                      str(date[0]),
+                                      str(date[3]).zfill(2), 
+                                      str(date[4]).zfill(2))
 
     def get_scanner (self):
@@ -630 +638 @@
     
     def get_finish_time (self):
-        return time.localtime(int(self.nmap['runstats'].get('finished_time', '0')))
+        return time.localtime(int(self.nmap['runstats'].get('finished_time',
+                                                            '0')))
 
     def set_finish_time(self, finish):
@@ -649 +658 @@
     def get_formated_finish_date(self):
         date = self.get_finish_time()
-        return "%s %s, %s - %s:%s" % (months[date[1]], str(date[2]), str(date[0]),
-                                      str(date[3]).zfill(2), str(date[4]).zfill(2))
+        return "%s %s, %s - %s:%s" % (months[date[1]], 
+                                      str(date[2]), 
+                                      str(date[0]),
+                                      str(date[3]).zfill(2), 
+                                      str(date[4]).zfill(2))
 
     def _verify_output_options (self, command):
@@ -669 +681 @@
     profile = property(get_profile, set_profile)
     profile_name = property(get_profile_name, set_profile_name)
-    profile_description = property(get_profile_description, set_profile_description)
+    profile_description = property(get_profile_description, 
+                                   set_profile_description)
     profile_hint = property(get_profile_hint, set_profile_hint)
-    profile_annotation = property(get_profile_annotation, set_profile_annotation)
+    profile_annotation = property(get_profile_annotation, 
+                                  set_profile_annotation)
     profile_options = property(get_profile_options, set_profile_options)
     target = property(get_target, set_target)
@@ -759 +773 @@
         self.nmap[run_tag]["scanner"] = attrs.get("scanner", "")
         self.nmap[run_tag]["version"] = attrs.get("version", "")
-        self.nmap[run_tag]["xmloutputversion"] = attrs.get("xmloutputversion", "")
+        self.nmap[run_tag]["xmloutputversion"] = attrs.get("xmloutputversion", 
+                                                           "")
         self.nmap["scan_name"] = attrs.get("scan_name", "")
 
@@ -818 +833 @@
 
     def _parse_host_port(self, attrs):
-        self.dic_port = {"protocol":attrs.get("protocol", ""), "portid":attrs.get("portid", "")}
+        self.dic_port = {"protocol":attrs.get("protocol", ""), 
+                         "portid":attrs.get("portid", "")}
 
     def _parse_host_port_state(self, attrs):
@@ -835 +851 @@
 
     def _parse_host_portused(self, attrs):
-        self.list_portused.append(self._parsing(attrs, ['state','proto','portid']))
+        self.list_portused.append(self._parsing(attrs, 
+                                                ['state','proto','portid']))
 
     def _parse_host_osclass(self, attrs):
-        self.list_osclass.append(self._parsing(attrs, ['type','vendor', 'osfamily',
-                                                       'osgen', 'accuracy']))
+        self.list_osclass.append(self._parsing(attrs, ['type',
+                                                       'vendor',
+                                                       'osfamily',
+                                                       'osgen',
+                                                       'accuracy']))
 
     def _parsing(self, attrs, attrs_list):
-        # Returns a dict with the attributes of a given tag with the atributes names
-        # as keys and their respective values
+        # Returns a dict with the attributes of a given tag with the
+        # atributes names as keys and their respective values
         dic = {}
         for at in attrs_list:
@@ -854 +874 @@
 
     def _parse_host_tcpsequence(self, attrs):
-        self.host_info.set_tcpsequence(self._parsing(attrs, ['index', 'class',
-                                                             'difficulty', 'values']))
+        self.host_info.set_tcpsequence(self._parsing(attrs, ['index',
+                                                             'class',
+                                                             'difficulty',
+                                                             'values']))
     
     def _parse_host_tcptssequence(self, attrs):
-        self.host_info.set_tcptssequence(self._parsing(attrs, ['class', 'values']))
+        self.host_info.set_tcptssequence(self._parsing(attrs, ['class',
+                                                               'values']))
 
     def _parse_host_ipidsequence(self, attrs):
-        self.host_info.set_ipidsequence(self._parsing(attrs, ['class', 'values']))
+        self.host_info.set_ipidsequence(self._parsing(attrs, ['class',
+                                                              'values']))
 
     def startElement(self, name, attrs):
@@ -900 +924 @@
             self.in_port = True
             self._parse_host_port(attrs)
-        elif self.in_host and self.in_ports and self.in_port and name == "state":
+        elif self.in_host and self.in_ports and \
+             self.in_port and name == "state":
             self._parse_host_port_state(attrs)
-        elif self.in_host and self.in_ports and self.in_port and name == "service":
+        elif self.in_host and self.in_ports and \
+             self.in_port and name == "service":
             self._parse_host_port_service(attrs)
         elif self.in_host and name == "os":
@@ -937 +963 @@
         elif self.in_host and name == "ports":
             self.in_ports = False
-            self.list_ports.append({"extraports":self.list_extraports, "port":self.list_port})
+            self.list_ports.append({"extraports":self.list_extraports,
+                                    "port":self.list_port})
         elif self.in_host and self.in_ports and name == "port":
             self.in_port = False
@@ -986 +1013 @@
         ## Finished element
         self.write_parser.startElement("finished",
-                                       Attributes(dict(time = str(self.finish_epoc_time))))
+                        Attributes(dict(time = str(self.finish_epoc_time))))
         self.write_parser.endElement("finished")
 
         ## Hosts element
-        self.write_parser.startElement("hosts", Attributes(dict(up = str(self.hosts_up),
-                                                              down = str(self.hosts_down),
-                                                              total = str(self.hosts_scanned))))
+        self.write_parser.startElement("hosts",
+                            Attributes(dict(up = str(self.hosts_up),
+                                            down = str(self.hosts_down),
+                                            total = str(self.hosts_scanned))))
         self.write_parser.endElement("hosts")
 
@@ -1003 +1031 @@
         for host in self.hosts:
             # Start host element
-            self.write_parser.startElement("host", Attributes(dict(comment=host.comment)))
+            self.write_parser.startElement("host",
+                                Attributes(dict(comment=host.comment)))
 
             # Status element
-            self.write_parser.startElement("status", Attributes(dict(state=host.state)))
+            self.write_parser.startElement("status",
+                                Attributes(dict(state=host.state)))
             self.write_parser.endElement("status")
 
@@ -1015 +1045 @@
             if type(host.ip) == type({}):
                 self.write_parser.startElement("address",
-                                               Attributes(dict(addr=host.ip.get("addr", ""),
-                                                             vendor=host.ip.get("vendor", ""),
-                                                             addrtype=host.ip.get("type", ""))))
+                            Attributes(dict(addr=host.ip.get("addr", ""),
+                                        vendor=host.ip.get("vendor", ""),
+                                        addrtype=host.ip.get("type", ""))))
                 self.write_parser.endElement("address")
 
@@ -1023 +1053 @@
             if type(host.ipv6) == type({}):
                 self.write_parser.startElement("address",
-                                               Attributes(dict(addr=host.ipv6.get("addr", ""),
-                                                          vendor=host.ipv6.get("vendor", ""),
-                                                          addrtype=host.ipv6.get("type", ""))))
+                            Attributes(dict(addr=host.ipv6.get("addr", ""),
+                                        vendor=host.ipv6.get("vendor", ""),
+                                        addrtype=host.ipv6.get("type", ""))))
                 self.write_parser.endElement("address")
 
@@ -1031 +1061 @@
             if type(host.mac) == type({}):
                 self.write_parser.startElement("address",
-                                               Attributes(dict(addr=host.mac.get("addr", ""),
-                                                          vendor=host.mac.get("vendor", ""),
-                                                          addrtype=host.mac.get("type", ""))))
+                            Attributes(dict(addr=host.mac.get("addr", ""),
+                                        vendor=host.mac.get("vendor", ""),
+                                        addrtype=host.mac.get("type", ""))))
                 self.write_parser.endElement("address")
             # End of Address elements
@@ -1046 +1076 @@
                 if type(hname) == type({}):
                     self.write_parser.startElement("hostname",
-                                            Attributes(dict(name = hname.get("hostname", ""),
-                                                       type = hname.get("hostname_type", ""))))
+                            Attributes(dict(name = hname.get("hostname", ""),
+                                        type = hname.get("hostname_type", ""))))
                     
                     self.write_parser.endElement("hostname")
@@ -1065 +1095 @@
                     if type(ext) == type({}):
                         self.write_parser.startElement("extraports",
-                                                   Attributes(dict(count = ext.get("count", ""),
-                                                              state = ext.get("state", ""))))
+                            Attributes(dict(count = ext.get("count", ""),
+                                            state = ext.get("state", ""))))
                         self.write_parser.endElement("extraports")
 
@@ -1073 +1103 @@
                     if type(p) == type({}):
                         self.write_parser.startElement("port",
-                                                   Attributes(dict(portid = p.get("portid", ""),
-                                                              protocol = p.get("protocol", ""))))
+                            Attributes(dict(portid = p.get("portid", ""),
+                                            protocol = p.get("protocol", ""))))
 
                         ### Port state
                         self.write_parser.startElement("state",
-                                                Attributes(dict(state=p.get("port_state", ""))))
+                            Attributes(dict(state=p.get("port_state", ""))))
                         self.write_parser.endElement("state")
 
                         ### Port service info
                         self.write_parser.startElement("service",
-                                        Attributes(dict(conf = p.get("service_conf", ""),
-                                                   method = p.get("service_method", ""),
-                                                   name = p.get("service_name", ""),
-                                                   product = p.get("service_product", ""),
-                                                   version = p.get("service_version", ""),
-                                                   extrainfo = p.get("service_extrainfo", ""))))
+                            Attributes(dict(conf = p.get("service_conf", ""),
+                                    method = p.get("service_method", ""),
+                                    name = p.get("service_name", ""),
+                                    product = p.get("service_product", ""),
+                                    version = p.get("service_version", ""),
+                                    extrainfo = p.get("service_extrainfo", "")\
+                                )))
                         self.write_parser.endElement("service")
 
@@ -1106 +1137 @@
                 if type(pu) == type({}):
                     self.write_parser.startElement("portused",
-                                                   Attributes(dict(state = pu.get("state", ""),
-                                                              proto = pu.get("proto", ""),
-                                                              portid = pu.get("portid", ""))))
+                                Attributes(dict(state = pu.get("state", ""),
+                                                proto = pu.get("proto", ""),
+                                                portid = pu.get("portid", ""))))
                     self.write_parser.endElement("portused")
 
@@ -1115 +1146 @@
                 if type(oc) == type({}):
                     self.write_parser.startElement("osclass",
-                                                   Attributes(dict(vendor = oc.get("vendor", ""),
-                                                            osfamily = oc.get("osfamily", ""),
-                                                            type = oc.get("type", ""),
-                                                            osgen = oc.get("osgen", ""),
-                                                            accuracy = oc.get("accuracy", ""))))
+                        Attributes(dict(vendor = oc.get("vendor", ""),
+                                        osfamily = oc.get("osfamily", ""),
+                                        type = oc.get("type", ""),
+                                        osgen = oc.get("osgen", ""),
+                                        accuracy = oc.get("accuracy", ""))))
                     self.write_parser.endElement("osclass")
 
@@ -1125 +1156 @@
             if type(host.osmatch) == type({}):
                 self.write_parser.startElement("osmatch",
-                                       Attributes(dict(name = host.osmatch.get("name", ""),
-                                                  accuracy = host.osmatch.get("accuracy", ""))))
+                    Attributes(dict(name = host.osmatch.get("name", ""),
+                                accuracy = host.osmatch.get("accuracy", ""))))
                 self.write_parser.endElement("osmatch")
 
@@ -1136 +1167 @@
             if type(host.uptime) == type({}):
                 self.write_parser.startElement("uptime",
-                                   Attributes(dict(seconds = host.uptime.get("seconds", ""),
-                                              lastboot = host.uptime.get("lastboot", ""))))
+                    Attributes(dict(seconds = host.uptime.get("seconds", ""),
+                                lastboot = host.uptime.get("lastboot", ""))))
                 self.write_parser.endElement("uptime")
 
@@ -1146 +1177 @@
             if type(host.tcpsequence) == type({}):
                 self.write_parser.startElement("tcpsequence",
-                                Attributes({"index":host.tcpsequence.get("index", ""),
-                                            "class":host.tcpsequence.get("class", ""),
-                                            "difficulty":host.tcpsequence.get("difficulty", ""),
-                                            "values":host.tcpsequence.get("values", "")}))
+                    Attributes({"index":host.tcpsequence.get("index", ""),
+                            "class":host.tcpsequence.get("class", ""),
+                            "difficulty":host.tcpsequence.get("difficulty", ""),
+                            "values":host.tcpsequence.get("values", "")}))
                 self.write_parser.endElement("tcpsequence")
 
@@ -1155 +1186 @@
             if type(host.ipidsequence) == type({}):
                 self.write_parser.startElement("ipidsequence",
-                                    Attributes({"class":host.ipidsequence.get("class", ""),
-                                                "values":host.ipidsequence.get("values", "")}))
+                    Attributes({"class":host.ipidsequence.get("class", ""),
+                                "values":host.ipidsequence.get("values", "")}))
                 self.write_parser.endElement("ipidsequence")
 
@@ -1162 +1193 @@
             if type(host.tcptssequence) == type({}):
                 self.write_parser.startElement("tcptssequence",
-                                    Attributes({"class":host.tcptssequence.get("class", ""),
-                                                "values":host.tcptssequence.get("values", "")}))
+                    Attributes({"class":host.tcptssequence.get("class", ""),
+                            "values":host.tcptssequence.get("values", "")}))
                 self.write_parser.endElement("tcptssequence")
             # End of sequences elements
@@ -1173 +1204 @@
     def _write_debugging(self):
         self.write_parser.startElement("debugging", Attributes(dict(
-                                                           level=str(self.debugging_level))))
+                                            level=str(self.debugging_level))))
         self.write_parser.endElement("debugging")
 
     def _write_verbose(self):
         self.write_parser.startElement("verbose", Attributes(dict(
-                                                             level=str(self.verbose_level))))
+                                            level=str(self.verbose_level))))
         self.write_parser.endElement("verbose")
 
@@ -1185 +1216 @@
             if type(scan) == type({}):
                 self.write_parser.startElement("scaninfo",
-                                    Attributes(dict(type = scan.get("type", ""),
-                                                    protocol = scan.get("protocol", ""),
-                                                    numservices = scan.get("numservices", ""),
-                                                    services = scan.get("services", ""))))
+                    Attributes(dict(type = scan.get("type", ""),
+                                    protocol = scan.get("protocol", ""),
+                                    numservices = scan.get("numservices", ""),
+                                    services = scan.get("services", ""))))
                 self.write_parser.endElement("scaninfo")
 
     def _write_nmaprun(self):
         self.write_parser.startElement("nmaprun",
-                            Attributes(dict(annotation = str(self.profile_annotation),
-                                            args = str(self.nmap_command),
-                                            description = str(self.profile_description),
-                                            hint = str(self.profile_hint),
-                                            nmap_output = str(self.nmap_output),
-                                            options = str(self.profile_options),
-                                            profile = str(self.profile),
-                                            profile_name = str(self.profile_name),
-                                            scanner = str(self.scanner),
-                                            start = str(self.start),
-                                            startstr = str(self.formated_date),
-                                            target = str(self.target),
-                                            version = str(self.scanner_version),
-                                            scan_name = str(self.scan_name))))
+                Attributes(dict(annotation = str(self.profile_annotation),
+                                args = str(self.nmap_command),
+                                description = str(self.profile_description),
+                                hint = str(self.profile_hint),
+                                nmap_output = str(self.nmap_output),
+                                options = str(self.profile_options),
+                                profile = str(self.profile),
+                                profile_name = str(self.profile_name),
+                                scanner = str(self.scanner),
+                                start = str(self.start),
+                                startstr = str(self.formated_date),
+                                target = str(self.target),
+                                version = str(self.scanner_version),
+                                scan_name = str(self.scan_name))))
 
     def _verify_file(self, xml_file):

trunk/umitCore/UmitConf.py

@@ -24 +24 @@
 
 from types import StringTypes
-from ConfigParser import NoSectionError
+from ConfigParser import NoSectionError, NoOptionError
 
 from umitCore.Paths import Path
@@ -207 +207 @@
         except: return None
         
-        [self._set_it(profile_name, attr, attributes[attr]) for attr in attributes]
+        [self._set_it(profile_name, attr, attributes[attr]) for attr in attributes if attr != "options"]
+        options = attributes["options"]
+        self._set_it(profile_name, "options", ",".join(options.keys()))
+        for opt in options:
+            if options[opt]:
+                self._set_it(profile_name, opt, options[opt])
         self.save_changes()
 
@@ -239 +244 @@
 
     def get_options(self, profile):
-        return self._get_it(profile, 'options').split(',')
-
+        dic = {}
+        for opt in self._get_it(profile, 'options').split(','):
+            try:
+                dic[unicode(opt.strip())] = self._get_it(profile, opt)
+            except NoOptionError:
+                dic[unicode(opt.strip())] = None
+        return dic
 
     def set_command(self, profile, command=''):
@@ -254 +264 @@
         self._set_it(profile, 'annotation', annotation)
     
-    def set_options(self, profile, options=''):
-        self._set_it(profile, 'options', options)
+    def set_options(self, profile, options={}):
+        for opt in options:
+            if options[opt]:
+                self._set_it(profile, opt, options[opt])
+        self._set_it(profile, 'options', ",".join(options.keys()))
 
     def get_profile(self, profile_name):

trunk/umitGUI/OptionBuilder.py

@@ -35 +35 @@
 
 
+class OptionTab(object):
+    def __init__(self, root_tab, options, constructor, update_func):
+        actions = {'option_list':self.__parse_option_list,\
+                   'option_check':self.__parse_option_check}
+
+        self.options = options
+        self.constructor = constructor
+        self.update_func = update_func
+        self.widgets_list = []
+
+        options_used = self.constructor.get_options()
+        
+        # Cannot use list comprehhension because text nodes raise exception
+        # when tagName is called
+        for option_element in root_tab.childNodes:
+            try:option_element.tagName
+            except:pass
+            else:
+                if option_element.tagName in actions.keys():
+                    self.widgets_list.append(actions[option_element.tagName](option_element, options_used))
+
+    def __parse_option_list(self, option_list, options_used):
+        options = option_list.getElementsByTagName(u'option')
+        
+        label = HIGEntryLabel(option_list.getAttribute(u'label'))
+        opt_list = OptionList()
+        
+        for opt in options:
+            opt_list.append(self.options.get_option(opt.getAttribute(u'name')))
+        
+        for i, row in enumerate(opt_list.list):
+            if row[0] in options_used:
+                opt_list.set_active(i)
+                
+        return label, opt_list
+    
+    def __parse_option_check(self, option_check, options_used):
+        arg_type = option_check.getAttribute(u'arg_type')
+        option = option_check.getAttribute(u'option')
+        label = option_check.getAttribute(u'label')
+        
+        check = OptionCheck(label, self.options.get_option(option))
+        check.set_active(option in options_used)
+            
+        type_mapping = { 
+            "str": OptionEntry,
+            "int": OptionIntSpin,
+            "float": OptionFloatSpin,
+            "level": OptionLevelSpin, 
+            "path": OptionFile,
+            "interface": OptionInterface
+            }
+
+        additional = None
+        if type_mapping.has_key(arg_type):
+            value = options_used.get(option, None)
+            if value:
+                additional = type_mapping[arg_type](value)
+            else:
+                additional = type_mapping[arg_type]()
+
+        check.connect('toggled', self.update_check, additional)
+        
+        return check, additional
+
+    def fill_table(self, table, expand_fill = True):
+        yopt = (0, gtk.EXPAND | gtk.FILL)[expand_fill]
+        for y, widget in enumerate(self.widgets_list):
+            if widget[1] == None:
+                table.attach(widget[0], 0, 2, y, y+1, yoptions=yopt)
+            else:
+                table.attach(widget[0], 0, 1, y, y+1, yoptions=yopt)
+                table.attach(widget[1], 1, 2, y, y+1, yoptions=yopt)
+
+        for widget in self.widgets_list:
+            te = type(widget[1])
+            if te == type(OptionList()):
+                widget[1].connect('changed',self.update_list_option)
+            elif te == type(OptionIntSpin()) or\
+                 te == type(OptionFloatSpin()) or\
+                 te == type(OptionEntry()):
+                widget[1].connect('changed', self.update_entry, widget[0])
+            elif te == type(OptionLevelSpin()):
+                widget[1].connect('changed', self.update_level, widget[0])
+            elif te == type(OptionFile()):
+                widget[1].entry.connect('changed', self.update_entry, widget[0])
+            elif te == type(OptionInterface()):
+                widget[1].child.connect('changed', self.update_entry, widget[0])
+            
+    def update_check(self, check, extra):
+        if check.get_active():
+            te = type(extra)
+            if te == type(OptionEntry()) or\
+               te == type(OptionIntSpin()) or\
+               te == type(OptionFloatSpin()):
+                self.update_entry(extra, check)
+            elif te == type(OptionLevelSpin()):
+                self.update_level(extra, check)
+            elif te == type(OptionFile()):
+                self.update_entry(extra.entry, check)
+            elif te == type(OptionInterface()):
+                self.update_entry(extra.child, check)
+            else:
+                self.constructor.add_option(check.option['name'])
+        else:
+            self.constructor.remove_option(check.option['name'])
+
+        self.update_command()
+        
+    def update_entry(self, widget, check):
+        if not check.get_active():
+            check.set_active(True)
+
+        self.constructor.remove_option(check.option['name'])
+        self.constructor.add_option(check.option['name'], widget.get_text())
+        
+        self.update_command()
+    
+    def update_level(self, widget, check):
+        if not check.get_active():
+            check.set_active(True)
+        
+        try:
+            self.constructor.remove_option(check.option['name'])
+            if int(widget.get_text()) == 0:
+                check.set_active(False)
+            else:
+                self.constructor.add_option(check.option['name'],\
+                                        level=int(widget.get_text()))
+        except:pass
+        
+        self.update_command()
+
+    def update_list_option(self, widget):
+        try:widget.last_selected
+        except:pass
+        else:
+            self.constructor.remove_option(widget.last_selected)
+        
+        option_name = widget.options[widget.get_active()]['name']
+      
+        self.constructor.add_option(option_name)
+        widget.last_selected = option_name
+        
+        self.update_command()
+
+    def update_command(self):
+        if self.update_func:
+            self.update_func()
+    
+                 
 class OptionBuilder(object):
-    def __init__(self, xml_file):
+    def __init__(self, xml_file, constructor, update_func):
+        """ OptionBuilder(xml_file, constructor)
+
+        xml_file is a UI description xml-file
+        constructor is a CommandConstructor instance
+        """
         xml_desc = open(xml_file)
         self.xml = minidom.parse(xml_desc)
-
         # Closing file to avoid problems with file descriptors
         xml_desc.close()
+
+        self.constructor = constructor
+        self.update_func = update_func
         
         self.root_tag = "interface"
-        self.actions = {'option_list':self.__parse_option_list,\
-                        'option_check':self.__parse_option_check}
         
         self.xml = self.xml.getElementsByTagName(self.root_tag)[0]
@@ -69 +225 @@
         dic = {}
         for tab_name in self.groups:
-            tab = self.xml.getElementsByTagName(tab_name)[0]
-            widgets_list = []
-            # Cannot use list comprehhension because text nodes raise exception
-            # when tagName is called
-            for option in tab.childNodes:
-                try:option.tagName
-                except:pass
-                else:
-                    if option.tagName in self.actions.keys():
-                        widgets_list.append\
-                            (self.actions[option.tagName](option))
-            
-            dic[tab_name] = widgets_list
-        
+            dic[tab_name] = OptionTab(self.xml.getElementsByTagName(tab_name)[0],
+                                      self.options, self.constructor, self.update_func)
         return dic
-    
-    def __parse_option_list(self, option_list):
-        options = option_list.getElementsByTagName(u'option')
-        
-        label = HIGEntryLabel(option_list.getAttribute(u'label'))
-        opt_list = OptionList()
-        
-        for opt in options:
-            opt_list.append(self.options.get_option\
-                            (opt.getAttribute(u'name')))
-        
-        return label, opt_list
-    
-    def __parse_option_check(self, option_check):
-        arg_type = option_check.getAttribute(u'arg_type')
-        option = option_check.getAttribute(u'option')
-        label = option_check.getAttribute(u'label')
-        
-        check = OptionCheck(label, self.options.get_option\
-                            (option_check.getAttribute(u'option')))
-        additional = None
-        
-        if arg_type == "str":
-            additional = OptionEntry()
-        elif arg_type == "int":
-            additional = OptionIntSpin()
-        elif arg_type == "float":
-            additional = OptionFloatSpin()
-        elif arg_type == "level":
-            additional = OptionLevelSpin()
-        elif arg_type == "path":
-            additional = OptionFile()
-        elif arg_type == "interface":
-            additional = OptionInterface()
-        
-        return check, additional
-
+
+    
 class OptionWidget:
     def enable_widget(self):
@@ -163 +272 @@
 
 class OptionEntry(gtk.Entry, OptionWidget):
-    def __init__(self):
+    def __init__(self, param = ""):
         gtk.Entry.__init__(self)
+        self.set_text(param)
 
 class OptionLevelSpin(gtk.SpinButton, OptionWidget):
     def __init__(self, initial=0):
-        gtk.SpinButton.__init__(self,gtk.Adjustment(initial,0,10,1),0.0,0)
+        gtk.SpinButton.__init__(self,gtk.Adjustment(int(initial),0,10,1),0.0,0)
 
 class OptionIntSpin(gtk.SpinButton, OptionWidget):
     def __init__(self, initial=1):
-        gtk.SpinButton.__init__(self,gtk.Adjustment(initial,0,10**100,1),0.0,0)
+        gtk.SpinButton.__init__(self,gtk.Adjustment(int(initial),0,10**100,1),0.0,0)
 
 class OptionFloatSpin(gtk.SpinButton, OptionWidget):
     def __init__(self, initial=1):
-        gtk.SpinButton.__init__(self,gtk.Adjustment(initial,0,10**100,1),0.1,2)
+        gtk.SpinButton.__init__(self,gtk.Adjustment(float(initial),0,10**100,1),0.1,2)
 
 class OptionFile(HIGHBox, OptionWidget, object):
-    def __init__(self):
+    def __init__(self, param=""):
         HIGHBox.__init__(self)
         
@@ -187 +297 @@
         self._pack_expand_fill(self.entry)
         self._pack_noexpand_nofill(self.button)
-        
+
+        self.entry.set_text(param)
         self.button.connect('clicked', self.open_dialog_cb)
     

trunk/umitGUI/ProfileEditor.py

@@ -50 +50 @@
         self.__pack_widgets()
         
-        self.options = OptionBuilder(profile_editor)
-        
-        log.debug("Option groups: %s" % str(self.options.groups))
-        log.debug("Option section names: %s" % str(self.options.section_names))
-        #log.debug("Option tabs: %s" % str(self.options.tabs))
-        
-        self.constructor = CommandConstructor()
         self.profile = CommandProfile()
         
         self.deleted = False
-        self.options_used = []
+        options_used = {}
         
         if profile_name:
             log.debug("Showing profile %s" % profile_name)
             prof = self.profile.get_profile(profile_name)
-            self.options_used = prof['options']
-
+            options_used = prof['options']
+            
             # Interface settings
             self.profile_name_entry.set_text(profile_name)
@@ -77 +70 @@
                 self.profile.remove_profile(profile_name)
                 self.deleted = True
+        
+        self.constructor = CommandConstructor(options_used)
+        self.options = OptionBuilder(profile_editor, self.constructor, self.update_command)
+        log.debug("Option groups: %s" % str(self.options.groups))
+        log.debug("Option section names: %s" % str(self.options.section_names))
+        #log.debug("Option tabs: %s" % str(self.options.tabs))
         
         for tab in self.options.groups:
@@ -99 +98 @@
         self.command_expander.set_expanded(True)
         self.command_entry = gtk.Entry()
-        
-        self.widgets = {}
         
         self.notebook = gtk.Notebook()
@@ -176 +173 @@
         self.buttons_hbox.set_spacing(6)
 
-    def __create_tab(self, tab_name, section_name, tab_widgets):
+    def __create_tab(self, tab_name, section_name, tab):
+        log.debug(">>> Tab name: %s" % tab_name)
+        log.debug(">>>Creating profile editor section: %s" % section_name)
+
         vbox = HIGVBox()
         table = HIGTable()
         section = HIGSectionLabel(section_name)
-        log.debug(">>> Tab name: %s" % tab_name)
-        log.debug(">>>Creating profile editor section: %s" % section_name)
         
         vbox._pack_noexpand_nofill(section)
         vbox._pack_noexpand_nofill(HIGSpacer(table))
-        
         vbox.set_border_width(5)
-        
-        self.widgets[tab_name] = tab_widgets
-        
-        y1 = 0
-        y2 = 1
-        
-        for widget in tab_widgets:
-            log.debug(">>> Widget: %s" % str(widget))
-            
-            if widget[1] == None:
-                table.attach(widget[0],0,2,y1,y2)
-            else:
-                table.attach(widget[0],0,1,y1,y2)
-                table.attach(widget[1],1,2,y1,y2)
-            
-            if type(widget[0]) == type(OptionCheck()):
-                widget[0].connect('toggled', self.update_check, widget[1])
-                
-                if widget[0].option['name'] in self.options_used:
-                    widget[0].set_active(True)
-            
-            te = type(widget[1])
-            
-            if te == type(OptionList()):
-                widget[1].connect('changed',self.update_list_option)
-                
-                for wid in range(widget[1].list.__len__()):
-                    if widget[1].list[wid][0] in self.options_used:
-                        widget[1].set_active(wid)
-            elif te == type(OptionIntSpin()) or\
-                 te == type(OptionFloatSpin()) or\
-                 te == type(OptionEntry()):
-                widget[1].connect('changed', self.update_entry, widget[0])
-            elif te == type(OptionLevelSpin()):
-                widget[1].connect('changed', self.update_level, widget[0])
-            elif te == type(OptionFile()):
-                widget[1].entry.connect('changed', self.update_entry, widget[0])
-            
-            y1+=1;y2+=1
+
+        tab.fill_table(table, True)
         
         self.notebook.append_page(vbox, gtk.Label(tab_name))
-    
-    def update_entry(self, widget, check):
-        if not check.get_active():
-            check.set_active(True)
-        
-        self.constructor.remove_option(check.option['name'])
-        self.constructor.add_option(check.option['name'], widget.get_text())
-        self.update_command()
-    
-    def update_level(self, widget, check):
-        if not check.get_active():
-            check.set_active(True)
-        
-        try:
-            self.constructor.remove_option(check.option['name'])
-            if int(widget.get_text()) == 0:
-                check.set_active(False)
-            else:
-                self.constructor.add_option(check.option['name'],\
-                                        level=int(widget.get_text()))
-        except:pass
-        self.update_command()
     
     def save_profile(self, widget):
@@ -275 +213 @@
         annotation = buf.get_text(buf.get_start_iter(),\
                                       buf.get_end_iter())
-        
+
         self.profile.add_profile(profile_name,\
                                  command=command,\
@@ -281 +219 @@
                                  description=description,\
                                  annotation=annotation,\
-                                 options=','.join(self.options_used))
+                                 options=self.constructor.get_options())
         
         self.deleted = False
@@ -291 +229 @@
         self.profile_description_text.get_buffer().set_text('')
         self.profile_annotation_text.get_buffer().set_text('')
-    
-    def update_list_option(self, widget):
-        try:widget.last_selected
-        except:pass
-        else:
-            self.constructor.remove_option(widget.last_selected)
-            try:del(self.options_used[self.options_used.index\
-                                      (widget.last_selected)])
-            except:pass
-        
-        option_name = widget.options[widget.get_active()]['name']
-        
-        self.constructor.add_option(option_name)
-        self.options_used.append(option_name)
-        widget.last_selected = option_name
-        
-        self.update_command()
-    
-    def update_check(self, check, extra):
-        if check.get_active():
-            te = type(extra)
-            if te == type(OptionEntry()) or\
-               te == type(OptionIntSpin()) or\
-               te == type(OptionFloatSpin()):
-                self.update_entry(extra, check)
-            elif te == type(OptionLevelSpin()):
-                self.update_level(extra, check)
-            elif te == type(OptionFile()):
-                self.update_entry(extra.entry, check)
-            elif te == type(OptionInterface()):
-                self.update_entry(extra.child, check)
-            else:
-                self.constructor.add_option(check.option['name'])
-                self.update_command()
-            
-            self.options_used.append(check.option['name'])
-        else:
-            self.constructor.remove_option(check.option['name'])
-            self.update_command()
-            try:del(self.options_used[self.options_used.index\
-                                      (check.option['name'])])
-            except:pass
-        
-        #print self.options_used
     
     def set_notebook(self, notebook):

trunk/umitGUI/Wizard.py

@@ -50 +50 @@
         self.set_position(gtk.WIN_POS_CENTER)
         
-        self.options = OptionBuilder(wizard)
+        self.profile = CommandProfile()
         self.constructor = CommandConstructor()
-        self.profile = CommandProfile()
-        self.options_used = []
+        self.options = OptionBuilder(wizard, self.constructor, self.update_command)
         
         self.target = '<target>'
@@ -98 +97 @@
 
     def __create_steps(self, step_name, back_step, next_step, step_description, content):
-        step = CommandPage(step_description, content, self)
-        step.bar.cancel.connect('clicked', self.close_wizard)
-        step.bar.help.connect('clicked', self._show_help)
-        step.bar.back.connect('clicked', self.switch_page, step_name, back_step)
-        step.bar.forward.connect('clicked', self.switch_page, step_name, next_step)
-        
-        return step
+        vbox = HIGVBox()
+        vbox.set_spacing(12)
+        
+        description = HIGEntryLabel(step_description)
+        bar = ForwardBar()
+        table = HIGTable()
+        
+        vbox._pack_noexpand_nofill(description)
+        vbox._pack_expand_fill(table)
+        vbox._pack_noexpand_nofill(bar)
+
+        content.fill_table(table, False)
+
+        bar.cancel.connect('clicked', self.close_wizard)
+        bar.help.connect('clicked', self._show_help)
+        bar.back.connect('clicked', self.switch_page, step_name, back_step)
+        bar.forward.connect('clicked', self.switch_page, step_name, next_step)
+        
+        return vbox
 
     def set_notebook(self, notebook):
@@ -288 +299 @@
         pass
     
-    def update_entry(self, widget, check):
-        if not check.get_active():
-            check.set_active(True)
-        
-        self.constructor.remove_option(check.option['name'])
-        self.constructor.add_option(check.option['name'], widget.get_text())
-        self.update_command()
-    
-    def update_level(self, widget, check):
-        if not check.get_active():
-            check.set_active(True)
-        
-        try:
-            self.constructor.remove_option(check.option['name'])
-            if int(widget.get_text()) == 0:
-                check.set_active(False)
-            else:
-                self.constructor.add_option(check.option['name'],\
-                                        level=int(widget.get_text()))
-        except:pass
-        self.update_command()
-
-    def update_list_option(self, widget):
-        try:widget.last_selected
-        except:pass
-        else:
-            self.constructor.remove_option(widget.last_selected)
-            try:del(self.options_used[self.options_used.index\
-                                      (widget.last_selected)])
-            except:pass
-        
-        option_name = widget.options[widget.get_active()]['name']
-        
-        self.constructor.add_option(option_name)
-        self.options_used.append(option_name)
-        widget.last_selected = option_name
-        
-        self.update_command()
-    
-    def update_check(self, check, extra):
-        if check.get_active():
-            te = type(extra)
-            if te == type(OptionEntry()) or\
-               te == type(OptionIntSpin()) or\
-               te == type(OptionFloatSpin()):
-                self.update_entry(extra, check)
-            elif te == type(OptionLevelSpin()):
-                self.update_level(extra, check)
-            elif te == type(OptionFile()):
-                self.update_entry(extra.entry, check)
-            elif te == type(OptionInterface()):
-                self.update_entry(extra.child, check)
-            else:
-                self.constructor.add_option(check.option['name'])
-                self.update_command()
-            
-            self.options_used.append(check.option['name'])
-        else:
-            self.constructor.remove_option(check.option['name'])
-            self.update_command()
-            try:del(self.options_used[self.options_used.index\
-                                      (check.option['name'])])
-            except:pass
-        
     def save_profile(self, widget):
         command = self.constructor.get_command('%s')
@@ -373 +320 @@
                                      description=description,\
                                      annotation=annotation,\
-                                     options=','.join(self.options_used))
+                                     options=','.join(self.constructor.get_options()))
             
             for i in xrange(self.notebook.get_n_pages()):
@@ -388 +335 @@
         
         self.close_wizard()
-
-class CommandPage(HIGVBox):
-    def __init__(self, description, content, wizard):
-        HIGVBox.__init__(self)
-        self.set_spacing(12)
-        
-        self.description = HIGEntryLabel(description)
-        self.bar = ForwardBar()
-        table = HIGTable()
-        
-        self._pack_noexpand_nofill(self.description)
-        self._pack_expand_fill(table)
-        self._pack_noexpand_nofill(self.bar)
-        
-        y1 = 0
-        y2 = 1
-        
-        for widget in content:
-            if widget[1] == None:
-                table.attach(widget[0],0,2,y1,y2, yoptions=0)
-            else:
-                table.attach(widget[0],0,1,y1,y2, yoptions=0)
-                table.attach(widget[1],1,2,y1,y2, yoptions=0)
-            
-            if type(widget[0]) == type(OptionCheck()):
-                widget[0].connect('toggled', wizard.update_check, widget[1])
-            
-            te = type(widget[1])
-            
-            if te == type(OptionList()):
-                widget[1].connect('changed',wizard.update_list_option)
-            elif te == type(OptionIntSpin()) or\
-                 te == type(OptionFloatSpin()) or\
-                 te == type(OptionEntry()):
-                widget[1].connect('changed', wizard.update_entry, widget[0])
-            elif te == type(OptionLevelSpin()):
-                widget[1].connect('changed', wizard.update_level, widget[0])
-            elif te == type(OptionFile()):
-                widget[1].entry.connect('changed', \
-                                        wizard.update_entry, widget[0])
-            
-            y1+=1;y2+=1
 
 class FinishPage(HIGVBox):