def _update_label(self, widget):
#XXX Replace by Command
log.debug("Update Label")
selected = self._selected
cmd = CommandChangeLabel(selected, self._entry_name.get_text(),
self._profilecore,self._boxeditable, True)
command_manager.add_command(cmd)
def _add(self):
#self._widget.do_draw()
label = self._widget.get_children()[0]
label = gtk.Label()
label.show()
self._widget.set_size_request(-1, 23)
self._widget.show()
self._widget.set_view(True)
if self._widget.is_voidplace():
self._widget.show_voidplace()
self._widget.set_view(True)
#self._table.attach(self._widget, 0,2,self._x,self._y)
#self._widget.do_voidplace()
self._table.set_row_spacing(self._x,self._spacing)
#from umit.interfaceeditor.BugDiff import BugDiff
#BugDiff.pdic(self._coords)
log.debug('CommandVoidplace: add voidplace')
def start(self, reader):
self.reader = reader
self.icon = None
self.wnd_pos = (0, 0)
self.menu = gtk.Menu()
self.menu.show()
action = gtk.Action(None, '_Quit', 'Quit from UMIT', gtk.STOCK_QUIT)
action.connect('activate', self.__on_quit)
item = action.create_menu_item()
item.show()
self.menu.append(item)
self.type = self.notifier = None
# Force to use win32 module
if WIN32_PRESENT:
self.set_type(TrayPlugin.TYPE_WINDOWS)
else:
self.set_type(tray_prefs.parser['notifications']['type'].value)
tray_prefs.parser['notifications']['type'].value = self.type
logo = os.path.join(Path.icons_dir, 'umit_16.ico')
log.debug('Creating status icon with %s as logo' % logo)
self.icon = gtk.status_icon_new_from_file(logo)
tray_prefs.change_cb = self.set_type
self.icon.connect('popup-menu', self.__on_right_click)
self.icon.connect('activate', self.__on_activate)
def _add_page(self):
log.debug('<<< Add new page')
if self.label == None :
label = self._notebook.create_label(self._name)
else :
label = self.label
if self._number == -1:
self._notebook.sections_widgets_list.append(label)
self._notebook.sections_widgets[label] = self._notebook.get_n_pages()
else:
num = self._number
self._notebook.sections_widgets_list.insert(num,label)
self._notebook.sections_widgets[label] = self._number-1
for i in range(num-1, len(self._notebook.sections_widgets)-1):
widget_tmp = self._notebook.sections_widgets_list[i+1]
self._notebook.sections_widgets[widget_tmp] = self._notebook.sections_widgets[widget_tmp] + 1
self._notebook.insert_page(self._page, label, self._number)
#self._notebook.append_page(self._page, label)
self._page.show_all()
label.voidplace()
label.show_all()
#profilecore
#print self._name
elem = self._profilecore.search_in_groups(self._name)
if elem == None:
self._profilecore.add_section(self._name)
label.set_name(self._name)
def _remove_option(self):
widget = self._widget
childs = widget.get_children()
self._saved = []
for i in childs:
widget.remove(i)
self._saved.append(i)
t = gtk.Label('-')
t.set_size_request(-1, 23)
t.show()
widget.pack_start(t)
widget.do_voidplace()
#Profile Core modifications:
po = self._widget.get_profileoption()
widget_prev = self._page.get_prev_widget(self._widget)
#widget_next = self._page.get_next_widget(self._widget)
#print widget_prev
#print widget_next
#po.set_next_opt(None)
#XXX <--- this protection should be wrong, too defencive
if widget_prev!=None:
widget_prev.get_profileoption().set_next_opt(po.get_next_opt())
self._profilecore.remove_opt(po.get_section(), po.get_label())
log.debug('Removing option, Adding Void Place')
def _add_option(self):
widget_option = self._widget_option
widget = self._widget
childs = widget.get_children()
widget.remove(childs[0])
if widget.is_voidplace():
widget.unload_voidplace()
if self._saved==None:
for k in widget_option:
widget.pack_start(k)
k.show_all()
else:
for k in self._saved:
widget.pack_start(k)
k.show_all()
#self._widget.show_all()
#widget_option.show() # XXX - may be need
#Profile Core modifications:
po = self._widget.get_profileoption()
#print po.get_next_opt()
widget_prev = self._page.get_prev_widget(self._widget)
#widget_next = self._page.get_next_widget(self._widget)
#print widget_prev
#print widget_next
if widget_prev !=None:
po.set_next_opt(widget_prev.get_profileoption().get_next_opt())
widget_prev.get_profileoption().set_next_opt(po.get_label())
self._profilecore.add_from_profileoption(po)
log.debug('Adding option')
def _on_remove_press(self, widget):
log.debug('<<< Remove Option from OptionList')
selected = self.get_selected()
(model, iter) = self.get_selected_option()
if selected!=None:
self._new_list.remove(selected)
self._model.remove(iter)
def add_profile(self, profile_name, **attributes):
log.debug(">>> Add Profile '%s': %s" % (profile_name, attributes))
try:
self.add_section(profile_name)
except DuplicateSectionError:
return None
except ValueError:
return None
for attr in attributes:
if attr != "options":
self._set_it(profile_name, attr, attributes[attr])
options = attributes["options"]
if isinstance(options, basestring):
self._set_it(profile_name, "options", options)
# Assuming there are no values for these options
options = {}
elif isinstance(options, dict):
self._set_it(profile_name, "options", ",".join(options))
for opt in options:
if options[opt]:
self._set_it(profile_name, opt, options[opt])
self.save_changes()
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)
vbox._pack_noexpand_nofill(section)
vbox._pack_noexpand_nofill(HIGSpacer(table))
vbox.set_border_width(6)
tab.fill_table(table, True)
self.scrollwindow = HIGScrolledWindow()
self.scrollwindow.set_size_request(600,300)
vp = gtk.Viewport()
vp.add(vbox)
vp.set_shadow_type(gtk.SHADOW_NONE)
self.scrollwindow.add(vp)
vbox_tmp = HIGVBox()
vbox_tmp.set_border_width(6)
vbox_tmp.set_spacing(12)
vbox_tmp.pack_start(self.scrollwindow)
self.notebook.append_page(vbox_tmp, gtk.Label(tab_name))
def get_scan_results(self):
scan_file = None
for i in range(self.scan_notebook.get_n_pages()):
sbook_page = self.scan_notebook.get_nth_page(i)
if not sbook_page.status.get_empty():
scan_file = sbook_page.parsed.nmap_xml_file
if hasattr(scan_file, "name"):
# this scan was loaded from a file so nmap_xml_file is
# actually a file object, but we are interested only in
# the file name.
scan_file = scan_file.name
if scan_file and os.access(scan_file, os.R_OK) and\
os.path.isfile(scan_file):
log.debug(">>> Retrieving unsaved scan result: %s" % scan_file)
try:
parsed = NmapParser()
parsed.set_xml_file(scan_file)
parsed.parse()
parsed.scan_name = "Unsaved " + sbook_page.get_tab_label()
parsed.unsaved = True
except:
pass
else:
yield parsed
def _move_right(self):
log.debug("move right")
current = self._notebook.get_current_page()
self._notebook.reorder_child(self._page,current+self._number )
name = self._page.get_name()
if name != None :
self._profilecore.move_section_right(name)
#Ajust sections childs (NotebookLabel)
dic = self._notebook.sections_widgets
list = self._notebook.sections_widgets_list
list_tmp = []
for i in range(len(list)):
widget = list.pop()
list_tmp.append(widget)
if widget.get_name()==name :
break
w_tmp = list_tmp.pop()
w_tmp2 = list_tmp.pop()
num = dic[w_tmp]
dic[w_tmp] = dic[w_tmp2]
dic[w_tmp2] = num
list.append(w_tmp2)
list.append(w_tmp)
for i in range(len(list_tmp)):
list.append(list_tmp.pop())
def delete_section(self):
if self._old_select.is_voidplace():
log.debug('Key press event on NotebookEditable \
-- unload 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())
num = self.get_current_page()
cmd = CommandPageNotebook(self,
self.get_nth_page(num),num,
self._profilecore,
False)
command_manager.add_command(cmd)
self._old_select=None
else:
log.debug('Key press event on NotebookEditable -- \
CommandAddRemoveLabel')
cmd = CommandAddRemoveLabel(self._old_select,
self._old_select.get_text(), self._profilecore,False)
command_manager.add_command(cmd)
self.emit('need-save', 'Sections', None)
def match_port(self, port):
log.debug("Match port:%s" % port)
if port == [""] or port == ["*"]:
return True
ports = []
for p in self.parsed_scan.ports:
for portid in p:
if self.port_open and portid["state"] == "open":
ports.append(portid["portid"])
elif self.port_filtered and portid["state"] == "filtered":
ports.append(portid["portid"])
elif self.port_closed and portid["state"] == "closed":
ports.append(portid["portid"])
elif not self.port_open and \
not self.port_filtered and \
not self.port_closed:
# In case every port state is False, add every port
ports.append(portid["portid"])
for keyport in port:
if keyport not in ports:
return False # No match for asked port
else:
return True # Every given port matched current result
def delete_files(self, widget):
# NOTE: This method should be adapted in umit.core.UserConf
# Creating an empty recent_scans file
log.debug('>>> Reset store files: - %s' % base_paths['user_dir'])
reset_user_dir(base_paths['user_dir'])
def __init__(self, value, \
name=None, def_value=None, desc=None, \
attrs=(), parent=None):
"""
Create a variable
@param value the value for variable
@param name the name for variable (optional if are in list)
@param def_val the default value for variable (optional if is user conf)
@param desc the description of value (optional if in user conf)
@param attrs a list of attributes
@param sectiondict the section dict
"""
self._value = self.__class__.convert(value)
self._name = name
self._def_val = self.__class__.convert(def_value)
self._desc = desc
self._parent = parent
# Compatibility for child objects
self.add_attribute(attrs, 'id', Integer, '_id')
self.set_attributes(attrs)
self.check_validity()
if not Variable.setted(self._value):
raise Exception("Value not setted")
if not isinstance(self._value, self.__class__.element_type):
raise Exception("Unable to set a valid type")
log.debug(">>> Variable named '%s' allocate with value '%s'" % (self._name, self._value))
def _move_down(self):
widget_swap = self._get_next()
if not self._voidplace :
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')
def sanity_settings(self, settings):
log.debug(">>> Sanitize %s" % str(settings))
tuple_regex = "[\(\[]\s?(\d+)\s?,\s?(\d+)\s?,\s?(\d+)\s?[\)\]]"
if isinstance(settings, basestring):
settings = [int(t) for t in re.findall(tuple_regex, settings)[0]]
return settings
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:
log.debug('Key press event on NotebookEditable -- Return')
return
if _keyval == "Delete" :
self.delete_section()
def match_profile(self, profile):
log.debug("Match profile: %s" % profile)
log.debug("Comparing: %s == %s ??" % \
(str(self.parsed_scan.profile_name).lower(),
"*%s*" % profile.lower()))
if profile == "*" or profile == "" or \
fnmatch(str(self.parsed_scan.profile_name).lower(),
"*%s*" % profile.lower()):
return True # Pattern matches
return False # Pattern doesn't match
def _remove_label(self):
self._widget.voidplace()
#ProfileCore
if self._new :
pass
log.debug('Removing label, Adding Void Place')
def root_dir():
"""Retrieves root dir on current filesystem"""
curr_dir = os.getcwd()
while True:
splited = os.path.dirname(curr_dir)
if curr_dir == splited:
break
curr_dir = splited
log.debug(">>> Root dir: %s" % curr_dir)
return curr_dir
def format_date(self, date):
"""
Format date to be displayed in Date column.
"""
try:
date.hour
except AttributeError, e:
log.critical(">>> Report this as a BUG!, sqlite didn't return "
"column with timestamp format, errmsg: %s" % e)
log.debug(">>> date, type(date):", date, type(date))
return date
def __init__(self, search_directory, file_extensions=["usr"]):
SearchResult.__init__(self)
log.debug(">>> SearchDir initialized")
self.search_directory = search_directory
if isinstance(file_extensions, basestring):
self.file_extensions = file_extensions.split(";")
elif isinstance(file_extensions, list):
self.file_extensions = file_extensions
else:
raise Exception("Wrong file extension format! '%s'" %
file_extensions)
def _move_up(self):
widget_swap = self._get_prev()
if not self._voidplace :
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')
def set_option_display(self, optiondisplay):
"""
Set a option display to change fields when cursor change
@param optiondisplay: it's a mainframe that contains fields to set
@type optiondisplay: OptionDisplay
"""
self.optiondisplay = optiondisplay
self.exists_display = (self.optiondisplay != None ) #True or False
if self.exists_display:
log.debug('<<< Cursor changed')
self.__treeview.connect("cursor-changed",self.update_option_display)
def match_osmatch(self, osmatch):
# XXX only the last osmatch is being used
log.debug("Match osmatch: %s" % osmatch)
if osmatch == "" or osmatch == "*":
return True
for host in self.parsed_scan.hosts:
if not host.osmatch:
continue
match = host.osmatch[-1].get("name", False)
if match and fnmatch(match.lower(), "*%s*" % osmatch.lower()):
return True
return False
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
widget.do_draw()
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 match_service(self, service):
log.debug("Match service: %s" % service)
if service == "" or service == "*":
return True
services = []
for port in self.parsed_scan.ports:
if 'name' in port and port['name'] not in services:
services.append(port["service_name"])
if service in services:
return True # Given service name matched current result
return False # Given service name didn't match current result
def create_user_dir(config_file, user_home):
log.debug(">>> Create user dir at given home: %s" % user_home)
log.debug(">>> Using %s as source" % config_file)
user_dir = os.path.join(user_home, base_paths['config_dir'])
if os.path.exists(user_home):
if os.access(user_home, os.R_OK and os.W_OK):
if not os.path.exists(user_dir):
os.mkdir(user_dir)
for dirname in userdir_dirs:
os.mkdir(os.path.join(user_dir, dirname))
log.debug(">>> Umit user dir (%r) successfully "
"created!" % user_dir)
else:
log.debug(">>> Umit user dir (%r) already exists" % user_dir)
else:
log.warning(">>> No permissions to create user dir!")
return False
main_dir = os.path.dirname(config_file)
for name in userdir_files:
copy_config_file(name, main_dir, user_dir)
return dict(user_dir = user_dir,
config_dir = user_dir,
config_file = os.path.join(user_dir, 'umit.conf'))
def change_combo(self,combo):
model = combo.get_model()
index = combo.get_active()
if index:
if model[index][0]=='Option List':
log.debug('Show Button List ')
self._button_list.show()
else:
log.debug('Hide Button List ')
self._button_list.hide()
return
def set_umit_conf(self, base_dir):
main_config_dir = ""
main_config_file = ""
if (os.path.exists(CONFIG_DIR) and os.path.exists(
os.path.join(CONFIG_DIR, base_paths['config_file']))):
main_config_dir = CONFIG_DIR
elif (os.path.exists(os.path.join(base_dir, CONFIG_DIR))
and os.path.exists(
os.path.join(base_dir, CONFIG_DIR,
base_paths['config_file']))):
main_config_dir = os.path.join(base_dir, CONFIG_DIR)
elif (os.path.exists(
os.path.join(os.path.dirname(base_dir), CONFIG_DIR))
and os.path.exists(
os.path.join(os.path.dirname(base_dir), CONFIG_DIR,
base_paths['config_file']))):
main_config_dir = (os.path.join(os.path.dirname(base_dir),
CONFIG_DIR))
else:
# XXX This is bad, it doesn't create temporary configuration
# files for everything that umit uses nowadays.
main_config_dir = create_temp_conf_dir(VERSION)
# Main config file, based on the main_config_dir got above
main_config_file = os.path.join(main_config_dir,
base_paths['config_file'])
# This is the expected place in which umit.conf should be placed
supposed_file = os.path.join(base_paths['user_dir'],
base_paths['config_file'])
config_dir = ""
config_file = ""
if os.path.exists(supposed_file)\
and check_access(supposed_file, os.R_OK and os.W_OK):
config_dir = base_paths['user_dir']
config_file = supposed_file
log.debug(">>> Using config files in user home directory: %s" \
% config_file)
# Verify if an old ~/.umit exists, and merge into user
# localappdata (Windows only).
backup = nt_appdata.merge()
if backup is not None:
log.debug(">>> Merging config files from %r to %r (new "
"configdir already exists)" % (backup, config_dir))
file_merger(backup, config_dir, True, *userdir_files)
elif not os.path.exists(supposed_file)\
and not check_access(base_paths['user_dir'],
os.R_OK and os.W_OK):
# Before attemping to create a new user directory, merge the older
# ~/.umit to user localappdata (Windows only).
backup = nt_appdata.merge()
if backup is not None:
log.debug(">>> Merging config files from %r to %r" %
(backup, config_dir))
file_merger(backup, config_dir, True, *userdir_files)
try:
result = create_user_dir(
os.path.join(main_config_dir, base_paths['config_file']),
HOME)
if not isinstance(result, dict):
raise Exception()
except:
log.debug(">>> Failed to create user home")
else:
config_dir = result['config_dir']
config_file = result['config_file']
log.debug(">>> Using recently created config files in "
"user home: %s" % config_file)
if config_dir and config_file:
# Either base_paths['user_dir'] existed or it just got created.
#
# In both cases it is possible that config merge is necessary,
# if the path already existed then it is possible that:
# 1) there are newer config files that need merging;
# 2) there are newer config dirs that need copying;
# 3) maybe there was an ~/.umit which got merged into user's
# local appdata and now configuration files need be merged
# [Windows only].
# if it just got created then:
# See 3) above.
dir_creator(config_dir, *userdir_dirs)
file_merger(main_config_dir, config_dir, False, *userdir_files)
else:
log.debug(">>> There is no way to create nor use home config.")
log.debug(">>> Trying to use main configuration files...")
config_dir = main_config_dir
config_file = main_config_file
self._parse_and_set_dirs(config_file, config_dir)
def close(self):
log.debug(">>> CLOSE")
self.email_server.close()
del(self.email_server)
def save_changes(self):
log.debug('call save changes - network settings')
self.parser.save_changes()
def unload_voidplace(self):
log.debug('<<< Unload voidplace happen')
self._voidplace.set_user_data(None)
self._voidplace.destroy()
self._voidplace = None
self._vp = False
def hide_voidplace(self):
if self.is_voidplace():
self._icon.hide_voidplace()
self._vp = False
log.debug('hide voidplace')
def save(self):
self._profilecore.write_file(self.profile_editor_file)
log.debug('<<< Saving to file %s ' % self.profile_editor_file)
def save_conf(self):
# Let's save our configuration to self.conf_file
log.debug("Saving configuration to %s" % self.conf_file)
self.parser.save_to_file(self.conf_file)
def add_port(self, port_info):
log.debug(">>> Add Port: %s" % str(port_info))
self.port_list.append([""] + list(port_info))
def save_changes(self):
log.debug('call save changes')
self.parser.save_changes()
def load_from_directory(self, path):
log.debug("Loading source files from plugin directory: %s" % path)
self.tree.load_directory(path)
def connect(self):
log.debug(">>> Connecting to smtp server at %s:%s as %s" % (
self.server, self.port, self.localdomain))
self.email_server = SMTP(self.server, self.port, self.localdomain)
log.debug(">>> Connected!")
log.debug(">>> EHLO %s" % self.from_addr)
self.email_server.ehlo(self.from_addr)
if self.tls:
log.debug(">>> STARTTLS")
self.email_server.starttls()
log.debug(">>> EHLO %s" % self.from_addr)
self.email_server.ehlo(self.from_addr)
if self.login_passwd:
log.debug(">>> LOGIN %s@%s" % (self.login, self.login_passwd))
self.email_server.login(self.login, self.login_passwd)
def __update_rich_list(self):
"""
This is the timeout callback called to update the gui
in the find phase
"""
working = False
for upd_obj in self.p_window.update_eng.list:
upd_obj.lock.acquire()
try:
# Check if we are working
if upd_obj.status == LATEST_GETTING:
working = True
# Update the row
row = upd_obj.object
row.message = upd_obj.label
finally:
upd_obj.lock.release()
# No locking from here we have finished
if not working:
# Mark as finished
self.p_window.update_eng.stop()
self.find_updates_btn.set_sensitive(True)
lst = filter( \
lambda x: (x.status == LATEST_GETTED) and (x) or (None),\
self.p_window.update_eng.list \
)
elst = filter( \
lambda x: (x.status == LATEST_ERROR) and (x) or (None),\
self.p_window.update_eng.list \
)
if not lst and not elst:
self.p_window.toolbar.unset_status()
self.p_window.animated_bar.label = \
_('<b>No updates found</b>')
self.p_window.animated_bar.start_animation(True)
self.richlist.clear()
self.populate()
self.menu_enabled = True
else:
# Now prepare the download page
if not elst:
self.p_window.toolbar.show_message( \
_("<b>Updates found: %d</b>") % len(lst), \
stock=gtk.STOCK_APPLY \
)
else:
self.p_window.toolbar.show_message( \
_('<b>Updates found: %d with %d errors</b>') \
% (len(lst), len(elst)), stock=gtk.STOCK_APPLY \
)
for obj in self.p_window.update_eng.list:
row = obj.object
active = (obj.status == LATEST_GETTED)
if active:
obj.last_update_idx = 0
row.show_include = True
log.debug("Connecting 'query-tooltip' for %s" % obj)
# The tooltip is showed and hidden continuously
row.versions_button.props.has_tooltip = True
row.versions_button.connect(
'query-tooltip',
self.__query_tooltip_versions_button, obj
)
row.versions_model.clear()
row.versions_model.append([
gtk.STOCK_CANCEL, _("Skip")
])
for update in obj.updates:
cur_v = Version(row.reader.version)
new_v = Version(update.version)
if new_v > cur_v:
row.versions_model.append([
gtk.STOCK_GO_UP, _("Update to %s") % \
update.version
])
elif new_v == cur_v:
row.versions_model.append([
gtk.STOCK_REFRESH, _("Reinstall %s") % \
update.version
])
else:
row.versions_model.append([
gtk.STOCK_GO_DOWN, _("Downgrade to %s") % \
update.version
])
row.versions_button.set_active(0)
row.message = obj.label
else:
row.saturate = True
if lst:
self.install_updates_btn.show()
self.find_updates_btn.hide()
self.skip_install_btn.show()
return working
def add_host(self, host_info):
log.debug(">>> Add Host: %s" % str(host_info))
self.host_list.append([""] + list(host_info))
def _parse_and_set_dirs(self, config_file, config_dir):
"""Parse the given config_file and then set the directories."""
# Parsing the umit main config file
self.config_parser.read(config_file)
# Should make the following only after reading the umit.conf file
self.config_dir = config_dir
self.config_file = config_file
self.config_file_set = True
self.locale_dir = LOCALE_DIR
self.pixmaps_dir = PIXMAPS_DIR
self.icons_dir = ICONS_DIR
self.misc_dir = MISC_DIR
self.docs_dir = DOCS_DIR
self.styles_dir = STYLES_DIR
self.languages_dir = LANGUAGES_DIR
log.debug(">>> Config file: %s" % config_file)
log.debug(">>> Locale: %s" % self.locale_dir)
log.debug(">>> Pixmaps: %s" % self.pixmaps_dir)
log.debug(">>> Icons: %s" % self.icons_dir)
log.debug(">>> Misc: %s" % self.misc_dir)
log.debug(">>> Docs: %s" % self.docs_dir)
log.debug(">>> Styles: %s" % self.styles_dir)
log.debug(">>> Languages: %s" % self.languages_dir)
def read(self, filename):
log.debug(">>> Trying to parse: %s" % filename)
self.filenames = ConfigParser.read(self, filename)
return self.filenames
def put_on_page(self):
log.debug('<<< Put on page %s' % self._page_in)
self.set_current_page(self._page_in)