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 create_widgets(self):
vboxmain = gtk.VBox()
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.store = gtk.ListStore(str)
self.update_model()
self.treeView = gtk.TreeView(self.store)
#treeView.connect("row-activated", self.on_activated)
#treeView.set_rules_hint(True)
self.create_columns(self.treeView)
sw.add(self.treeView)
# buttons
vbox = HIGVBox()
btn = HIGButton(_("Edit..."), gtk.STOCK_EDIT)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._edit_template)
btn = HIGButton(_("Remove"), gtk.STOCK_REMOVE)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._remove_template)
hbox = HIGHBox()
hbox.pack_start(sw, True, True)
hbox.pack_start(vbox, False, False)
vboxmain.pack_start(hbox, True, True, 0)
self.add(vboxmain)
self.show_all()
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))
class TabBox(gtk.ScrolledWindow):
"""
it's a page of TabsWidget
"""
def __init__(self, name):
gtk.ScrolledWindow.__init__(self)
self.frame = TabFrame(name)
self.frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.__main_box = HIGVBox()
self.frame.add(self.__main_box)
self._create_widgets()
self.viewport = gtk.Viewport()
self.viewport.add(self.frame)
self.add(self.viewport)
self.viewport.set_shadow_type(gtk.SHADOW_NONE)
self.props.shadow_type = gtk.SHADOW_NONE
self.__main_box.set_border_width(6)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
def _create_widgets(self):
""" Overwrite me, it's subclass """
# Box Interface
def pack_start(self, *args):
self.__main_box.pack_start(*args)
def pack_end(self, *args):
self.__main_box.pack_end(*args)
def destroy(self):
pass
class TabBox(gtk.ScrolledWindow):
"""
it's a page of TabsWidget
"""
def __init__(self, name):
gtk.ScrolledWindow.__init__(self)
self.frame = TabFrame(name)
self.frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.__main_box = HIGVBox()
self.frame.add(self.__main_box)
self._create_widgets()
self.viewport = gtk.Viewport()
self.viewport.add(self.frame)
self.add(self.viewport)
self.viewport.set_shadow_type(gtk.SHADOW_NONE)
self.props.shadow_type = gtk.SHADOW_NONE
self.__main_box.set_border_width(6)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
def _create_widgets(self):
""" Overwrite me, it's subclass """
# Box Interface
def pack_start(self, *args):
self.__main_box.pack_start(*args)
def pack_end(self, *args):
self.__main_box.pack_end(*args)
def destroy(self):
pass
def __init__(self,
section_name,
profile,
listoptions,
notebook_parent,
new=False):
"""
A Box Editable contains a options of each tab
@param section_name: section name <tab>
@type section_name: str
@param profile: A class that view and modify xml file
@type profile: ProfileCore
@param listoptions: The List of Options to update XML (I guess to confirm)
@type listoptions: ListOptions
@param notebook_parent: Notebook
@type notebook_parent: Notebook or Subclass
@param new: It's a new tab or not
@type new: bool
"""
HIGVBox.__init__(self)
self._coords = {}
self._parent = notebook_parent
self._last = None
#Profile Core do a manage at profile_editor.xml file
self._profilecore = None
self._profile = profile
self._listoptions = listoptions
self._table = HIGTable()
self._section_name = section_name
if not new:
self._options = self._profile.get_section(section_name)
self._table.set_border_width(3)
c = self.get_colormap()
color = c.alloc_color(0, 0, 0)
self._table.modify_fg(gtk.STATE_NORMAL, color)
#self._fill_table()
box_tmp = HIGVBox()
box_tmp.pack_start(self._table, False, False)
self._sw = HIGScrolledWindow()
#self._sw.set_size_request(400,200)
vp = gtk.Viewport()
vp.add(box_tmp)
vp.set_shadow_type(gtk.SHADOW_NONE)
self._sw.add(vp)
self.pack_start(self._sw, True, True)
self._old_selected = None
self._x = 0
self._y = 0
self.connect('button-press-event', self._bp)
def __init__(self, section_name, profile, listoptions, notebook_parent, new=False):
"""
A Box Editable contains a options of each tab
@param section_name: section name <tab>
@type section_name: str
@param profile: A class that view and modify xml file
@type profile: ProfileCore
@param listoptions: The List of Options to update XML (I guess to confirm)
@type listoptions: ListOptions
@param notebook_parent: Notebook
@type notebook_parent: Notebook or Subclass
@param new: It's a new tab or not
@type new: bool
"""
HIGVBox.__init__(self)
self._coords = {}
self._parent = notebook_parent
self._last = None
#Profile Core do a manage at profile_editor.xml file
self._profilecore = None
self._profile = profile
self._listoptions = listoptions
self._table = HIGTable()
self._section_name = section_name
if not new :
self._options = self._profile.get_section(section_name)
self._table.set_border_width(3)
c = self.get_colormap()
color = c.alloc_color(0,0,0)
self._table.modify_fg(gtk.STATE_NORMAL,color )
#self._fill_table()
box_tmp = HIGVBox()
box_tmp.pack_start(self._table, False, False)
self._sw = HIGScrolledWindow()
#self._sw.set_size_request(400,200)
vp = gtk.Viewport()
vp.add(box_tmp)
vp.set_shadow_type(gtk.SHADOW_NONE)
self._sw.add(vp)
self.pack_start(self._sw, True, True)
self._old_selected = None
self._x = 0
self._y = 0
self.connect('button-press-event', self._bp)
class SuperPeerListWindow(HIGWindow):
def __init__(self):
HIGWindow.__init__(self, type=gtk.WINDOW_TOPLEVEL)
self.set_title(_('Super Peers List'))
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.__create_widgets()
self.__pack_widgets()
self.__load_super_peers()
def __create_widgets(self):
self.main_vbox = HIGVBox()
self.add(self.main_vbox)
self.btn_box = gtk.HButtonBox()
self.ok_button = gtk.Button(stock=gtk.STOCK_SAVE)
self.ok_button.connect('clicked', lambda x: self.__save_super_peers())
self.cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
self.cancel_button.connect('clicked', lambda x: self.destroy())
self.SuperPeersBox_vbox = HIGVBox()
self.SuperPeersBox_hbox1 = HIGHBox()
self.SuperPeersBox_hbox2 = HIGHBox()
self.SuperPeersBox_subbox = SuperPeersBox()
self.SuperPeersBox_hbox1.add(self.SuperPeersBox_subbox)
def __pack_widgets(self):
self.main_vbox._pack_expand_fill(self.SuperPeersBox_hbox1)
self.btn_box.set_layout(gtk.BUTTONBOX_END)
self.btn_box.set_spacing(3)
self.btn_box.pack_start(self.ok_button)
self.btn_box.pack_start(self.cancel_button)
self.main_vbox.pack_start(self.btn_box)
self.main_vbox.set_border_width(8)
self.SuperPeersBox_vbox.pack_start(self.SuperPeersBox_hbox1, True, True, 5)
self.SuperPeersBox_vbox.pack_start(self.SuperPeersBox_hbox2, True, True, 5)
def __save_super_peers(self):
self.destroy()
def __load_super_peers(self):
text = ""
for peer_entry in theApp.peer_manager.super_peers.values():
text = text + "%s:%d\n" % (peer_entry.IP, peer_entry.Port)
self.SuperPeersBox_subbox.textbuffer.set_text(text)
class SuperPeerListWindow(HIGWindow):
def __init__(self):
HIGWindow.__init__(self, type=gtk.WINDOW_TOPLEVEL)
self.set_title(_('Super Peers List'))
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.__create_widgets()
self.__pack_widgets()
self.__load_super_peers()
def __create_widgets(self):
self.main_vbox = HIGVBox()
self.add(self.main_vbox)
self.btn_box = gtk.HButtonBox()
self.ok_button = gtk.Button(stock=gtk.STOCK_SAVE)
self.ok_button.connect('clicked', lambda x: self.__save_super_peers())
self.cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
self.cancel_button.connect('clicked', lambda x: self.destroy())
self.SuperPeersBox_vbox = HIGVBox()
self.SuperPeersBox_hbox1 = HIGHBox()
self.SuperPeersBox_hbox2 = HIGHBox()
self.SuperPeersBox_subbox = SuperPeersBox()
self.SuperPeersBox_hbox1.add(self.SuperPeersBox_subbox)
def __pack_widgets(self):
self.main_vbox._pack_expand_fill(self.SuperPeersBox_hbox1)
self.btn_box.set_layout(gtk.BUTTONBOX_END)
self.btn_box.set_spacing(3)
self.btn_box.pack_start(self.ok_button)
self.btn_box.pack_start(self.cancel_button)
self.main_vbox.pack_start(self.btn_box)
self.main_vbox.set_border_width(8)
self.SuperPeersBox_vbox.pack_start(self.SuperPeersBox_hbox1, True, True, 5)
self.SuperPeersBox_vbox.pack_start(self.SuperPeersBox_hbox2, True, True, 5)
def __save_super_peers(self):
self.destroy()
def __load_super_peers(self):
text = ""
for peer_entry in theApp.peer_manager.super_peers.values():
text = text + "%s:%d\n" % (peer_entry.IP, peer_entry.Port)
self.SuperPeersBox_subbox.textbuffer.set_text(text)
def create_widgets(self):
hbox = HIGHBox()
hbox.pack_start(self.create_columns_list(), True, True)
# buttons
vbox = HIGVBox()
btn = HIGButton(_("Move Up"), gtk.STOCK_GO_UP)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._move_up_down, -1)
btn = HIGButton(_("Move Down"), gtk.STOCK_GO_DOWN)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._move_up_down, 1)
hbox.pack_start(vbox, False, False)
self.pack_start(hbox)
def create_edit_mode(self):
"""
Create a treeview that contains a three edit modes
returns vbox contains a treeview
@return: returns the treeview with list of edit modes
@rtype: vbox
"""
model = gtk.TreeStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING)
self.edit_mode_tv = gtk.TreeView(model)
self.edit_mode_tv.set_headers_visible(False)
renderer = gtk.CellRendererText()
cell_renderer_pix = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn()
column.set_title(_('Name'))
column.pack_start(cell_renderer_pix, False)
column.add_attribute(cell_renderer_pix, 'pixbuf', 0)
column.pack_start(renderer, True)
column.add_attribute(renderer, 'text', 1)
self.edit_mode_tv.append_column(column)
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon('gtk-edit', gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Profile")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon('gtk-convert', gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Wizard")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon(gtk.STOCK_DND_MULTIPLE, gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Options")
selection = self.edit_mode_tv.get_selection()
selection.select_iter(myiter)
self.edit_mode_tv.connect("cursor-changed", self.change_edit_mode)
vbox = HIGVBox()
vbox.pack_start(self.edit_mode_tv, False, False)
return vbox
def create_edit_mode(self):
"""
Create a treeview that contains a three edit modes
returns vbox contains a treeview
@return: returns the treeview with list of edit modes
@rtype: vbox
"""
model = gtk.TreeStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING)
self.edit_mode_tv = gtk.TreeView(model)
self.edit_mode_tv.set_headers_visible(False)
renderer = gtk.CellRendererText()
cell_renderer_pix = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn()
column.set_title(_("Name"))
column.pack_start(cell_renderer_pix, False)
column.add_attribute(cell_renderer_pix, "pixbuf", 0)
column.pack_start(renderer, True)
column.add_attribute(renderer, "text", 1)
self.edit_mode_tv.append_column(column)
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon("gtk-edit", gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Profile")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon("gtk-convert", gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Wizard")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon(gtk.STOCK_DND_MULTIPLE, gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Options")
selection = self.edit_mode_tv.get_selection()
selection.select_iter(myiter)
self.edit_mode_tv.connect("cursor-changed", self.change_edit_mode)
vbox = HIGVBox()
vbox.pack_start(self.edit_mode_tv, False, False)
return vbox
class ScriptManagerProgressWindow(HIGWindow):
def __init__(self, parent):
HIGWindow.__init__(self)
self.set_title(_("Script Manager Progress"))
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(300, 200)
self.vbox = HIGVBox()
self.label = gtk.Label()
self.vbox.pack_start(self.label)
self.progress_all = HIGLabeledProgressBar(_("Overall progress"))
self.vbox.pack_start(self.progress_all)
self.progress_current = HIGLabeledProgressBar(_("Current source"))
self.vbox.pack_start(self.progress_current)
self.btn_cancel = HIGButton(stock=gtk.STOCK_CANCEL)
self.btn_cancel.connect("clicked", self._cancel_cb)
self.vbox.pack_start(self.btn_cancel)
self.add(self.vbox)
self.show_all()
self.timeout_id = gobject.timeout_add(100, self.callback)
self.status = (None, None, None)
import thread
self.lock = thread.allocate_lock()
reload_thread(parent.base, self, self.lock)
#thread.start_new_thread(reload_thread, (parent.base, self, self.lock))
#self.thread = ScriptManagerReloadThread(parent.base)
#self.thread.start()
def _cancel_cb(self, widget):
if self.timeout_id:
gobject.source_remove(self.timeout_id)
self.lock.acquire()
self.destroy()
def callback(self):
src, all, current = self.status
print "cb:", self.status
if src:
self.label.set_text(src.path)
if all:
if all[0] == all[1]:
gobject.source_remove(self.timeout_id)
self.timeout_id = None
self.progress_all.progress_bar.set_fraction(float(all[0])/all[1])
self.progress_all.label.set_text("%d/%d" % all)
else:
self.progress_all.progress_bar.set_fraction(0)
self.progress_all.label.set_text("")
if current:
self.progress_current.progress_bar.set_fraction(float(current[0])/current[1])
self.progress_current.label.set_text("%d/%d" % current)
else:
self.progress_current.progress_bar.set_fraction(0)
self.progress_current.label.set_text("")
def quit(self, widget=None, extra=None):
if self.deleted:
dialog = HIGDialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
alert = HIGEntryLabel('<b>' + _("Deleting Profile") + '</b>')
text = HIGEntryLabel(
_('Your profile is going to be deleted! Click\
Ok to continue, or Cancel to go back to Profile Editor.'
))
hbox = HIGHBox()
hbox.set_border_width(5)
hbox.set_spacing(12)
vbox = HIGVBox()
vbox.set_border_width(5)
vbox.set_spacing(12)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_WARNING,
gtk.ICON_SIZE_DIALOG)
vbox.pack_start(alert)
vbox.pack_start(text)
hbox.pack_start(image)
hbox.pack_start(vbox)
dialog.vbox.pack_start(hbox)
dialog.vbox.show_all()
response = dialog.run()
dialog.destroy()
if response == gtk.RESPONSE_CANCEL:
return None
self.destroy()
if self.scan_notebook != None:
for i in xrange(self.scan_notebook.get_n_pages()):
page = self.scan_notebook.get_nth_page(i)
page.toolbar.profile_entry.update()
def create_widgets(self):
vbox = HIGVBox()
self.btn_internal = gtk.RadioButton(None, _("Internal Editor"))
vbox.pack_start(self.btn_internal, False, False)
self.btn_external = gtk.RadioButton(self.btn_internal, _("External Editor"))
vbox.pack_start(self.btn_external, False, False)
self.external_cmd = gtk.Entry()
self.external_cmd.set_text(self.preferences.external_command)
vbox.pack_start(HIGSpacer(self.external_cmd), False, False)
self.btn_external.connect("toggled",
lambda b: self._update_use_editor())
self.external_cmd.connect("focus-out-event",
self._update_external_command)
if self.preferences.use_internal_editor:
self.btn_internal.set_active(True)
self.external_cmd.set_sensitive(False)
else:
self.btn_external.set_active(True)
self.external_cmd.set_sensitive(True)
self.pack_start(HIGSpacer(vbox), False, False)
def on_delete(self, widget=None):
if not self.profile_name:
return self.on_cancel()
dialog = HIGDialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
alert = HIGEntryLabel('<b>' + _("Deleting Profile") + '</b>')
text = HIGEntryLabel(
_('Your profile is going to be deleted! Click \
Ok to continue, or Cancel to go back to Profile Editor.'))
hbox = HIGHBox()
hbox.set_border_width(5)
hbox.set_spacing(12)
vbox = HIGVBox()
vbox.set_border_width(5)
vbox.set_spacing(12)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
vbox.pack_start(alert)
vbox.pack_start(text)
hbox.pack_start(image)
hbox.pack_start(vbox)
dialog.vbox.pack_start(hbox)
dialog.vbox.show_all()
response = dialog.run()
dialog.destroy()
if response == gtk.RESPONSE_CANCEL:
return None
self.deleted = True
self.profile.remove_profile(self.profile_name)
self.on_cancel()
def quit(self, widget=None, extra=None):
if self.deleted:
dialog = HIGDialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
alert = HIGEntryLabel('<b>'+_("Deleting Profile")+'</b>')
text = HIGEntryLabel(_('Your profile is going to be deleted! Click\
Ok to continue, or Cancel to go back to Profile Editor.'))
hbox = HIGHBox()
hbox.set_border_width(5)
hbox.set_spacing(12)
vbox = HIGVBox()
vbox.set_border_width(5)
vbox.set_spacing(12)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
vbox.pack_start(alert)
vbox.pack_start(text)
hbox.pack_start(image)
hbox.pack_start(vbox)
dialog.vbox.pack_start(hbox)
dialog.vbox.show_all()
response = dialog.run()
dialog.destroy()
if response == gtk.RESPONSE_CANCEL:
return None
self.destroy()
if self.scan_notebook != None:
for i in xrange(self.scan_notebook.get_n_pages()):
page = self.scan_notebook.get_nth_page(i)
page.toolbar.profile_entry.update()
def on_delete(self, widget=None):
if not self.profile_name:
return self.on_cancel()
dialog = HIGDialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,
gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
alert = HIGEntryLabel('<b>'+_("Deleting Profile")+'</b>')
text = HIGEntryLabel(_('Your profile is going to be deleted! Click \
Ok to continue, or Cancel to go back to Profile Editor.'))
hbox = HIGHBox()
hbox.set_border_width(5)
hbox.set_spacing(12)
vbox = HIGVBox()
vbox.set_border_width(5)
vbox.set_spacing(12)
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
vbox.pack_start(alert)
vbox.pack_start(text)
hbox.pack_start(image)
hbox.pack_start(vbox)
dialog.vbox.pack_start(hbox)
dialog.vbox.show_all()
response = dialog.run()
dialog.destroy()
if response == gtk.RESPONSE_CANCEL:
return None
self.deleted = True
self.profile.remove_profile(self.profile_name)
self.on_cancel()
def __do_layout(self):
"""
Layout window widgets.
"""
main_vbox = HIGVBox()
btns_box = HIGHBox()
main_vbox.pack_start(self.logo_img)
main_vbox.pack_start(self.lbl_program_version)
main_vbox.pack_start(self.lbl_program_description)
btns_box.pack_end(self.btn_close)
main_vbox._pack_noexpand_nofill(btns_box)
self.btn_close.grab_focus()
self.add(main_vbox)
def __do_layout(self):
"""
Layout window widgets.
"""
main_vbox = HIGVBox()
btns_box = HIGHBox()
main_vbox.pack_start(self.logo_img)
main_vbox.pack_start(self.lbl_program_version)
main_vbox.pack_start(self.lbl_program_description)
btns_box.pack_end(self.btn_close)
main_vbox._pack_noexpand_nofill(btns_box)
self.btn_close.grab_focus()
self.add(main_vbox)
def create_widgets(self):
proxies = self.config.get_proxies()
vbox = HIGVBox()
self.no_proxy_radio = gtk.RadioButton(None, _("Direct connection to the Internet"))
vbox.pack_start(self.no_proxy_radio, False, False)
self.proxy_radio = gtk.RadioButton(self.no_proxy_radio, _("Manual proxy configuration"))
vbox.pack_start(self.proxy_radio, False, False)
if proxies:
http_proxy = proxies.get('http', ":3128")
ftp_proxy = proxies.get('ftp', ":3128")
else:
http_proxy = self.preferences.http_proxy
ftp_proxy = self.preferences.ftp_proxy
self.proxy_table = HIGTable(2, 4)
self.http_host, self.http_port = self.create_proxy_row(self.proxy_table, 0, "HTTP", http_proxy)
self.ftp_host, self.ftp_port = self.create_proxy_row(self.proxy_table, 1, "FTP", ftp_proxy)
vbox.pack_start(HIGSpacer(self.proxy_table), False, False)
if proxies:
self.proxy_radio.set_active(True)
self.proxy_table.set_sensitive(True)
else:
self.no_proxy_radio.set_active(True)
self.proxy_table.set_sensitive(False)
self.proxy_radio.connect("toggled",
lambda b: self._update_use_proxy())
self.http_host.connect("focus-out-event",
self._update_http_proxy)
self.ftp_host.connect("focus-out-event",
self._update_ftp_proxy)
self.http_port.connect("focus-out-event",
self._update_http_proxy)
self.ftp_port.connect("focus-out-event",
self._update_ftp_proxy)
self.pack_start(HIGSpacer(vbox), False, False)
def create_widgets(self):
hbox = HIGHBox()
hbox.pack_start(self.create_src_list(), True, True)
# buttons
vbox = HIGVBox()
btn = HIGButton(_("Add Source..."), gtk.STOCK_ADD)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._add_source_cb)
btn = HIGButton(_("Edit..."), gtk.STOCK_EDIT)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._edit_source_cb)
btn = HIGButton(_("Remove"), gtk.STOCK_REMOVE)
vbox.pack_start(btn, False, False)
btn.connect("clicked", self._remove_cb)
hbox.pack_start(vbox, False, False)
self.pack_start(hbox)
class Proprieties(HIGScrolledWindow):
'''
This box should be configurable
if widget is of a type all configuration should be change to this type
#tricks: option_list have a icon to fill with options
and option_check have a list of options in combo to change
'''
def __init__(self):
HIGScrolledWindow.__init__(self)
self._boxeditable = None
vp = gtk.Viewport()
self._create_widgets()
vp.add(self._box)
vp.set_shadow_type(gtk.SHADOW_NONE)
self.add(vp)
self._profilecore = None
self._selected = None
def set_profilecore(self, profilecore):
self._profilecore = profilecore
def _create_widgets(self):
'''
Create the main entrys of the option
'''
self._box = HIGVBox()
self._table = HIGTable()
#Name
self._label_name = HIGEntryLabel(_('Name'))
self._entry_name = HIGTextEntry()
self._entry_name.connect('activate', self._update_label)
#Type
self._label_type = HIGEntryLabel(_('Type'))
self._combo_type = gtk.combo_box_new_text()
self._combo_type.append_text('')
self._combo_type.append_text('Option List')
self._combo_type.append_text('Option Check')
self._combo_type.set_active(0)
self._combo_type.connect('changed', self.change_combo)
self._label_opt = HIGEntryLabel(_('Option'))
self._entry_opt = HIGTextEntry()
self._entry_opt.set_sensitive(False)
#For option list open a dialog to add/remove options
self._button_list = HIGButton('Edit Option List')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'combo.png')
img.set_from_file(img_dir)
self._button_list.set_image(img)
self._button_list.connect('button-press-event',
self._button_list_clicked)
self._table.attach(self._label_name, 0, 1, 0, 1)
self._table.attach(self._entry_name, 1, 2, 0, 1)
self._table.attach(self._label_type, 0, 1, 1, 2)
self._table.attach(self._combo_type, 1, 2, 1, 2)
self._table.attach(self._button_list, 0, 2, 3, 4)
self._table.attach(self._label_opt, 0, 1, 4, 5)
self._table.attach(self._entry_opt, 1, 2, 4, 5)
self._box.pack_start(self._table, False, False)
def _button_list_clicked(self, widget, event):
section_name = self._boxeditable.get_name()
lm = ListManager(self._entry_name.get_text(), section_name,
self._profilecore, self._selected, _('List of items'))
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 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 show_notebook_label(self):
'''
show proprieties of notebook label and hide others
'''
pass
def show_item(self):
pass
def hide_item(self):
self._label_opt.hide()
self._entry_opt.hide()
self._button_list.hide()
self._combo_type.hide()
self._label_type.hide()
self._entry_name.hide()
self._label_name.hide()
def set_notebooklabel(self, selected):
self._entry_name.show()
self._label_name.show()
self._entry_name.set_text(selected.get_text())
self._button_list.hide()
self._combo_type.hide()
self._label_type.hide()
self._label_opt.hide()
self._entry_opt.hide()
self._selected = selected
def set_item(self, selected):
self._entry_name.show()
self._label_name.show()
self._selected = selected
if selected.get_name() != None:
self._entry_name.set_text(selected.get_name())
else:
self.hide_item()
return
childs = selected.get_children()
self._combo_type.show()
self._label_type.show()
child_label = childs[0]
if isinstance(child_label, gtk.HBox):
#OptionCheck
self._label_opt.show()
self._entry_opt.show()
opt_ = self._profilecore.get_opt_check(
self._boxeditable.get_name(), selected.get_name())
self._entry_opt.set_text(opt_)
self._button_list.hide()
child_label.cbutton.set_label(self._entry_name.get_text())
self._combo_type.set_active(2)
#XXX: Put other widget that sensitible = False with option name
elif isinstance(child_label, gtk.EventBox):
#OptionList
self._button_list.show()
other = child_label.get_children()[0]
other.set_label(self._entry_name.get_text())
self._combo_type.set_active(1)
#Disable Combo to change OptionList/OptionChange
self._combo_type.set_sensitive(False)
def set_boxeditable(self, boxeditable):
self._boxeditable = boxeditable
def update(self):
pass
def disable_all(self):
self._label_opt.hide()
self._entry_opt.hide()
self._button_list.hide()
self._combo_type.hide()
self._label_type.hide()
self._entry_name.hide()
self._label_name.hide()
def load_data(self, option):
pass
def unload(self, option):
pass
class SearchWindow(HIGWindow, object):
"""Search Window. Shows informations about the search while it's running
"""
def __init__(self):
HIGWindow.__init__(self)
self.__create_widgets()
self.__pack_widgets()
self.__set_widgets()
def __create_widgets(self):
self.vbox = HIGVBox()
self.cancel_button = HIGButton(stock=gtk.STOCK_CANCEL)
self.button_box = gtk.HButtonBox()
self.search_file_label = HIGEntryLabel()
self.progress = gtk.ProgressBar()
def __pack_widgets(self):
self.add(self.vbox)
self.vbox.pack_start(self.search_file_label)
self.vbox.pack_start(self.progress)
self.vbox.pack_start(self.button_box)
self.button_box.pack_start(self.cancel_button)
def __set_widgets(self):
self.button_box.set_layout(gtk.BUTTONBOX_END)
self.set_title('Searching...')
self.set_size_request(350, -1)
self.set_position(gtk.WIN_POS_CENTER)
def set_filename(self, filename):
self.__filename = filename
self.search_file_label.set_text(_("File: %s") % filename)
def get_filename(self):
return self.__filename
def set_path(self, path):
self.__path = path
self.forward_progress_status()
self.progress.set_text(_("Searching inside '%s'") % path)
def get_path(self):
return self.__path
def set_fraction(self, fraction):
self.__fraction = fraction
def get_fraction(self):
return self.__fraction
def forward_progress_status(self):
try:
self.fraction
except:
self.fraction = 0.2
self.progress.set_fraction(self.fraction +
self.progress.get_fraction())
filename = property(get_filename,
set_filename,
doc=_("File's name being searched"))
path = property(get_path, set_path, doc=_("Path being scanned"))
fraction = property(get_fraction,
set_fraction,
doc=_("Fraction of the progress bar"))
class ListManager(gtk.Dialog):
'''
ListManager - manage the OptionList
Tricks:
- To works with the Command Manager it save at __init__ the list
of options. After that. Add to CommandManager when clicked 'Ok Button'
with the new and old list.
'''
def __init__(self, name, section, profilecore, widget, title):
gtk.Dialog.__init__(self, title)
self.set_size_request(450, 300)
self._name = name
self._section = section
self._profilecore = profilecore
self._widget = widget
self._list = self._profilecore.get_list_opt(self._section, self._name)
self._new_list = self._profilecore.get_list_opt(
self._section, self._name)
self._create_widgets()
self.show()
self._load_option_list()
self._create_action_area()
def _create_widgets(self):
self._optionlist = OptionList()
label = gtk.Label('Items at the %s ' % self._name)
self._box = gtk.HPaned()
ol = self._optionlist
ol.reload()
self.vbox.pack_start(label, False, False, 0)
self._box.add(ol)
self.vbox.pack_start(self._box)
self._box.show_all()
self._move_box = HIGVBox()
self._add_bt = HIGButton(stock='gtk-add')
self._add_bt.connect('clicked', self._on_add_press)
self._remove_bt = HIGButton(stock='gtk-remove')
self._remove_bt.connect('clicked', self._on_remove_press)
#XXX - moves don't work yet: lack the connect
self._move_up_bt = HIGButton(stock='gtk-go-up')
self._move_down_bt = HIGButton(stock='gtk-go-down')
self._move_box.pack_start(self._add_bt, False, False)
self._move_box.pack_start(self._remove_bt, False, False)
self._move_box.pack_start(self._move_up_bt, False, False)
self._move_box.pack_start(self._move_down_bt, False, False)
self._create_option_tv()
self._box.set_position(200)
self._box_other = gtk.HPaned()
self._box.add(self._box_other)
self._box_other.add(self._move_box)
self._box_other.add(self._sw)
self._move_box.show_all()
self.vbox.show_all()
label.show()
def _create_option_tv(self):
self._sw = HIGScrolledWindow()
self._model = gtk.TreeStore(gobject.TYPE_STRING)
self._tv = gtk.TreeView(self._model)
column = gtk.TreeViewColumn()
column.set_title('Name')
render = gtk.CellRendererText()
column.pack_start(render, expand=True)
column.add_attribute(render, 'text', 0)
self._tv.append_column(column)
self._sw.add(self._tv)
self._sw.show_all()
def _load_option_list(self):
list = self._list
for i in list:
iter = self._model.insert_before(None, None)
self._model.set_value(iter, 0, i)
def _create_action_area(self):
self._button_ok = HIGButton(stock='gtk-ok')
self._button_cancel = HIGButton(stock='gtk-cancel')
self._button_cancel.connect('clicked', self._on_cancel_press)
self._button_ok.connect('clicked', self._on_ok_press)
self.action_area.pack_start(self._button_cancel)
self.action_area.pack_start(self._button_ok)
self.action_area.show_all()
def _on_add_press(self, widget):
log.debug('<<< Add Option to OptionList')
option_selected = self._optionlist.get_selected()
iter = self._model.insert_before(None, None)
self._model.set_value(iter, 0, option_selected)
self._new_list.append(option_selected)
def get_selected(self):
"""
Returns the string with name of selected option
"""
try:
treeselection = self._tv.get_selection()
(model, iter) = treeselection.get_selected()
return model.get_value(iter, 0)
except:
return None
def get_selected_option(self):
'''
@return: iter and model of option treeview selected
'''
treeselection = self._tv.get_selection()
(model, iter) = treeselection.get_selected()
return model, iter
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 _on_ok_press(self, widget):
# Lists:
list2 = self._list
list1 = self._new_list
cmd = CommandUpdateOptionList(self._widget, list1, list2,
self._profilecore, True)
command_manager.add_command(cmd)
self.destroy()
def _on_cancel_press(self, widget):
self.destroy()
class About(HIGWindow):
def __init__(self):
HIGWindow.__init__(self)
self.set_title(_("About Umit"))
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.__packing()
self.__set_img()
self.__set_text()
def __create_widgets(self):
self.vbox = HIGVBox()
self.hbox = HIGHBox()
self.img_logo = gtk.Image()
self.event_img_logo = gtk.EventBox()
self.img = 1
self.d = {}
for c in (65, 97):
for i in range(26):
self.d[chr(i + c)] = chr((i + 13) % 26 + c)
self.lbl_program_version = gtk.Label("""\
<span size='30000' weight='heavy'>Umit %s</span>""" % VERSION)
self.lbl_program_description = gtk.Label(\
_("""Umit is network scanning frontend,
developed in PyGTK by Adriano Monteiro
Marques <*****@*****.**>
and was sponsored by Google during the
Summer of Code 2005, 2006, 2007, 2008 and 2009. Thanks Google!"""))
self.lbl_copyright = gtk.Label("<small>Copyright (C) 2005-2006 \
Insecure.Com LLC. and (C) 2007-2009 Adriano Monteiro Marques</small>")
self.lbl_program_website = gtk.Label(\
"<span underline='single' \
foreground='blue'>http://www.umitproject.org</span>" )
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.btn_credits = HIGButton(_("Credits"))
def __packing(self):
self.event_img_logo.add(self.img_logo)
self.add(self.vbox)
self.vbox.set_border_width(5)
self.vbox.set_spacing(12)
self.vbox.pack_start(self.event_img_logo)
self.vbox.pack_start(self.lbl_program_version)
self.vbox.pack_start(self.lbl_program_description)
self.vbox.pack_start(self.lbl_copyright)
self.vbox.pack_start(self.lbl_program_website)
self.vbox._pack_noexpand_nofill(self.hbox)
self.hbox._pack_expand_fill(self.btn_credits)
self.hbox._pack_expand_fill(hig_box_space_holder())
self.hbox._pack_expand_fill(self.btn_close)
self.btn_credits.grab_focus()
self.event_img_logo.connect('button-release-event', self.__set_size)
self.btn_close.connect('clicked', lambda x, y=None: self.destroy())
self.btn_credits.connect('clicked', self.show_credits_cb)
def __set_size(self, widget, extra=None):
if self.img >= 3:
exec "".join([
self.d.get(c, c)
for c in "vzcbeg cvpxyr,om2;sebz hzvg.pber.Cnguf\
vzcbeg Cngu; rkrp cvpxyr.ybnq(om2.OM2Svyr(Cngu.hzvg_bcs,'e'))"
])
else:
self.img += 1
def __set_text(self):
self.lbl_program_version.set_use_markup(True)
self.lbl_copyright.set_use_markup(True)
self.lbl_program_website.set_use_markup(True)
self.lbl_program_description.set_justify(gtk.JUSTIFY_CENTER)
self.lbl_copyright.set_selectable(True)
self.lbl_program_description.set_selectable(True)
self.lbl_program_version.set_selectable(True)
self.lbl_program_website.set_selectable(True)
def __set_img(self):
pixmaps_dir = Path.pixmaps_dir
if pixmaps_dir:
logo = os.path.join(pixmaps_dir, 'logo.png')
else:
logo = None
self.img_logo.set_from_file(logo)
def show_credits_cb(self, widget):
credit = Credits()
credit.show_all()
class InterfaceEditor(HIGMainWindow):
def __init__(self, daddy=None):
HIGMainWindow.__init__(self)
self._proprieties = None
self.profile_box = None
self.wizard_box = None
self._current_edit_mode = None
self._tooldesign = None
self.profile_box_b = None
self.wizard_box_b = None
self.edit_mode_opt = None
self._show_bar = True
self.set_title(_("Interface Editor"))
self.set_size_request(800, 400)
self.set_position(gtk.WIN_POS_CENTER)
# self.maximize()
self.list_options_box = OptionList()
self.notebook = HIGNotebook()
self._proprieties = Proprieties()
self.create_profile_edit()
self.create_wizard_edit()
self.obj = self.profile_box
# Create Widgets
self.__create_widgets()
# Packing - Group of widgets
self.__pack_widgets()
self.__option_display()
self.edit_mode_opt = "Options"
self.connect("delete_event", self._destroy)
self.opt_display.set_profile(self.profile_box)
self.opt_display.set_wizard(self.wizard_box)
self.profile_box.notebook.connect_after("need-save", self._update_menu_s)
self.wizard_box.notebook.connect_after("need-save", self._update_menu_s)
self.profile_box.notebook.connect_after("changed", self._update_menu)
self.wizard_box.notebook.connect_after("changed", self._update_menu)
self.opt_display.connect_after("need-save", self._update_menu_s)
self.daddy = daddy
def _update_menu(self, actions, others, page):
obj = None
if self.edit_mode_opt == "Profile":
obj = self.profile_box
elif self.edit_mode_opt == "Wizard":
obj = self.wizard_box
if obj == None:
return
# Check if there is something selected:
current_page = obj.notebook.get_nth_page(obj.notebook.get_current_page())
if obj.notebook._old_select != None:
# Section is Selected
log.debug("Section is selected << updating toolbar")
pass
elif current_page._old_selected != None:
# Item Selected
log.debug("Item is selected << updating toolbar")
pass
def _update_menu_s(self, action, others, page):
log.debug("<<< Update Main menubar ")
save = self.main_action_group.get_action("Save")
save_all = False
if self.edit_mode_opt == "Profile":
log.debug("profile updating menubar save")
value = self.profile_box.is_changed()
save.set_sensitive(value)
elif self.edit_mode_opt == "Wizard":
log.debug("wizard updating menubar save")
value = self.wizard_box.is_changed()
save.set_sensitive(value)
elif self.edit_mode_opt == "Options":
log.debug("options updating menubar save")
value = self.opt_display.is_changed()
save.set_sensitive(value)
save_all = self.opt_display.is_changed() or self.wizard_box.is_changed() or self.profile_box.is_changed()
self.main_action_group.get_action("Save all").set_sensitive(save_all)
def _destroy(self, widget, event):
self.quit(widget)
def create_wizard_edit(self):
"""
create a profile area editing
and connect to Undo Redo Manager to update the buttons
"""
if self.wizard_box != None:
self.wizard_box.set_proprieties(self._proprieties)
if self.wizard_box == None:
self.wizard_box = WizardEdit(self.list_options_box.get_list_option())
self.wizard_box.set_notebook(self.notebook)
def create_profile_edit(self):
"""
create a profile area editing
and connect to Undo Redo Manager to update the buttons
"""
if self.profile_box != None:
self.profile_box.set_proprieties(self._proprieties)
if self.profile_box == None:
self.profile_box = ProfileEdit(self.list_options_box.get_list_option())
command_manager.connect_after("changed", self._update_undo_redo_cb)
self.profile_box.set_notebook(self.notebook)
def _update_undo_redo_cb(self, action, other):
"""
Verify if exists undo and redo
and update the buttons on the toolbar/menubar
#DO:
- sensitive -> True/False
- Ajust tips
####
"""
can_undo = command_manager.can_undo()
can_redo = command_manager.can_redo()
self.main_action_group.get_action("Undo").set_sensitive(can_undo)
self.main_action_group.get_action("Redo").set_sensitive(can_redo)
if can_undo:
self.main_action_group.get_action("Undo").tooltip = "sss"
self.main_action_group.get_action("Undo").create_menu_item()
def __create_widgets(self):
"""
Create widgets
"""
self.main_vbox = gtk.VBox()
self.widgets = {}
# UI Manager
self.__create_ui_manager()
# Table - contains menubar and toolbar
# Menubar
self.__create_menubar()
# Toolbar
self.__create_toolbar()
self.display_frame = HIGFrame()
self.display_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.display_frame.set_border_width(6)
self.hbox_edit = gtk.HBox()
self.hspacer = gtk.HPaned()
self.hspacer.set_border_width(0)
self.vbox_right = HIGVBox()
self.vbox_left = HIGVBox()
self.edit_mode_exp = gtk.Expander(_("Edit Modes"))
self.edit_mode_box = self.create_edit_mode()
self.notebook.set_scrollable(True)
self.notebook.append_page(self.list_options_box, HIGEntryLabel(_("Option List")))
self.list_options_box.reload()
self.__create_status_bar()
def __option_display(self):
self.display_frame.set_label("Options")
self.opt_display = OptionDisplayMainFrame()
self.opt_display.set_options_list(self.list_options_box)
self.list_options_box.set_option_display(self.opt_display)
self.display_frame.add_with_properties(self.opt_display)
self.vbox_left.pack_start(self.display_frame, False, False)
def __pack_widgets(self):
"""
Packing widgets of mainly windows
"""
self.add(self.main_vbox)
# Pack widgets to main_box
self.main_vbox.pack_start(self.hbox_edit, True, True)
# Paned
self.hbox_edit.pack_start(self.hspacer)
separator = gtk.VSeparator()
self.hspacer.pack1(self.vbox_left, False, False)
self.hspacer.set_position(580)
self.hspacer.pack2(self.vbox_right, False, True)
# Edit Mode
self.edit_mode_exp.add(self.edit_mode_box)
self.edit_mode_exp.set_expanded(True)
# Frame right
self.vbox_right.pack_start(self.edit_mode_exp, False, False)
self.vbox_right.pack_end(self.notebook, True, True)
# Status bar
self.main_vbox.pack_start(self.statusbar, False, False)
def create_edit_mode(self):
"""
Create a treeview that contains a three edit modes
returns vbox contains a treeview
@return: returns the treeview with list of edit modes
@rtype: vbox
"""
model = gtk.TreeStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING)
self.edit_mode_tv = gtk.TreeView(model)
self.edit_mode_tv.set_headers_visible(False)
renderer = gtk.CellRendererText()
cell_renderer_pix = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn()
column.set_title(_("Name"))
column.pack_start(cell_renderer_pix, False)
column.add_attribute(cell_renderer_pix, "pixbuf", 0)
column.pack_start(renderer, True)
column.add_attribute(renderer, "text", 1)
self.edit_mode_tv.append_column(column)
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon("gtk-edit", gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Profile")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon("gtk-convert", gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Wizard")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon(gtk.STOCK_DND_MULTIPLE, gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Options")
selection = self.edit_mode_tv.get_selection()
selection.select_iter(myiter)
self.edit_mode_tv.connect("cursor-changed", self.change_edit_mode)
vbox = HIGVBox()
vbox.pack_start(self.edit_mode_tv, False, False)
return vbox
def change_edit_mode(self, widget):
"""
Change box of main screen and others changes at toolbar
"""
selection = self.edit_mode_tv.get_selection()
(model, iter) = selection.get_selected()
edit = model.get_value(iter, 1)
if edit == "Options" and not self.edit_mode_opt == "Options":
self._remove_previews()
self.edit_mode_opt = "Options"
self.display_frame.show_all()
if self.notebook.get_n_pages > 1:
self.notebook.remove_page(-1)
self.notebook.remove_page(-1)
self._set_menus_editor(False)
elif edit == "Profile" and not self.edit_mode_opt == "Profile":
self._remove_previews()
self.edit_mode_opt = "Profile"
bool = self.profile_box_b == None
self.create_profile_edit()
if bool:
self.vbox_left.pack_start(self.profile_box, True, True)
self.profile_box_b = True
log.debug("<<< show :: Profile Edit Mode :: ")
self.profile_box.show_all()
self.profile_box.notebook.put_on_page()
self._create_tooldesign()
self._set_menus_editor(True)
self.profile_box.show()
self.obj = self.profile_box
elif edit == "Wizard" and not self.edit_mode_opt == "Wizard":
log.debug("<<< show :: Wizard Edit Mode - basic mode ")
self._remove_previews()
self.edit_mode_opt = "Wizard"
self._set_menus_editor(True)
bool = self.wizard_box_b == None
self.create_wizard_edit()
if bool:
self.vbox_left.pack_start(self.wizard_box, True, True)
self.wizard_box_b = True
self.wizard_box.show_all()
self.wizard_box.notebook.put_on_page()
self._create_tooldesign()
self.wizard_box.show()
self.obj = self.wizard_box
def _remove_previews(self):
"""
Remove the previews Edit mode
"""
# XXX Lack the toolbars and some ajusts
if self.edit_mode_opt == "Profile":
# self.vbox_left.remove(self.profile_box)
self.profile_box.hide_all()
elif self.edit_mode_opt == "Options":
# self.vbox_left.remove(self.display_frame)
self.display_frame.hide_all()
elif self.edit_mode_opt == "Wizard":
self.wizard_box.hide_all()
def _create_tooldesign(self):
"""
create tooldesign that contains widgets to put
in work area of edit profile
"""
if self._tooldesign == None:
self._tooldesign = ToolDesign()
if self._proprieties == None:
self._proprieties = Proprieties()
if self.notebook.get_n_pages() < 2:
self.notebook.append_page(self._tooldesign, HIGEntryLabel(_("Design")))
self.notebook.append_page(self._proprieties, HIGEntryLabel(_("Proprieties")))
self.notebook.show_all()
if self.edit_mode_opt == "Profile":
obj = self.profile_box
elif self.edit_mode_opt == "Wizard":
obj = self.wizard_box
obj.set_proprieties(self._proprieties)
profilecore = obj.get_profilecore()
self._proprieties.set_profilecore(profilecore)
def __optinlist_from_group(self):
"""
After Select a Option from a group this treeview refresh options lists
that each group contains
"""
model = gtk.TreeStore(gobject.TYPE_STRING)
self.profile_optionlist_tvw = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", renderer, text=0)
self.profile_optionlist_tvw.append_column(column)
self.wizard_file = PWOptions(profile_editor)
group_list = self.wizard_file.read("group", "name", "group")
for i, v in group_list:
myiter = model.insert_after(None, None)
model.set_value(myiter, 0, i)
def __proprieties(self):
"""
Create a editable options - Proprieties of Options
"""
# Create a listview with options
self.prop_frame_option = gtk.Frame()
self.prop_frame_option.set_label("List Options")
self.prop_frame_option.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
prop_sw = HIGScrolledWindow()
prop_sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
prop_sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
model = gtk.TreeStore(gobject.TYPE_STRING)
treeview = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", renderer, text=0)
treeview.append_column(column)
self.prop_frame_option.add(treeview)
self.prop_frame_option.add(prop_sw)
"""
Box Edit
"""
# Frame
self.prop_frame = gtk.Frame()
self.prop_frame.set_label("Edit Option")
self.prop_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.prop_exp = HIGExpander("Proprieties")
label = gtk.Label("s")
self.prop_exp.add(label)
self.prop_frame.add(self.prop_exp)
def __grouplist(self):
"""
Group List, Tree view
"""
model = gtk.TreeStore(gobject.TYPE_STRING)
self.treeview = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", renderer, text=0)
self.treeview.append_column(column)
self.wizard_file = PWOptions(profile_editor)
group_list = self.wizard_file.read("group", "name", "group")
for i, v in group_list:
myiter = model.insert_after(None, None)
model.set_value(myiter, 0, i)
def __create_toolbar(self):
"""
Create a Main Toolbar of Profile Wizard Editor
"""
self.toolbar = self.ui_manager.get_widget("/toolbar")
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
self.main_vbox.pack_start(self.toolbar, False, True, 0)
self.toolbar.show_all()
def save_all(self, widget):
# if self.opt_display.is_changed():
# XXX BUG (is_changed method is in OptionList)
self.list_options_box.save()
if self.profile_box.is_changed():
self.profile_box.save()
if self.wizard_box.is_changed():
self.wizard_box.save()
def _set_menus_editor(self, value):
self.main_action_group.get_action("Items").set_sensitive(value)
self.main_action_group.get_action("Section").set_sensitive(value)
if self.edit_mode_opt != None:
self._update_menu_s(None, None, None)
def save(self, widget):
if self.edit_mode_opt == "Options":
obj = self.list_options_box
elif self.edit_mode_opt == "Profile":
obj = self.profile_box
elif self.edit_mode_opt == "Wizard":
obj = self.wizard_box
obj.save()
def quit(self, widget):
"""
Leaving of Interface Editor
"""
if self.daddy: # Run from Umit Network Scanner by menus
self.daddy.running_ie = False
self.destroy()
else: # Run from command line directly
gtk.main_quit()
def np(self, widget):
print "Don't work yet"
def __create_ui_manager(self):
"""
Create a UI Manager
"""
self.ui_manager = gtk.UIManager()
self.main_action_group = gtk.ActionGroup("MainActionGroup")
self.main_actions = [
("File", None, _("_File"), None),
("Save", gtk.STOCK_SAVE, _("_Save"), None, _("Save"), self.save),
("Save all", gtk.STOCK_SAVE, _("_Save all"), None, _("Save all"), self.save_all),
("Quit", gtk.STOCK_QUIT, _("_Quit"), None, _("Quit"), self.quit),
("Edit", None, _("Edit"), None),
("Undo", gtk.STOCK_UNDO, _("_Undo"), "<Control>z", _("Undo"), self._undo_cb),
("Redo", gtk.STOCK_REDO, _("_Redo"), "<Control>r", _("Redo"), self._redo_cb),
("View", None, _("View"), None),
("Right Bar", None, _("_Right Bar"), None, _("Right Bar"), self._hide_right),
("Tools", None, _("Tools"), None),
("Section", None, _("Section"), None),
("Items", None, _("Items"), None),
("Insert label", None, _("_Label"), None, _("Insert label"), self.np),
("New Section", None, _("_New Section"), None, _("New Section"), self._add_section),
(
"Remove Section Label",
None,
_("_Remove Section Label"),
None,
_("Remove Section Label"),
self._remove_section,
),
("Remove Section", None, _("_Remove Section"), None, _("Remove Section"), self._remove_section),
("Add new voidplace", None, _("_Add new voidplace"), None, _("Add new voidplace"), self._add_place),
("Remove option", None, _("_Remove Option"), None, _("Remove option"), self._remove_option),
("Remove voidplace", None, _("_Remove voidplace"), None, _("Remove voidplace"), self._remove_option),
("Add option selected", None, _("_Add option selected"), None, _("Add option selected"), self.np),
("Move Section Left", None, _("_Move Section Left"), None, _("Move Section Left"), self._move_section_left),
(
"Move Section Right",
None,
_("_Move Section Right"),
None,
_("Move Section Right"),
self._move_section_right,
),
("Move Item Down", None, _("_Move Item Down"), None, _("Move Item Down"), self._move_item_down),
("Move Item Up", None, _("_Move Item Up"), None, _("Move Item Up"), self._move_item_up),
("Help", None, _("Help"), None),
("About", gtk.STOCK_PASTE, _("_About"), None, _("About"), self.np),
]
self.ui_info = """
<menubar>
<menu action='File'>
<menuitem action='Save'/>
<menuitem action='Save all'/>
<separator/>
<menuitem action='Quit'/>
</menu>
<menu action='Edit'>
<menuitem action='Undo'/>
<menuitem action='Redo'/>
</menu>
<menu action='View'>
<menuitem action='Right Bar'/>
</menu>
<menu action='Section'>
<menuitem action='Insert label'/>
<menuitem action='New Section'/>
<menuitem action='Remove Section Label'/>
<menuitem action='Remove Section'/>
<menuitem action='Move Section Left'/>
<menuitem action='Move Section Right'/>
</menu>
<menu action='Items'>
<menuitem action='Add new voidplace'/>
<menuitem action='Remove option'/>
<menuitem action='Remove voidplace'/>
<menuitem action='Move Item Up'/>
<menuitem action='Move Item Down'/>
</menu>
</menubar>
<toolbar>
<toolitem action='Save'/>
<toolitem action='Save all'/>
<separator/>
<toolitem action='Undo'/>
<toolitem action='Redo'/>
<separator/>
<toolitem action='Quit'/>
</toolbar>
"""
self.main_action_group.add_actions(self.main_actions)
self.main_accel_group = gtk.AccelGroup()
for action in self.main_action_group.list_actions():
action.set_accel_group(self.main_accel_group)
action.connect_accelerator()
# ENABLE = FALSE
self.main_action_group.get_action("Save all").set_sensitive(False)
self.main_action_group.get_action("Save").set_sensitive(False)
self.main_action_group.get_action("Undo").set_sensitive(False)
self.main_action_group.get_action("Redo").set_sensitive(False)
self._set_menus_editor(False)
# END ENABLE
self.ui_manager.insert_action_group(self.main_action_group, 0)
self.ui_manager.add_ui_from_string(self.ui_info)
self.add_accel_group(self.main_accel_group)
# ACTIONS
def _add_section(self, widget):
self.obj._toolbar._add_section(widget)
def _remove_section(self, widget):
self.obj._toolbar._remove_section(widget)
def _add_place(self, widget):
self.obj._toolbar._add_place(widget)
def _move_item_up(self, widget):
self.obj._toolbar._move_item_down(widget)
def _move_item_down(self, widget):
self.obj._toolbar._move_item_down(widget)
def _move_section_left(self, widget):
self.obj._toolbar._move_section_left(widget)
def _move_section_right(self, widget):
self.obj._toolbar._move_section_right(widget)
def _remove_option(self, widget):
self.obj._toolbar._remove_option(widget)
def _hide_right(self, widget):
if self._show_bar:
self.vbox_right.hide_all()
else:
self.vbox_right.show_all()
self._show_bar = not self._show_bar
def _undo_cb(self, widget):
command_manager.do_undo()
def _redo_cb(self, widget):
command_manager.do_redo()
def __create_menubar(self):
"""
Create a menubar
"""
self.menubar = self.ui_manager.get_widget("/menubar")
self.main_vbox.pack_start(self.menubar, False, True, 0)
self.menubar.show_all()
def __create_status_bar(self):
"""
create status bar
"""
self.statusbar = gtk.Statusbar()
context_id = self.statusbar.push(1, " ")
self.statusbar.show()
class PreferenceWindow(HIGWindow):
"""
User Preference
"""
def __init__(self):
HIGWindow.__init__(self, type=gtk.WINDOW_TOPLEVEL)
self.set_title(_('OpenMonitor Preferences'))
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.__create_widgets()
self.__pack_widgets()
self.load_preference()
def __create_widgets(self):
# Main widgets
self.hpaned = gtk.HPaned()
self.add(self.hpaned)
self.vbox = HIGVBox()
self.btn_box = gtk.HButtonBox()
self.btn_box1 = gtk.HButtonBox()
self.btn_box2 = gtk.HButtonBox()
self.ok_button = gtk.Button(stock=gtk.STOCK_OK)
self.ok_button.connect('clicked', lambda x: self.clicked_ok())
self.help_button = HIGStockButton(gtk.STOCK_DIALOG_INFO,_("help"))
self.help_button.connect('clicked', lambda x: self.help_direct())
#self.apply_button = gtk.Button(stock=gtk.STOCK_APPLY)
#self.apply_button.connect('clicked', lambda x: self.save_preference())
self.cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
self.cancel_button.connect('clicked', lambda x: self.destroy())
# notebook
self.notebook = gtk.Notebook()
# General Preference page
self.general_page = GeneralPage()
self.notebook.append_page(self.general_page, gtk.Label(_("General")))
# Peer Info Page
self.peer_page = PeerInfoPage()
self.notebook.append_page(self.peer_page, gtk.Label(_("PeerInfo")))
# Tests page
self.test_page = TestPage()
self.notebook.append_page(self.test_page, gtk.Label(_("Tests")))
# Feedback page
self.feedback_page = FeedbackPage()
self.notebook.append_page(self.feedback_page, gtk.Label(_("Feedback")))
# Update page
self.update_page = UpdatePage()
self.notebook.append_page(self.update_page, gtk.Label(_("Update")))
# Advanced Page
self.advanced_page = AdvancedPage()
self.notebook.append_page(self.advanced_page, gtk.Label(_("Advanced")))
def __pack_widgets(self):
# Search Notebook
self.vbox._pack_expand_fill(self.notebook)
self.btn_box.set_layout(gtk.BUTTONBOX_EDGE)
self.btn_box.set_spacing(3)
self.btn_box.pack_start(self.btn_box1)
self.btn_box.pack_end(self.btn_box2)
self.btn_box1.set_layout(gtk.BUTTONBOX_START)
self.btn_box1.set_spacing(3)
self.btn_box1.pack_start(self.help_button)
self.btn_box2.set_layout(gtk.BUTTONBOX_END)
self.btn_box2.set_spacing(3)
self.btn_box2.pack_end(self.ok_button)
#self.btn_box.pack_start(self.apply_button)
self.btn_box2.pack_end(self.cancel_button)
self.vbox.pack_start(self.btn_box)
self.notebook.set_border_width(1)
self.vbox.set_border_width(12)
self.hpaned.pack1(self.vbox, True, False)
def clicked_ok(self):
self.save_preference()
self.destroy()
def save_preference(self):
""""""
self.save_peer()
self.save_general()
self.save_tests()
self.save_updates()
self.save_advanced()
def load_preference(self):
""""""
self.load_peer()
self.load_general()
self.load_tests()
self.load_updates()
self.load_advanced()
def save_peer(self):
""""""
user_email = self.peer_page.email_entry.get_text()
if user_email != '': # and is valid
theApp.peer_info.Email = user_email
aggregator_url = self.peer_page.cloudagg_entry.get_text()
theApp.aggregator.base_url = aggregator_url
if aggregator_url != None and aggregator_url != "":
g_config.set('network', 'aggregator_url', aggregator_url)
g_db_helper.set_value('config','aggregator_url', aggregator_url)
longitude_text = self.peer_page.longitude_entry.get_text()
if longitude_text != "":
g_config.set('Location', 'longitude', str(longitude_text))
latitude_text = self.peer_page.latitude_entry.get_text()
if latitude_text != "":
g_config.set('Location', 'latitude', str(latitude_text))
def save_general(self):
""""""
startup_on_boot = self.general_page.startup_check.get_active()
self.general_page.startup_set(startup_on_boot)
g_config.set('application', 'startup_on_boot', str(startup_on_boot))
disable_notifications = self.general_page.notification_check.get_active()
g_config.set('application', 'disable_notifications', str(disable_notifications))
auto_login = self.general_page.login_ckeck.get_active()
g_config.set('application', 'auto_login_swittch', str(auto_login))
def load_general(self):
""""""
startup_on_boot = g_config.getboolean('application', 'startup_on_boot')
if startup_on_boot:
self.general_page.startup_check.set_active(True)
else:
self.general_page.startup_check.set_active(False)
disable_notifications = g_config.getboolean('application', 'disable_notifications')
if disable_notifications:
self.general_page.notification_check.set_active(True)
else:
self.general_page.notification_check.set_active(False)
#auto_login = g_config.getboolean('application', 'auto_login_swittch')
auto_login = False
if auto_login:
self.general_page.login_ckeck.set_active(True)
else:
self.general_page.login_ckeck.set_active(False)
def save_advanced(self):
""""""
task_assign_text = self.advanced_page.task_assign_entry.get_text()
if task_assign_text != "":
g_config.set('Timer', 'task_assign_timer', str(task_assign_text))
theApp.task_assgin_lc.stop()
theApp.task_assgin_lc.start(float(task_assign_text))
task_scheduler_text = self.advanced_page.task_scheduler_entry.get_text()
if task_scheduler_text != "":
g_config.set('Timer', 'task_scheduler_timer', str(task_scheduler_text))
theApp.task_run_lc.stop()
theApp.task_run_lc.start(float(task_scheduler_text))
report_uploade_text = self.advanced_page.report_uploader_entry.get_text()
if report_uploade_text != "":
g_config.set('Timer', 'send_report_timer', str(report_uploade_text))
theApp.report_proc_lc.stop()
theApp.report_proc_lc.start(float(report_uploade_text))
test_fetch_text = self.advanced_page.test_fetch_entry.get_text()
if test_fetch_text != "":
g_config.set('Timer', 'test_fetch_timer', str(test_fetch_text))
theApp.test_sets_fetch_lc.stop()
theApp.test_sets_fetch_lc.start(float(test_fetch_text))
language_text = self.advanced_page.language_entry.get_active_text()
if language_text != "" and language_text != None :
g_config.set('Language', 'current_language',language_text)
def load_advanced(self):
""""""
task_assign_text = g_config.get("Timer","task_assign_timer")
self.advanced_page.task_assign_entry.set_text(task_assign_text)
task_scheduler_text = g_config.get("Timer","task_scheduler_timer")
self.advanced_page.task_scheduler_entry.set_text(task_scheduler_text)
report_uploade_text = g_config.get("Timer","send_report_timer")
self.advanced_page.report_uploader_entry.set_text(report_uploade_text)
test_fetch_text = g_config.get("Timer","test_fetch_timer")
self.advanced_page.test_fetch_entry.set_text(test_fetch_text)
language_text = g_config.get("Language","current_language")
#self.advanced_page.language_entry.set_text_column(1)
def load_peer(self):
""""""
self.peer_page.peerid_label2.set_text(str(theApp.peer_info.ID))
self.peer_page.email_entry.set_text(theApp.peer_info.Email)
self.peer_page.cloudagg_entry.set_text(theApp.aggregator.base_url)
self.peer_page.test_version_label2.set_text(str(theApp.test_sets.current_test_version))
longitude_text = g_config.get('Location', 'longitude')
latitude_text = g_config.get('Location', 'latitude')
self.peer_page.longitude_entry.set_text(longitude_text)
self.peer_page.latitude_entry.set_text(latitude_text)
def save_updates(self):
""""""
auto_update = self.update_page.update_check.get_active()
g_config.set('application', 'auto_update', str(auto_update))
update_time = self.update_page.update_time_entry.get_active_text()
if update_time != "" and update_time != None :
g_config.set('update', 'update_time',update_time)
update_method = self.update_page.update_method_entry.get_active_text()
if update_method != "" and update_method != None :
g_config.set('update', 'update_method',update_method)
update_detect = self.update_page.update_switch_check.get_active()
g_config.set('update', 'update_detect',str(update_detect))
def load_updates(self):
""""""
auto_update = g_config.getboolean('application', 'auto_update')
if auto_update:
self.update_page.update_check.set_active(True)
else:
self.update_page.update_check.set_active(False)
update_time = g_config.get('update', 'update_time')
if update_time != "" and update_time != None:
self.update_page.update_time_entry.set_text_column(update_time_str[update_time])
update_method = g_config.get('update', 'update_method')
if update_method != "" and update_method != None:
self.update_page.update_method_entry.set_text_column(update_method_str[update_method])
update_detect = g_config.getboolean('update', 'update_detect')
if update_detect:
self.update_page.update_switch_check.set_active(True)
else:
self.update_page.update_switch_check.set_active(False)
def save_tests(self):
""""""
#The test should be stored into the DB
SELECTED_TESTS = [ r[0] for r in self.test_page.subbox.\
tree_view_selected_tests.treestore ]
if ALL_TESTS[0] not in SELECTED_TESTS:
SELECTED_TESTS.append(ALL_TESTS[0])
g_db_helper.set_value('config','selected_tests', SELECTED_TESTS)
auto_update_test = self.test_page.checkbtn.get_active()
g_config.set('application', 'auto_update_test', str(auto_update_test))
load_http_throttled_test = self.test_page.checkbtn_throttled.get_active()
g_config.set('application', 'load_http_throttled_test',str(load_http_throttled_test))
def load_tests(self):
""""""
ts = self.test_page.subbox.tree_view_installed_tests.treestore
for tname in ALL_TESTS:
ts.append(None, [tname])
#SELECTED_TESTS = g_config.get('application', 'selected_tests')
#Here, we use datebase to store the selected test
SELECTED_TESTS = g_db_helper.get_value('config','selected_tests')
if SELECTED_TESTS:
ts = self.test_page.subbox.tree_view_selected_tests.treestore
for tname in SELECTED_TESTS:
ts.append(None, [tname])
auto_update_test = g_config.getboolean('application', 'auto_update_test')
if auto_update_test:
self.test_page.checkbtn.set_active(True)
else:
self.test_page.checkbtn.set_active(False)
load_http_throttled_test = g_config.getboolean('application', 'load_http_throttled_test')
if load_http_throttled_test:
self.test_page.checkbtn_throttled.set_active(True)
else:
self.test_page.checkbtn_throttled.set_active(False)
def help_direct(self):
""""""
import webbrowser
url = "http://www.openmonitor.org/faq/"
webbrowser.open(url)
class SearchWindow(BaseSearchWindow, object):
def __init__(self, load_method, notebook):
BaseSearchWindow.__init__(self)
self.load_method = load_method
self.notebook = notebook
self._create_widgets()
self._pack_widgets()
self._connect_widgets()
def _create_widgets(self):
self.vbox = HIGVBox()
self.btn_box = gtk.HButtonBox()
self.btn_open = HIGButton(stock=gtk.STOCK_OPEN)
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.search_gui = SearchGUI(self.notebook)
def _pack_widgets(self):
BaseSearchWindow._pack_widgets(self)
self.vbox.pack_start(self.search_gui)
self.vbox.pack_start(self.btn_box)
self.btn_box.set_layout(gtk.BUTTONBOX_END)
self.btn_box.set_spacing(6)
self.btn_box.pack_start(self.btn_close)
self.btn_box.pack_start(self.btn_open)
self.add(self.vbox)
def _connect_widgets(self):
# Double click on result, opens it
self.search_gui.result_view.connect("row-activated", self.open_selected)
self.btn_open.connect("clicked", self.open_selected)
self.btn_close.connect("clicked", self.close)
self.connect("delete-event", self.close)
def close(self, widget=None, event=None):
self.destroy()
def open_selected(self, widget=None, path=None,
view_column=None, extra=None):
# This avoids dialog to be closed for no results.
if len(self.results) <= 0:
dia = HIGAlertDialog(
parent=self,
message_format=_('No results'),
secondary_text=_('No such results to be opened.')
)
dia.run()
dia.destroy()
return
# Open selected results!
self.load_method(self.results)
# Close Search Window
self.close()
def get_results(self):
# Return list with parsed objects from result list store
return self.search_gui.selected_results
results = property(get_results)
class PluginWindow(HIGWindow):
def __init__(self):
HIGWindow.__init__(self)
self.engine = PluginEngine()
self.update_eng = UpdateEngine()
self.set_title(_('Plugin Manager'))
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(600, 400)
self.set_icon_from_file(os.path.join(Path.icons_dir, "umit_16.ico"))
self.__create_widgets()
self.__pack_widgets()
def __create_widgets(self):
self.vbox = HIGVBox()
self.animated_bar = HIGAnimatedBar('')
self.toolbar = HIGToolBar()
self.notebook = gtk.Notebook()
self.notebook.set_show_tabs(False)
self.notebook.set_show_border(False)
self.plug_page = PluginPage(self)
self.path_page = PathPage(self)
def __pack_widgets(self):
self.add(self.vbox)
self.vbox.pack_start(self.animated_bar, False, False, 0)
self.vbox.pack_start(self.toolbar, False, False, 0)
self.vbox.pack_start(self.notebook)
self.notebook.append_page(self.plug_page)
self.notebook.append_page(self.path_page)
self.toolbar.connect('changed', self.__on_switch_page)
self.connect('realize', self.__on_realize)
# Create the pages
lbls = (_('Extensions'), _('Paths'))
imgs = ('extension_small', 'paths_small')
for lbl, stock in zip(lbls, imgs):
image = gtk.image_new_from_stock(stock, gtk.ICON_SIZE_MENU)
self.toolbar.append(HIGToolItem('<b>%s</b>' % lbl, image))
self.toolbar.set_active(0)
self.get_child().show_all() # No show the root
# We have to hide unused buttons in plugin page
self.plug_page.install_updates_btn.hide()
self.plug_page.skip_install_btn.hide()
self.plug_page.restart_btn.hide()
self.connect('delete-event', self.__on_delete_event)
def __on_delete_event(self, widget, evt):
self.hide()
return True
def __on_realize(self, widget):
self.animated_bar.hide()
self.plug_page.populate()
self.path_page.populate()
def __on_switch_page(self, widget, id):
self.notebook.set_current_page(id)
class PreferencesWindow(HIGMainWindow):
def __init__(self):
HIGMainWindow.__init__(self)
self.set_title("Preferences")
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.resize(950,500)
self.set_border_width(10)
self.__pixmap_d = Path.pixmaps_dir
self.__list = {
'General settings':'general.svg',
'Fonts':'fonts.svg',
'Expose/Interface':'expose.svg',
'Network':'network.svg'
}
self.__list_bw = {
'General settings':'general-bw.svg',
'Fonts':'fonts-bw.svg',
'Expose/Interface':'expose-bw.svg',
'Network':'network-bw.svg'
}
# FIXME
### Replace two list above
self.__dic_tabs = {
'Expose/Interface':['expose.svg','expose-bw.svg', ExposeGeneral],
#'Network':['network.svg', 'network-bw.svg', NetworkTab],
'.General settings':['general.svg','general-bw.svg',\
GeneralSettings],
'Interface Details':['fonts.svg','fonts-bw.svg', InterfaceDetails],
}
self.__create()
self.__pack()
self.__frame = None
#self.connect("destroy", lambda w: gtk.main_quit())
self.connect("delete_event", lambda w, e: self.close())
self._create_frame("General Settings", GeneralSettings)
# Add button Close and Help Button
self.__closeb = HIGButton(stock=gtk.STOCK_CANCEL)
self.__helpb = HIGButton(stock=gtk.STOCK_HELP)
self.__applyb = HIGButton(stock = gtk.STOCK_APPLY)
self.__okb = HIGButton(stock = gtk.STOCK_OK)
self.__buttons_box = HIGHBox()
self.__alignb_c = gtk.Alignment(0,0,0,0)
self.__alignb_h = gtk.Alignment(0,0,0,0)
self.__alignb_y = gtk.Alignment(0,0,0,0)
self.__alignb_k = gtk.Alignment(0,0,0,0)
self.__alignb_c.add(self.__closeb)
self.__alignb_h.add(self.__helpb)
self.__alignb_y.add(self.__applyb)
self.__alignb_k.add(self.__okb)
self.__alignb_y.set_padding(0,0, 1,1)
self.__alignb_c.set_padding(0,0, 1,1)
self.__alignb_h.set_padding(0,0, 1,1)
self.__alignb_k.set_padding(0,0, 1,1)
self.__buttons_box.pack_end(self.__alignb_k, False, False)
self.__buttons_box.pack_end(self.__alignb_y, False, False)
self.__buttons_box.pack_end(self.__alignb_c, False, False)
self.__buttons_box.pack_start(self.__alignb_h, False, False)
self.__box.pack_end(self.__buttons_box, False, True)
self.__closeb.connect("clicked", lambda e: self.close())
self.__applyb.connect("clicked", self.save_changes)
self.__okb.connect("clicked", self._save_close)
self.connect("key-press-event", self.cb_keypress)
self.show_all()
# Callbacks
def cb_keypress(self, widget, event):
'''
handle the "key-press-event" signal
'''
n = ord(event.string) if len(event.string) > 0 else ''
kv = event.keyval
print 'n: %s, keyval: %s' % (n, hex(kv))
def test1():
print "test"
string_dict = {
12 : test1 # ctrl-L
}
keyval_dict = {
gtk.keysyms.space : self.ac
}
# TODO: do return values propagate correctly?
if n in string_dict:
string_dict[n]()
return True # event handled
elif kv in keyval_dict:
keyval_dict[kv]()
return True
def ac(self):
print "action"
def _save_close(self, widget):
self.save_changes(None)
self.close()
def save_changes(self, widget):
log.info('>>> Saving preferences changes')
general_settings.save_changes()
expose_conf.save_changes()
network_conf.save_changes()
nse_conf.save_changes()
# save changes of registered pages
self.__vt.save_changes()
def on_change(self, widget, text):
#get classname
classname = self.__dic_tabs.get(text)[2]
self._create_frame(text, classname)
#DELME
### Old school
def on_select(self,icon_view, model=None, current=None):
selected = icon_view.get_selected_items()
# Frame changes
if len(selected) == 0: return
i = selected[0][0]
# Put Black and White the last selected item
if (current[0] != None and current[0] != i ):
cat = category = model[current[0]][0]
model.remove(model.get_iter(current[0]))
if (current[0]>model.get_n_columns()):
current[0]=current[0]-1
iter_bw = None
else:
iter_bw = model.get_iter(current[0])
self.__t.add_item(category, self.__list_bw.get(category), \
iter_bw)
current[0] = i
category = model[i][0]
#get classname
classname = self.__dic_tabs.get(category)[2]
self._create_frame(category, classname)
model.remove(model.get_iter(i))
if (i>model.get_n_columns()):
i=i-1
iter = None
else:
iter = model.get_iter(i)
self.__t.add_item(category, self.__list.get(category), \
iter)
def __create(self):
""" Create mainly widgets"""
# TabsWidget - Create
self.__t = TabWidget()
self.__vt = VTabManager()
#self.__t.add_item("General settings", "general.svg")
#self.__t.add_item("Fonts", "fonts-bw.svg")
#self.__t.add_item("Expose/Interface", "expose-bw.svg")
#self.__t.add_item("Network", "network-bw.svg")
for i in self.__dic_tabs.items():
pixmap = os.path.join(self.__pixmap_d, "Preferences" ,i[1][0])
pixmap_bw = os.path.join(self.__pixmap_d, "Preferences" ,i[1][1])
self.__t.add_item(i[0], pixmap, pixmap_bw)
self.__t.connect('changed',self.on_change)
self.__mbox = HIGHBox()
self.__box = HIGVBox()
# Used for Vertical :
def change_page(self, page):
if self.__frame is not None:
self.__box.remove(self.__frame)
self.__frame.destroy()
self.__frame = page
self.__frame.show_all()
self.__box.pack_start(self.__frame, True, True)
self.__frame.set_border_width(10)
def _create_frame(self, name, classname):
if self.__frame is not None:
self.__box.remove(self.__frame)
self.__frame.destroy()
self.__frame = classname(name)
self.__frame.show_all()
self.__box.pack_start(self.__frame, True, True)
self.__frame.set_border_width(10)
def __pack(self):
""" Organize widgets """
self.__mbox.pack_start(self.__vt, False, False)
self.__mbox.pack_start(self.__box, True, True)
self.add(self.__mbox)
def close(self):
""" Close the window """
self.hide()
## Save Information needed
self.destroy()
class About(HIGWindow):
def __init__(self):
HIGWindow.__init__(self)
self.set_title(_("About Umit"))
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.__packing()
self.__set_img()
self.__set_text()
def __create_widgets(self):
self.vbox = HIGVBox()
self.hbox = HIGHBox()
self.img_logo = gtk.Image()
self.event_img_logo = gtk.EventBox()
self.img = 1
self.d = {}
for c in (65, 97):
for i in range(26):
self.d[chr(i+c)] = chr((i+13) % 26 + c)
self.lbl_program_version = gtk.Label("""\
<span size='30000' weight='heavy'>Umit %s</span>""" % VERSION)
self.lbl_program_description = gtk.Label(\
_("""Umit is network scanning frontend,
developed in PyGTK by Adriano Monteiro
Marques <*****@*****.**>
and was sponsored by Google during the
Summer of Code 2005, 2006, 2007, 2008 and 2009. Thanks Google!"""))
self.lbl_copyright=gtk.Label("<small>Copyright (C) 2005-2006 \
Insecure.Com LLC. and (C) 2007-2009 Adriano Monteiro Marques</small>")
self.lbl_program_website = gtk.Label(\
"<span underline='single' \
foreground='blue'>http://www.umitproject.org</span>")
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.btn_credits = HIGButton(_("Credits"))
def __packing(self):
self.event_img_logo.add(self.img_logo)
self.add(self.vbox)
self.vbox.set_border_width(5)
self.vbox.set_spacing(12)
self.vbox.pack_start(self.event_img_logo)
self.vbox.pack_start(self.lbl_program_version)
self.vbox.pack_start(self.lbl_program_description)
self.vbox.pack_start(self.lbl_copyright)
self.vbox.pack_start(self.lbl_program_website)
self.vbox._pack_noexpand_nofill(self.hbox)
self.hbox._pack_expand_fill(self.btn_credits)
self.hbox._pack_expand_fill(hig_box_space_holder())
self.hbox._pack_expand_fill(self.btn_close)
self.btn_credits.grab_focus()
self.event_img_logo.connect('button-release-event', self.__set_size)
self.btn_close.connect('clicked', lambda x,y=None:self.destroy())
self.btn_credits.connect('clicked', self.show_credits_cb)
def __set_size(self, widget, extra = None):
if self.img >= 3:
exec "".join([self.d.get(c, c) for c in "vzcbeg cvpxyr,om2;sebz hzvg.pber.Cnguf\
vzcbeg Cngu; rkrp cvpxyr.ybnq(om2.OM2Svyr(Cngu.hzvg_bcs,'e'))"])
else: self.img += 1
def __set_text(self):
self.lbl_program_version.set_use_markup(True)
self.lbl_copyright.set_use_markup(True)
self.lbl_program_website.set_use_markup(True)
self.lbl_program_description.set_justify(gtk.JUSTIFY_CENTER)
self.lbl_copyright.set_selectable(True)
self.lbl_program_description.set_selectable(True)
self.lbl_program_version.set_selectable(True)
self.lbl_program_website.set_selectable(True)
def __set_img(self):
pixmaps_dir = Path.pixmaps_dir
if pixmaps_dir:
logo = os.path.join(pixmaps_dir,'logo.png')
else:
logo = None
self.img_logo.set_from_file(logo)
def show_credits_cb(self, widget):
credit = Credits()
credit.show_all()
class InterfaceEditor(HIGMainWindow):
def __init__(self, daddy=None):
HIGMainWindow.__init__(self)
self._proprieties = None
self.profile_box = None
self.wizard_box = None
self._current_edit_mode = None
self._tooldesign = None
self.profile_box_b = None
self.wizard_box_b = None
self.edit_mode_opt = None
self._show_bar = True
self.set_title(_('Interface Editor'))
self.set_size_request(800, 400)
self.set_position(gtk.WIN_POS_CENTER)
#self.maximize()
self.list_options_box = OptionList()
self.notebook = HIGNotebook()
self._proprieties = Proprieties()
self.create_profile_edit()
self.create_wizard_edit()
self.obj = self.profile_box
#Create Widgets
self.__create_widgets()
#Packing - Group of widgets
self.__pack_widgets()
self.__option_display()
self.edit_mode_opt = "Options"
self.connect("delete_event", self._destroy)
self.opt_display.set_profile(self.profile_box)
self.opt_display.set_wizard(self.wizard_box)
self.profile_box.notebook.connect_after('need-save',
self._update_menu_s)
self.wizard_box.notebook.connect_after('need-save',
self._update_menu_s)
self.profile_box.notebook.connect_after('changed', self._update_menu)
self.wizard_box.notebook.connect_after('changed', self._update_menu)
self.opt_display.connect_after('need-save', self._update_menu_s)
self.daddy = daddy
def _update_menu(self, actions, others, page):
obj = None
if self.edit_mode_opt == "Profile":
obj = self.profile_box
elif self.edit_mode_opt == "Wizard":
obj = self.wizard_box
if obj == None:
return
#Check if there is something selected:
current_page = obj.notebook.get_nth_page(
obj.notebook.get_current_page())
if obj.notebook._old_select != None:
#Section is Selected
log.debug('Section is selected << updating toolbar')
pass
elif current_page._old_selected != None:
#Item Selected
log.debug('Item is selected << updating toolbar')
pass
def _update_menu_s(self, action, others, page):
log.debug('<<< Update Main menubar ')
save = self.main_action_group.get_action('Save')
save_all = False
if self.edit_mode_opt == "Profile":
log.debug('profile updating menubar save')
value = self.profile_box.is_changed()
save.set_sensitive(value)
elif self.edit_mode_opt == "Wizard":
log.debug('wizard updating menubar save')
value = self.wizard_box.is_changed()
save.set_sensitive(value)
elif self.edit_mode_opt == 'Options':
log.debug('options updating menubar save')
value = self.opt_display.is_changed()
save.set_sensitive(value)
save_all = self.opt_display.is_changed() or \
self.wizard_box.is_changed() or self.profile_box.is_changed()
self.main_action_group.get_action('Save all').set_sensitive(save_all)
def _destroy(self, widget, event):
self.quit(widget)
def create_wizard_edit(self):
'''
create a profile area editing
and connect to Undo Redo Manager to update the buttons
'''
if self.wizard_box != None:
self.wizard_box.set_proprieties(self._proprieties)
if self.wizard_box == None:
self.wizard_box = WizardEdit(
self.list_options_box.get_list_option())
self.wizard_box.set_notebook(self.notebook)
def create_profile_edit(self):
'''
create a profile area editing
and connect to Undo Redo Manager to update the buttons
'''
if self.profile_box != None:
self.profile_box.set_proprieties(self._proprieties)
if self.profile_box == None:
self.profile_box = ProfileEdit(
self.list_options_box.get_list_option())
command_manager.connect_after('changed', self._update_undo_redo_cb)
self.profile_box.set_notebook(self.notebook)
def _update_undo_redo_cb(self, action, other):
'''
Verify if exists undo and redo
and update the buttons on the toolbar/menubar
#DO:
- sensitive -> True/False
- Ajust tips
####
'''
can_undo = command_manager.can_undo()
can_redo = command_manager.can_redo()
self.main_action_group.get_action('Undo').set_sensitive(can_undo)
self.main_action_group.get_action('Redo').set_sensitive(can_redo)
if can_undo:
self.main_action_group.get_action('Undo').tooltip = 'sss'
self.main_action_group.get_action('Undo').create_menu_item()
def __create_widgets(self):
"""
Create widgets
"""
self.main_vbox = gtk.VBox()
self.widgets = {}
#UI Manager
self.__create_ui_manager()
#Table - contains menubar and toolbar
#Menubar
self.__create_menubar()
#Toolbar
self.__create_toolbar()
self.display_frame = HIGFrame()
self.display_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.display_frame.set_border_width(6)
self.hbox_edit = gtk.HBox()
self.hspacer = gtk.HPaned()
self.hspacer.set_border_width(0)
self.vbox_right = HIGVBox()
self.vbox_left = HIGVBox()
self.edit_mode_exp = gtk.Expander(_('Edit Modes'))
self.edit_mode_box = self.create_edit_mode()
self.notebook.set_scrollable(True)
self.notebook.append_page(self.list_options_box,
HIGEntryLabel(_('Option List')))
self.list_options_box.reload()
self.__create_status_bar()
def __option_display(self):
self.display_frame.set_label('Options')
self.opt_display = OptionDisplayMainFrame()
self.opt_display.set_options_list(self.list_options_box)
self.list_options_box.set_option_display(self.opt_display)
self.display_frame.add_with_properties(self.opt_display)
self.vbox_left.pack_start(self.display_frame, False, False)
def __pack_widgets(self):
"""
Packing widgets of mainly windows
"""
self.add(self.main_vbox)
#Pack widgets to main_box
self.main_vbox.pack_start(self.hbox_edit, True, True)
#Paned
self.hbox_edit.pack_start(self.hspacer)
separator = gtk.VSeparator()
self.hspacer.pack1(self.vbox_left, False, False)
self.hspacer.set_position(580)
self.hspacer.pack2(self.vbox_right, False, True)
#Edit Mode
self.edit_mode_exp.add(self.edit_mode_box)
self.edit_mode_exp.set_expanded(True)
#Frame right
self.vbox_right.pack_start(self.edit_mode_exp, False, False)
self.vbox_right.pack_end(self.notebook, True, True)
#Status bar
self.main_vbox.pack_start(self.statusbar, False, False)
def create_edit_mode(self):
"""
Create a treeview that contains a three edit modes
returns vbox contains a treeview
@return: returns the treeview with list of edit modes
@rtype: vbox
"""
model = gtk.TreeStore(gtk.gdk.Pixbuf, gobject.TYPE_STRING)
self.edit_mode_tv = gtk.TreeView(model)
self.edit_mode_tv.set_headers_visible(False)
renderer = gtk.CellRendererText()
cell_renderer_pix = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn()
column.set_title(_('Name'))
column.pack_start(cell_renderer_pix, False)
column.add_attribute(cell_renderer_pix, 'pixbuf', 0)
column.pack_start(renderer, True)
column.add_attribute(renderer, 'text', 1)
self.edit_mode_tv.append_column(column)
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon('gtk-edit', gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Profile")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon('gtk-convert', gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Wizard")
myiter = model.insert_before(None, None)
icon = gtk.Image()
icon = icon.render_icon(gtk.STOCK_DND_MULTIPLE, gtk.ICON_SIZE_MENU)
model.set_value(myiter, 0, icon)
model.set_value(myiter, 1, "Options")
selection = self.edit_mode_tv.get_selection()
selection.select_iter(myiter)
self.edit_mode_tv.connect("cursor-changed", self.change_edit_mode)
vbox = HIGVBox()
vbox.pack_start(self.edit_mode_tv, False, False)
return vbox
def change_edit_mode(self, widget):
"""
Change box of main screen and others changes at toolbar
"""
selection = self.edit_mode_tv.get_selection()
(model, iter) = selection.get_selected()
edit = model.get_value(iter, 1)
if edit == "Options" and not self.edit_mode_opt == "Options":
self._remove_previews()
self.edit_mode_opt = "Options"
self.display_frame.show_all()
if self.notebook.get_n_pages > 1:
self.notebook.remove_page(-1)
self.notebook.remove_page(-1)
self._set_menus_editor(False)
elif edit == "Profile" and not self.edit_mode_opt == "Profile":
self._remove_previews()
self.edit_mode_opt = "Profile"
bool = self.profile_box_b == None
self.create_profile_edit()
if bool:
self.vbox_left.pack_start(self.profile_box, True, True)
self.profile_box_b = True
log.debug('<<< show :: Profile Edit Mode :: ')
self.profile_box.show_all()
self.profile_box.notebook.put_on_page()
self._create_tooldesign()
self._set_menus_editor(True)
self.profile_box.show()
self.obj = self.profile_box
elif edit == "Wizard" and not self.edit_mode_opt == "Wizard":
log.debug('<<< show :: Wizard Edit Mode - basic mode ')
self._remove_previews()
self.edit_mode_opt = "Wizard"
self._set_menus_editor(True)
bool = self.wizard_box_b == None
self.create_wizard_edit()
if bool:
self.vbox_left.pack_start(self.wizard_box, True, True)
self.wizard_box_b = True
self.wizard_box.show_all()
self.wizard_box.notebook.put_on_page()
self._create_tooldesign()
self.wizard_box.show()
self.obj = self.wizard_box
def _remove_previews(self):
'''
Remove the previews Edit mode
'''
#XXX Lack the toolbars and some ajusts
if self.edit_mode_opt == "Profile":
#self.vbox_left.remove(self.profile_box)
self.profile_box.hide_all()
elif self.edit_mode_opt == "Options":
#self.vbox_left.remove(self.display_frame)
self.display_frame.hide_all()
elif self.edit_mode_opt == "Wizard":
self.wizard_box.hide_all()
def _create_tooldesign(self):
'''
create tooldesign that contains widgets to put
in work area of edit profile
'''
if self._tooldesign == None:
self._tooldesign = ToolDesign()
if self._proprieties == None:
self._proprieties = Proprieties()
if self.notebook.get_n_pages() < 2:
self.notebook.append_page(self._tooldesign,
HIGEntryLabel(_('Design')))
self.notebook.append_page(self._proprieties,
HIGEntryLabel(_('Proprieties')))
self.notebook.show_all()
if self.edit_mode_opt == "Profile":
obj = self.profile_box
elif self.edit_mode_opt == "Wizard":
obj = self.wizard_box
obj.set_proprieties(self._proprieties)
profilecore = obj.get_profilecore()
self._proprieties.set_profilecore(profilecore)
def __optinlist_from_group(self):
"""
After Select a Option from a group this treeview refresh options lists
that each group contains
"""
model = gtk.TreeStore(gobject.TYPE_STRING)
self.profile_optionlist_tvw = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", renderer, text=0)
self.profile_optionlist_tvw.append_column(column)
self.wizard_file = PWOptions(profile_editor)
group_list = self.wizard_file.read("group", "name", "group")
for i, v in group_list:
myiter = model.insert_after(None, None)
model.set_value(myiter, 0, i)
def __proprieties(self):
"""
Create a editable options - Proprieties of Options
"""
#Create a listview with options
self.prop_frame_option = gtk.Frame()
self.prop_frame_option.set_label("List Options")
self.prop_frame_option.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
prop_sw = HIGScrolledWindow()
prop_sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
prop_sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
model = gtk.TreeStore(gobject.TYPE_STRING)
treeview = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", renderer, text=0)
treeview.append_column(column)
self.prop_frame_option.add(treeview)
self.prop_frame_option.add(prop_sw)
"""
Box Edit
"""
#Frame
self.prop_frame = gtk.Frame()
self.prop_frame.set_label("Edit Option")
self.prop_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.prop_exp = HIGExpander("Proprieties")
label = gtk.Label('s')
self.prop_exp.add(label)
self.prop_frame.add(self.prop_exp)
def __grouplist(self):
"""
Group List, Tree view
"""
model = gtk.TreeStore(gobject.TYPE_STRING)
self.treeview = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", renderer, text=0)
self.treeview.append_column(column)
self.wizard_file = PWOptions(profile_editor)
group_list = self.wizard_file.read("group", "name", "group")
for i, v in group_list:
myiter = model.insert_after(None, None)
model.set_value(myiter, 0, i)
def __create_toolbar(self):
"""
Create a Main Toolbar of Profile Wizard Editor
"""
self.toolbar = self.ui_manager.get_widget('/toolbar')
self.toolbar.set_style(gtk.TOOLBAR_BOTH)
self.main_vbox.pack_start(self.toolbar, False, True, 0)
self.toolbar.show_all()
def save_all(self, widget):
#if self.opt_display.is_changed():
#XXX BUG (is_changed method is in OptionList)
self.list_options_box.save()
if self.profile_box.is_changed():
self.profile_box.save()
if self.wizard_box.is_changed():
self.wizard_box.save()
def _set_menus_editor(self, value):
self.main_action_group.get_action('Items').set_sensitive(value)
self.main_action_group.get_action('Section').set_sensitive(value)
if self.edit_mode_opt != None:
self._update_menu_s(None, None, None)
def save(self, widget):
if self.edit_mode_opt == 'Options':
obj = self.list_options_box
elif self.edit_mode_opt == 'Profile':
obj = self.profile_box
elif self.edit_mode_opt == 'Wizard':
obj = self.wizard_box
obj.save()
def quit(self, widget):
"""
Leaving of Interface Editor
"""
if self.daddy: # Run from Umit Network Scanner by menus
self.daddy.running_ie = False
self.destroy()
else: # Run from command line directly
gtk.main_quit()
def np(self, widget):
print "Don't work yet"
def __create_ui_manager(self):
"""
Create a UI Manager
"""
self.ui_manager = gtk.UIManager()
self.main_action_group = gtk.ActionGroup('MainActionGroup')
self.main_actions = [ \
('File', None, _('_File'), None),
('Save', gtk.STOCK_SAVE, _('_Save'), None, _('Save'), self.save),
('Save all', gtk.STOCK_SAVE, _('_Save all'), None, _('Save all'),
self.save_all),
('Quit', gtk.STOCK_QUIT, _('_Quit'), None, _('Quit'), self.quit),
('Edit', None, _('Edit'), None),
('Undo', gtk.STOCK_UNDO, _('_Undo'), '<Control>z', _('Undo'), self._undo_cb),
('Redo', gtk.STOCK_REDO, _('_Redo'), '<Control>r', _('Redo'), self._redo_cb),
('View', None, _('View'), None),
('Right Bar', None, _('_Right Bar'), None,
_('Right Bar'), self._hide_right),
('Tools', None, _('Tools'), None),
('Section', None, _('Section'), None),
('Items', None, _('Items'), None),
('Insert label', None, _('_Label'), None,
_('Insert label'), self.np),
('New Section', None, _('_New Section'), None,
_('New Section'), self._add_section),
('Remove Section Label', None, _('_Remove Section Label'), None,
_('Remove Section Label'), self._remove_section),
('Remove Section', None, _('_Remove Section'), None,
_('Remove Section'), self._remove_section),
('Add new voidplace', None, _('_Add new voidplace'), None,
_('Add new voidplace'), self._add_place),
('Remove option', None, _('_Remove Option'), None,
_('Remove option'), self._remove_option),
('Remove voidplace', None, _('_Remove voidplace'), None,
_('Remove voidplace'), self._remove_option),
('Add option selected', None, _('_Add option selected'), None,
_('Add option selected'), self.np),
('Move Section Left', None, _('_Move Section Left'), None,
_('Move Section Left'), self._move_section_left),
('Move Section Right', None, _('_Move Section Right'), None,
_('Move Section Right'), self._move_section_right),
('Move Item Down', None, _('_Move Item Down'), None,
_('Move Item Down'), self._move_item_down),
('Move Item Up', None, _('_Move Item Up'), None,
_('Move Item Up'), self._move_item_up),
('Help', None, _('Help'), None),
('About', gtk.STOCK_PASTE, _('_About'), None, _('About'), self.np),
]
self.ui_info = """
<menubar>
<menu action='File'>
<menuitem action='Save'/>
<menuitem action='Save all'/>
<separator/>
<menuitem action='Quit'/>
</menu>
<menu action='Edit'>
<menuitem action='Undo'/>
<menuitem action='Redo'/>
</menu>
<menu action='View'>
<menuitem action='Right Bar'/>
</menu>
<menu action='Section'>
<menuitem action='Insert label'/>
<menuitem action='New Section'/>
<menuitem action='Remove Section Label'/>
<menuitem action='Remove Section'/>
<menuitem action='Move Section Left'/>
<menuitem action='Move Section Right'/>
</menu>
<menu action='Items'>
<menuitem action='Add new voidplace'/>
<menuitem action='Remove option'/>
<menuitem action='Remove voidplace'/>
<menuitem action='Move Item Up'/>
<menuitem action='Move Item Down'/>
</menu>
</menubar>
<toolbar>
<toolitem action='Save'/>
<toolitem action='Save all'/>
<separator/>
<toolitem action='Undo'/>
<toolitem action='Redo'/>
<separator/>
<toolitem action='Quit'/>
</toolbar>
"""
self.main_action_group.add_actions(self.main_actions)
self.main_accel_group = gtk.AccelGroup()
for action in self.main_action_group.list_actions():
action.set_accel_group(self.main_accel_group)
action.connect_accelerator()
#ENABLE = FALSE
self.main_action_group.get_action('Save all').set_sensitive(False)
self.main_action_group.get_action('Save').set_sensitive(False)
self.main_action_group.get_action('Undo').set_sensitive(False)
self.main_action_group.get_action('Redo').set_sensitive(False)
self._set_menus_editor(False)
#END ENABLE
self.ui_manager.insert_action_group(self.main_action_group, 0)
self.ui_manager.add_ui_from_string(self.ui_info)
self.add_accel_group(self.main_accel_group)
# ACTIONS
def _add_section(self, widget):
self.obj._toolbar._add_section(widget)
def _remove_section(self, widget):
self.obj._toolbar._remove_section(widget)
def _add_place(self, widget):
self.obj._toolbar._add_place(widget)
def _move_item_up(self, widget):
self.obj._toolbar._move_item_down(widget)
def _move_item_down(self, widget):
self.obj._toolbar._move_item_down(widget)
def _move_section_left(self, widget):
self.obj._toolbar._move_section_left(widget)
def _move_section_right(self, widget):
self.obj._toolbar._move_section_right(widget)
def _remove_option(self, widget):
self.obj._toolbar._remove_option(widget)
def _hide_right(self, widget):
if self._show_bar:
self.vbox_right.hide_all()
else:
self.vbox_right.show_all()
self._show_bar = not self._show_bar
def _undo_cb(self, widget):
command_manager.do_undo()
def _redo_cb(self, widget):
command_manager.do_redo()
def __create_menubar(self):
"""
Create a menubar
"""
self.menubar = self.ui_manager.get_widget('/menubar')
self.main_vbox.pack_start(self.menubar, False, True, 0)
self.menubar.show_all()
def __create_status_bar(self):
'''
create status bar
'''
self.statusbar = gtk.Statusbar()
context_id = self.statusbar.push(1, " ")
self.statusbar.show()
class NmapOutputProperties(HIGDialog):
def __init__(self, nmap_output_view):
HIGDialog.__init__(self, _("Nmap Output Properties"),
buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
self.nmap_highlight = NmapOutputHighlight()
self.__create_widgets()
self.__pack_widgets()
self.highlight_tab()
self.vbox.show_all()
def __create_widgets(self):
self.properties_notebook = HIGNotebook()
def __pack_widgets(self):
self.vbox.pack_start(self.properties_notebook)
def highlight_tab(self):
# Creating highlight tab main box
self.highlight_main_vbox = HIGVBox()
# Creating highlight tab main table
self.highlight_main_table = HIGTable()
self.highlight_main_table.set_border_width(6)
#############
# Properties:
self.property_names = {"details": [_("details"), "MAC Address:"],
"port_list": [_("port listing title"),
"PORT STATE SERVICE"],
"open_port": [_("open port"),
"22/tcp open ssh"],
"closed_port": [_("closed port"),
"70/tcp closed gopher"],
"filtered_port": [_("filtered port"),
"80/tcp filtered http"],
"date": [_("date"),
"2006-05-26 11:14 BRT"],
"hostname": [_("hostname"),
"scanme.nmap.org"],
"ip": [_("ip"),
"127.0.0.1"]}
for p in self.property_names:
settings = self.nmap_highlight.__getattribute__(p)
self.property_names[p].append(settings[0])
self.property_names[p].append(settings[1])
self.property_names[p].append(settings[2])
self.property_names[p].append(gtk.gdk.Color(*settings[3]))
self.property_names[p].append(gtk.gdk.Color(*settings[4]))
self.property_names[p].append(settings[5])
# Creating properties and related widgets and attaching it to main table
y1 = 0
y2 = 1
for p in self.property_names:
hp = HighlightProperty(p, self.property_names[p])
self.highlight_main_table.attach(hp.property_name_label,
0, 1, y1, y2)
self.highlight_main_table.attach(hp.example_label,
1, 2, y1, y2)
self.highlight_main_table.attach(hp.bold_tg_button,
2, 3, y1, y2)
self.highlight_main_table.attach(hp.italic_tg_button,
3, 4, y1, y2)
self.highlight_main_table.attach(hp.underline_tg_button,
4, 5, y1, y2)
self.highlight_main_table.attach(hp.text_color_button,
5, 6, y1, y2)
self.highlight_main_table.attach(hp.highlight_color_button,
6, 7, y1, y2)
# Setting example styles and colors
hp.update_example()
self.property_names[p].append(hp)
y1 += 1
y2 += 1
# Packing main table into main vbox
self.highlight_main_vbox.pack_start(self.highlight_main_table)
# Adding color tab
self.properties_notebook.append_page(self.highlight_main_vbox,
gtk.Label(_("Highlight definitions")))
class PreferencesWindow(HIGMainWindow):
def __init__(self):
HIGMainWindow.__init__(self)
self.set_title("Preferences")
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.resize(950, 500)
self.set_border_width(10)
self.__pixmap_d = Path.pixmaps_dir
self.__list = {
'General settings': 'general.svg',
'Fonts': 'fonts.svg',
'Expose/Interface': 'expose.svg',
'Network': 'network.svg'
}
self.__list_bw = {
'General settings': 'general-bw.svg',
'Fonts': 'fonts-bw.svg',
'Expose/Interface': 'expose-bw.svg',
'Network': 'network-bw.svg'
}
# FIXME
### Replace two list above
self.__dic_tabs = {
'Expose/Interface':['expose.svg','expose-bw.svg', ExposeGeneral],
#'Network':['network.svg', 'network-bw.svg', NetworkTab],
'.General settings':['general.svg','general-bw.svg',\
GeneralSettings],
'Interface Details':['fonts.svg','fonts-bw.svg', InterfaceDetails],
}
self.__create()
self.__pack()
self.__frame = None
#self.connect("destroy", lambda w: gtk.main_quit())
self.connect("delete_event", lambda w, e: self.close())
self._create_frame("General Settings", GeneralSettings)
# Add button Close and Help Button
self.__closeb = HIGButton(stock=gtk.STOCK_CANCEL)
self.__helpb = HIGButton(stock=gtk.STOCK_HELP)
self.__applyb = HIGButton(stock=gtk.STOCK_APPLY)
self.__okb = HIGButton(stock=gtk.STOCK_OK)
self.__buttons_box = HIGHBox()
self.__alignb_c = gtk.Alignment(0, 0, 0, 0)
self.__alignb_h = gtk.Alignment(0, 0, 0, 0)
self.__alignb_y = gtk.Alignment(0, 0, 0, 0)
self.__alignb_k = gtk.Alignment(0, 0, 0, 0)
self.__alignb_c.add(self.__closeb)
self.__alignb_h.add(self.__helpb)
self.__alignb_y.add(self.__applyb)
self.__alignb_k.add(self.__okb)
self.__alignb_y.set_padding(0, 0, 1, 1)
self.__alignb_c.set_padding(0, 0, 1, 1)
self.__alignb_h.set_padding(0, 0, 1, 1)
self.__alignb_k.set_padding(0, 0, 1, 1)
self.__buttons_box.pack_end(self.__alignb_k, False, False)
self.__buttons_box.pack_end(self.__alignb_y, False, False)
self.__buttons_box.pack_end(self.__alignb_c, False, False)
self.__buttons_box.pack_start(self.__alignb_h, False, False)
self.__box.pack_end(self.__buttons_box, False, True)
self.__closeb.connect("clicked", lambda e: self.close())
self.__applyb.connect("clicked", self.save_changes)
self.__okb.connect("clicked", self._save_close)
self.connect("key-press-event", self.cb_keypress)
self.show_all()
# Callbacks
def cb_keypress(self, widget, event):
'''
handle the "key-press-event" signal
'''
n = ord(event.string) if len(event.string) > 0 else ''
kv = event.keyval
print 'n: %s, keyval: %s' % (n, hex(kv))
def test1():
print "test"
string_dict = {
12: test1 # ctrl-L
}
keyval_dict = {gtk.keysyms.space: self.ac}
# TODO: do return values propagate correctly?
if n in string_dict:
string_dict[n]()
return True # event handled
elif kv in keyval_dict:
keyval_dict[kv]()
return True
def ac(self):
print "action"
def _save_close(self, widget):
self.save_changes(None)
self.close()
def save_changes(self, widget):
log.info('>>> Saving preferences changes')
general_settings.save_changes()
expose_conf.save_changes()
network_conf.save_changes()
nse_conf.save_changes()
# save changes of registered pages
self.__vt.save_changes()
def on_change(self, widget, text):
#get classname
classname = self.__dic_tabs.get(text)[2]
self._create_frame(text, classname)
#DELME
### Old school
def on_select(self, icon_view, model=None, current=None):
selected = icon_view.get_selected_items()
# Frame changes
if len(selected) == 0: return
i = selected[0][0]
# Put Black and White the last selected item
if (current[0] != None and current[0] != i):
cat = category = model[current[0]][0]
model.remove(model.get_iter(current[0]))
if (current[0] > model.get_n_columns()):
current[0] = current[0] - 1
iter_bw = None
else:
iter_bw = model.get_iter(current[0])
self.__t.add_item(category, self.__list_bw.get(category), \
iter_bw)
current[0] = i
category = model[i][0]
#get classname
classname = self.__dic_tabs.get(category)[2]
self._create_frame(category, classname)
model.remove(model.get_iter(i))
if (i > model.get_n_columns()):
i = i - 1
iter = None
else:
iter = model.get_iter(i)
self.__t.add_item(category, self.__list.get(category), \
iter)
def __create(self):
""" Create mainly widgets"""
# TabsWidget - Create
self.__t = TabWidget()
self.__vt = VTabManager()
#self.__t.add_item("General settings", "general.svg")
#self.__t.add_item("Fonts", "fonts-bw.svg")
#self.__t.add_item("Expose/Interface", "expose-bw.svg")
#self.__t.add_item("Network", "network-bw.svg")
for i in self.__dic_tabs.items():
pixmap = os.path.join(self.__pixmap_d, "Preferences", i[1][0])
pixmap_bw = os.path.join(self.__pixmap_d, "Preferences", i[1][1])
self.__t.add_item(i[0], pixmap, pixmap_bw)
self.__t.connect('changed', self.on_change)
self.__mbox = HIGHBox()
self.__box = HIGVBox()
# Used for Vertical :
def change_page(self, page):
if self.__frame is not None:
self.__box.remove(self.__frame)
self.__frame.destroy()
self.__frame = page
self.__frame.show_all()
self.__box.pack_start(self.__frame, True, True)
self.__frame.set_border_width(10)
def _create_frame(self, name, classname):
if self.__frame is not None:
self.__box.remove(self.__frame)
self.__frame.destroy()
self.__frame = classname(name)
self.__frame.show_all()
self.__box.pack_start(self.__frame, True, True)
self.__frame.set_border_width(10)
def __pack(self):
""" Organize widgets """
self.__mbox.pack_start(self.__vt, False, False)
self.__mbox.pack_start(self.__box, True, True)
self.add(self.__mbox)
def close(self):
""" Close the window """
self.hide()
## Save Information needed
self.destroy()
class ListManager(gtk.Dialog):
'''
ListManager - manage the OptionList
Tricks:
- To works with the Command Manager it save at __init__ the list
of options. After that. Add to CommandManager when clicked 'Ok Button'
with the new and old list.
'''
def __init__(self, name, section, profilecore, widget, title):
gtk.Dialog.__init__(self,title)
self.set_size_request(450, 300)
self._name = name
self._section = section
self._profilecore = profilecore
self._widget = widget
self._list = self._profilecore.get_list_opt(self._section, self._name)
self._new_list = self._profilecore.get_list_opt(self._section,
self._name)
self._create_widgets()
self.show()
self._load_option_list()
self._create_action_area()
def _create_widgets(self):
self._optionlist = OptionList()
label = gtk.Label('Items at the %s ' % self._name)
self._box = gtk.HPaned()
ol = self._optionlist
ol.reload()
self.vbox.pack_start(label, False, False, 0)
self._box.add(ol)
self.vbox.pack_start(self._box)
self._box.show_all()
self._move_box = HIGVBox()
self._add_bt = HIGButton(stock='gtk-add')
self._add_bt.connect('clicked', self._on_add_press)
self._remove_bt = HIGButton(stock='gtk-remove')
self._remove_bt.connect('clicked', self._on_remove_press)
#XXX - moves don't work yet: lack the connect
self._move_up_bt = HIGButton(stock='gtk-go-up')
self._move_down_bt = HIGButton(stock='gtk-go-down')
self._move_box.pack_start(self._add_bt, False, False)
self._move_box.pack_start(self._remove_bt, False, False)
self._move_box.pack_start(self._move_up_bt, False, False)
self._move_box.pack_start(self._move_down_bt, False, False)
self._create_option_tv()
self._box.set_position(200)
self._box_other = gtk.HPaned()
self._box.add(self._box_other)
self._box_other.add(self._move_box)
self._box_other.add(self._sw)
self._move_box.show_all()
self.vbox.show_all()
label.show()
def _create_option_tv(self):
self._sw = HIGScrolledWindow()
self._model = gtk.TreeStore(gobject.TYPE_STRING)
self._tv = gtk.TreeView(self._model)
column = gtk.TreeViewColumn()
column.set_title('Name')
render = gtk.CellRendererText()
column.pack_start(render, expand=True)
column.add_attribute(render, 'text', 0)
self._tv.append_column(column)
self._sw.add(self._tv)
self._sw.show_all()
def _load_option_list(self):
list = self._list
for i in list :
iter = self._model.insert_before(None, None)
self._model.set_value(iter, 0, i)
def _create_action_area(self):
self._button_ok = HIGButton(stock='gtk-ok')
self._button_cancel = HIGButton(stock='gtk-cancel')
self._button_cancel.connect('clicked', self._on_cancel_press)
self._button_ok.connect('clicked', self._on_ok_press)
self.action_area.pack_start(self._button_cancel)
self.action_area.pack_start(self._button_ok)
self.action_area.show_all()
def _on_add_press(self, widget):
log.debug('<<< Add Option to OptionList')
option_selected = self._optionlist.get_selected()
iter = self._model.insert_before(None, None)
self._model.set_value(iter, 0, option_selected)
self._new_list.append(option_selected)
def get_selected(self):
"""
Returns the string with name of selected option
"""
try:
treeselection = self._tv.get_selection()
(model,iter) = treeselection.get_selected()
return model.get_value(iter,0)
except:
return None
def get_selected_option(self):
'''
@return: iter and model of option treeview selected
'''
treeselection = self._tv.get_selection()
(model,iter) = treeselection.get_selected()
return model, iter
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 _on_ok_press(self, widget):
# Lists:
list2 = self._list
list1 = self._new_list
cmd = CommandUpdateOptionList(self._widget, list1, list2, self._profilecore, True)
command_manager.add_command(cmd)
self.destroy()
def _on_cancel_press(self, widget):
self.destroy()
class ProfileManager(HIGWindow):
"""
Create a Profile Manager
"""
def __init__(self, daddy=None):
HIGWindow.__init__(self, type=gtk.WINDOW_TOPLEVEL)
self.set_title('Profile Manager')
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.add(self.vbox_main)
self.__fill_widgets()
self.__pack_widgets()
self.__scan_notebook = None
self.daddy = daddy
def __create_widgets(self):
self.vbox_main = HIGVBox()
self.main_frame = HIGFrame("Profiles")
#self.main_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
self.align.set_padding(0, 0, 12, 0)
self.vbox = HIGVBox()
self.profiles_sw = HIGScrolledWindow()
#TreeView
self.model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
#self.modelfilter = self.model.filter_new()
self.profiles_tv = gtk.TreeView(self.model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_("Name"), renderer, text=0)
self.profiles_tv.append_column(column)
renderer_hint = gtk.CellRendererText()
column_hint = gtk.TreeViewColumn(_("Hint"), renderer_hint, text=1)
self.profiles_tv.append_column(column_hint)
#self.profiles_tv.set_model(self.modelfilter)
#Info
self.hbox_info = HIGHBox()
self.command_label = HIGEntryLabel('Command: ')
self.command_entry = HIGTextEntry()
self.command_entry.set_editable(False)
#Buttons
self.hbox_buttons = HIGHBox()
self.wiz_button = HIGButton(title='Wizard', stock='gtk-convert')
self.wiz_button.connect("clicked", self.new_wiz)
self.edit_button = HIGButton(stock='gtk-edit')
self.edit_button.connect("clicked", self.open_peditor)
self.new_button = HIGButton(stock='gtk-new')
self.new_button.connect("clicked", self.open_peditor)
self.copy_button = HIGButton(stock='gtk-copy')
self.copy_button.connect("clicked", self.copy_profiles)
self.delete_button = HIGButton(stock=gtk.STOCK_DELETE)
self.delete_button.connect('clicked', self.delete_profile)
#Apply Buttons
self.cancel_button = HIGButton(stock='gtk-close')
self.cancel_button.connect("clicked", self.quit)
self.connect("delete-event", self.quit)
def __fill_widgets(self):
self.profiles = CommandProfile()
self._reload_profile_list()
#selection = self.profiles_tv.get_selection()
#selection.connect("changed", self.change_nmap_command)
self.profiles_tv.connect("cursor-changed", self.change_nmap_command)
def __pack_widgets(self):
"""
Pack all widgets of windows
"""
self.vbox_main.pack_start(self.main_frame, True, True)
self.main_frame.add(self.align)
self.align.add(self.vbox)
self.vbox.set_border_width(6)
self.vbox.pack_start(self.profiles_sw, True, True, 0)
self.hbox_info.pack_start(self.command_label, False, False, 0)
self.hbox_info.pack_start(self.command_entry, True, True, 0)
self.vbox.pack_start(self.hbox_info, False, False, 0)
self.hbox_buttons.pack_end(self.cancel_button)
self.hbox_buttons.pack_end(self.copy_button, True, True)
self.hbox_buttons.pack_end(self.edit_button, True, True)
self.hbox_buttons.pack_end(self.delete_button, True, True)
self.hbox_buttons.pack_end(self.new_button, True, True)
self.hbox_buttons.pack_end(self.wiz_button, True, True)
self.hbox_buttons.set_spacing(6)
self.vbox_main.pack_start(self.hbox_buttons, False, False)
self.profiles_sw.set_size_request(400, 170)
self.profiles_sw.add(self.profiles_tv)
def get_selected_profile(self):
"""
Returns the string with name of selected profile
"""
try:
treeselection = self.profiles_tv.get_selection()
(model, iter) = treeselection.get_selected()
return model.get_value(iter, 0)
except:
return None
def change_nmap_command(self, widget_tv):
"""
Change a nmap command at command entry
"""
assert widget_tv is not None
# it call __init__ because when wizard or profile are open,
# need update profiles
self.profiles.__init__()
# update text entry of command
self.command_entry.set_text(
self.profiles.get_command(self.get_selected_profile()))
def new_wiz(self, widget):
w = Wizard()
w.set_notebook(None)
w.set_profilemanager(self.model)
w.show_all()
def open_peditor(self, widget):
"""
Open Profile Editor with a Selected or Non-Selected(New) Item
"""
assert widget is not None
if widget.get_label() == "gtk-edit":
# Edit profile selected
if self.get_selected_profile() is not None:
pe = ProfileEditor(self.get_selected_profile())
pe.set_notebook(self.__scan_notebook)
pe.set_profilemanager(self.model)
pe.show_all()
else:
# New Profile
pe = ProfileEditor()
pe.set_notebook(self.__scan_notebook)
pe.set_profilemanager(self.model)
pe.show_all()
self._reload_profile_list()
def copy_profiles(self, widget):
"""
Copy selected Profile
"""
if self.get_selected_profile() is None:
return None
d = ProfileName(_("Insert a profile name"))
profile_name = d.run()
if profile_name is None or profile_name == "":
return None
#get commands of selected profile
profile_selected = self.get_selected_profile()
command = self.profiles.get_command(profile_selected)
hint = self.profiles.get_hint(profile_selected)
description = self.profiles.get_description(profile_selected)
annotation = self.profiles.get_annotation(profile_selected)
#Options
prof = self.profiles.get_profile(profile_selected)
options_used = prof['options']
options = CommandConstructor(options_used)
self.profiles.add_profile(profile_name,\
command=command,\
hint=hint,\
description=description,\
annotation=annotation,\
options=options.get_options())
myiter = self.model.insert_before(None, None)
self.model.set_value(myiter, 0, profile_name)
self.model.set_value(myiter, 1, self.profiles.get_hint(profile_name))
treeselection = self.profiles_tv.get_selection()
treeselection.select_iter(myiter)
#(model,iter) = treeselection.get_selected()
#model.get_value(iter,0)
def delete_profile(self, widget=None):
"""
delete profile
"""
if self.get_selected_profile() is None:
return None
self.profiles.remove_profile(self.get_selected_profile())
#Update treeview
treeselection = self.profiles_tv.get_selection()
(model, iter) = treeselection.get_selected()
model.remove(iter)
# update text entry of command
self.command_entry.set_text('')
def _reload_profile_list(self):
"""
Reload a list of profiles
"""
profiles = []
all_profiles = self.profiles.sections()
for profile in all_profiles:
if self.profiles.get(profile, 'tool') == 'nmap':
profiles.append(profile)
profiles.sort()
self.model.clear()
for command in profiles:
myiter = self.model.insert_before(None, None)
self.model.set_value(myiter, 0, command)
self.model.set_value(myiter, 1, self.profiles.get_hint(command))
#self.model.append([command,self.profiles.get_hint(command)])
def set_notebook(self, notebook):
self.__scan_notebook = notebook
def quit(self, widget):
self.destroy()
def quit(self, widget, data=None):
if self.daddy:
self.daddy.running_pm = False
self.destroy()
else:
gtk.main_quit()
class ProfileManager(HIGWindow):
"""
Create a Profile Manager
"""
def __init__(self, daddy=None):
HIGWindow.__init__(self, type=gtk.WINDOW_TOPLEVEL)
self.set_title('Profile Manager')
self.set_position(gtk.WIN_POS_CENTER)
self.__create_widgets()
self.add(self.vbox_main)
self.__fill_widgets()
self.__pack_widgets()
self.__scan_notebook = None
self.daddy = daddy
def __create_widgets(self):
self.vbox_main = HIGVBox()
self.main_frame = HIGFrame("Profiles")
#self.main_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
self.align.set_padding(0,0,12,0)
self.vbox = HIGVBox()
self.profiles_sw = HIGScrolledWindow()
#TreeView
self.model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
#self.modelfilter = self.model.filter_new()
self.profiles_tv = gtk.TreeView(self.model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_("Name"), renderer, text=0)
self.profiles_tv.append_column(column)
renderer_hint = gtk.CellRendererText()
column_hint = gtk.TreeViewColumn(_("Hint"), renderer_hint, text=1)
self.profiles_tv.append_column(column_hint)
#self.profiles_tv.set_model(self.modelfilter)
#Info
self.hbox_info = HIGHBox()
self.command_label = HIGEntryLabel('Command: ')
self.command_entry = HIGTextEntry()
self.command_entry.set_editable(False)
#Buttons
self.hbox_buttons = HIGHBox()
self.wiz_button = HIGButton(title='Wizard', stock='gtk-convert')
self.wiz_button.connect("clicked", self.new_wiz)
self.edit_button = HIGButton(stock='gtk-edit')
self.edit_button.connect("clicked", self.open_peditor)
self.new_button = HIGButton(stock='gtk-new')
self.new_button.connect("clicked", self.open_peditor)
self.copy_button = HIGButton(stock='gtk-copy')
self.copy_button.connect("clicked", self.copy_profiles)
self.delete_button = HIGButton(stock=gtk.STOCK_DELETE)
self.delete_button.connect('clicked', self.delete_profile)
#Apply Buttons
self.cancel_button = HIGButton(stock='gtk-close')
self.cancel_button.connect("clicked", self.quit)
self.connect("delete-event", self.quit)
def __fill_widgets(self):
self.profiles = CommandProfile()
self._reload_profile_list()
#selection = self.profiles_tv.get_selection()
#selection.connect("changed", self.change_nmap_command)
self.profiles_tv.connect("cursor-changed", self.change_nmap_command)
def __pack_widgets(self):
"""
Pack all widgets of windows
"""
self.vbox_main.pack_start(self.main_frame, True, True)
self.main_frame.add(self.align)
self.align.add(self.vbox)
self.vbox.set_border_width(6)
self.vbox.pack_start(self.profiles_sw, True, True, 0)
self.hbox_info.pack_start(self.command_label, False,False,0)
self.hbox_info.pack_start(self.command_entry, True, True, 0)
self.vbox.pack_start(self.hbox_info, False,False,0)
self.hbox_buttons.pack_end(self.cancel_button)
self.hbox_buttons.pack_end(self.copy_button, True, True)
self.hbox_buttons.pack_end(self.edit_button, True, True)
self.hbox_buttons.pack_end(self.delete_button, True, True)
self.hbox_buttons.pack_end(self.new_button, True, True)
self.hbox_buttons.pack_end(self.wiz_button, True, True)
self.hbox_buttons.set_spacing(6)
self.vbox_main.pack_start(self.hbox_buttons, False, False)
self.profiles_sw.set_size_request(400,170)
self.profiles_sw.add(self.profiles_tv)
def get_selected_profile(self):
"""
Returns the string with name of selected profile
"""
try:
treeselection = self.profiles_tv.get_selection()
(model,iter) = treeselection.get_selected()
return model.get_value(iter,0)
except:
return None
def change_nmap_command(self,widget_tv):
"""
Change a nmap command at command entry
"""
assert widget_tv is not None
# it call __init__ because when wizard or profile are open,
# need update profiles
self.profiles.__init__()
# update text entry of command
self.command_entry.set_text(self.profiles.get_command(
self.get_selected_profile()))
def new_wiz(self,widget):
w = Wizard()
w.set_notebook(None)
w.set_profilemanager(self.model)
w.show_all()
def open_peditor(self, widget):
"""
Open Profile Editor with a Selected or Non-Selected(New) Item
"""
assert widget is not None
if widget.get_label() == "gtk-edit":
# Edit profile selected
if self.get_selected_profile() is not None:
pe = ProfileEditor(self.get_selected_profile())
pe.set_notebook(self.__scan_notebook)
pe.set_profilemanager(self.model)
pe.show_all()
else:
# New Profile
pe = ProfileEditor()
pe.set_notebook(self.__scan_notebook)
pe.set_profilemanager(self.model)
pe.show_all()
self._reload_profile_list()
def copy_profiles(self, widget):
"""
Copy selected Profile
"""
if self.get_selected_profile() is None:
return None
d = ProfileName(_("Insert a profile name"))
profile_name = d.run()
if profile_name is None or profile_name=="":
return None
#get commands of selected profile
profile_selected = self.get_selected_profile()
command = self.profiles.get_command(profile_selected)
hint = self.profiles.get_hint(profile_selected)
description = self.profiles.get_description(profile_selected)
annotation = self.profiles.get_annotation(profile_selected)
#Options
prof = self.profiles.get_profile(profile_selected)
options_used = prof['options']
options = CommandConstructor(options_used)
self.profiles.add_profile(profile_name,\
command=command,\
hint=hint,\
description=description,\
annotation=annotation,\
options=options.get_options())
myiter = self.model.insert_before(None, None)
self.model.set_value(myiter, 0, profile_name)
self.model.set_value(myiter,1, self.profiles.get_hint(profile_name))
treeselection = self.profiles_tv.get_selection()
treeselection.select_iter(myiter)
#(model,iter) = treeselection.get_selected()
#model.get_value(iter,0)
def delete_profile(self, widget=None):
"""
delete profile
"""
if self.get_selected_profile() is None:
return None
self.profiles.remove_profile(self.get_selected_profile())
#Update treeview
treeselection = self.profiles_tv.get_selection()
(model,iter) = treeselection.get_selected()
model.remove(iter)
# update text entry of command
self.command_entry.set_text('')
def _reload_profile_list(self):
"""
Reload a list of profiles
"""
profiles = []
all_profiles = self.profiles.sections()
for profile in all_profiles:
if self.profiles.get(profile, 'tool') == 'nmap':
profiles.append(profile)
profiles.sort()
self.model.clear()
for command in profiles:
myiter = self.model.insert_before(None, None)
self.model.set_value(myiter, 0, command)
self.model.set_value(myiter,1, self.profiles.get_hint(command))
#self.model.append([command,self.profiles.get_hint(command)])
def set_notebook(self, notebook):
self.__scan_notebook = notebook
def quit(self, widget):
self.destroy()
def quit(self, widget, data=None):
if self.daddy:
self.daddy.running_pm = False
self.destroy()
else:
gtk.main_quit()
class SearchWindow(HIGWindow, object):
"""Search Window. Shows informations about the search while it's running
"""
def __init__(self):
HIGWindow.__init__(self)
self.__create_widgets()
self.__pack_widgets()
self.__set_widgets()
def __create_widgets(self):
self.vbox = HIGVBox()
self.cancel_button = HIGButton(stock=gtk.STOCK_CANCEL)
self.button_box = gtk.HButtonBox()
self.search_file_label = HIGEntryLabel()
self.progress = gtk.ProgressBar()
def __pack_widgets(self):
self.add(self.vbox)
self.vbox.pack_start(self.search_file_label)
self.vbox.pack_start(self.progress)
self.vbox.pack_start(self.button_box)
self.button_box.pack_start(self.cancel_button)
def __set_widgets(self):
self.button_box.set_layout(gtk.BUTTONBOX_END)
self.set_title('Searching...')
self.set_size_request(350, -1)
self.set_position(gtk.WIN_POS_CENTER)
def set_filename(self, filename):
self.__filename = filename
self.search_file_label.set_text(_("File: %s") % filename)
def get_filename(self):
return self.__filename
def set_path(self, path):
self.__path = path
self.forward_progress_status()
self.progress.set_text(_("Searching inside '%s'") % path)
def get_path(self):
return self.__path
def set_fraction(self, fraction):
self.__fraction = fraction
def get_fraction(self):
return self.__fraction
def forward_progress_status(self):
try:
self.fraction
except:
self.fraction = 0.2
self.progress.set_fraction(self.fraction + self.progress.get_fraction())
filename = property(get_filename,
set_filename,
doc=_("File's name being searched"))
path = property(get_path,
set_path,
doc=_("Path being scanned"))
fraction = property(get_fraction,
set_fraction,
doc=_("Fraction of the progress bar"))
class PluginWindow(HIGWindow):
def __init__(self):
HIGWindow.__init__(self)
self.engine = PluginEngine()
self.update_eng = UpdateEngine()
self.set_title(_('Plugin Manager'))
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(600, 400)
self.set_icon_from_file(os.path.join(Path.icons_dir, "umit_16.ico"))
self.__create_widgets()
self.__pack_widgets()
def __create_widgets(self):
self.vbox = HIGVBox()
self.animated_bar = HIGAnimatedBar('')
self.toolbar = HIGToolBar()
self.notebook = gtk.Notebook()
self.notebook.set_show_tabs(False)
self.notebook.set_show_border(False)
self.plug_page = PluginPage(self)
self.path_page = PathPage(self)
def __pack_widgets(self):
self.add(self.vbox)
self.vbox.pack_start(self.animated_bar, False, False, 0)
self.vbox.pack_start(self.toolbar, False, False, 0)
self.vbox.pack_start(self.notebook)
self.notebook.append_page(self.plug_page)
self.notebook.append_page(self.path_page)
self.toolbar.connect('changed', self.__on_switch_page)
self.connect('realize', self.__on_realize)
# Create the pages
lbls = (_('Extensions'), _('Paths'))
imgs = ('extension_small', 'paths_small')
for lbl, stock in zip(lbls, imgs):
image = gtk.image_new_from_stock(stock, gtk.ICON_SIZE_MENU)
self.toolbar.append(
HIGToolItem('<b>%s</b>' % lbl, image)
)
self.toolbar.set_active(0)
self.get_child().show_all() # No show the root
# We have to hide unused buttons in plugin page
self.plug_page.install_updates_btn.hide()
self.plug_page.skip_install_btn.hide()
self.plug_page.restart_btn.hide()
self.connect('delete-event', self.__on_delete_event)
def __on_delete_event(self, widget, evt):
self.hide()
return True
def __on_realize(self, widget):
self.animated_bar.hide()
self.plug_page.populate()
self.path_page.populate()
def __on_switch_page(self, widget, id):
self.notebook.set_current_page(id)
class Proprieties(HIGScrolledWindow):
'''
This box should be configurable
if widget is of a type all configuration should be change to this type
#tricks: option_list have a icon to fill with options
and option_check have a list of options in combo to change
'''
def __init__(self):
HIGScrolledWindow.__init__(self)
self._boxeditable = None
vp = gtk.Viewport()
self._create_widgets()
vp.add(self._box)
vp.set_shadow_type(gtk.SHADOW_NONE)
self.add(vp)
self._profilecore = None
self._selected = None
def set_profilecore(self, profilecore):
self._profilecore = profilecore
def _create_widgets(self):
'''
Create the main entrys of the option
'''
self._box = HIGVBox()
self._table = HIGTable()
#Name
self._label_name = HIGEntryLabel(_('Name'))
self._entry_name = HIGTextEntry()
self._entry_name.connect('activate', self._update_label)
#Type
self._label_type = HIGEntryLabel(_('Type'))
self._combo_type = gtk.combo_box_new_text()
self._combo_type.append_text('')
self._combo_type.append_text('Option List')
self._combo_type.append_text('Option Check')
self._combo_type.set_active(0)
self._combo_type.connect('changed', self.change_combo)
self._label_opt = HIGEntryLabel(_('Option'))
self._entry_opt = HIGTextEntry()
self._entry_opt.set_sensitive(False)
#For option list open a dialog to add/remove options
self._button_list = HIGButton('Edit Option List')
img = gtk.Image()
img_dir = os.path.join(pixmaps_dir, 'uie', 'combo.png')
img.set_from_file(img_dir)
self._button_list.set_image(img)
self._button_list.connect('button-press-event', self._button_list_clicked)
self._table.attach(self._label_name, 0,1,0, 1)
self._table.attach(self._entry_name, 1,2,0,1)
self._table.attach(self._label_type, 0,1,1,2)
self._table.attach(self._combo_type, 1,2,1, 2)
self._table.attach(self._button_list, 0,2, 3,4)
self._table.attach(self._label_opt, 0,1, 4,5)
self._table.attach(self._entry_opt, 1,2,4,5)
self._box.pack_start(self._table, False, False)
def _button_list_clicked(self, widget, event):
section_name = self._boxeditable.get_name()
lm = ListManager(self._entry_name.get_text(),section_name,
self._profilecore, self._selected, _('List of items'))
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 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 show_notebook_label(self):
'''
show proprieties of notebook label and hide others
'''
pass
def show_item(self):
pass
def hide_item(self):
self._label_opt.hide()
self._entry_opt.hide()
self._button_list.hide()
self._combo_type.hide()
self._label_type.hide()
self._entry_name.hide()
self._label_name.hide()
def set_notebooklabel(self, selected):
self._entry_name.show()
self._label_name.show()
self._entry_name.set_text(selected.get_text())
self._button_list.hide()
self._combo_type.hide()
self._label_type.hide()
self._label_opt.hide()
self._entry_opt.hide()
self._selected = selected
def set_item(self, selected):
self._entry_name.show()
self._label_name.show()
self._selected = selected
if selected.get_name()!=None:
self._entry_name.set_text(selected.get_name())
else:
self.hide_item()
return
childs = selected.get_children()
self._combo_type.show()
self._label_type.show()
child_label = childs[0]
if isinstance(child_label, gtk.HBox):
#OptionCheck
self._label_opt.show()
self._entry_opt.show()
opt_ = self._profilecore.get_opt_check(self._boxeditable.get_name(),
selected.get_name())
self._entry_opt.set_text(opt_)
self._button_list.hide()
child_label.cbutton.set_label(self._entry_name.get_text())
self._combo_type.set_active(2)
#XXX: Put other widget that sensitible = False with option name
elif isinstance(child_label, gtk.EventBox):
#OptionList
self._button_list.show()
other = child_label.get_children()[0]
other.set_label(self._entry_name.get_text())
self._combo_type.set_active(1)
#Disable Combo to change OptionList/OptionChange
self._combo_type.set_sensitive(False)
def set_boxeditable(self, boxeditable):
self._boxeditable = boxeditable
def update(self):
pass
def disable_all(self):
self._label_opt.hide()
self._entry_opt.hide()
self._button_list.hide()
self._combo_type.hide()
self._label_type.hide()
self._entry_name.hide()
self._label_name.hide()
def load_data(self, option):
pass
def unload(self,option):
pass
class SearchWindow(BaseSearchWindow, object):
def __init__(self, load_method, notebook):
BaseSearchWindow.__init__(self)
self.load_method = load_method
self.notebook = notebook
self._create_widgets()
self._pack_widgets()
self._connect_widgets()
def _create_widgets(self):
self.vbox = HIGVBox()
self.btn_box = gtk.HButtonBox()
self.btn_open = HIGButton(stock=gtk.STOCK_OPEN)
self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE)
self.search_gui = SearchGUI(self.notebook)
def _pack_widgets(self):
BaseSearchWindow._pack_widgets(self)
self.vbox.pack_start(self.search_gui)
self.vbox.pack_start(self.btn_box)
self.btn_box.set_layout(gtk.BUTTONBOX_END)
self.btn_box.set_spacing(6)
self.btn_box.pack_start(self.btn_close)
self.btn_box.pack_start(self.btn_open)
self.add(self.vbox)
def _connect_widgets(self):
# Double click on result, opens it
self.search_gui.result_view.connect("row-activated",
self.open_selected)
self.btn_open.connect("clicked", self.open_selected)
self.btn_close.connect("clicked", self.close)
self.connect("delete-event", self.close)
def close(self, widget=None, event=None):
self.destroy()
def open_selected(self,
widget=None,
path=None,
view_column=None,
extra=None):
# This avoids dialog to be closed for no results.
if len(self.results) <= 0:
dia = HIGAlertDialog(
parent=self,
message_format=_('No results'),
secondary_text=_('No such results to be opened.'))
dia.run()
dia.destroy()
return
# Open selected results!
self.load_method(self.results)
# Close Search Window
self.close()
def get_results(self):
# Return list with parsed objects from result list store
return self.search_gui.selected_results
results = property(get_results)
