def __init__(self, option=None): OptionDisplay.__init__(self) #Profile and Wizard core self._profilecore = None self._wizardcore = None self._notebook= None self._profile = None self._wizard = None self._changed = False hbox = HIGHBox() hbox.set_border_width(12) self.delete_button = HIGButton(stock='gtk-delete') self.delete_button.connect('clicked', self.delete_option) self.new_button = HIGButton(stock='gtk-new') self.new_button.connect('clicked', self.new_option) self.update_button = HIGButton(stock='gtk-refresh') self.update_button.connect('clicked', self.update_option) self.add_button = HIGButton(stock='gtk-add') self.add_button.connect('clicked', self.add_option) hbox.pack_end(self.delete_button,False,False) hbox.pack_end(self.update_button, False, False) hbox.pack_end(self.add_button, False, False) hbox.pack_end(self.new_button, False,False) self.attach(hbox, 1,2,6,7) self.optionlist = option
class PathEntry(HIGHBox, object): def __init__(self): HIGHBox.__init__(self) self.entry = gtk.Entry() self.button = HIGButton(stock=gtk.STOCK_OPEN) self.entry.set_width_chars(20) self.button.connect("clicked", self.open_dialog) self._pack_expand_fill(self.entry) self._pack_noexpand_nofill(self.button) def connect_entry_change(self, method): self.entry.connect("focus-out-event", method) def open_dialog(self, widget): dialog = DirectoryChooserDialog(title=_("Choose the path to search in")) dialog.run() self.path = dialog.get_filename() self.entry.grab_focus() dialog.destroy() def get_path(self): return self.entry.get_text() def set_path(self, path): self.entry.set_text(path) path = property(get_path, set_path)
class OptionFile(HIGHBox, OptionWidget, object): def __init__(self, param=""): HIGHBox.__init__(self) self.entry = OptionEntry() self.button = HIGButton(stock=gtk.STOCK_OPEN) self._pack_expand_fill(self.entry) self._pack_noexpand_nofill(self.button) self.entry.set_text(param) self.button.connect('clicked', self.open_dialog_cb) def open_dialog_cb(self, widget): dialog = AllFilesFileChooserDialog(_("Choose file")) if dialog.run() == gtk.RESPONSE_OK: self.entry.set_text(dialog.get_filename()) dialog.destroy() def get_filename(self): return "\ ".join(self.entry.get_text().split(" ")) def set_filename(self, filename): self.entry.set_text(" ".join(filename.split("\ "))) filename = property(get_filename, set_filename)
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_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 __create_widgets(self): self.label = HIGAnimatedLabel(self.label_text) self.close_image = gtk.Image() self.close_image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON) self.close_button = HIGButton() self.close_button.set_size_request(22, 22) self.close_button.set_relief(gtk.RELIEF_NONE) self.close_button.set_focus_on_click(False) self.close_button.add(self.close_image) self.ok_image = gtk.Image() self.ok_image.set_from_stock(gtk.STOCK_APPLY, gtk.ICON_SIZE_BUTTON) self.ok_button = HIGButton() self.ok_button.set_size_request(22, 22) self.ok_button.set_relief(gtk.RELIEF_NONE) self.ok_button.set_focus_on_click(False) self.ok_button.add(self.ok_image) self.close_button.connect('clicked', self.__close_button_clicked) self.ok_button.connect('clicked', self.__ok_button_clicked) self.label.connect('button-press-event', self.on_button_press_event) self.label.entry.connect('focus-out-event', self.on_entry_focus_out) for w in (self.label, self.close_button, self.ok_button): self.pack_start(w, False, False, 0) self.show_all() self.switch_button_mode(False) # Change to label mode
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 __create_buttons(self): # bottom buttons self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.ok = HIGButton(stock=gtk.STOCK_OK) self.apply.connect("clicked", self._apply_settings) self.ok.connect("clicked", self._apply_settings_exit) self.cancel.connect("clicked", self._exit)
def __init__(self): HIGWindow.__init__(self) self.wtitle = _("SMTP Account Editor") # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # schemas name self.schema_name_lbl = HIGEntryLabel(_("Schema name")) self.schema_name = gtk.combo_box_entry_new_text() self.schema_name.connect('changed', self._check_schema) # smtp server self.smtp_server_lbl = HIGEntryLabel(_("Server")) self.smtp_server = gtk.Entry() self.smtp_port_lbl = HIGEntryLabel(_("Port")) self.smtp_port = gtk.Entry() # sending mail.. self.smtp_mailfrom_lbl = HIGEntryLabel(_("Mail from")) self.smtp_mailfrom = gtk.Entry() # smtp auth self.smtp_need_auth = gtk.CheckButton(_("Servers requires authentication")) self.smtp_need_auth.connect('toggled', self._auth_need) self.smtp_login_lbl = HIGEntryLabel(_("Username")) self.smtp_login = gtk.Entry() self.smtp_passwd_lbl = HIGEntryLabel(_("Password")) self.smtp_passwd = gtk.Entry() self.smtp_passwd.set_visibility(False) self._auth_need(None) # smtp encryption self.smtp_encrypt_tls = gtk.CheckButton(_("Use TLS Encryption")) """ Missing: SSL encryption, Other authentication methods. """ # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect('clicked', self._show_help) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect('clicked', self._save_schema) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect('clicked', self._exit) self.ok = HIGButton(stock=gtk.STOCK_OK) self.ok.connect('clicked', self._save_schema_and_leave) self.load_schemas() self.__set_props() self.__do_layout() self.connect('destroy', self._exit)
def __create_widgets(self): self.property_name_label = HIGEntryLabel("") self.example_label = HIGEntryLabel("") self.bold_tg_button = HIGToggleButton(" ", gtk.STOCK_BOLD) self.italic_tg_button = HIGToggleButton(" ", gtk.STOCK_ITALIC) self.underline_tg_button = HIGToggleButton(" ", gtk.STOCK_UNDERLINE) self.text_color_button = HIGButton(_("Text"), stock=gtk.STOCK_SELECT_COLOR) self.highlight_color_button = HIGButton(_("Highlight"), stock=gtk.STOCK_SELECT_COLOR)
class About(HIGWindow): def __init__(self): HIGWindow.__init__(self) self.lbl_program_version = gtk.Label( ("<span size='30000' weight='heavy'>UMIT %s</span>" % VERSION) + ("\n<span size='10000' weight='heavy'>Network Inventory ") + _("Build") + (" %s</span>" % __version__)) self.lbl_program_description = gtk.Label( _("UMIT Network Inventory and UMIT Scheduler are UMIT\n") + _("extensions developed by") + (" %s\n" % __author__) + _("and was sponsored by Google during the Summer of Code " "2007.\nThanks Google!")) self.logo_img = gtk.Image() self.logo_img.set_from_file(logo) self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.btn_close.connect('clicked', lambda x, y=None:self.destroy()) self.__set_props() self.__do_layout() def __set_props(self): """ Set widget properties. """ self.set_title(_("About UMIT Network Inventory")) self.set_position(gtk.WIN_POS_CENTER) self.lbl_program_version.set_use_markup(True) self.lbl_program_description.set_justify(gtk.JUSTIFY_CENTER) self.lbl_program_description.set_selectable(True) self.lbl_program_version.set_selectable(True) 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)
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 __create_widgets(self): """""" self.peerinfo_hbox = HIGHBox() self.cloudagg_hbox = HIGHBox() self.superpeers_hbox = HIGHBox() self.pref_location_hbox = HIGHBox() self.peerinfo_section = HIGSectionLabel(_("Peer Info")) self.peerinfo_table = HIGTable() self.pref_location_section = HIGSectionLabel(_("Preferred Locations")) self.pref_location_table = HIGTable() self.cloudagg_section = HIGSectionLabel(_("Cloud Aggregator")) self.cloudagg_table = HIGTable() self.cloudagg_subhbox = HIGHBox() self.superpeers_section = HIGSectionLabel(_("Super Peers")) self.superpeers_table = HIGTable() self.peerid_label = HIGEntryLabel(_("Peer ID:")) self.email_label = HIGEntryLabel(_("Email Address:")) self.test_version_label = HIGEntryLabel(_("Test Sets Version:")) self.peerid_label2 = HIGEntryLabel() self.email_entry = gtk.Entry() self.test_version_label2 = HIGEntryLabel() self.longitude_label = HIGLabel(_("longitude:")) self.longitude_entry = gtk.Entry() self.latitude_label = HIGLabel(_("latitude:")) self.latitude_entry = gtk.Entry() self.cloudagg_entry = gtk.Entry() self.cloudagg_button = HIGButton(_("Reset")) self.cloudagg_button.connect('clicked', lambda w: self.reset_aggregator_url()) self.cloudagg_button.set_size_request(80, 28) self.superpeers_ip_label = HIGLabel(_("IP:")) self.superpeers_ip_entry = gtk.Entry() self.superpeers_ip_entry.set_size_request(160, 26) self.superpeers_port_label = HIGLabel(_("Port:")) self.superpeers_port_entry = gtk.Entry() self.superpeers_port_entry.set_size_request(80, 26) self.superpeers_subhbox = HIGHBox() self.btn_box = gtk.HButtonBox() self.superpeers_button1 = HIGButton(_("Add")) self.superpeers_button1.connect('clicked',lambda w:self.add_superpeer()) self.superpeers_button2 = HIGButton(_("Show all")) self.superpeers_button2.connect('clicked', lambda w: self.show_super_peer_list_window())
class TimeBox(gtk.HBox): """ GUI Controls for handling Timeline date visualization. """ def __init__(self, connector, tlbase): gtk.HBox.__init__(self) self.connector = connector self.tlbase = tlbase self.connector.connect('date-changed', self._update_current_date) # viewing by cur_mode = view_mode_descr[self.tlbase.graph_mode] self.dateselect_lbl = HIGEntryLabel(cur_mode) values = self.tlbase.bounds_by_graphmode() self.dateselect = gtk.SpinButton(gtk.Adjustment(value=values[2], lower=values[0], upper=values[1], step_incr=1), 1) self.dateselect_apply = HIGButton(stock=gtk.STOCK_APPLY) self.dateselect_apply.connect("clicked", self._date_change) self.__layout() def _date_change(self, event): """ Sends new date. """ self.connector.emit('date-update', self.dateselect.get_value_as_int()) def _update_current_date(self, event): """ Update spinbutton and values based on new date. """ cur_mode = view_mode_descr[self.tlbase.graph_mode] self.dateselect_lbl.set_label(cur_mode) values = self.tlbase.bounds_by_graphmode() self.dateselect.set_range(values[0], values[1]) self.dateselect.set_value(values[2]) def __layout(self): """ Layout widgets. """ self.pack_start(self.dateselect_lbl, False, False, 0) self.pack_start(self.dateselect, False, False, 0) self.pack_start(self.dateselect_apply, False, False, 0)
def __create_widgets(self): self.set_spacing(4) self.richlist = HIGRichList() self.hbbox = gtk.HButtonBox() self.hbbox.set_layout(gtk.BUTTONBOX_END) self.find_updates_btn = \ HIGButton(_('Find updates'), gtk.STOCK_REFRESH) self.install_updates_btn = \ HIGButton(_('Install updates'), gtk.STOCK_APPLY) self.skip_install_btn = \ HIGButton(_('Skip'), gtk.STOCK_CANCEL) self.restart_btn = \ HIGButton(_('Restart UMIT'), gtk.STOCK_REFRESH)
def __init__(self, type_ = None, path = None): if type_ and path: title = _("Edit Source") else: type_ = "FILE" path = "" title = _("Add Source") HIGDialog.__init__(self, title, None, gtk.DIALOG_MODAL, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) hbox = HIGHBox() self.combo = gtk.combo_box_new_text() types = sorted(self.types.keys()) for t in types: self.combo.append_text(t) self.combo.set_active(types.index(type_)) self.combo.connect("changed", self._changed_cb) hbox.pack_start(self.combo, False, False) self.entry = HIGTextEntry() self.entry.set_text(path) hbox.pack_start(self.entry) self.btn = HIGButton(_("Browse..."), stock=gtk.STOCK_OPEN) self.btn.connect("clicked", self._clicked_cb) hbox.pack_start(self.btn, False, False) self.vbox.add(hbox) self.show_all() self.update()
def __create_widgets(self): self.vbox = HIGVBox() self.hbox = HIGHBox() self.notebook = HIGNotebook() self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.written_by_scroll = HIGScrolledWindow() self.written_by_text = HIGTextView() self.design_scroll = HIGScrolledWindow() self.design_text = HIGTextView() self.soc2007_scroll = HIGScrolledWindow() self.soc2007_text = HIGTextView() self.soc2008_scroll = HIGScrolledWindow() self.soc2008_text = HIGTextView() self.soc2009_scroll = HIGScrolledWindow() self.soc2009_text = HIGTextView() self.contributors_scroll = HIGScrolledWindow() self.contributors_text = HIGTextView() self.translation_scroll = HIGScrolledWindow() self.translation_text = HIGTextView() self.nokia_scroll = HIGScrolledWindow() self.nokia_text = HIGTextView()
def create_and_attach_widgets(self): self.option_label = HIGSectionLabel('New Option') self.attach(self.option_label, 0, 3, 0, 1) self.name_label = HIGEntryLabel(_('Name:')) self.name_entry = HIGTextEntry() self.attach(self.name_label, 0,1,1,2) self.attach(self.name_entry, 1,3,1,2) self.hint_label = HIGEntryLabel(_('Hint:')) self.hint_entry = HIGTextEntry() self.attach(self.hint_label, 0,1,2,3) self.attach(self.hint_entry,1,3,2,3) self.need_root = gtk.CheckButton(_('Need root')) self.attach(self.need_root, 0,1,3,4) self.options_label = HIGEntryLabel(_('Options:')) hbox = HIGHBox() self.options_entry = HIGTextEntry() self.insert_arg_button = HIGButton(title='Args', stock='gtk-add') self.insert_arg_button.connect('clicked', self.update_args) self.attach(self.options_label,0,1,4,5) self.attach(self.options_entry, 1,2,4,5) self.attach(self.insert_arg_button, 2,3, 4, 5) self.aguments_label = HIGEntryLabel(_('Arguments:')) self.arguments_entry = HIGTextEntry() self.arguments_entry.set_editable(False) self.attach(self.aguments_label, 0,1, 5,6) self.attach(self.arguments_entry, 1,3,5,6)
def __create_widgets(self): self.image = gtk.image_new_from_pixbuf(self._reader.get_logo()) self.label = gtk.Label('') self.label.set_ellipsize(pango.ELLIPSIZE_END) self.versions_model = gtk.ListStore(str, str) self.versions_button = gtk.ComboBox(self.versions_model) rend = gtk.CellRendererPixbuf() self.versions_button.pack_start(rend, False) self.versions_button.add_attribute(rend, 'stock-id', 0) rend = gtk.CellRendererText() self.versions_button.pack_end(rend) self.versions_button.add_attribute(rend, 'text', 1) self.img_play = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, \ gtk.ICON_SIZE_BUTTON) self.img_stop = gtk.image_new_from_stock(gtk.STOCK_MEDIA_STOP, \ gtk.ICON_SIZE_BUTTON) self.action_btn = HIGButton('') self.uninstall_btn = HIGButton(_("Uninstall"), gtk.STOCK_CLEAR) self.preference_btn = HIGButton(stock=gtk.STOCK_PREFERENCES) self.progressbar = gtk.ProgressBar()
def __init__(self, daddy, profile=None): HIGWindow.__init__(self) self.daddy = daddy self.wtitle = _("Scheduling Profiles Editor") self.start_profile = profile # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # profiles name self.schedp_name_lbl = HIGEntryLabel(_("Scheduling Profile")) self.schedp_name = gtk.combo_box_entry_new_text() self.schedp_name.connect("changed", self._check_profile) # cron format self.cron_frame = HIGFrame(_("Schedule")) self.cron_minute_lbl = HIGEntryLabel(_("Minute")) self.cron_minute = gtk.Entry() self.cron_hour_lbl = HIGEntryLabel(_("Hour")) self.cron_hour = gtk.Entry() self.cron_day_lbl = HIGEntryLabel(_("Day of month")) self.cron_day = gtk.Entry() self.cron_month_lbl = HIGEntryLabel(_("Month")) self.cron_month = gtk.Entry() self.cron_weekday_lbl = HIGEntryLabel(_("Weekday")) self.cron_weekday = gtk.Entry() # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect("clicked", self._show_help) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect("clicked", self._save_profile) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect("clicked", self._exit) self.ok = HIGButton(stock=gtk.STOCK_OK) self.ok.connect("clicked", self._save_profile_and_leave) self.load_profiles() self.__set_props() self.__do_layout() self.connect("destroy", self._exit)
def __create_widgets (self): # Creating widgets self.scrolled = gtk.ScrolledWindow () self.text_view = gtk.TextView () self.btn_refresh = gtk.Button (stock=gtk.STOCK_REFRESH) self.check_enable_color = gtk.CheckButton(\ _("Enable Nmap output highlight")) self.btn_output_properties = HIGButton(stock=gtk.STOCK_PREFERENCES) self.hbox_buttons = gtk.HBox (spacing=5)
def __init__(self): HIGHBox.__init__(self) self.entry = gtk.Entry() self.button = HIGButton(stock=gtk.STOCK_OPEN) self.entry.set_width_chars(20) self.button.connect("clicked", self.open_dialog) self._pack_expand_fill(self.entry) self._pack_noexpand_nofill(self.button)
def __init__(self, param=""): HIGHBox.__init__(self) self.entry = OptionEntry() self.button = HIGButton(stock=gtk.STOCK_OPEN) self._pack_expand_fill(self.entry) self._pack_noexpand_nofill(self.button) self.entry.set_text(param) self.button.connect('clicked', self.open_dialog_cb)
def __init__(self): HIGWindow.__init__(self) self.tooltips = gtk.Tooltips() self.data_lbl = HIGSectionLabel(_("Delete data older than")) self.days_lbl = HIGSectionLabel(_("days")) self.days = gtk.SpinButton(gtk.Adjustment(value=get_decays()[1], lower=0, upper=5000, step_incr=1), 1) self.tooltips.set_tip(self.days, _("Set value as 0 to disable data removal")) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.cancel.connect("clicked", self._exit) self.apply.connect("clicked", self._set_new_decay) self.__set_props() self.__do_layout()
def __create_widgets(self): self.main_vbox = HIGVBox() self.command_expander = HIGExpander('<b>'+_('Command')+'</b>') self.command_expander.set_expanded(True) self.command_entry = gtk.Entry() self.notebook = gtk.Notebook() # Profile info page self.profile_info_vbox = HIGVBox() self.profile_info_label = HIGSectionLabel(_('Profile Information')) self.profile_name_label = HIGEntryLabel(_('Profile name')) self.profile_name_entry = gtk.Entry() self.profile_hint_label = HIGEntryLabel(_('Hint')) self.profile_hint_entry = gtk.Entry() self.profile_description_label = HIGEntryLabel(_('Description')) #self.profile_description_label = HIGHBox() self.profile_description_scroll = HIGScrolledWindow() self.profile_description_text = HIGTextView() self.profile_annotation_label = HIGEntryLabel(_('Annotation')) #self.profile_annotation_label = HIGHBox() self.profile_annotation_scroll = HIGScrolledWindow() self.profile_annotation_text = HIGTextView() # Buttons self.buttons_hbox = HIGHBox() self.help_button = HIGButton(stock=gtk.STOCK_HELP) self.help_button.connect('clicked', self.help) #self.delete_button = HIGButton(stock=gtk.STOCK_DELETE) #self.delete_button.connect('clicked', self.delete_profile) self.cancel_button = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel_button.connect('clicked', self.quit_without_saving) self.ok_button = HIGButton(stock=gtk.STOCK_OK) self.ok_button.connect('clicked', self.save_profile)
def _create_widgets(self): self.main_vbox = HIGVBox() self.hbox_mode = HIGHBox() self.hbox_settings = HIGHBox() self.hbox_buttons = HIGHBox() self.hbox_result = HIGHBox() self.btn_open_browser = HIGButton(_("Open in Browser"), stock=gtk.STOCK_EXECUTE) self.btn_help = HIGButton(stock=gtk.STOCK_HELP) self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.check_color = gtk.CheckButton(_("Enable colored diffies")) self.btn_legend = HIGButton(_("Color Descriptions"), stock=gtk.STOCK_SELECT_COLOR) self.text_mode = gtk.ToggleButton(_("Text Mode")) self.compare_mode = gtk.ToggleButton(_("Compare Mode")) self.vpaned = gtk.VPaned() self.hpaned = gtk.HPaned() self.scan_chooser1 = ScanChooser(self.scans, "1") self.scan_chooser2 = ScanChooser(self.scans, "2") self.scan_buffer1 = self.scan_chooser1.get_buffer() self.scan_buffer2 = self.scan_chooser2.get_buffer()
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_widgets(self): t = localtime() self.date_button = HIGButton() self.date_sep = gtk.Label(", ") self.hour = gtk.SpinButton(gtk.Adjustment(value=t[3], lower=0, upper=23, step_incr=1), 1) self.hour_sep = gtk.Label(":") self.minute = gtk.SpinButton(gtk.Adjustment(value=t[4], lower=0, upper=59, step_incr=1), 1)
def _draw_buttons(self): self.button_list = HIGButton('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.drag_source_set(gtk.gdk.BUTTON1_MASK , target, gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE) self.button_list.connect('drag_data_get', self._drag_option_list) self.button_label = HIGButton('Label') img = gtk.Image() img_dir = os.path.join(pixmaps_dir,'uie', 'label.png') img.set_from_file(img_dir) self.button_label.set_image(img) self.button_label.drag_source_set(gtk.gdk.BUTTON1_MASK , target, gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE) self.button_label.connect('drag_data_get', self.source_drag_data_get) self.button_check = HIGButton('Option Check') img = gtk.Image() img_dir = os.path.join(pixmaps_dir, 'uie', 'checkbutton.png') img.set_from_file(img_dir) self.button_check.set_image(img) self.button_path = HIGButton('Choose Path') self.button_text_entry = HIGButton('String') img = gtk.Image() img_dir = os.path.join(pixmaps_dir,'uie', 'entry.png') img.set_from_file(img_dir) self.button_text_entry.set_image(img) self.button_float = HIGButton('Float Spin') img = gtk.Image() img_dir = os.path.join(pixmaps_dir, 'uie', 'spinbutton.png') img.set_from_file(img_dir) self.button_float.set_image(img) self.button_level = HIGButton('Level Spin') img = gtk.Image() img_dir = os.path.join(pixmaps_dir, 'uie', 'spinbutton.png') img.set_from_file(img_dir) self.button_level.set_image(img) self.button_interface = HIGButton('Interface') self.button_integer = HIGButton('Integer Spin ') img = gtk.Image() img_dir = os.path.join(pixmaps_dir, 'uie', 'spinbutton.png') img.set_from_file(img_dir) self.button_integer.set_image(img)
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)
class PeerInfoPage(HIGVBox): """""" #---------------------------------------------------------------------- def __init__(self): """Constructor""" HIGVBox.__init__(self) self.__create_widgets() self.__pack_widgets() def __create_widgets(self): """""" self.peerinfo_hbox = HIGHBox() self.cloudagg_hbox = HIGHBox() self.superpeers_hbox = HIGHBox() self.pref_location_hbox = HIGHBox() self.peerinfo_section = HIGSectionLabel(_("Peer Info")) self.peerinfo_table = HIGTable() self.pref_location_section = HIGSectionLabel(_("Preferred Locations")) self.pref_location_table = HIGTable() self.cloudagg_section = HIGSectionLabel(_("Cloud Aggregator")) self.cloudagg_table = HIGTable() self.cloudagg_subhbox = HIGHBox() self.superpeers_section = HIGSectionLabel(_("Super Peers")) self.superpeers_table = HIGTable() self.peerid_label = HIGEntryLabel(_("Peer ID:")) self.email_label = HIGEntryLabel(_("Email Address:")) self.test_version_label = HIGEntryLabel(_("Test Sets Version:")) self.peerid_label2 = HIGEntryLabel() self.email_entry = gtk.Entry() self.test_version_label2 = HIGEntryLabel() self.longitude_label = HIGLabel(_("longitude:")) self.longitude_entry = gtk.Entry() self.latitude_label = HIGLabel(_("latitude:")) self.latitude_entry = gtk.Entry() self.cloudagg_entry = gtk.Entry() self.cloudagg_button = HIGButton(_("Reset")) self.cloudagg_button.connect('clicked', lambda w: self.reset_aggregator_url()) self.cloudagg_button.set_size_request(80, 28) self.superpeers_ip_label = HIGLabel(_("IP:")) self.superpeers_ip_entry = gtk.Entry() self.superpeers_ip_entry.set_size_request(160, 26) self.superpeers_port_label = HIGLabel(_("Port:")) self.superpeers_port_entry = gtk.Entry() self.superpeers_port_entry.set_size_request(80, 26) self.superpeers_subhbox = HIGHBox() self.btn_box = gtk.HButtonBox() self.superpeers_button1 = HIGButton(_("Add")) self.superpeers_button1.connect('clicked', lambda w: self.add_superpeer()) self.superpeers_button2 = HIGButton(_("Show all")) self.superpeers_button2.connect( 'clicked', lambda w: self.show_super_peer_list_window()) def __pack_widgets(self): self.set_border_width(12) self._pack_noexpand_nofill(self.peerinfo_section) self._pack_noexpand_nofill(self.peerinfo_hbox) self._pack_noexpand_nofill(self.pref_location_section) self._pack_noexpand_nofill(self.pref_location_hbox) self._pack_noexpand_nofill(self.cloudagg_section) self._pack_noexpand_nofill(self.cloudagg_hbox) self._pack_noexpand_nofill(self.superpeers_section) self._pack_noexpand_nofill(self.superpeers_hbox) self.peerinfo_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.peerinfo_hbox._pack_expand_fill(self.peerinfo_table) self.pref_location_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.pref_location_hbox._pack_expand_fill(self.pref_location_table) self.cloudagg_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.cloudagg_hbox._pack_expand_fill(self.cloudagg_table) self.superpeers_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.superpeers_hbox._pack_expand_fill(self.superpeers_table) self.peerinfo_table.attach_label(self.peerid_label, 0, 1, 0, 1) self.peerinfo_table.attach_label(self.email_label, 0, 1, 2, 3) self.peerinfo_table.attach_label(self.test_version_label, 0, 1, 1, 2) self.peerinfo_table.attach_label(self.test_version_label2, 1, 2, 1, 2) self.peerinfo_table.attach_label(self.peerid_label2, 1, 2, 0, 1) self.peerinfo_table.attach_entry(self.email_entry, 1, 2, 2, 3) self.pref_location_table.attach(self.longitude_label, 0, 1, 0, 1) self.pref_location_table.attach(self.longitude_entry, 1, 2, 0, 1) self.pref_location_table.attach(self.latitude_label, 2, 3, 0, 1) self.pref_location_table.attach(self.latitude_entry, 3, 4, 0, 1) self.cloudagg_subhbox._pack_expand_fill(self.cloudagg_entry) self.cloudagg_subhbox._pack_noexpand_nofill(self.cloudagg_button) self.cloudagg_table.attach_entry(self.cloudagg_subhbox, 0, 1, 0, 1) self.btn_box.set_layout(gtk.BUTTONBOX_END) self.btn_box.set_spacing(8) self.btn_box.pack_start(self.superpeers_button1) self.btn_box.pack_start(self.superpeers_button2) self.superpeers_subhbox._pack_expand_fill(self.superpeers_ip_label) self.superpeers_subhbox._pack_expand_fill(self.superpeers_ip_entry) self.superpeers_subhbox._pack_expand_fill(self.superpeers_port_label) self.superpeers_subhbox._pack_expand_fill(self.superpeers_port_entry) self.superpeers_subhbox._pack_noexpand_nofill(self.btn_box) self.superpeers_table.attach_label(self.superpeers_subhbox, 0, 1, 0, 1) def add_superpeer(self): """ Add Super Peer by manual into database """ ip = self.superpeers_ip_entry.get_text() port = self.superpeers_port_entry.get_text() g_db_helper.set_super_peer_manual(ip, port) def reset_aggregator_url(self): """ """ aggregator_url = 'http://east1.openmonitor.org' self.cloudagg_entry.set_text(aggregator_url) theApp.aggregator.base_url = aggregator_url g_config.set('network', 'aggregator_url', aggregator_url) g_db_helper.set_value('config', 'aggregator_url', aggregator_url) def show_super_peer_list_window(self): from umit.icm.agent.gui.Preference.SuperPeerSetting import SuperPeerListWindow, SuperPeersBox wnd = SuperPeerListWindow() wnd.show_all()
class GeneralSettings(TabBox, object): """ General Settings - Splash enable/disable - Warnings - Erros, log, configure bugreport - Autosave: clean up, define folder etc - Define Nmap Command """ def __init__(self, name): TabBox.__init__(self, name) def _create_widgets(self): """ Design all """ # Create general widgets self._create_widgets_common() self._create_widgets_autosave() self._create_widgets_error() # Packing main section self.pack_start(self._box_common, False, False) self.pack_start(self._box_error_frame, False, False) self.pack_start(self._box_save_frame, False, False) self._box_error_frame.set_shadow_type(gtk.SHADOW_NONE) self._box_error_frame.set_shadow_type(gtk.SHADOW_NONE) # Settings Values self.splash = general_settings.splash self.warnings_extensions = general_settings.warnings_extensions self.silent_root = general_settings.silent_root self.crash_report = general_settings.crash_report self.log = general_settings.log self.log_file = general_settings.log_file self.warnings_save = general_settings.warnings_save self._connect_events() def _create_widgets_common(self): """ generally tab """ self._box_common = HIGVBox() # pack main section self.__check_splash = gtk.CheckButton(_('Enable Splash on start')) self.__check_silent_root = gtk.CheckButton(\ _('Silent Warning Non-Root')) self.__check_warning_extensions = gtk.CheckButton(\ _('Set/Check extensions - Windows only')) self._box_common.pack_start(self.__check_splash, False, False) #self._box_common.pack_start(self.__check_warning_extensions, False, \ # False) self._box_common.pack_start(self.__check_silent_root, False, False) self.__label_nmap = HIGEntryLabel(_('Nmap Command')) self.__entry_nmap = HIGTextEntry() # Files usr saved on predefined directory: self.__label_path = HIGEntryLabel(_('Nmap Command')) self.__entry_path = HIGTextEntry() self.__button_path = HIGButton(_('Choose')) self.__box_path = HIGHBox() self.__box_path.pack_start(self.__label_path, False, False) self.__box_path.pack_end(self.__button_path, False, False) self._box_common.set_border_width(0) def _create_widgets_error(self): # Create Widgets self._box_error_frame = HIGFrame('Error') self._box_error = HIGTable(5, 2) self._box_error.set_border_width(10) self._box_error_frame.add(self._box_error) self.__crash_report = gtk.CheckButton(_('Enable Crash Report')) # Radio Button List self.__log_no = gtk.RadioButton(None, _('No log')) self.__log_terminal = gtk.RadioButton(self.__log_no, _('Enable log in terminal')) self.__log_file = gtk.RadioButton(self.__log_terminal,\ _('Enable log file')) self.__log_file_label = HIGEntryLabel(_('Log file')) self.__log_file_entry = HIGTextEntry() self.__log_file_entry.set_editable(False) # FIXME: Do default file ~/.umit/umit.log self.__log_file_browser = HIGButton(_('Browse file'), \ gtk.STOCK_DIRECTORY) tmpbox = HIGHBox() tmpbox.pack_start(self.__log_file_entry, False, False) tmpbox.pack_start(self.__log_file_browser, False, False) # attach table self._box_error.attach(self.__crash_report, 0,1,0,1,\ gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL) self._box_error.attach(self.__log_no, 0,1,1,2,\ gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL) self._box_error.attach(self.__log_terminal, 0,1,2,3,\ gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL) self._box_error.attach(self.__log_file, 0,1,3,4,\ gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL) self._box_error.attach(self.__log_file_label, 0,1,4,5,\ gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL) self._box_error.attach(tmpbox, 1,2,4,5,\ gtk.FILL|gtk.EXPAND| gtk.SHRINK, gtk.FILL) def _create_widgets_autosave(self): # Create Widgets self._box_save_frame = HIGFrame('Auto-save') self._box_save = HIGVBox() self._box_save_frame.add(self._box_save) self._box_save.set_border_width(10) self._warnings_save = gtk.CheckButton( _('Enable warnings without saving')) self._clean_b = HIGButton(_('Delete saved files'), gtk.STOCK_CLEAR) self._clean_b_box = HIGHBox() self._clean_b_box.pack_start(self._clean_b, False, True) # pack self._box_save.pack_start(self._warnings_save, False, False) self._box_save.pack_start(self._clean_b_box, False, False) def _connect_events(self): """ connect call backs """ self.__check_splash.connect('toggled', self.update_splash) self.__check_silent_root.connect('toggled', self.update_silent_root) self.__crash_report.connect('toggled', self.update_crash_report) self.__log_file.connect('toggled', self.update_log) self.__log_file.connect('toggled', self.update_log_file) self.__log_terminal.connect('toggled', self.update_log) self.__log_no.connect('toggled', self.update_log) self.__log_file_browser.connect('clicked', self.read_file) self.__log_file_entry.connect('changed', self.update_log_file_text) self._warnings_save.connect('toggled', self.update_save_warn) self._clean_b.connect('clicked', self.delete_files) self.update_log_file(None) # Callbacks def delete_files(self, widget): # NOTE: This method should be adapted in umit.core.UserConf # Creating an empty recent_scans file log.debug('>>> Reset store files: - %s' % base_paths['user_dir']) reset_user_dir(base_paths['user_dir']) def update_save_warn(self, widget): general_settings.warnings_save = self.warnings_save def read_file(self, widget): dialog = gtk.FileChooserDialog("Open..", None, gtk.FILE_CHOOSER_ACTION_SAVE, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE_AS, gtk.RESPONSE_OK)) dialog.set_default_response(gtk.RESPONSE_OK) response = dialog.run() if response == gtk.RESPONSE_OK: # Get name of file self.__log_file_entry.set_text(dialog.get_filename()) dialog.destroy() def update_crash_report(self, widget): general_settings.crash_report = self.crash_report def update_splash(self, widget): general_settings.splash = self.splash def update_silent_root(self, widget): general_settings.silent_root = self.silent_root def update_log_file_text(self, widget): general_settings.log_file = self.log_file def update_log_file(self, widget): if not self.__log_file.get_active(): self.__log_file_active(False) else: self.__log_file_active(True) def update_log(self, widget): """ Verify if is enable, if it is not enable nothing to do """ if not widget.get_active(): return # Widget is enable. ## But which is enable? # Setting kind of log if widget == self.__log_no: general_settings.log = "None" elif widget == self.__log_terminal: general_settings.log = "Debug" elif widget == self.__log_file: general_settings.log = "File" # API def get_splash(self): return self.__check_splash.get_active() def set_splash(self, splash): self.__check_splash.set_active(splash) def set_warnings_extensions(self, extensions): self.__check_warning_extensions.set_active(extensions) def get_warnings_extensions(self): return self.__check_warning_extensions.get_active() def set_silent_root(self, root): self.__check_silent_root.set_active(root) def get_silent_root(self): return self.__check_silent_root.get_active() def set_crash_report(self, crash): self.__crash_report.set_active(crash) def get_crash_report(self): return self.__crash_report.get_active() def get_log(self): """ filter a str with None, Debug or File return: int (means 0 - No debug, 1 - debug, 2 - debug file) """ if self.__log_no.get_active(): return "None" elif self.__log_terminal.get_active(): return "Debug" elif self.__log_file.get_active(): return "File" else: raise LogException() def set_log(self, log): if log == "None": self.__log_no.set_active(True) elif log == "Debug": self.__log_terminal.set_active(True) elif log == "File": self.__log_file.set_active(True) def __log_file_active(self, bool): self.__log_file_label.set_sensitive(bool) self.__log_file_entry.set_sensitive(bool) self.__log_file_browser.set_sensitive(bool) def set_log_file(self, filename): self.__log_file_entry.set_text(filename) def get_log_file(self): return self.__log_file_entry.get_text() def set_warnings_save(self, save): self._warnings_save.set_active(save) def get_warnings_save(self): return self._warnings_save.get_active() # Propertys splash = property(get_splash, set_splash) warnings_extensions = property(get_warnings_extensions, \ set_warnings_extensions) silent_root = property(get_silent_root, set_silent_root) crash_report = property(get_crash_report, set_crash_report) log = property(get_log, set_log) log_file = property(get_log_file, set_log_file) warnings_save = property(get_warnings_save, set_warnings_save)
class ConfigureDataRemoval(HIGWindow): """ Sets for how long to keep Inventory data. """ def __init__(self): HIGWindow.__init__(self) self.tooltips = gtk.Tooltips() self.data_lbl = HIGSectionLabel(_("Delete data older than")) self.days_lbl = HIGSectionLabel(_("days")) self.days = gtk.SpinButton( gtk.Adjustment(value=get_decays()[1], lower=0, upper=5000, step_incr=1), 1) self.tooltips.set_tip(self.days, _("Set value as 0 to disable data removal")) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.cancel.connect("clicked", self._exit) self.apply.connect("clicked", self._set_new_decay) self.__set_props() self.__do_layout() def _set_new_decay(self, event): """ Set new decay value for inventories in config file. """ set_decay("inventory_decay", self.days.get_value_as_int()) self._exit(None) def _exit(self, event): """ Destroy window. """ self.destroy() def __set_props(self): """ Window properties. """ self.set_title(_("Configure Inventory Data Removal")) def __do_layout(self): """ Layout window widgets. """ main_vbox = HIGVBox() days_box = HIGHBox() btns_box = HIGHBox() days_box._pack_noexpand_nofill(self.data_lbl) days_box._pack_expand_fill(self.days) days_box._pack_noexpand_nofill(self.days_lbl) btns_box.pack_end(self.apply, False, False, 0) btns_box.pack_end(self.cancel, False, False, 0) main_vbox._pack_noexpand_nofill(days_box) main_vbox.pack_end(btns_box, False, False, 0) self.add(main_vbox)
def _create_widgets(self): # Main widgets self.hpaned = gtk.HPaned() self.main_vbox = HIGVBox() # Results section self.result_section = HIGSectionLabel(_("Results")) self.result_vbox = HIGVBox() self.result_hbox = HIGHBox() self.result_list = gtk.ListStore(str, str, int) # title, date, id self.result_view = gtk.TreeView(self.result_list) self.result_scrolled = gtk.ScrolledWindow() self.result_title_column = gtk.TreeViewColumn(_("Scan")) self.result_date_column = gtk.TreeViewColumn(_("Date")) # Search notebook self.search_vbox = HIGVBox() self.search_notebook = gtk.Notebook() self.search_button = HIGButton(stock=gtk.STOCK_FIND) # General page self.general_vbox = HIGVBox() self.general_hbox = HIGHBox() #self.general_start_hbox = HIGHBox() #self.general_finish_hbox = HIGHBox() self.general_section = HIGSectionLabel(_("General search parameters")) self.general_table = HIGTable() self.general_option_label = HIGEntryLabel(_("Option")) self.general_profile_label = HIGEntryLabel(_("Profile")) #self.general_finished_label = HIGEntryLabel(_("Finished")) #self.general_started_label = HIGEntryLabel(_("Started")) self.general_keyword_label = HIGEntryLabel(_("Keyword")) self.general_keyword_entry = gtk.Entry() self.general_option_combo = OptionCombo() self.general_profile_combo = ProfileCombo() #self.general_started_range = DateRange() #self.general_finished_range = DateRange() # Host page self.host_vbox = HIGVBox() self.host_hbox = HIGHBox() #self.host_uptime_hbox = HIGHBox() #self.host_lastboot_hbox = HIGHBox() self.host_section = HIGSectionLabel(_("Host search parameters")) self.host_table = HIGTable() self.host_target_label = HIGEntryLabel(_("Target")) self.host_mac_label = HIGEntryLabel(_("MAC")) self.host_ipv4_label = HIGEntryLabel(_("IPv4")) self.host_ipv6_label = HIGEntryLabel(_("IPv6")) #self.host_uptime_label = HIGEntryLabel(_("Uptime")) #self.host_lastboot_label = HIGEntryLabel(_("Last boot")) self.host_target_combo = TargetCombo() self.host_mac_entry = gtk.Entry() self.host_ipv4_entry = gtk.Entry() self.host_ipv6_entry = gtk.Entry() #self.host_uptime_range = DateRange() #self.host_lastboot_range = DateRange() # Service self.serv_vbox = HIGVBox() self.serv_hbox = HIGHBox() self.serv_section = HIGSectionLabel(_("Service search parameters")) self.serv_table = HIGTable() self.serv_port_label = HIGEntryLabel(_("Port number")) self.serv_service_label = HIGEntryLabel(_("Service")) self.serv_product_label = HIGEntryLabel(_("Product")) self.serv_portstate_label = HIGEntryLabel(_("Port state")) self.serv_port_entry = gtk.Entry() self.serv_service_combo = ServiceCombo() self.serv_product_entry = gtk.Entry() self.serv_portstate_check = PortState() # OS self.os_vbox = HIGVBox() self.os_hbox = HIGHBox() self.os_section = HIGSectionLabel(_("Operating System search \ parameters")) self.os_table = HIGTable() self.os_osclass_label = HIGEntryLabel(_("OS class")) self.os_osmatch_label = HIGEntryLabel(_("OS match")) self.os_osclass_combo = OSClassCombo() self.os_osmatch_combo = OSMatchCombo() # Search options page self.opt_vbox = HIGVBox() self.opt_local_hbox = HIGHBox() self.opt_base_hbox = HIGHBox() self.opt_local_section = HIGSectionLabel(_("Local files")) self.opt_local_table = HIGTable() self.opt_base_section = HIGSectionLabel(_("Database")) self.opt_base_table = HIGTable() self.opt_path_label = HIGEntryLabel(_("Directory")) self.opt_extension_label = HIGEntryLabel(_("File extension")) self.opt_savetime_label = HIGEntryLabel(_("Save results for")) self.opt_path_entry = PathEntry() self.opt_extension_entry = gtk.Entry() self.opt_savetime_entry = SaveTime() self.opt_save_check = gtk.CheckButton(_("Save scan results in data \ base for latter search")) self.opt_search_check = gtk.CheckButton(_("Search saved scan results \ in data base"))
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()
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 PluginPage(gtk.VBox): def __init__(self, parent): gtk.VBox.__init__(self, False, 2) self.p_window = parent self.menu_enabled = True self.__create_widgets() self.__pack_widgets() self.install_updates_btn.hide() def __create_widgets(self): self.set_spacing(4) self.richlist = HIGRichList() self.hbbox = gtk.HButtonBox() self.hbbox.set_layout(gtk.BUTTONBOX_END) self.find_updates_btn = \ HIGButton(_('Find updates'), gtk.STOCK_REFRESH) self.install_updates_btn = \ HIGButton(_('Install updates'), gtk.STOCK_APPLY) self.skip_install_btn = \ HIGButton(_('Skip'), gtk.STOCK_CANCEL) self.restart_btn = \ HIGButton(_('Restart UMIT'), gtk.STOCK_REFRESH) def __pack_widgets(self): self.hbbox.pack_start(self.find_updates_btn) self.hbbox.pack_start(self.skip_install_btn) self.hbbox.pack_start(self.install_updates_btn) self.hbbox.pack_start(self.restart_btn) self.pack_start(self.richlist) self.pack_start(self.hbbox, False, False, 0) self.find_updates_btn.connect('clicked', self.__on_find_updates) self.install_updates_btn.connect('clicked', self.__on_install_updates) self.skip_install_btn.connect('clicked', self.__on_skip_updates) self.restart_btn.connect('clicked', self.__on_restart) self.show_all() def clear(self, include_loaded=True): if include_loaded: self.richlist.clear() return def remove(row, richlist): if not row.reader.enabled: richlist.remove_row(row) self.richlist.foreach(remove, self.richlist) return self.richlist.get_rows() def populate(self): "Populate the richlist using available_plugins field" # We need a list of present plugin row to check for dup presents = [] def add_to_list(row, list): list.append(row) self.richlist.foreach(add_to_list, presents) warn_reboot = False # We have to load available_plugins from engine for reader in self.p_window.engine.available_plugins: # Check if it's already present then remove the original # and add the new in case something is getting update. row = PluginRow(self.richlist, reader) for old in presents: # FIXME? we need to check also for version equality # and if are different just ignore the addition and # continue with the loop if old.reader.get_path() == row.reader.get_path(): self.richlist.remove_row(old) row.enabled = True warn_reboot = True # Connect the various buttons row.action_btn.connect('clicked', self.__on_row_action, row) row.uninstall_btn.connect('clicked', self.__on_row_uninstall, row) row.preference_btn.connect('clicked', self.__on_row_preference, row) row.connect('clicked', self.__on_row_preference, row) row.connect('popup', self.__on_row_popup) self.richlist.append_row(row) if warn_reboot: # Warn the user self.p_window.animated_bar.label = \ _('Remember that you have to restart UMIT to make new version' \ ' of plugins to be loaded correctly.') self.p_window.animated_bar.start_animation(True) def __on_restart(self, widget): "Called when the user click on the restart button" Core().mainwindow.emit('delete-event', None) def __on_skip_updates(self, widget): "Called when the user click on the skip button" # We need to repopulate the tree self.richlist.clear() self.populate() self.p_window.toolbar.unset_status() if self.restart_btn.flags() & gtk.VISIBLE: # That callback is called from a self.___on_install_updates self.restart_btn.hide() self.p_window.animated_bar.label = \ _('Rembember to restart UMIT to use new version of plugins.') else: self.p_window.animated_bar.label = \ _('Update skipped') self.p_window.animated_bar.start_animation(True) self.skip_install_btn.hide() self.install_updates_btn.hide() self.find_updates_btn.show() self.menu_enabled = True def __on_install_updates(self, widget): """ Called when the user click on 'install updates' button This function call the start_download() of UpdateEngine and then add a timeout callback (__refresh_row_download) to update the gui at interval of 300 milliseconds. """ lst = [] for obj in self.p_window.update_eng.list: if obj.status != LATEST_GETTED: self.richlist.remove_row(obj.object) continue if obj.object.show_include: lst.append(obj) obj.object.show_include = False # Reset indexes obj.last_update_idx = 0 obj.selected_update_idx = obj.object.versions_button.get_active()-1 self.install_updates_btn.set_sensitive(False) self.skip_install_btn.set_sensitive(False) self.p_window.update_eng.list = lst self.p_window.update_eng.start_download() self.p_window.toolbar.show_message( \ _("<b>Downloading updates ...</b>"), \ file=os.path.join(Path.pixmaps_dir, "Throbber.gif") \ ) gobject.timeout_add(300, self.__refresh_row_download) def __refresh_row_download(self): """ This is the timeout callback called to update the gui in the download phase (the last) """ working = False for obj in self.p_window.update_eng.list: obj.lock.acquire() try: if obj.status == FILE_GETTING or \ obj.status == FILE_CHECKING: working = True row = obj.object row.message = obj.label row.progress = obj.fract finally: obj.lock.release() if not working: errors = '' for obj in self.p_window.update_eng.list: row = obj.object row.message = obj.label row.progress = None if not errors and obj.status == FILE_ERROR: errors = ' but with <b>some errors</b>' # Only warn the user about changes take effects on restart # on restart just move the plugins stored in home directory # in the proper location self.p_window.animated_bar.label = \ _('Update phase complete%s. Now restart ' \ 'UMIT to changes make effects.') % errors self.p_window.animated_bar.start_animation(True) self.p_window.toolbar.unset_status() self.install_updates_btn.hide() # Let the user to choose to restart or not UMIT self.skip_install_btn.set_sensitive(True) self.restart_btn.show() return working def __on_find_updates(self, widget): """ Called when the user click on 'find updates' button This function call the start_update() of UpdateEngine and then add a timeout callback (__update_rich_list) to update the gui at interval of 300 milliseconds. """ self.find_updates_btn.set_sensitive(False) self.menu_enabled = False lst = [] def append(row, lst): if row.reader.update: row.message = _("Waiting ...") row.activatable = False row.enabled = True lst.append(row) else: self.richlist.remove_row(row) self.richlist.foreach(append, lst) if not lst: self.p_window.toolbar.unset_status() self.p_window.animated_bar.label = \ _("No plugins provide an update URL. Cannot proceed.") self.p_window.animated_bar.image = gtk.STOCK_DIALOG_ERROR self.p_window.animated_bar.start_animation(True) self.p_window.update_eng.updating = False self.find_updates_btn.set_sensitive(True) self.menu_enabled = True self.populate() return # We can now begin the update phase, so warn the user. self.p_window.toolbar.show_message( \ _("<b>Looking for %d updates ...</b>") % len(lst), \ file=os.path.join(Path.pixmaps_dir, "Throbber.gif") \ ) self.p_window.update_eng.list = lst self.p_window.update_eng.start_update() # Add a timeout function to update label gobject.timeout_add(300, self.__update_rich_list) def __query_tooltip_versions_button(self, widget, x, y, keyboard_tip, \ tooltip, obj): idx = obj.object.versions_button.get_active() - 1 if idx >= 0: desc = obj.updates[idx].description if desc: tooltip.set_markup(desc) tooltip.set_icon_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_MENU) return True return False def __update_rich_list(self): """ This is the timeout callback called to update the gui in the find phase """ working = False for upd_obj in self.p_window.update_eng.list: upd_obj.lock.acquire() try: # Check if we are working if upd_obj.status == LATEST_GETTING: working = True # Update the row row = upd_obj.object row.message = upd_obj.label finally: upd_obj.lock.release() # No locking from here we have finished if not working: # Mark as finished self.p_window.update_eng.stop() self.find_updates_btn.set_sensitive(True) lst = filter( \ lambda x: (x.status == LATEST_GETTED) and (x) or (None),\ self.p_window.update_eng.list \ ) elst = filter( \ lambda x: (x.status == LATEST_ERROR) and (x) or (None),\ self.p_window.update_eng.list \ ) if not lst and not elst: self.p_window.toolbar.unset_status() self.p_window.animated_bar.label = \ _('<b>No updates found</b>') self.p_window.animated_bar.start_animation(True) self.richlist.clear() self.populate() self.menu_enabled = True else: # Now prepare the download page if not elst: self.p_window.toolbar.show_message( \ _("<b>Updates found: %d</b>") % len(lst), \ stock=gtk.STOCK_APPLY \ ) else: self.p_window.toolbar.show_message( \ _('<b>Updates found: %d with %d errors</b>') \ % (len(lst), len(elst)), stock=gtk.STOCK_APPLY \ ) for obj in self.p_window.update_eng.list: row = obj.object active = (obj.status == LATEST_GETTED) if active: obj.last_update_idx = 0 row.show_include = True log.debug("Connecting 'query-tooltip' for %s" % obj) # The tooltip is showed and hidden continuously row.versions_button.props.has_tooltip = True row.versions_button.connect( 'query-tooltip', self.__query_tooltip_versions_button, obj ) row.versions_model.clear() row.versions_model.append([ gtk.STOCK_CANCEL, _("Skip") ]) for update in obj.updates: cur_v = Version(row.reader.version) new_v = Version(update.version) if new_v > cur_v: row.versions_model.append([ gtk.STOCK_GO_UP, _("Update to %s") % \ update.version ]) elif new_v == cur_v: row.versions_model.append([ gtk.STOCK_REFRESH, _("Reinstall %s") % \ update.version ]) else: row.versions_model.append([ gtk.STOCK_GO_DOWN, _("Downgrade to %s") % \ update.version ]) row.versions_button.set_active(0) row.message = obj.label else: row.saturate = True if lst: self.install_updates_btn.show() self.find_updates_btn.hide() self.skip_install_btn.show() return working def __on_row_popup(self, row, evt): "Popup menu" if not self.menu_enabled or not row.activatable: return menu = gtk.Menu() stocks = ( gtk.STOCK_PREFERENCES, gtk.STOCK_HOME, gtk.STOCK_ABOUT, None, (gtk.STOCK_MEDIA_PLAY, gtk.STOCK_MEDIA_STOP), gtk.STOCK_CLEAR ) labels = ( _('<b>Preferences</b>'), _('Visit homepage'), _('About %s') % row.reader.name, None, (_('Enable'), _('Disable')), _('Uninstall') ) callbacks = ( self.__on_row_preference, self.__on_row_homepage, self.__on_row_about, None, self.__on_row_action, self.__on_row_uninstall ) for stock, label, cb in zip(stocks, labels, callbacks): if not label: menu.append(gtk.SeparatorMenuItem()) continue # Get the right stock, label choosing from the row state if isinstance(label, tuple): if row.enabled: stock, label = stock[1], label[1] else: stock, label = stock[0], label[0] act = gtk.Action(None, label, '', stock) item = act.create_menu_item() item.get_child().set_use_markup(True) item.connect('activate', cb, row) menu.append(item) menu.show_all() menu.popup(None, None, None, evt.button, evt.time) def __on_row_action(self, widget, row): "Enable/Disable menu/button callback" if not row.enabled: func = self.p_window.engine.load_plugin else: func = self.p_window.engine.unload_plugin ret, errmsg = func(row.reader) if not ret: dialog = HIGAlertDialog( self.p_window, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, message_format=errmsg, secondary_text=errmsg.summary ) dialog.run() dialog.destroy() else: row.enabled = not row.enabled def __on_row_uninstall(self, widget, row): "Uninstall button callback" # If it's enabled we must disable and then disinstall def dialog(txt, sec): return HIGAlertDialog(self.p_window, 0, gtk.MESSAGE_QUESTION, \ gtk.BUTTONS_YES_NO, txt, sec) if row.enabled: d = dialog( \ _('Disabling Plugin'), \ _('Do you want to disable %s plugin?') % row.reader.name \ ) r = d.run() d.hide() d.destroy() if r == gtk.RESPONSE_YES: r, err = self.p_window.engine.unload_plugin(row.reader) if not r: d = dialog( \ _('Can not disable Plugin'), \ _('%s\nDo you want to force ' 'the unload phase for %s plugin?') % \ (err.summary, row.reader.name) \ ) r = d.run() d.hide() d.destroy() if r == gtk.RESPONSE_YES: self.p_window.engine.unload_plugin(row.reader, True) self.__uninstall(row) else: self.__uninstall(row) else: self.__uninstall(row) def __uninstall(self, row): "Uninstall semi-low level function" row.activatable = False if self.p_window.engine.uninstall_plugin(row.reader): del row self.richlist.clear() self.p_window.plug_page.populate() else: row.activatable = True self.p_window.animated_bar.label = \ _('Unable to uninstall %s plugin.') % row.reader self.p_window.animated_bar.start_animation(True) def __on_row_preference(self, widget, row): "Preference button callback" if not self.p_window.engine.tree.show_preferences(row.reader): self.p_window.animated_bar.label = \ _('No preferences for %s') % row.reader.name self.p_window.animated_bar.start_animation(True) def __on_row_about(self, widget, row): "About menu callback" self.p_window.engine.tree.show_about(row.reader) def __on_row_homepage(self, widget, row): "Homepage menu callback" Core().open_url(row.reader.url)
class SMTPSetup(HIGWindow): """ SMTP editor. """ def __init__(self): HIGWindow.__init__(self) self.wtitle = _("SMTP Account Editor") # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # schemas name self.schema_name_lbl = HIGEntryLabel(_("Schema name")) self.schema_name = gtk.combo_box_entry_new_text() self.schema_name.connect('changed', self._check_schema) # smtp server self.smtp_server_lbl = HIGEntryLabel(_("Server")) self.smtp_server = gtk.Entry() self.smtp_port_lbl = HIGEntryLabel(_("Port")) self.smtp_port = gtk.Entry() # sending mail.. self.smtp_mailfrom_lbl = HIGEntryLabel(_("Mail from")) self.smtp_mailfrom = gtk.Entry() # smtp auth self.smtp_need_auth = gtk.CheckButton( _("Servers requires authentication")) self.smtp_need_auth.connect('toggled', self._auth_need) self.smtp_login_lbl = HIGEntryLabel(_("Username")) self.smtp_login = gtk.Entry() self.smtp_passwd_lbl = HIGEntryLabel(_("Password")) self.smtp_passwd = gtk.Entry() self.smtp_passwd.set_visibility(False) self._auth_need(None) # smtp encryption self.smtp_encrypt_tls = gtk.CheckButton(_("Use TLS Encryption")) """ Missing: SSL encryption, Other authentication methods. """ # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect('clicked', self._show_help) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect('clicked', self._save_schema) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect('clicked', self._exit) self.ok = HIGButton(stock=gtk.STOCK_OK) self.ok.connect('clicked', self._save_schema_and_leave) self.load_schemas() self.__set_props() self.__do_layout() self.connect('destroy', self._exit) def load_schemas(self): """ Load schemas profiles. """ schemas = ConfigParser() schemas.read(Path.smtp_schemas) self.sections = [] self.schema_name.get_model().clear() for section in schemas.sections(): self.sections.append(section) self.schema_name.append_text(section) self.schema_name.set_active(0) self._check_schema(None) def _load_schema(self): """ Load current set schedule schema. """ schema = ConfigParser() schema.read(Path.smtp_schemas) enable = { 'tls': self.smtp_encrypt_tls.set_active, 'auth': self.smtp_need_auth.set_active } values = { 'user': self.smtp_login.set_text, 'pass': self.smtp_passwd.set_text, 'server': self.smtp_server.set_text, 'port': self.smtp_port.set_text, 'mailfrom': self.smtp_mailfrom.set_text } for item in schema.items(self.schema_name.get_active_text()): if item[0] in ('tls', 'auth'): enable[item[0]](int(item[1])) else: values[item[0]](item[1]) def _check_schema(self, event): """ Check if current text in schema_name combobox is a schema name. """ if self.schema_name.get_active_text() in self.sections: # load schema self._load_schema() else: # reset to default values self.smtp_mailfrom.set_text('') self.smtp_server.set_text('') self.smtp_port.set_text('') self.smtp_encrypt_tls.set_active(False) self.smtp_login.set_text('') self.smtp_passwd.set_text('') self.smtp_need_auth.set_active(False) self._auth_need(None) def _auth_need(self, event): """ SMTP Authentication toggled. """ status = self.smtp_need_auth.get_active() self.smtp_login.set_sensitive(status) self.smtp_passwd.set_sensitive(status) self.smtp_login_lbl.set_sensitive(status) self.smtp_passwd_lbl.set_sensitive(status) def _save_schema(self, event): """ Save current schema. """ schema = self.schema_name.get_active_text() server = self.smtp_server.get_text() port = self.smtp_port.get_text() auth = self.smtp_need_auth.get_active() mailfrom = self.smtp_mailfrom.get_text() if auth: user = self.smtp_login.get_text() passwd = self.smtp_passwd.get_text() if auth and not (user and passwd): dlg = HIGAlertDialog(self, message_format=_('SMTP Schema - Error\ while saving.'), secondary_text=_("You need to specify an \ username and password for this SMTP Schema.")) dlg.run() dlg.destroy() return if not schema or not server or not port or not mailfrom: dlg = HIGAlertDialog(self, message_format=_('SMTP Schema - Error\ while saving.'), secondary_text=_("The following fields \ need to be filled: Schema Name, Server, Port and Mail from.")) dlg.run() dlg.destroy() return # write schema to file s_cfg = ConfigParser() s_cfg.read(Path.smtp_schemas) if not s_cfg.has_section(schema): new_sec = True s_cfg.add_section(schema) else: new_sec = False if auth: s_cfg.set(schema, 'auth', '1') else: s_cfg.set(schema, 'auth', '0') user = '' passwd = '' s_cfg.set(schema, 'port', port) s_cfg.set(schema, 'server', server) s_cfg.set(schema, 'user', user) s_cfg.set(schema, 'pass', passwd) s_cfg.set(schema, 'mailfrom', mailfrom) if self.smtp_encrypt_tls.get_active(): s_cfg.set(schema, 'tls', '1') else: s_cfg.set(schema, 'tls', '0') s_cfg.write(open(Path.smtp_schemas, 'w')) if new_sec: self.load_schemas() def _save_schema_and_leave(self, event): """ Save current schema and close editor. """ self._save_schema(None) self._exit(None) def __set_props(self): """ Set window properties. """ self.set_title(self.wtitle) def _show_help(self, event): """ Open SMTP Setup help """ show_help(self, "smtpsetup.html") def __do_layout(self): """ Layout widgets in window. """ main_vbox = HIGVBox() main_vbox.set_border_width(5) main_vbox.set_spacing(12) header_hbox = HIGHBox() schema_table = HIGTable() auth_table = HIGTable() btns_hbox = HIGHBox() header_hbox._pack_expand_fill(self.ttitle) header_hbox._pack_noexpand_nofill(self.umit_logo) # schema name schema_table.attach_label(self.schema_name_lbl, 0, 1, 0, 1) schema_table.attach_entry(self.schema_name, 1, 2, 0, 1) # smtp server schema_table.attach_label(self.smtp_server_lbl, 0, 1, 1, 2) schema_table.attach_entry(self.smtp_server, 1, 2, 1, 2) # smtp server port schema_table.attach_label(self.smtp_port_lbl, 0, 1, 2, 3) schema_table.attach_entry(self.smtp_port, 1, 2, 2, 3) # smtp mail from schema_table.attach_label(self.smtp_mailfrom_lbl, 0, 1, 3, 4) schema_table.attach_entry(self.smtp_mailfrom, 1, 2, 3, 4) # smtp user auth_table.attach_label(self.smtp_login_lbl, 0, 1, 0, 1) auth_table.attach_entry(self.smtp_login, 1, 2, 0, 1) # smtp passwd auth_table.attach_label(self.smtp_passwd_lbl, 0, 1, 1, 2) auth_table.attach_label(self.smtp_passwd, 1, 2, 1, 2) # bottom buttons btns_hbox.set_homogeneous(True) btns_hbox._pack_expand_fill(self.help) btns_hbox._pack_expand_fill(hig_box_space_holder()) btns_hbox._pack_expand_fill(self.apply) btns_hbox._pack_expand_fill(self.cancel) btns_hbox._pack_expand_fill(self.ok) main_vbox._pack_noexpand_nofill(header_hbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(schema_table) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(self.smtp_need_auth) main_vbox._pack_noexpand_nofill(auth_table) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(self.smtp_encrypt_tls) main_vbox.pack_end(btns_hbox, False, False, 0) self.add(main_vbox) def _exit(self, event): """ Close current window. """ 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 Credits(HIGWindow): def __init__(self): HIGWindow.__init__(self) self.set_title(_("Umit credits")) self.set_size_request(-1, 450) self.set_position(gtk.WIN_POS_CENTER) self.__create_widgets() self.__packing() self.set_text() def __create_widgets(self): self.vbox = HIGVBox() self.hbox = HIGHBox() self.notebook = HIGNotebook() self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.written_by_scroll = HIGScrolledWindow() self.written_by_text = HIGTextView() self.design_scroll = HIGScrolledWindow() self.design_text = HIGTextView() self.soc2007_scroll = HIGScrolledWindow() self.soc2007_text = HIGTextView() self.soc2008_scroll = HIGScrolledWindow() self.soc2008_text = HIGTextView() self.soc2009_scroll = HIGScrolledWindow() self.soc2009_text = HIGTextView() self.contributors_scroll = HIGScrolledWindow() self.contributors_text = HIGTextView() self.translation_scroll = HIGScrolledWindow() self.translation_text = HIGTextView() self.nokia_scroll = HIGScrolledWindow() self.nokia_text = HIGTextView() def __packing(self): self.add(self.vbox) self.vbox.set_spacing(12) self.vbox._pack_expand_fill(self.notebook) self.vbox._pack_noexpand_nofill(self.hbox) self.hbox._pack_expand_fill(hig_box_space_holder()) self.hbox._pack_noexpand_nofill(self.btn_close) self.notebook.append_page(self.written_by_scroll, gtk.Label(_("Written by"))) self.notebook.append_page(self.design_scroll, gtk.Label(_("Design"))) self.notebook.append_page(self.soc2007_scroll, gtk.Label(_("SoC 2007"))) self.notebook.append_page(self.soc2008_scroll, gtk.Label(_("SoC 2008"))) self.notebook.append_page(self.soc2009_scroll, gtk.Label(_("SoC 2009"))) self.notebook.append_page(self.contributors_scroll, gtk.Label(_("Contributors"))) self.notebook.append_page(self.translation_scroll, gtk.Label(_("Translations"))) self.notebook.append_page(self.nokia_scroll, gtk.Label(_("Maemo"))) self.written_by_scroll.add(self.written_by_text) self.written_by_text.set_wrap_mode(gtk.WRAP_NONE) self.design_scroll.add(self.design_text) self.design_text.set_wrap_mode(gtk.WRAP_NONE) self.soc2007_scroll.add(self.soc2007_text) self.soc2007_text.set_wrap_mode(gtk.WRAP_NONE) self.soc2008_scroll.add(self.soc2008_text) self.soc2008_text.set_wrap_mode(gtk.WRAP_NONE) self.soc2009_scroll.add(self.soc2009_text) self.soc2009_text.set_wrap_mode(gtk.WRAP_NONE) self.contributors_scroll.add(self.contributors_text) self.contributors_text.set_wrap_mode(gtk.WRAP_NONE) self.translation_scroll.add(self.translation_text) self.translation_text.set_wrap_mode(gtk.WRAP_NONE) self.nokia_scroll.add(self.nokia_text) self.nokia_text.set_wrap_mode(gtk.WRAP_NONE) self.btn_close.connect('clicked', lambda x, y=None: self.destroy()) def set_text(self): b = self.written_by_text.get_buffer() b.set_text("""Adriano Monteiro Marques <*****@*****.**> Bartosz Skowron <*****@*****.**> Francesco Piccinno <*****@*****.**> Guilherme Polo <*****@*****.**> João Medeiros <*****@*****.**> Luís A. Bastião Silva <*****@*****.**>""") b = self.design_text.get_buffer() b.set_text( _("""Operating System and Vulnerability Icons: Takeshi Alexandre Gondo <*****@*****.**> Logo, Application Icons, Splash screen and Umit GNU/Linux theme: Virgílio Carlo de Menezes Vasconcelos <*****@*****.**> The Umit Project Web Site Design: Joao Paulo Pacheco <*****@*****.**>""")) b = self.soc2007_text.get_buffer() b.set_text( _("""Independent Features: Adriano Monteiro Marques <*****@*****.**> Frederico Silva Ribeiro <*****@*****.**> Network Inventory: Guilherme Henrique Polo Gonçalves <*****@*****.**> Umit Radial Mapper: João Paulo de Souza Medeiros <*****@*****.**> Profile/Wizard interface editor: Luis Antonio Bastião Silva <*****@*****.**> NSE Facilitator: Maxim I. Gavrilov <*****@*****.**> Umit Web: Rodolfo da Silva Carvalho <*****@*****.**>""")) b = self.soc2008_text.get_buffer() b.set_text( _("""Packet Manipulation Backend Bartosz Adam Skowron <*****@*****.**> Bluetooth Scanner & Vulnerabilities Database System: Devtar Singh <*****@*****.**> Umit Plugins and Packet Manipulation Frontend Francesco Piccinno <*****@*****.**> Preferences Window and Interface Editor improvements: Luis Antonio Bastião Silva <*****@*****.**> UmitWeb Improvements and Independent Features: Rodolfo da Silva Carvalho <*****@*****.**> """)) b = self.soc2009_text.get_buffer() b.set_text( _("""UMPA Improvements Bartosz Adam Skowron <*****@*****.**> Quick Scan: Daniel Mendes Cassiano <*****@*****.**> Bluetooth Sniffer: Shu Yang Quek <*****@*****.**> Audits Framework Francesco Piccinno <*****@*****.**> ZION João Paulo de Souza Medeiros <*****@*****.**> USoC: Message Sequence Chart Abhiram Kasina <*****@*****.**> Independent Features and Test Suite Mahesh PM <*****@*****.**> """)) b = self.contributors_text.get_buffer() b.set_text( _("""Sponsored by (SoC 2005, 2006, 2007 and 2008): Google <*****@*****.**> Mentor of Umit for Google SoC 2005 and 2006: Fyodor <*****@*****.**> Mentor of Umit for Google SoC 2007 Projects: Adriano Monteiro Marques <*****@*****.**> Mentor of Umit for Google SoC 2008 Projects: Adriano Monteiro Marques <*****@*****.**> Initial development: Adriano Monteiro Marques <*****@*****.**> Cleber Rodrigues Rosa Junior <*****@*****.**> Nmap students from Google SoC 2007 that helped Umit: Eddie Bell <*****@*****.**> David Fifield <*****@*****.**> Kris Katterjohn <*****@*****.**> The Umit Project WebSite: Abrao Barbosa dos Santos Neto <*****@*****.**> Adriano Monteiro Marques <*****@*****.**> Heitor de Lima Matos <*****@*****.**> Joao Paulo Pacheco <*****@*****.**> João Paulo de Souza Medeiros <*****@*****.**> Luis Antonio Bastião Silva <*****@*****.**> Rodolfo da Silva Carvalho <*****@*****.**> Helpers: Daniel Mendes Cassiano <*****@*****.**> Luiz Paulo de Souza Medeiros <*****@*****.**> Beta testers for 0.9.5RC1: Bartosz Adam Skowron <*****@*****.**> Denis Kurov <*****@*****.**> Devtar Singh <*****@*****.**> Drew Miller <*****@*****.**> Francesco Piccinno <*****@*****.**> Igor Feghali <*****@*****.**> Joao Paulo Pacheco <*****@*****.**> Luis Antonio Bastião Silva <*****@*****.**> Rodolfo da Silva Carvalho <*****@*****.**> Regis Kuramoto Dias <*****@*****.**> <*****@*****.**> <*****@*****.**> <*****@*****.**> Special thanks to our GSoC volunteers heroes: Daniel Mendes Cassiano <*****@*****.**> Túlio Gonçalves <*****@*****.**> Initial attempt on Maemo port: Adriano Monteiro Marques <*****@*****.**> Osvaldo Santana Neto <*****@*****.**>""")) b = self.soc2007_text.get_buffer() b.set_text("""Independent Features: Adriano Monteiro Marques <*****@*****.**> Frederico Silva Ribeiro <*****@*****.**> Network Inventory: Guilherme Henrique Polo Gonçalves <*****@*****.**> Umit Radial Mapper: João Paulo de Souza Medeiros <*****@*****.**> Profile/Wizard interface editor: Luis Antonio Bastião Silva <*****@*****.**> NSE Facilitator: Maxim I. Gavrilov <*****@*****.**> Nmap Python Wrapper: Pavel Klemenkov <*****@*****.**> Umit Web: Rodolfo da Silva Carvalho <*****@*****.**> Summer of Code's projects Design: Virgílio Carlo de Menezes Vasconcelos <*****@*****.**>""") b = self.translation_text.get_buffer() b.set_text( _("""Bahasa Indonesia: Devtar Singh <*****@*****.**> Bahasa Melayu: Devtar Singh <*****@*****.**> Brazilian Portuguese: Adriano Monteiro Marques <*****@*****.**> Rodolfo da Silva Carvalho <*****@*****.**> Italian: Francesco Piccinno <*****@*****.**> Polish: Bartosz Adam Skowron <*****@*****.**> Portuguese Portugal: Luis Antonio Bastião Silva <*****@*****.**> Simplified Chinese: Devtar Singh <*****@*****.**> Haoyu Bai <*****@*****.**> Aron Xu <*****@*****.**> Swedish: Daniel Nylander <*****@*****.**> """)) b = self.nokia_text.get_buffer() b.set_text("""Adriano Monteiro Marques <*****@*****.**>""")
class SearchGUI(gtk.HPaned, object): def __init__(self, notebook): gtk.HPaned.__init__(self) self._create_widgets() self._pack_widgets() self._connect_events() self.any_profile = _("Any profile") self.any_option = _("Any option") self.any_target = _("Any target") self.any_service = _("Any service") self.any_product = _("Any product") self.any_osclass = _("Any os class") self.any_osmatch = _("Any os match") self.any = _("Any") # Setting default values self.port_open = True self.port_filtered = True self.port_closed = True self.profile = self.any_profile self.option = self.any_option self.target = self.any_target self.service = self.any_service self.product = self.any_product self.osclass = self.any_osclass self.osmatch = self.any_osmatch # Search options self.directory = search_config.directory self.file_extension = search_config.file_extension self.save_time = search_config.save_time self.save = search_config.store_results self.search_db = search_config.search_db self.parsed_results = {} self._set_result_view() self.scan_num = 1 self.id = 0 self.notebook = notebook def _create_widgets(self): # Main widgets self.hpaned = gtk.HPaned() self.main_vbox = HIGVBox() # Results section self.result_section = HIGSectionLabel(_("Results")) self.result_vbox = HIGVBox() self.result_hbox = HIGHBox() self.result_list = gtk.ListStore(str, str, int) # title, date, id self.result_view = gtk.TreeView(self.result_list) self.result_scrolled = gtk.ScrolledWindow() self.result_title_column = gtk.TreeViewColumn(_("Scan")) self.result_date_column = gtk.TreeViewColumn(_("Date")) # Search notebook self.search_vbox = HIGVBox() self.search_notebook = gtk.Notebook() self.search_button = HIGButton(stock=gtk.STOCK_FIND) # General page self.general_vbox = HIGVBox() self.general_hbox = HIGHBox() #self.general_start_hbox = HIGHBox() #self.general_finish_hbox = HIGHBox() self.general_section = HIGSectionLabel(_("General search parameters")) self.general_table = HIGTable() self.general_option_label = HIGEntryLabel(_("Option")) self.general_profile_label = HIGEntryLabel(_("Profile")) #self.general_finished_label = HIGEntryLabel(_("Finished")) #self.general_started_label = HIGEntryLabel(_("Started")) self.general_keyword_label = HIGEntryLabel(_("Keyword")) self.general_keyword_entry = gtk.Entry() self.general_option_combo = OptionCombo() self.general_profile_combo = ProfileCombo() #self.general_started_range = DateRange() #self.general_finished_range = DateRange() # Host page self.host_vbox = HIGVBox() self.host_hbox = HIGHBox() #self.host_uptime_hbox = HIGHBox() #self.host_lastboot_hbox = HIGHBox() self.host_section = HIGSectionLabel(_("Host search parameters")) self.host_table = HIGTable() self.host_target_label = HIGEntryLabel(_("Target")) self.host_mac_label = HIGEntryLabel(_("MAC")) self.host_ipv4_label = HIGEntryLabel(_("IPv4")) self.host_ipv6_label = HIGEntryLabel(_("IPv6")) #self.host_uptime_label = HIGEntryLabel(_("Uptime")) #self.host_lastboot_label = HIGEntryLabel(_("Last boot")) self.host_target_combo = TargetCombo() self.host_mac_entry = gtk.Entry() self.host_ipv4_entry = gtk.Entry() self.host_ipv6_entry = gtk.Entry() #self.host_uptime_range = DateRange() #self.host_lastboot_range = DateRange() # Service self.serv_vbox = HIGVBox() self.serv_hbox = HIGHBox() self.serv_section = HIGSectionLabel(_("Service search parameters")) self.serv_table = HIGTable() self.serv_port_label = HIGEntryLabel(_("Port number")) self.serv_service_label = HIGEntryLabel(_("Service")) self.serv_product_label = HIGEntryLabel(_("Product")) self.serv_portstate_label = HIGEntryLabel(_("Port state")) self.serv_port_entry = gtk.Entry() self.serv_service_combo = ServiceCombo() self.serv_product_entry = gtk.Entry() self.serv_portstate_check = PortState() # OS self.os_vbox = HIGVBox() self.os_hbox = HIGHBox() self.os_section = HIGSectionLabel(_("Operating System search \ parameters")) self.os_table = HIGTable() self.os_osclass_label = HIGEntryLabel(_("OS class")) self.os_osmatch_label = HIGEntryLabel(_("OS match")) self.os_osclass_combo = OSClassCombo() self.os_osmatch_combo = OSMatchCombo() # Search options page self.opt_vbox = HIGVBox() self.opt_local_hbox = HIGHBox() self.opt_base_hbox = HIGHBox() self.opt_local_section = HIGSectionLabel(_("Local files")) self.opt_local_table = HIGTable() self.opt_base_section = HIGSectionLabel(_("Database")) self.opt_base_table = HIGTable() self.opt_path_label = HIGEntryLabel(_("Directory")) self.opt_extension_label = HIGEntryLabel(_("File extension")) self.opt_savetime_label = HIGEntryLabel(_("Save results for")) self.opt_path_entry = PathEntry() self.opt_extension_entry = gtk.Entry() self.opt_savetime_entry = SaveTime() self.opt_save_check = gtk.CheckButton(_("Save scan results in data \ base for latter search")) self.opt_search_check = gtk.CheckButton(_("Search saved scan results \ in data base")) def _pack_widgets(self): # Packing result section self.result_vbox.set_border_width(12) self.result_vbox._pack_noexpand_nofill(self.result_section) self.result_vbox._pack_expand_fill(self.result_hbox) self.result_scrolled.set_size_request(185, -1) #self.result_scrolled.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.result_scrolled.add(self.result_view) self.result_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.result_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.result_hbox._pack_expand_fill(self.result_scrolled) ## Search Notebook self.search_vbox._pack_expand_fill(self.search_notebook) self.search_vbox._pack_expand_fill(self.search_button) self.search_notebook.set_border_width(1) self.search_vbox.set_border_width(12) # General page self.general_vbox.set_border_width(12) self.general_vbox._pack_noexpand_nofill(self.general_section) self.general_vbox._pack_noexpand_nofill(self.general_hbox) #self.general_vbox._pack_noexpand_nofill(self.general_start_section) #self.general_vbox._pack_noexpand_nofill(self.general_start_hbox) #self.general_vbox._pack_noexpand_nofill(self.general_finish_section) #self.general_vbox._pack_noexpand_nofill(self.general_finish_hbox) self.general_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.general_hbox._pack_expand_fill(self.general_table) #self.general_start_hbox._pack_noexpand_nofill(hig_box_space_holder()) #self.general_start_hbox._pack_noexpand_nofill(self.general_started_range) #self.general_finish_hbox._pack_noexpand_nofill(hig_box_space_holder()) #self.general_finish_hbox._pack_expand_fill(self.general_finished_range) self.general_table.attach_label(self.general_keyword_label, 0, 1, 0, 1) self.general_table.attach_label(self.general_profile_label, 0, 1, 1, 2) self.general_table.attach_label(self.general_option_label, 0, 1, 2, 3) self.general_table.attach_entry(self.general_keyword_entry, 1, 2, 0, 1) self.general_table.attach_entry(self.general_profile_combo, 1, 2, 1, 2) self.general_table.attach_entry(self.general_option_combo, 1, 2, 2, 3) self.search_notebook.append_page(self.general_vbox, gtk.Label(_("General"))) # Host page self.host_vbox.set_border_width(12) self.host_vbox._pack_noexpand_nofill(self.host_section) self.host_vbox._pack_noexpand_nofill(self.host_hbox) #self.host_vbox._pack_noexpand_nofill(self.host_uptime_section) #self.host_vbox._pack_noexpand_nofill(self.host_uptime_hbox) #self.host_vbox._pack_noexpand_nofill(self.host_lastboot_section) #self.host_vbox._pack_noexpand_nofill(self.host_lastboot_hbox) self.host_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.host_hbox._pack_expand_fill(self.host_table) #self.host_uptime_hbox._pack_noexpand_nofill(hig_box_space_holder()) #self.host_uptime_hbox._pack_noexpand_nofill(self.host_uptime_range) #self.host_lastboot_hbox._pack_noexpand_nofill(hig_box_space_holder()) #self.host_lastboot_hbox._pack_expand_fill(self.host_lastboot_range) self.host_table.attach_label(self.host_target_label, 0, 1, 0, 1) self.host_table.attach_label(self.host_mac_label, 0, 1, 1, 2) self.host_table.attach_label(self.host_ipv4_label, 0, 1, 2, 3) self.host_table.attach_label(self.host_ipv6_label, 0, 1, 3, 4) self.host_table.attach_entry(self.host_target_combo, 1, 2, 0, 1) self.host_table.attach_entry(self.host_mac_entry, 1, 2, 1, 2) self.host_table.attach_entry(self.host_ipv4_entry, 1, 2, 2, 3) self.host_table.attach_entry(self.host_ipv6_entry, 1, 2, 3, 4) self.search_notebook.append_page(self.host_vbox, gtk.Label(_("Host"))) # Service page self.serv_vbox.set_border_width(12) self.serv_vbox._pack_noexpand_nofill(self.serv_section) self.serv_vbox._pack_noexpand_nofill(self.serv_hbox) self.serv_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.serv_hbox._pack_expand_fill(self.serv_table) self.serv_table.attach_label(self.serv_port_label, 0, 1, 0, 1) self.serv_table.attach_label(self.serv_portstate_label, 0, 1, 1, 2) self.serv_table.attach_label(self.serv_product_label, 0, 1, 2, 3) self.serv_table.attach_label(self.serv_service_label, 0, 1, 3, 4) self.serv_table.attach_entry(self.serv_port_entry, 1, 2, 0, 1) self.serv_table.attach_entry(self.serv_portstate_check, 1, 2, 1, 2) self.serv_table.attach_entry(self.serv_product_entry, 1, 2, 2, 3) self.serv_table.attach_entry(self.serv_service_combo, 1, 2, 3, 4) self.search_notebook.append_page(self.serv_vbox, gtk.Label(_("Service"))) # OS page self.os_vbox.set_border_width(12) self.os_vbox._pack_noexpand_nofill(self.os_section) self.os_vbox._pack_noexpand_nofill(self.os_hbox) self.os_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.os_hbox._pack_expand_fill(self.os_table) self.os_table.attach_label(self.os_osclass_label, 0, 1, 0, 1) self.os_table.attach_label(self.os_osmatch_label, 0, 1, 1, 2) self.os_table.attach_entry(self.os_osclass_combo, 1, 2, 0, 1) self.os_table.attach_entry(self.os_osmatch_combo, 1, 2, 1, 2) self.search_notebook.append_page(self.os_vbox, gtk.Label(_("OS"))) # Search options page self.opt_vbox.set_border_width(12) self.opt_vbox._pack_noexpand_nofill(self.opt_local_section) self.opt_vbox._pack_noexpand_nofill(self.opt_local_hbox) self.opt_vbox._pack_noexpand_nofill(self.opt_base_section) self.opt_vbox._pack_noexpand_nofill(self.opt_base_hbox) self.opt_local_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.opt_local_hbox._pack_expand_fill(self.opt_local_table) self.opt_base_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.opt_base_hbox._pack_expand_fill(self.opt_base_table) self.opt_local_table.attach_label(self.opt_path_label, 0, 1, 0, 1) self.opt_local_table.attach_label(self.opt_extension_label, 0, 1, 1, 2) self.opt_local_table.attach_entry(self.opt_path_entry, 1, 2, 0, 1) self.opt_local_table.attach_entry(self.opt_extension_entry, 1, 2, 1, 2) self.opt_base_table.attach_label(self.opt_savetime_label, 0, 1, 0, 1) self.opt_base_table.attach_label(self.opt_save_check, 0, 2, 1, 2) self.opt_base_table.attach_label(self.opt_search_check, 0, 2, 2, 3) self.opt_base_table.attach_entry(self.opt_savetime_entry, 1, 2, 0, 1) self.search_notebook.append_page(self.opt_vbox, gtk.Label(_("Search options"))) self.pack1(self.search_vbox, True, False) self.pack2(self.result_vbox, True, False) def _connect_events(self): self.os_osclass_combo.connect("changed", self.update_osmatch) self.search_button.connect("clicked", self.start_search) self.opt_extension_entry.connect("focus-out-event", self.update_extension_entry) self.opt_save_check.connect("toggled", self.update_save_check) self.opt_search_check.connect("toggled", self.update_search_check) self.opt_path_entry.connect_entry_change(self.update_path_entry) self.opt_savetime_entry.connect_entry_change(self.update_savetime_entry) def update_path_entry(self, widget, extra=None): search_config.directory = widget.get_text() def update_savetime_entry(self, widget, extra=None): search_config.save_time = self.opt_savetime_entry.time def update_extension_entry(self, widget, extra=None): search_config.file_extension = widget.get_text() def update_save_check(self, widget): search_config.store_results = widget.get_active() def update_search_check(self, widget): search_config.search_db = widget.get_active() def start_search(self, widget): if not self.search_db and \ not self.directory: self.search_notebook.set_current_page(-1) d = HIGAlertDialog(message_format=_("No search method selected!"), secondary_text=_("Umit can search results on \ directories or inside it's own database. Please, select a method by choosing \ a directory or by checking the search data base option at the 'Search options' \ tab before start the search")) d.run() d.destroy() return search_dict = dict(keyword=self.keyword, profile=self.profile, option=self.option, target=self.target, mac=self.mac, ipv4=self.ipv4, ipv6=self.ipv6, port=self.port, port_open=self.port_open, port_filtered=self.port_filtered, port_closed=self.port_closed, service=self.service, osclass=self.osclass, osmatch=self.osmatch, product=self.product) self.clear_result_list() if self.search_db: search_db = SearchDB() for result in search_db.search(**search_dict): self.append_result(result) if self.directory: search_dir = SearchDir(self.directory, self.file_extension) for result in search_dir.search(**search_dict): self.append_result(result) search_tabs = SearchTabs(self.notebook) for result in search_tabs.search(**search_dict): self.append_result(result) def clear_result_list(self): for i in range(len(self.result_list)): iter = self.result_list.get_iter_root() del(self.result_list[iter]) def append_result(self, parsed_result): title = "" if parsed_result.scan_name: title = parsed_result.scan_name elif parsed_result.nmap_xml_file: title = os.path.split(parsed_result.nmap_xml_file)[-1] elif parsed_result.profile_name and parsed_result.target: title = "%s on %s" % (parsed_result.profile_name, parsed_result.target) else: title = "Scan %s" % (self.scan_num) self.scan_num += 1 try: date = localtime(float(parsed_result.start)) date_field = "%02d %s %04d" % (date[2], calendar.month_name[date[1]][:3], date[0]) except ValueError: date_field = _("Unknown") self.parsed_results[self.id] = [title, parsed_result] self.result_list.append([title, date_field, self.id]) self.id += 1 def update_osmatch(self, widegt): self.os_osmatch_combo.update(self.os_osclass_combo.selected_osclass) def get_keyword(self): return self.general_keyword_entry.get_text() def set_keyword(self, keyword): self.general_keyword_entry.set_text(keyword) def get_profile(self): if self.general_profile_combo.selected_profile == self.any_profile or \ self.general_profile_combo.selected_profile == self.any: return "*" return self.general_profile_combo.selected_profile def set_profile(self, profile): self.general_profile_combo.selected_profile = profile def get_option(self): if self.general_option_combo.selected_option == self.any_option or \ self.general_option_combo.selected_option == self.any: return "*" return self.general_option_combo.selected_option def set_option(self, option): self.general_option_combo.selected_option = option def get_target(self): if self.host_target_combo.selected_target == self.any_target or \ self.host_target_combo.selected_target == self.any: return "*" return self.host_target_combo.selected_target def set_target(self, target): self.host_target_combo.selected_target = target def get_mac(self): return self.host_mac_entry.get_text() def set_mac(self, mac): self.host_mac_entry.set_text(mac) def get_ipv4(self): return self.host_ipv4_entry.get_text() def set_ipv4(self, ipv4): self.host_ipv4_entry.set_text(ipv4) def get_ipv6(self): return self.host_ipv6_entry.get_text() def set_ipv6(self, ipv6): self.host_ipv6_entry.set_text(ipv6) def get_port(self): return self.serv_port_entry.get_text().split(";") def set_port(self, port): if isinstance(port, basestring): self.serv_port_entry.set_text(port) elif isinstance(port, list): self.serv_port_entry.set_text(";".join(port)) def get_port_open(self): return self.serv_portstate_check.open def set_port_open(self, open): self.serv_portstate_check.open = open def get_port_filtered(self): return self.serv_portstate_check.filtered def set_port_filtered(self, filtered): self.serv_portstate_check.filtered = filtered def get_port_closed(self): return self.serv_portstate_check.closed def set_port_closed(self, closed): self.serv_portstate_check.closed = closed def get_service(self): if self.serv_service_combo.selected_service == self.any_service or \ self.serv_service_combo.selected_service == self.any: return "*" return self.serv_service_combo.selected_service def set_service(self, service): self.serv_service_combo.selected_service = service def get_osclass(self): if self.os_osclass_combo.selected_osclass == self.any_osclass or \ self.os_osclass_combo.selected_osclass == self.any: return "*" return self.os_osclass_combo.selected_osclass def set_osclass(self, osclass): self.os_osclass_combo.selected_osclass = osclass def get_osmatch(self): if self.os_osmatch_combo.selected_osmatch == self.any_osmatch or \ self.os_osmatch_combo.selected_osmatch == self.any: return "*" return self.os_osmatch_combo.selected_osmatch def set_osmatch(self, osmatch): self.os_osmatch_combo.selected_osmatch = osmatch def get_product(self): if self.serv_product_entry.get_text() == self.any_product or \ self.serv_product_entry.get_text() == self.any: return "*" return self.serv_product_entry.get_text() def set_product(self, product): self.serv_product_entry.set_text(product) def get_directory(self): return self.opt_path_entry.path def set_directory(self, directory): self.opt_path_entry.path = directory def get_file_extension(self): return self.opt_extension_entry.get_text().split(";") def set_file_extension(self, file_extension): if isinstance(file_extension, list): self.opt_extension_entry.set_text(";".join(file_extension)) elif isinstance(file_extension, basestring): self.opt_extension_entry.set_text(file_extension) def get_save_time(self): return self.opt_savetime_entry.time def set_save_time(self, save_time): self.opt_savetime_entry.time = save_time def get_save(self): return self.opt_save_check.get_active() def set_save(self, save): self.opt_save_check.set_active(save) def get_search_db(self): return self.opt_search_check.get_active() def set_search_db(self, search_db): self.opt_search_check.set_active(search_db) def get_selected_results(self): selection = self.result_view.get_selection() rows = selection.get_selected_rows() list_store = rows[0] results = {} for row in rows[1]: r = row[0] results[list_store[r][2]] = self.parsed_results[list_store[r][2]] return results def _set_result_view(self): self.result_view.set_enable_search(True) self.result_view.set_search_column(0) selection = self.result_view.get_selection() selection.set_mode(gtk.SELECTION_MULTIPLE) self.result_view.append_column(self.result_title_column) self.result_view.append_column(self.result_date_column) self.result_title_column.set_resizable(True) self.result_date_column.set_resizable(True) self.result_title_column.set_sort_column_id(0) self.result_date_column.set_sort_column_id(1) self.result_title_column.set_reorderable(True) self.result_date_column.set_reorderable(True) cell = gtk.CellRendererText() self.result_title_column.pack_start(cell, True) self.result_date_column.pack_start(cell, True) self.result_title_column.set_attributes(cell, text=0) self.result_date_column.set_attributes(cell, text=1) keyword = property(get_keyword, set_keyword) profile = property(get_profile, set_profile) option = property(get_option, set_option) target = property(get_target, set_target) mac = property(get_mac, set_mac) ipv4 = property(get_ipv4, set_ipv4) ipv6 = property(get_ipv6, set_ipv6) port = property(get_port, set_port) port_open = property(get_port_open, set_port_open) port_filtered = property(get_port_filtered, set_port_filtered) port_closed = property(get_port_closed, set_port_closed) service = property(get_service, set_service) product = property(get_product, set_product) osclass = property(get_osclass, set_osclass) osmatch = property(get_osmatch, set_osmatch) directory = property(get_directory, set_directory) file_extension = property(get_file_extension, set_file_extension) save_time = property(get_save_time, set_save_time) save = property(get_save, set_save) search_db = property(get_search_db, set_search_db) selected_results = property(get_selected_results)
class Date(gtk.HBox, object): def __init__(self): gtk.HBox.__init__(self) self._create_widgets() self._connect_widgets() self._pack_widgets() self.date = localtime()[:3] def _create_widgets(self): t = localtime() self.date_button = HIGButton() self.date_sep = gtk.Label(", ") self.hour = gtk.SpinButton(gtk.Adjustment(value=t[3], lower=0, upper=23, step_incr=1), 1) self.hour_sep = gtk.Label(":") self.minute = gtk.SpinButton(gtk.Adjustment(value=t[4], lower=0, upper=59, step_incr=1), 1) def _connect_widgets(self): self.date_button.connect("clicked", self.show_calendar) def _pack_widgets(self): self.hour.set_width_chars(2) self.minute.set_width_chars(2) self.pack_start(self.date_button, False, False) self.pack_start(self.date_sep, False, False) self.pack_start(self.hour, False, False) self.pack_start(self.hour_sep, False, False) self.pack_start(self.minute, False, False) def show_calendar(self, widget): calendar = DateCalendar() calendar.connect_calendar(self.update_button) calendar.show_all() def update_button(self, widget): date = list(widget.get_date()) date[1] += 1 # Add 1 to month, because calendar date is zero-based self.date = tuple(date) def set_date(self, date): # Localtime Format: (year, month, day) self.date_button.set_label("%02d %s %04d" % ( date[2], calendar.month_name[date[1]][:3], date[0])) self._date = date def get_date(self): return self._date def get_time(self): return (self.hour.get_value_as_int(), self.minute.get_value_as_int()) def set_time(self, time): print time if isinstance(time, list): self.hour.set_value(time[0]) self.minute.set_value(time[1]) elif isinstance(time, basestring): time = time.split(";") self.hour.set_value(time[0]) self.minute.set_value(time[1]) date = property(get_date, set_date) time = property(get_time, set_time) _date = localtime()[:3]
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)
def __init__(self, daddy): gtk.Window.__init__(self) self.daddy = daddy self.rowsel = None self.tooltips = gtk.Tooltips() self.wtitle = _("Host Discovery") # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # discovery options self.netdetect_btn = gtk.Button(_("Detect network(s)")) self.netdetect_btn.connect('clicked', self.get_networks) self.networks_box = None self.addnetworks = gtk.Button(_("Add new entry")) self.addnetworks.connect('clicked', self._create_network_entry) self.hostdetect_btn = gtk.Button(_("Find hosts")) self.hostdetect_btn.connect('clicked', self.get_addresses) # target list self.target_lbl = HIGEntryLabel(_("Target list")) self.target_model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.tview = gtk.TreeView(self.target_model) self.tview.set_size_request(300, int(300 / 1.6)) self.tview.columns = [None] * 2 self.tview.columns[0] = gtk.TreeViewColumn(_("Host")) self.tview.columns[1] = gtk.TreeViewColumn(_("Network")) for n in range(2): self.tview.append_column(self.tview.columns[n]) self.tview.columns[n].cell = gtk.CellRendererText() self.tview.columns[n].pack_start(self.tview.columns[n].cell, True) self.tview.columns[n].set_attributes(self.tview.columns[n].cell, text=n) self.tview.get_selection().connect('changed', self._tview_sel_change) self.target_remove = gtk.Button(_("Remove from list")) self.target_remove.set_sensitive(False) self.target_remove.connect('clicked', self._remove_target) # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect('clicked', self._show_help) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect('clicked', self._exit) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect('clicked', self._return_list) # tooltips self.tooltips.set_tip(self.addnetworks, _("Add new entry for a network")) self.tooltips.set_tip(self.netdetect_btn, _("Try to detect network(s)")) self.tooltips.set_tip(self.hostdetect_btn, _("Find hosts in entered network(s)")) self.tooltips.set_tip(self.target_remove, _("Remove selection from target list")) self.__layout()
class About(HIGWindow): def __init__(self): """""" HIGWindow.__init__(self) self.set_title("About Open Monitor Desktop Agent") self.set_position(gtk.WIN_POS_CENTER) self.__create_widgets() self.__packing() self.__connect_widgets() self.__set_img() self.__set_text() def __create_widgets(self): """""" self.vbox = HIGVBox() self.vbox_content = HIGVBox() self.img_logo = gtk.Image() self.event_img_logo = gtk.EventBox() self.vbox.set_border_width(5) self.vbox.set_spacing(12) 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='15000' weight='heavy'>Open Monitor Desktop Agent</span>" ) self.lbl_program_description = gtk.Label("""\ ICM Internet Connectivity is a global monitor to inspect the connectivity issues happened in the world. Developer: Alan Wang<*****@*****.**> Paul Pei<*****@*****.**> Tianwei Liu<*****@*****.**> It was sponsered by Google Summer of Code 2011-2012. Thanks Google!""") self.lbl_copyright = gtk.Label( "<small>Copyright (C) 2012 Adriano Monteiro Marques</small>") self.lbl_program_website = gtk.Label( "<span underline='single' foreground='blue'>" "http://www.umitproject.org</span>") self.lbl_program_website2 = gtk.Label( "<span underline='single' foreground='blue'>" "http://www.openmonitor.org</span>") self.bottom_btn_box = gtk.HButtonBox() self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.btn_close.grab_focus() def __packing(self): """""" self.vbox._pack_expand_fill(self.vbox_content) self.vbox._pack_noexpand_nofill(self.bottom_btn_box) self.bottom_btn_box.set_layout(gtk.BUTTONBOX_CENTER) self.bottom_btn_box.set_spacing(8) self.bottom_btn_box.pack_start(self.btn_close) self.event_img_logo.add(self.img_logo) self.vbox_content._pack_expand_fill(self.event_img_logo) self.vbox_content._pack_expand_fill(self.lbl_program_version) self.vbox_content._pack_expand_fill(self.lbl_program_description) self.vbox_content._pack_expand_fill(self.lbl_copyright) self.vbox_content._pack_expand_fill(self.lbl_program_website) self.vbox_content._pack_expand_fill(self.lbl_program_website2) self.add(self.vbox) def __connect_widgets(self): """""" self.event_img_logo.connect('button-release-event', self.__set_size) self.btn_close.connect('clicked', lambda x: self.destroy()) def __set_size(self, widget, extra=None): """""" if self.img >= 3: import webbrowser webbrowser.open("http://www.openmonitor.org") #print "".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'))"]) #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_website2.set_use_markup(True) self.lbl_program_description.set_justify(gtk.JUSTIFY_CENTER) self.lbl_copyright.set_selectable(False) self.lbl_program_description.set_selectable(False) self.lbl_program_version.set_selectable(False) self.lbl_program_website.set_selectable(False) def __set_img(self): """""" #ixmaps_dir = Path.pixmaps_dir #if pixmaps_dir: # logo = os.path.join(pixmaps_dir,'logo.png') #else: # logo = None logo = os.path.join(IMAGES_DIR, "logo.png") self.img_logo.set_from_file(logo)
class HostDiscovery(gtk.Window): """ GUI for network/host discovery. """ def __init__(self, daddy): gtk.Window.__init__(self) self.daddy = daddy self.rowsel = None self.tooltips = gtk.Tooltips() self.wtitle = _("Host Discovery") # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # discovery options self.netdetect_btn = gtk.Button(_("Detect network(s)")) self.netdetect_btn.connect('clicked', self.get_networks) self.networks_box = None self.addnetworks = gtk.Button(_("Add new entry")) self.addnetworks.connect('clicked', self._create_network_entry) self.hostdetect_btn = gtk.Button(_("Find hosts")) self.hostdetect_btn.connect('clicked', self.get_addresses) # target list self.target_lbl = HIGEntryLabel(_("Target list")) self.target_model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.tview = gtk.TreeView(self.target_model) self.tview.set_size_request(300, int(300 / 1.6)) self.tview.columns = [None] * 2 self.tview.columns[0] = gtk.TreeViewColumn(_("Host")) self.tview.columns[1] = gtk.TreeViewColumn(_("Network")) for n in range(2): self.tview.append_column(self.tview.columns[n]) self.tview.columns[n].cell = gtk.CellRendererText() self.tview.columns[n].pack_start(self.tview.columns[n].cell, True) self.tview.columns[n].set_attributes(self.tview.columns[n].cell, text=n) self.tview.get_selection().connect('changed', self._tview_sel_change) self.target_remove = gtk.Button(_("Remove from list")) self.target_remove.set_sensitive(False) self.target_remove.connect('clicked', self._remove_target) # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect('clicked', self._show_help) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect('clicked', self._exit) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect('clicked', self._return_list) # tooltips self.tooltips.set_tip(self.addnetworks, _("Add new entry for a network")) self.tooltips.set_tip(self.netdetect_btn, _("Try to detect network(s)")) self.tooltips.set_tip(self.hostdetect_btn, _("Find hosts in entered network(s)")) self.tooltips.set_tip(self.target_remove, _("Remove selection from target list")) self.__layout() def _create_network_entry(self, event): """ Create a new network entry. """ entry = gtk.Entry() entry.set_text('') entry.show() self.networks_box.add(entry) def _tview_sel_change(self, event): """ Row selection changed in treeview. """ model, tv_iter = event.get_selected() self.rowsel = tv_iter self.target_remove.set_sensitive(True) def _remove_target(self, event): """ Remove a host from target list. """ if self.rowsel: self.target_model.remove(self.rowsel) self.target_remove.set_sensitive(False) self.rowsel = None def _show_help(self, event): """ Show help. """ pass def _exit(self, event): """ Close window. """ self.daddy.discoverywin = None # daddy is NewInventory instance self.destroy() def _return_list(self, event): """ Return target list. """ hosts = [] for row in self.target_model: hosts.append(row[0]) self.results = ' '.join([str(h) for h in hosts]) if self.daddy: # NewInventory instance self.daddy.scantarget.set_text(self.results) self._exit(None) def get_networks(self, event): """ Try to detect network(s). """ networks = tryto_detect_networks() if not networks: dlg = HIGAlertDialog( self, message_format=_("No network(s) detected."), secondary_text=_( "You will need to especify the " "network(s) yourself before detecting hosts.")) dlg.run() dlg.destroy() return entries = len(self.networks_box.get_children()) - 1 for amount, nw in enumerate(networks): if amount == entries: e = gtk.Entry() e.set_text('') e.show() self.networks_box.add(e) entries += 1 entry = self.networks_box.get_children()[amount] entry.set_text(nw.cidr_netaddress()) def get_addresses(self, event): """ Get hosts for network(s). """ networks = [] for entry in self.networks_box.get_children()[:-1]: text_entry = entry.get_text() wrong = alpha.search(text_entry) if wrong: self._error_invalid_network(text_entry) return elif text_entry: networks.append(text_entry) if not networks: dlg = HIGAlertDialog(self, message_format=_("No network."), secondary_text=_( "You need to specify at least " "one network to search for hosts.")) dlg.run() dlg.destroy() return self.scans = {} self.scount = 0 for n in networks: discovery = NmapCommand("%s -sP %s" % ('nmap', n)) discovery.run_scan() self.scans[self.scount] = (discovery, n) self.scount += 1 self.target_model.clear() self.hostdetect_btn.set_sensitive(False) self._adjust_target_label() gobject.timeout_add(500, self._check_scans) def _adjust_target_label(self): """Update target_lbl according to the current scount (assumes that scount > 0).""" word = append_s(_("scan"), self.scount) self.target_lbl.set_label( _("Target list") + (" (%d) " % self.scount) + word + _(" running")) def _check_scans(self): """ Check if some scan finished. """ for item in self.scans.items(): index = item[0] scan = item[1][0] network = item[1][1] if not scan.scan_state(): # scan finished np = NmapParser(scan.get_xml_output_file()) np.parse() for host in np.nmap["hosts"]: # get hosts with 'up' state if host.state == 'up': self.target_model.append((host.ip['addr'], network)) # remove scan from list del self.scans[index] self.scount -= 1 if self.scount: self._adjust_target_label() # clean up temp files scan.close() if self.scount == 0: # all scans finished self.hostdetect_btn.set_sensitive(True) self.target_lbl.set_label(_("Target list")) return False return True def _error_invalid_network(self, network): """ Show error dialog for invalid network(s). """ dlg = HIGAlertDialog( self, message_format=_('Invalid network(s).'), secondary_text=(_("There is some invalid character in network") + (" %r" % network) + _("please verify."))) dlg.run() dlg.destroy() def __layout(self): """ Layout widgets """ main_vbox = HIGVBox() main_vbox.set_border_width(5) main_vbox.set_spacing(12) main_hpaned = gtk.HPaned() btns_hbox = HIGHBox() left_box = HIGVBox() right_box = gtk.VBox() header_hbox = HIGHBox() hostdetect_hbox = HIGHBox() targetl_hbox = HIGHBox() targetv_hbox = HIGHBox() targetr_hbox = HIGHBox() # header header_hbox._pack_expand_fill(self.ttitle) header_hbox._pack_noexpand_nofill(self.umit_logo) # network list netframe = HIGFrame(_("Network list")) settings_align = gtk.Alignment(0.5, 0.5, 1, 1) settings_align.set_padding(6, 0, 12, 0) nbox = HIGVBox() entry = gtk.Entry() entry.set_text(_("Sample 192.168.254.0/24")) nbox._pack_noexpand_nofill(entry) addnw_hbox = HIGHBox() addnw_hbox._pack_noexpand_nofill(self.addnetworks) nbox.pack_end(addnw_hbox, False, False, 0) self.networks_box = nbox settings_align.add(nbox) netframe.add(settings_align) # detection hostdetect_hbox._pack_noexpand_nofill(self.netdetect_btn) hostdetect_hbox._pack_noexpand_nofill(self.hostdetect_btn) # target list targetl_hbox._pack_noexpand_nofill(self.target_lbl) targetv_hbox._pack_expand_fill(self.tview) targetr_hbox.pack_end(self.target_remove, False, False, 0) # bottom buttons btns_hbox.set_homogeneous(True) btns_hbox._pack_expand_fill(self.help) btns_hbox._pack_expand_fill(hig_box_space_holder()) btns_hbox._pack_expand_fill(self.cancel) btns_hbox._pack_expand_fill(self.apply) # change apply button stock text lbl = self.apply.get_children()[0].get_children()[0].get_children()[1] lbl.set_text(_("Use target list")) left_box._pack_noexpand_nofill(netframe) left_box.pack_end(hostdetect_hbox, False, False, 0) right_box.pack_start(targetl_hbox, False, False, 0) right_box.pack_start(targetv_hbox, True, True, 6) right_box.pack_start(targetr_hbox, False, False, 0) left_align = gtk.Alignment(0.5, 0.5, 1, 1) left_align.set_padding(0, 0, 0, 6) left_align.add(left_box) right_align = gtk.Alignment(0.5, 0.5, 1, 1) right_align.set_padding(0, 0, 6, 0) right_align.add(right_box) main_hpaned.add1(left_align) main_hpaned.add2(right_align) main_vbox._pack_noexpand_nofill(header_hbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_expand_fill(main_hpaned) main_vbox.pack_end(btns_hbox, False, False, 0) self.add(main_vbox)
def __init__(self, daddy=None): HIGWindow.__init__(self) self.daddy = daddy self.wtitle = _("Scan Scheduler Editor") # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # schemas name self.schema_name_lbl = HIGEntryLabel(_("Schema Name")) self.schema_name = gtk.combo_box_entry_new_text() self.schema_name.connect('changed', self._check_schema) # target and scan profiles #self.target_lbl = HIGEntryLabel(_("Target")) #self.target = gtk.Entry() self.scan_name_lbl = HIGEntryLabel(_("Scan Profile")) self.scan_name = ProfileCombo() self.scan_name.update() self.scan_name.set_active(0) self.scan_name.connect('changed', self._set_scan_command) # scan command self.scan_command_lbl = HIGEntryLabel(_("Command")) self.scan_command = gtk.Entry() # scheduling profile self.sched_name_lbl = HIGEntryLabel(_("Scheduling Profile")) self.sched_name = gtk.combo_box_new_text() self.sched_name_edit = gtk.Button(stock=gtk.STOCK_EDIT) blbl = self.sched_name_edit.get_children()[0].get_children( )[0].get_children()[1] blbl.set_text(_("Edit Profiles")) self.sched_name_edit.connect('clicked', self._edit_schedprofiles) # schema settings self.schema_sett_frame = HIGFrame() self.setting_saveto = gtk.CheckButton(_("Save outputs to")) self.setting_saveto_entry = gtk.Entry() self.setting_saveto_browse = gtk.Button(_("...")) self.setting_saveto_browse.connect('clicked', self._select_saveto) self.setting_mailto = gtk.CheckButton(_("Send output to email")) self.setting_mailto_entry = gtk.Entry() self.setting_smtp_lbl = HIGEntryLabel(_("SMTP Schema")) self.setting_smtp = gtk.combo_box_new_text() self.setting_addtoinv = gtk.CheckButton(_("Add to the Inventory")) self.setting_enabled = gtk.CheckButton(_("Enabled")) # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect('clicked', self._show_help) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect('clicked', self._save_schema) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect('clicked', self._exit) self.ok = HIGButton(stock=gtk.STOCK_OK) self.ok.connect('clicked', self._save_schema_and_leave) self.load_smtp_schemas() self._set_scan_command(None) self.profile_running = None # no SchedProfileEditor instance is running. self._load_pscheds() self.load_schemas() self.__set_props() self.__do_layout() self.connect('destroy', self._exit)
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)
class SchedProfileEditor(HIGWindow): """ Scheduling Profiles Editor """ def __init__(self, daddy, profile=None): HIGWindow.__init__(self) self.daddy = daddy self.wtitle = _("Scheduling Profiles Editor") self.start_profile = profile # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # profiles name self.schedp_name_lbl = HIGEntryLabel(_("Scheduling Profile")) self.schedp_name = gtk.combo_box_entry_new_text() self.schedp_name.connect('changed', self._check_profile) # cron format self.cron_frame = HIGFrame(_("Schedule")) self.cron_minute_lbl = HIGEntryLabel(_("Minute")) self.cron_minute = gtk.Entry() self.cron_hour_lbl = HIGEntryLabel(_("Hour")) self.cron_hour = gtk.Entry() self.cron_day_lbl = HIGEntryLabel(_("Day of month")) self.cron_day = gtk.Entry() self.cron_month_lbl = HIGEntryLabel(_("Month")) self.cron_month = gtk.Entry() self.cron_weekday_lbl = HIGEntryLabel(_("Weekday")) self.cron_weekday = gtk.Entry() # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect('clicked', self._show_help) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect('clicked', self._save_profile) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect('clicked', self._exit) self.ok = HIGButton(stock=gtk.STOCK_OK) self.ok.connect('clicked', self._save_profile_and_leave) self.load_profiles() self.__set_props() self.__do_layout() self.connect('destroy', self._exit) def load_profiles(self): """ Load scheduling profiles. """ profiles = ConfigParser() profiles.read(Path.sched_profiles) self.sections = [] ind = 0 for indx, section in enumerate(profiles.sections()): self.sections.append(section) self.schedp_name.append_text(section) if section == self.start_profile: ind = indx self.schedp_name.set_active(ind) self._check_profile(None) def _load_profile(self): """ Load current set schedule profile. """ profile = ConfigParser() profile.read(Path.sched_profiles) values = { 'minute': self.cron_minute.set_text, 'hour': self.cron_hour.set_text, 'day': self.cron_day.set_text, 'month': self.cron_month.set_text, 'weekday': self.cron_weekday.set_text } for item in profile.items(self.schedp_name.get_active_text()): values[item[0]](item[1]) def _check_profile(self, event): """ Check if current text in schedp_name combobox is a profile name. """ if self.schedp_name.get_active_text() in self.sections: self._load_profile() else: self.cron_minute.set_text('') self.cron_hour.set_text('') self.cron_day.set_text('') self.cron_month.set_text('') self.cron_weekday.set_text('') def _save_profile(self, event): """ Save scheduling profile. """ pname = self.schedp_name.get_active_text() if not len(pname): dlg = HIGAlertDialog(self, message_format=_('Scheduling Profile - Error \ while saving'), secondary_text=_("You need to specify a name \ for Profile.")) dlg.run() dlg.destroy() return parser = CronParser() minute = self.cron_minute.get_text() hour = self.cron_hour.get_text() day = self.cron_day.get_text() month = self.cron_month.get_text() weekday = self.cron_weekday.get_text() try: parser.parse_minute(minute) parser.parse_hour(hour) parser.parse_day(day) parser.parse_month(month) parser.parse_weekday(weekday) except Exception, e: dlg = HIGAlertDialog(self, message_format=_('Scheduling Profile - Error \ while saving'), secondary_text=_("Check your cron syntax and \ try to save again.")) dlg.run() dlg.destroy() return # write profile to file p_cfg = ConfigParser() p_cfg.read(Path.sched_profiles) if not p_cfg.has_section(pname): new_sec = True p_cfg.add_section(pname) else: new_sec = False p_cfg.set(pname, 'minute', minute) p_cfg.set(pname, 'hour', hour) p_cfg.set(pname, 'day', day) p_cfg.set(pname, 'month', month) p_cfg.set(pname, 'weekday', weekday) p_cfg.write(open(Path.sched_profiles, 'w')) if new_sec: # update daddy scheduling profiles list self.daddy._load_pscheds()
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)
class SchedSchemaEditor(HIGWindow): """ Scheduler Schemas Editor """ def __init__(self, daddy=None): HIGWindow.__init__(self) self.daddy = daddy self.wtitle = _("Scan Scheduler Editor") # header self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.ttitle = HIGEntryLabel("") self.ttitle.set_line_wrap(False) self.ttitle.set_markup(self.title_markup % self.wtitle) self.umit_logo = gtk.Image() self.umit_logo.set_from_file(logo) # schemas name self.schema_name_lbl = HIGEntryLabel(_("Schema Name")) self.schema_name = gtk.combo_box_entry_new_text() self.schema_name.connect('changed', self._check_schema) # target and scan profiles #self.target_lbl = HIGEntryLabel(_("Target")) #self.target = gtk.Entry() self.scan_name_lbl = HIGEntryLabel(_("Scan Profile")) self.scan_name = ProfileCombo() self.scan_name.update() self.scan_name.set_active(0) self.scan_name.connect('changed', self._set_scan_command) # scan command self.scan_command_lbl = HIGEntryLabel(_("Command")) self.scan_command = gtk.Entry() # scheduling profile self.sched_name_lbl = HIGEntryLabel(_("Scheduling Profile")) self.sched_name = gtk.combo_box_new_text() self.sched_name_edit = gtk.Button(stock=gtk.STOCK_EDIT) blbl = self.sched_name_edit.get_children()[0].get_children( )[0].get_children()[1] blbl.set_text(_("Edit Profiles")) self.sched_name_edit.connect('clicked', self._edit_schedprofiles) # schema settings self.schema_sett_frame = HIGFrame() self.setting_saveto = gtk.CheckButton(_("Save outputs to")) self.setting_saveto_entry = gtk.Entry() self.setting_saveto_browse = gtk.Button(_("...")) self.setting_saveto_browse.connect('clicked', self._select_saveto) self.setting_mailto = gtk.CheckButton(_("Send output to email")) self.setting_mailto_entry = gtk.Entry() self.setting_smtp_lbl = HIGEntryLabel(_("SMTP Schema")) self.setting_smtp = gtk.combo_box_new_text() self.setting_addtoinv = gtk.CheckButton(_("Add to the Inventory")) self.setting_enabled = gtk.CheckButton(_("Enabled")) # bottom buttons self.help = HIGButton(stock=gtk.STOCK_HELP) self.help.connect('clicked', self._show_help) self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.apply.connect('clicked', self._save_schema) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.cancel.connect('clicked', self._exit) self.ok = HIGButton(stock=gtk.STOCK_OK) self.ok.connect('clicked', self._save_schema_and_leave) self.load_smtp_schemas() self._set_scan_command(None) self.profile_running = None # no SchedProfileEditor instance is running. self._load_pscheds() self.load_schemas() self.__set_props() self.__do_layout() self.connect('destroy', self._exit) def load_smtp_schemas(self): """ Load smtp profiles. """ schemas = ConfigParser() schemas.read(Path.smtp_schemas) self.smtp_sections = [] self.setting_smtp.get_model().clear() for section in schemas.sections(): self.smtp_sections.append(section) self.setting_smtp.append_text(section) self.setting_smtp.set_active(0) def load_schemas(self): """ Load schemas profiles. """ schemas = ConfigParser() schemas.read(Path.sched_schemas) self.sections = [] self.schema_name.get_model().clear() for section in schemas.sections(): self.sections.append(section) self.schema_name.append_text(section) self.schema_name.set_active(0) self._check_schema(None) def _load_schema(self): """ Load current set schedule schema. """ schema = ConfigParser() schema.read(Path.sched_schemas) values = { 'command': self.scan_command.set_text, 'saveto': self.setting_saveto_entry.set_text, 'mailto': self.setting_mailto_entry.set_text } enable = { 'saveto': self.setting_saveto.set_active, 'mailto': self.setting_mailto.set_active } for item in schema.items(self.schema_name.get_active_text()): if item[0] == 'addtoinv': self.setting_addtoinv.set_active(int(item[1])) if item[1] == '2': self.apply.set_sensitive(False) self.ok.set_sensitive(False) else: self.apply.set_sensitive(True) self.ok.set_sensitive(True) elif item[0] == 'enabled': self.setting_enabled.set_active(int(item[1])) elif item[0] == 'profile': pindx = self.profiles.index(item[1]) self.sched_name.set_active(pindx) elif item[0] == 'smtp': if item[1]: pindx = self.smtp_sections.index(item[1]) self.setting_smtp.set_active(pindx) else: values[item[0]](item[1]) if item[0] in ('saveto', 'mailto'): if len(item[1]): enable[item[0]](True) else: enable[item[0]](False) def _check_schema(self, event): """ Check if current text in schema_name combobox is a schema name. """ if self.schema_name.get_active_text() in self.sections: # load schema self._load_schema() else: # reset to default values self.apply.set_sensitive(True) self.ok.set_sensitive(True) self.setting_addtoinv.set_active(False) self.setting_enabled.set_active(False) self.setting_mailto.set_active(False) self.setting_mailto_entry.set_text('') self.setting_saveto.set_active(False) self.setting_saveto_entry.set_text('') self.schema_sett_frame._set_label(self.schema_name.get_active_text() \ + " - Settings") def _set_scan_command(self, event): """ Set scan command based on chosen profile. """ profile = self.scan_name.get_selected_profile() cmd_profile = CommandProfile() command = cmd_profile.get_command(profile) self.scan_command.set_text(command % '<target>') def _load_pscheds(self): """ Load scheduling profiles. """ pscheds = ConfigParser() pscheds.read(Path.sched_profiles) self.profiles = [] self.sched_name.get_model().clear() for section in pscheds.sections(): self.sched_name.append_text(section) self.profiles.append(section) self.sched_name.set_active(0) def _edit_schedprofiles(self, event): """ Open Scheduling Profiles Editor. """ if self.profile_running: return win = SchedProfileEditor(self, self.sched_name.get_active_text()) win.show_all() self.profile_running = win def _select_saveto(self, event): """ Select directory to save file. """ dir_chooser = DirectoryChooserDialog(_("Select a directory")) dir_chooser.run() dir_chosen = dir_chooser.get_filename() dir_chooser.destroy() self.setting_saveto_entry.set_text(dir_chosen) def _save_schema(self, event): """ Save current schema. """ schema = self.schema_name.get_active_text() command = self.scan_command.get_text() schedule = self.sched_name.get_active_text() mailto = self.setting_mailto.get_active() if not schema or not schedule or not command or '<target>' in command: dlg = HIGAlertDialog(self, message_format=_('Scheduling Schema - Error\ while saving.'), secondary_text=_("There is some error in at \ least one of the following fields: \"Schema name\", \"Command\" or \"Scheduling\ Profile\"\n\nCheck if \"Schema name\" is not empty.\nCheck if \"Command\" does\ contain \"<target>\" on it.\nCheck if there is some \"Scheduling Profile\" \ selected.")) dlg.run() dlg.destroy() return if mailto and not self.setting_smtp.get_active_text(): dlg = HIGAlertDialog(self, message_format=_('Scheduling Schema - Error\ while saving.'), secondary_text=_("You need to create a \ a SMTP Schema for sending email.")) dlg.run() dlg.destroy() return # check for output existance if self.setting_saveto.get_active() and \ not os.path.isdir(self.setting_saveto_entry.get_text()): dlg = HIGAlertDialog(self, message_format=_('Scheduling Schema - Error\ while saving.'), secondary_text=_("You especified an invalid \ directory to save scans output.")) dlg.run() dlg.destroy() return # write schema to file s_cfg = ConfigParser() s_cfg.read(Path.sched_schemas) if not s_cfg.has_section(schema): new_sec = True s_cfg.add_section(schema) else: new_sec = False s_cfg.set(schema, 'profile', schedule) s_cfg.set(schema, 'command', command) if self.setting_enabled.get_active(): s_cfg.set(schema, 'enabled', '1') else: s_cfg.set(schema, 'enabled', '0') if self.setting_addtoinv.get_active(): s_cfg.set(schema, 'addtoinv', '1') else: s_cfg.set(schema, 'addtoinv', '0') if self.setting_saveto.get_active(): s_cfg.set(schema, 'saveto', self.setting_saveto_entry.get_text()) else: s_cfg.set(schema, 'saveto', '') if mailto: s_cfg.set(schema, 'mailto', self.setting_mailto_entry.get_text()) s_cfg.set(schema, 'smtp', self.setting_smtp.get_active_text()) else: s_cfg.set(schema, 'mailto', '') s_cfg.set(schema, 'smtp', '') s_cfg.write(open(Path.sched_schemas, 'w')) if new_sec: self.load_schemas() if self.daddy: self.daddy.load_schemas() def _save_schema_and_leave(self, event): """ Save current schema and close editor. """ self._save_schema(None) self._exit(None) def _show_help(self, event): """ Show help for Scan Scheduler Editor. """ show_help(self, "scheduler.html#setting-up-a-schedule") def __set_props(self): """ Set window properties. """ self.set_title(self.wtitle) self.set_default_size(440, -1) def __do_layout(self): """ Layout widgets in window. """ main_vbox = HIGVBox() main_vbox.set_border_width(5) main_vbox.set_spacing(12) header_hbox = HIGHBox() schema_table = HIGTable() schedsn_hbox = HIGHBox() sett_table = HIGTable() btns_hbox = HIGHBox() header_hbox._pack_expand_fill(self.ttitle) header_hbox._pack_noexpand_nofill(self.umit_logo) # schema name schema_table.attach_label(self.schema_name_lbl, 0, 1, 0, 1) schema_table.attach_entry(self.schema_name, 1, 2, 0, 1) # target and scan profile schema_table.attach_label(self.scan_name_lbl, 0, 1, 1, 2) schema_table.attach_entry(self.scan_name, 1, 2, 1, 2) # scan command schema_table.attach_label(self.scan_command_lbl, 0, 1, 2, 3) schema_table.attach_label(self.scan_command, 1, 2, 2, 3) # scheduling profile schedsn_hbox._pack_expand_fill(self.sched_name) schedsn_hbox._pack_noexpand_nofill(self.sched_name_edit) schema_table.attach_label(self.sched_name_lbl, 0, 1, 3, 4) schema_table.attach_entry(schedsn_hbox, 1, 2, 3, 4) # settings frame settings_align = gtk.Alignment(0.5, 0.5, 1, 1) settings_align.set_padding(6, 0, 12, 0) schemasett_hbox = HIGVBox() # saveto sett_hbox = HIGHBox() sett_hbox._pack_expand_fill(self.setting_saveto_entry) sett_hbox._pack_noexpand_nofill(self.setting_saveto_browse) sett_table.attach_label(self.setting_saveto, 0, 1, 0, 1) sett_table.attach_entry(sett_hbox, 1, 2, 0, 1) # mailto, smtp sett_hbox = HIGHBox() sett_hbox._pack_expand_fill(self.setting_mailto_entry) sett_hbox._pack_noexpand_nofill(self.setting_smtp_lbl) sett_hbox._pack_expand_fill(self.setting_smtp) sett_table.attach_label(self.setting_mailto, 0, 1, 1, 2) sett_table.attach_entry(sett_hbox, 1, 2, 1, 2) schemasett_hbox._pack_noexpand_nofill(sett_table) # add to inventory sett_hbox = HIGHBox() sett_hbox._pack_noexpand_nofill(self.setting_addtoinv) schemasett_hbox._pack_noexpand_nofill(sett_hbox) # enabled/disabled sett_hbox = HIGHBox() sett_hbox._pack_noexpand_nofill(self.setting_enabled) schemasett_hbox._pack_noexpand_nofill(sett_hbox) settings_align.add(schemasett_hbox) self.schema_sett_frame.add(settings_align) # bottom buttons btns_hbox.set_homogeneous(True) btns_hbox._pack_expand_fill(self.help) btns_hbox._pack_expand_fill(hig_box_space_holder()) btns_hbox._pack_expand_fill(self.apply) btns_hbox._pack_expand_fill(self.cancel) btns_hbox._pack_expand_fill(self.ok) main_vbox._pack_noexpand_nofill(header_hbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(schema_table) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(self.schema_sett_frame) main_vbox.pack_end(btns_hbox, False, False, 0) self.add(main_vbox) def _exit(self, event): """ Close current and window and profile editor if it is running. """ if self.profile_running: self.profile_running._exit(None) if self.daddy: self.daddy.schemawin = None self.destroy() def _get_profile_running(self): """ Get profile editor running instance. """ return self.__profilerunning def _set_profile_running(self, running): """ Set profile editor instance. """ self.__profilerunning = running # Properties profile_running = property(_get_profile_running, _set_profile_running)
class NISettingsBox(): def __init__(self, create_buttons=True): self.__create_widgets() if (create_buttons): self.__create_buttons() self._fill_comboboxes() self._load_settings() self.main_vbox = self.__do_layout(create_buttons) def __create_widgets(self): self.timeline = HIGFrame(_("Timeline Settings")) self.tl_mode_lbl = gtk.Label(_("Timeline view mode")) self.tl_kind_lbl = gtk.Label(_("Timeline view kind")) self.tl_mode = gtk.combo_box_new_text() self.tl_kind = gtk.combo_box_new_text() self.tabs = HIGFrame(_("Devices tab")) self.tabs_cbtn = gtk.CheckButton(_("Place close button")) self.sbar = HIGFrame(_("Statusbar")) self.sbar_tips = gtk.CheckButton(_("Show tips")) def __create_buttons(self): # bottom buttons self.apply = HIGButton(stock=gtk.STOCK_APPLY) self.cancel = HIGButton(stock=gtk.STOCK_CANCEL) self.ok = HIGButton(stock=gtk.STOCK_OK) self.apply.connect("clicked", self._apply_settings) self.ok.connect("clicked", self._apply_settings_exit) self.cancel.connect("clicked", self._exit) def _fill_comboboxes(self): """ Fill timeline mode and timeline kind combo boxes with available options. """ self.tl_kind_opts = {} self.tl_mode_opts = {} for opt, value in view_kind.items(): self.tl_kind.append_text(value) self.tl_kind_opts[opt] = value for opt, value in view_mode.items(): self.tl_mode.append_text(value) self.tl_mode_opts[opt] = value def _load_settings(self): """ Load current settings values. """ options = startup_options() start_tlkind = self.tl_kind_opts[options['kind']] start_tlmode = self.tl_mode_opts[options['mode']] store = self.tl_kind.get_model() for indx, item in enumerate(store): if item[0] == start_tlkind: self.tl_kind.set_active(indx) break store = self.tl_mode.get_model() for indx, item in enumerate(store): if item[0] == start_tlmode: self.tl_mode.set_active(indx) break self.tabs_cbtn.set_active(options['tabs_close_btn']) self.sbar_tips.set_active(options['tips']) def _apply_settings(self, event): """ Apply current settings. """ curr_kind = self.tl_kind.get_active_text() for kind, value in self.tl_kind_opts.items(): if value == curr_kind: curr_kind = kind break curr_mode = self.tl_mode.get_active_text() for mode, value in self.tl_mode_opts.items(): if value == curr_mode: curr_mode = mode break write_startup_setting(TL_SECTION, "mode", curr_mode) write_startup_setting(TL_SECTION, "kind", curr_kind) write_startup_setting(INV_SECTION, "tabs_close_btn", self.tabs_cbtn.get_active()) write_startup_setting(INV_SECTION, "tips", self.sbar_tips.get_active()) def _apply_settings_exit(self, event): """ Apply current settings and leave. """ self._apply_settings(None) self._exit(None) def _exit(self, event): """ Close this window. """ self.destroy() def __set_props(self): """ Window properties. """ self.set_title(_("Network Inventory Settings")) self.set_default_size(305, -1) def __do_layout(self, create_buttons): main_vbox = HIGVBox() # timeline frame tl_settings_align = gtk.Alignment(0.5, 0.5, 1, 1) tl_settings_align.set_padding(6, 0, 12, 0) tl_settings_vbox = HIGVBox() mode_hbox = HIGHBox() mode_hbox._pack_noexpand_nofill(self.tl_mode_lbl) mode_hbox._pack_expand_fill(self.tl_mode) kind_hbox = HIGHBox() kind_hbox._pack_noexpand_nofill(self.tl_kind_lbl) kind_hbox._pack_expand_fill(self.tl_kind) tl_settings_vbox._pack_noexpand_nofill(mode_hbox) tl_settings_vbox._pack_noexpand_nofill(kind_hbox) tl_settings_align.add(tl_settings_vbox) self.timeline.add(tl_settings_align) main_vbox._pack_noexpand_nofill(self.timeline) # end timeline frame # statusbar frame sbar_settings_align = gtk.Alignment(0.5, 0.5, 1, 1) sbar_settings_align.set_padding(6, 0, 12, 0) sbar_settings_vbox = HIGVBox() sbar_settings_vbox._pack_noexpand_nofill(self.sbar_tips) sbar_settings_align.add(sbar_settings_vbox) self.sbar.add(sbar_settings_align) main_vbox._pack_noexpand_nofill(self.sbar) # end statusbar frame # tabs frame tabs_settings_align = gtk.Alignment(0.5, 0.5, 1, 1) tabs_settings_align.set_padding(6, 0, 12, 0) tabs_settings_vbox = HIGVBox() tabs_settings_vbox._pack_noexpand_nofill(self.tabs_cbtn) tabs_settings_align.add(tabs_settings_vbox) self.tabs.add(tabs_settings_align) main_vbox._pack_noexpand_nofill(self.tabs) # end tabs frame if create_buttons: # buttons box btnsbox = HIGHBox() btnsbox._pack_noexpand_nofill(self.apply) btnsbox._pack_noexpand_nofill(self.cancel) btnsbox._pack_noexpand_nofill(self.ok) bbox = gtk.HBox() bbox.pack_end(btnsbox, False, False, 0) main_vbox.pack_end(bbox, False, False, 0) main_vbox.pack_end(gtk.HSeparator(), False, False, 0) # end buttons box return main_vbox def get_layout(self): return self.main_vbox
class DiffWindow(gtk.Window): def __init__(self, scans): """scans in the format: {"scan_title":parsed_scan} """ gtk.Window.__init__(self) self.set_title(_("Compare Results")) self.scans = scans self.umit_conf = UmitConf() self.colors = Colors() # Diff views self.text_view = DiffText(self.colors, self.umit_conf.colored_diff) self.compare_view = DiffTree(self.colors) self._create_widgets() self._pack_widgets() self._connect_widgets() # Settings if self.umit_conf.diff_mode == "text": self.text_mode.set_active(True) else: self.compare_mode.set_active(True) self.check_color.set_active(self.umit_conf.colored_diff) # Initial Size Request self.initial_size = self.size_request() def _show_help(self, action): show_help(self, "index.html") def _create_widgets(self): self.main_vbox = HIGVBox() self.hbox_mode = HIGHBox() self.hbox_settings = HIGHBox() self.hbox_buttons = HIGHBox() self.hbox_result = HIGHBox() self.btn_open_browser = HIGButton(_("Open in Browser"), stock=gtk.STOCK_EXECUTE) self.btn_help = HIGButton(stock=gtk.STOCK_HELP) self.btn_close = HIGButton(stock=gtk.STOCK_CLOSE) self.check_color = gtk.CheckButton(_("Enable colored diffies")) self.btn_legend = HIGButton(_("Color Descriptions"), stock=gtk.STOCK_SELECT_COLOR) self.text_mode = gtk.ToggleButton(_("Text Mode")) self.compare_mode = gtk.ToggleButton(_("Compare Mode")) self.vpaned = gtk.VPaned() self.hpaned = gtk.HPaned() self.scan_chooser1 = ScanChooser(self.scans, "1") self.scan_chooser2 = ScanChooser(self.scans, "2") self.scan_buffer1 = self.scan_chooser1.get_buffer() self.scan_buffer2 = self.scan_chooser2.get_buffer() def _pack_widgets(self): self.main_vbox.set_border_width(6) self.vpaned.pack1(self.hpaned, True, False) self.vpaned.pack2(self.hbox_result) self.hpaned.pack1(self.scan_chooser1, True, False) self.hpaned.pack2(self.scan_chooser2, True, False) self.hbox_buttons._pack_expand_fill(self.btn_help) self.hbox_buttons._pack_expand_fill(self.btn_legend) self.hbox_buttons._pack_expand_fill(self.btn_open_browser) self.hbox_buttons._pack_expand_fill(self.btn_close) self.hbox_buttons.set_homogeneous(True) self.hbox_mode.set_homogeneous(True) self.hbox_mode.pack_start(self.text_mode) self.hbox_mode.pack_start(self.compare_mode) self.hbox_settings._pack_noexpand_nofill(self.hbox_mode) self.hbox_settings._pack_expand_fill(self.check_color) self.main_vbox._pack_expand_fill(self.vpaned) self.main_vbox._pack_noexpand_nofill(self.hbox_settings) self.main_vbox._pack_noexpand_nofill(self.hbox_buttons) self.add(self.main_vbox) def _connect_widgets(self): self.connect("delete-event", self.close) self.btn_legend.connect("clicked", self.show_legend_window) self.btn_help.connect("clicked", self._show_help) self.btn_close.connect("clicked", self.close) self.btn_open_browser.connect("clicked", self.open_browser) self.check_color.connect("toggled", self._set_color) self.text_mode.connect("clicked", self._change_to_text) self.compare_mode.connect("clicked", self._change_to_compare) self.scan_chooser1.exp_scan.connect('activate', self.resize_vpane) self.scan_chooser2.exp_scan.connect('activate', self.resize_vpane) self.scan_buffer1.connect('changed', self.text_changed) self.scan_buffer2.connect('changed', self.text_changed) def open_browser(self, widget): text1=self.scan_buffer1.get_text(self.scan_buffer1.get_start_iter(),\ self.scan_buffer1.get_end_iter()) text2=self.scan_buffer2.get_text(self.scan_buffer2.get_start_iter(),\ self.scan_buffer2.get_end_iter()) if not text1 or not text2: alert = HIGAlertDialog( message_format='<b>' + _('Select Scan') + '</b>', secondary_text=_("You must select two different scans to \ generate diff.")) alert.run() alert.destroy() return False text1 = text1.split('\n') text2 = text2.split('\n') self.temp_view = mktemp('.html') text1 = [text + '\n' for text in text1] text2 = [text + '\n' for text in text2] if use_html: diff = DiffHtml(text1, text2) diff = diff.generate() file_desc = open(self.temp_view, 'w') file_desc.write(''.join(diff)) # Closing file to avoid problems with file descriptors file_desc.close() else: diff = Diff(text1, text2) diff = diff.generate() diff.insert( 0, '''<pre>(This diff is been shown in pure text \ because you dont have Python 2.4 or higher.)\n''') diff.append('</pre>') file_desc = open(self.temp_view, 'w') file_desc.writelines(diff) # Closing file to avoid problems with file descriptors file_desc.close() webbrowser.open("file://" + self.temp_view, autoraise=1) def show_legend_window(self, widget): legend_window = DiffLegendWindow(self.colors) legend_window.run() legend_window.destroy() self.text_changed(None) def text_changed(self, widget): text1 = self.scan_buffer1.get_text(self.scan_buffer1.get_start_iter(),\ self.scan_buffer1.get_end_iter()) text2 = self.scan_buffer2.get_text(self.scan_buffer2.get_start_iter(),\ self.scan_buffer2.get_end_iter()) if text1 != '' and text2 != '': if self.compare_mode.get_active(): self.compare_view.make_diff(self.scan_chooser1.parsed_scan, self.scan_chooser2.parsed_scan) self.compare_view.activate_color(self.check_color.get_active()) else: self.text1 = text1.split('\n') self.text2 = text2.split('\n') self.diff = Diff(self.text1, self.text2) self.text_view.txt_diff_result.get_buffer().set_text\ ('\n'.join(self.diff.generate_without_banner())) self.text_view.activate_color(self.check_color.get_active()) self.text_view._text_changed(None) def resize_vpane(self, widget): exp1 = not widget.get_expanded() if widget == self.scan_chooser1.exp_scan: exp2 = self.scan_chooser2.exp_scan.get_expanded() else: exp2 = self.scan_chooser1.exp_scan.get_expanded() if not exp1 and not exp2: self.vpaned.compute_position(-1, 0, 500) self.size_allocate( gtk.gdk.Rectangle(width=self.initial_size[0], height=self.initial_size[1])) self.queue_resize() def _change_to_text(self, widget): if not widget.get_active(): return self.umit_conf.diff_mode = "text" children = self.hbox_result.get_children() if children: self.hbox_result.remove(children[0]) self.compare_view.hide() self.hbox_result._pack_expand_fill(self.text_view) self.text_view.show_all() self.compare_mode.set_active(False) self.text_changed(None) def _change_to_compare(self, widget): if not widget.get_active(): return self.umit_conf.diff_mode = "compare" children = self.hbox_result.get_children() if children: self.hbox_result.remove(children[0]) self.text_view.hide() self.hbox_result._pack_expand_fill(self.compare_view) self.compare_view.show_all() self.text_mode.set_active(False) self.text_changed(None) def _set_color(self, widget): activate = widget.get_active() self.umit_conf.colored_diff = activate self.compare_view.activate_color(activate) self.text_view.activate_color(activate) def close(self, widget=None, extra=None): self.destroy()