def __create_wizard_widgets(self): self.wizard_title = HIGEntryLabel("") self.wizard_title.set_line_wrap(False) self.wizard_event = gtk.EventBox() self.wizard_logo = gtk.Image() self.wizard_event.add(self.wizard_logo) self.d = {} for c in (65, 97): for i in range(26): self.d[chr(i + c)] = chr((i + 13) % 26 + c) self.img = 1 command_hbox = HIGHBox() self.command_label = HIGEntryLabel(_("Command")) self.command_entry = gtk.Entry() separator = gtk.HSeparator() self.wizard_header_hbox = HIGHBox() self.wizard_header_hbox._pack_expand_fill(self.wizard_title) self.wizard_header_hbox._pack_noexpand_nofill(self.wizard_event) command_hbox._pack_noexpand_nofill(self.command_label) command_hbox._pack_expand_fill(self.command_entry) self.main_vbox._pack_noexpand_nofill(self.wizard_header_hbox) self.main_vbox._pack_noexpand_nofill(command_hbox) self.main_vbox._pack_noexpand_nofill(separator) self.wizard_logo.set_from_file(logo)
def __create_wizard_widgets(self): self.wizard_title = HIGEntryLabel("") self.wizard_title.set_line_wrap(False) self.wizard_event = gtk.EventBox() self.wizard_logo = gtk.Image() self.wizard_event.add(self.wizard_logo) self.d = {} for c in (65, 97): for i in range(26): self.d[chr(i+c)] = chr((i+13) % 26 + c) self.img = 1 command_hbox = HIGHBox() self.command_label = HIGEntryLabel(_("Command")) self.command_entry = gtk.Entry() separator = gtk.HSeparator() self.wizard_header_hbox = HIGHBox() self.wizard_header_hbox._pack_expand_fill(self.wizard_title) self.wizard_header_hbox._pack_noexpand_nofill(self.wizard_event) command_hbox._pack_noexpand_nofill(self.command_label) command_hbox._pack_expand_fill(self.command_entry) self.main_vbox._pack_noexpand_nofill(self.wizard_header_hbox) self.main_vbox._pack_noexpand_nofill(command_hbox) self.main_vbox._pack_noexpand_nofill(separator) self.wizard_logo.set_from_file(logo)
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
class ScanMapperPage(HIGVBox): def __init__(self): HIGVBox.__init__(self) self.__parser = None self.__radialnet = None self.__created = False def create_widgets(self): if self.__created: self.__toolbar.enable_tools() self.update_graph() return self.set_spacing(0) self.__hbox = HIGHBox(spacing=0) # Create RadialNet self.__radialnet = RadialNet(LAYOUT_WEIGHTED) self.__radialnet.set_no_show_all(True) self.__radialnet.set_empty() self.update_graph() self.__radialnet.show() # Create Controlors self.__control = ControlWidget(self.__radialnet) self.__control_sw = HIGScrolledWindow() self.__control_sw.set_no_show_all(True) self.__control_sw.add_with_viewport(self.__control) self.__control_sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) self.__fisheye = ControlFisheye(self.__radialnet) self.__fisheye.set_no_show_all(True) self.__toolbar = Toolbar(self.__radialnet, self, self.__control_sw, self.__fisheye) self.__toolbar.disable_tools() self.__hbox._pack_expand_fill(self.__radialnet) self.__hbox._pack_noexpand_nofill(self.__control_sw) self._pack_noexpand_nofill(self.__toolbar) self._pack_expand_fill(self.__hbox) self._pack_noexpand_nofill(self.__fisheye) self.show_all() self.__created = True def update_graph(self): self.__graph = GraphBuilder() self.__graph.make(self.__parser) self.__radialnet.set_graph(self.__graph) def set_parse(self, parse): self.__parser = parse if self.__radialnet is not None: self.__radialnet.set_graph(self.__graph)
class ChoosePage(HIGVBox): def __init__(self): HIGVBox.__init__(self) self.set_spacing(12) table = HIGTable() self.hbox = HIGHBox() self.description = HIGEntryLabel( _("""You wish to create a new profile,\ or just want to quickly create a command and run it once?""")) self.profile_radio = gtk.RadioButton(None, _('Profile')) self.command_radio = gtk.RadioButton(self.profile_radio, _('Command')) self.command_radio.connect('toggled', self.enable_target) self.profile_radio.connect('toggled', self.disable_target) self.target_label = HIGEntryLabel(_("Target")) self.target_entry = gtk.Entry() self.set_completion() self.hbox._pack_noexpand_nofill(hig_box_space_holder()) self.hbox._pack_noexpand_nofill(self.target_label) self.hbox._pack_expand_fill(self.target_entry) self.bar = ForwardBar() self._pack_noexpand_nofill(self.description) self._pack_expand_fill(table) self._pack_noexpand_nofill(self.bar) table.attach(self.profile_radio, 0, 1, 0, 1, yoptions=0) table.attach(self.command_radio, 0, 1, 1, 2, yoptions=0) table.attach(self.hbox, 0, 1, 2, 3, yoptions=0) self.disable_target() def set_completion(self): self.completion = gtk.EntryCompletion() self.target_list = gtk.ListStore(str) self.completion.set_model(self.target_list) self.completion.set_text_column(0) self.target_entry.set_completion(self.completion) for target in target_list.get_target_list()[:15]: self.target_list.append([target.replace('\n', '')]) def add_new_target(self, target): target_list.add_target(target) def enable_target(self, widget=None): self.hbox.set_sensitive(True) def disable_target(self, widget=None): self.hbox.set_sensitive(False)
class ChoosePage(HIGVBox): def __init__(self): HIGVBox.__init__(self) self.set_spacing(12) table = HIGTable() self.hbox = HIGHBox() self.description = HIGEntryLabel(_("""You wish to create a new profile,\ or just want to quickly create a command and run it once?""")) self.profile_radio = gtk.RadioButton(None, _('Profile')) self.command_radio = gtk.RadioButton(self.profile_radio, _('Command')) self.command_radio.connect('toggled', self.enable_target) self.profile_radio.connect('toggled', self.disable_target) self.target_label = HIGEntryLabel(_("Target")) self.target_entry = gtk.Entry() self.set_completion() self.hbox._pack_noexpand_nofill(hig_box_space_holder()) self.hbox._pack_noexpand_nofill(self.target_label) self.hbox._pack_expand_fill(self.target_entry) self.bar = ForwardBar() self._pack_noexpand_nofill(self.description) self._pack_expand_fill(table) self._pack_noexpand_nofill(self.bar) table.attach(self.profile_radio,0,1,0,1, yoptions=0) table.attach(self.command_radio,0,1,1,2, yoptions=0) table.attach(self.hbox,0,1,2,3, yoptions=0) self.disable_target() def set_completion(self): self.completion = gtk.EntryCompletion() self.target_list = gtk.ListStore(str) self.completion.set_model(self.target_list) self.completion.set_text_column(0) self.target_entry.set_completion(self.completion) for target in target_list.get_target_list()[:15]: self.target_list.append([target.replace('\n','')]) def add_new_target(self, target): target_list.add_target(target) def enable_target(self, widget=None): self.hbox.set_sensitive(True) def disable_target(self, widget=None): self.hbox.set_sensitive(False)
class LogsWindow(HIGWindow): """ Logs Window """ def __init__(self): HIGWindow.__init__(self, type=gtk.WINDOW_TOPLEVEL) self.set_title(_('Logs')) self.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.set_size_request(720,480) self.set_border_width(10) self.__create_widgets() self.__pack_widgets() self.__connect_widgets() #test #from umit.icm.agent.gui.Notifications import * #t = NotificationUpdate(mode=new_release_mode,text="test",timeout=10000) def __create_widgets(self): """""" #box self.main_vbox = HIGVBox() self.btn_box = gtk.HButtonBox() self.LogsGUI_vbox = HIGHBox() self.main_vbox.set_border_width(2) #close button self.close_button = gtk.Button(stock=gtk.STOCK_CLOSE) #log information box self.LogsGUI_hbox1 = HIGHBox() self.LogsGUI_hbox2 = HIGHBox() self.LogsGUI_subbox = LogsGUI() def __pack_widgets(self): self.main_vbox._pack_expand_fill(self.LogsGUI_vbox) self.main_vbox._pack_noexpand_nofill(self.btn_box) self.LogsGUI_vbox._pack_expand_fill(self.LogsGUI_hbox1) self.LogsGUI_vbox._pack_noexpand_nofill(self.LogsGUI_hbox2) self.LogsGUI_hbox1._pack_expand_fill(self.LogsGUI_subbox) self.btn_box.set_layout(gtk.BUTTONBOX_END) self.btn_box.set_spacing(8) self.btn_box.pack_start(self.close_button) self.add(self.main_vbox) def __connect_widgets(self): """""" self.close_button.connect('clicked', lambda x: self.destroy())
class SaveDialog(gtk.FileChooserDialog): def __init__(self): """ """ super(SaveDialog, self).__init__( title=_("Save Topology"), action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK), ) self.__combo = gtk.combo_box_new_text() types_list = TYPES.keys() types_list.sort() for i in types_list: self.__combo.append_text(i) self.__combo.set_active(1) self.__label = HIGLabel(_("Select the output type:")) self.__hbox = HIGHBox() self.__hbox._pack_noexpand_nofill(self.__label) self.__hbox._pack_expand_fill(self.__combo) self.set_extra_widget(self.__hbox) self.set_do_overwrite_confirmation(True) self.__hbox.show_all() def show_error(self): """ """ alert = HIGAlertDialog( parent=self, type=gtk.MESSAGE_ERROR, message_format=_("Can't create file"), secondary_text=_("Please check if you have permission to " "write this file."), ) alert.run() alert.destroy() def get_filetype(self): """ """ return TYPES[self.__combo.get_active_text()]
class SaveDialog(gtk.FileChooserDialog): def __init__(self): """ """ super(SaveDialog, self).__init__(title=_("Save Topology"), action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK)) self.__combo = gtk.combo_box_new_text() types_list = TYPES.keys() types_list.sort() for i in types_list: self.__combo.append_text(i) self.__combo.set_active(1) self.__label = HIGLabel(_("Select the output type:")) self.__hbox = HIGHBox() self.__hbox._pack_noexpand_nofill(self.__label) self.__hbox._pack_expand_fill(self.__combo) self.set_extra_widget(self.__hbox) self.set_do_overwrite_confirmation(True) self.__hbox.show_all() def show_error(self): """ """ alert = HIGAlertDialog(parent=self, type=gtk.MESSAGE_ERROR, message_format=_("Can't create file"), secondary_text=_( "Please check if you have permission to " "write this file.")) alert.run() alert.destroy() def get_filetype(self): """ """ return TYPES[self.__combo.get_active_text()]
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)
class ControlRingGap(HIGVBox): """ """ def __init__(self, radialnet): """ """ HIGVBox.__init__(self) self.radialnet = radialnet self.__create_widgets() def __create_widgets(self): """ """ self.__radius = ControlVariable('Ring gap', self.radialnet.get_ring_gap, self.radialnet.set_ring_gap) self.__label = gtk.Label('Lower ring gap') self.__label.set_alignment(0.0, 0.5) self.__adjustment = gtk.Adjustment(self.radialnet.get_min_ring_gap(), 0, 50, 1) self.__spin = gtk.SpinButton(self.__adjustment) self.__spin.connect('value_changed', self.__change_lower) self.__lower_hbox = HIGHBox() self.__lower_hbox._pack_expand_fill(self.__label) self.__lower_hbox._pack_noexpand_nofill(self.__spin) self._pack_noexpand_nofill(self.__radius) self._pack_noexpand_nofill(self.__lower_hbox) def __change_lower(self, widget): """ """ if not self.radialnet.set_min_ring_gap(self.__adjustment.get_value()): self.__adjustment.set_value(self.radialnet.get_min_ring_gap())
def set_comment(self, comment=''): self.comment_expander.set_use_markup(True) if comment: self.comment_expander.set_expanded(True) hbox = HIGHBox() self.comment_scrolled = gtk.ScrolledWindow() self.comment_scrolled.set_border_width(5) self.comment_scrolled.set_policy(gtk.POLICY_AUTOMATIC,\ gtk.POLICY_AUTOMATIC) self.comment_txt_vw = gtk.TextView() self.comment_txt_vw.set_wrap_mode(gtk.WRAP_WORD) self.comment_txt_vw.get_buffer().set_text(comment) self.comment_scrolled.add(self.comment_txt_vw) hbox._pack_expand_fill(self.comment_scrolled) self.comment_expander.add(hbox) self._pack_noexpand_nofill(self.comment_expander)
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 NodeWindow(HIGWindow): """ """ def __init__(self, node, position, parent): """ """ HIGWindow.__init__(self, gtk.WINDOW_POPUP) self.set_decorated(False) self.set_keep_above(True) self.set_skip_taskbar_hint(True) self.move(position[0], position[1]) self.set_size_request(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.__button_press_position = self.get_pointer() self.__is_compacted = True self.__is_collapsed = False self.__node = node self.__pressed = False self.__parent = parent self.connect('button_press_event', self.button_press) self.connect('button_release_event', self.button_release) self.connect('enter_notify_event', self.enter_notify) self.connect('leave_notify_event', self.leave_notify) self.connect('motion_notify_event', self.motion_notify) self.__title_font = pango.FontDescription('Monospace Bold') self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.ENTER_NOTIFY | gtk.gdk.LEAVE_NOTIFY | gtk.gdk.POINTER_MOTION_HINT_MASK) self.__icon = Application() self.__create_widgets() def __create_widgets(self): """ """ self.__content = HIGVBox() self.__head = HIGHBox(spacing=2) self.__notebook = NodeNotebook(self.__node) # create head elements # icon with node's score color self.__color_box = gtk.EventBox() self.__color_image = gtk.Image() self.__color_image.set_from_file(self.__icon.get_icon('border')) self.__color_box.add(self.__color_image) self.__color_box.set_size_request(15, 15) r, g, b = drawing.cairo_to_gdk_color(self.__node.get_draw_info('color')) self.__color_box.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(r, g, b)) # title with the node ip and hostname self.__title = "" if self.__node.get_info('hostname') is not None: self.__title = self.__node.get_info('hostname') + ' - ' self.__title += self.__node.get_info('ip') self.__title_label = HIGSectionLabel(self.__title) self.__title_label.modify_font(self.__title_font) # icon to collapse window self.__collapse_box = gtk.EventBox() self.__collapse_img = gtk.Image() self.__collapse_img.set_from_file(self.__icon.get_icon('collapse')) self.__collapse_box.add(self.__collapse_img) self.__collapse_box.connect('button_press_event', self.collapse_window) self.__collapse_box.add_events(gtk.gdk.BUTTON_PRESS_MASK) # icon to close window self.__close_box = gtk.EventBox() self.__close_img = gtk.Image() self.__close_img.set_from_file(self.__icon.get_icon('close')) self.__close_box.add(self.__close_img) self.__close_box.connect('button_press_event', self.close_window) self.__close_box.add_events(gtk.gdk.BUTTON_PRESS_MASK) # packing head elements self.__head._pack_noexpand_nofill(self.__color_box) self.__head._pack_expand_fill(self.__title_label) self.__head._pack_noexpand_nofill(self.__collapse_box) self.__head._pack_noexpand_nofill(self.__close_box) # packing all to content self.__content._pack_noexpand_nofill(self.__head) self.__content._pack_expand_fill(self.__notebook) # add context to window self.add(self.__content) def close_window(self, widget, event): """ """ self.__node.set_draw_info({'over':False}) self.hide() self.__parent.queue_draw() return True def restore(self, x, y): """ """ self.move(x, y) self.show_all() self.__is_collapsed = False self.resize(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.__collapse_img.set_from_file(self.__icon.get_icon('collapse')) def collapse_window(self, widget, event): """ """ self.present() if self.__is_collapsed == False: self.__notebook.hide() self.__is_collapsed = True self.set_size_request(DIMENSION_SHADED[0], DIMENSION_SHADED[1]) self.resize(DIMENSION_SHADED[0], DIMENSION_SHADED[1]) self.__collapse_img.set_from_file(self.__icon.get_icon('expand')) else: self.__notebook.show() self.__is_collapsed = False self.set_size_request(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.resize(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.__collapse_img.set_from_file(self.__icon.get_icon('collapse')) return True def button_press(self, widget, event): """ """ self.present() self.__pressed = True self.__button_press_position = self.get_pointer() return True def button_release(self, widget, event): """ """ self.__pressed = False return True def enter_notify(self, widget, event): """ """ self.__node.set_draw_info({'over':True}) self.__parent.queue_draw() def leave_notify(self, widget, event): """ """ self.set_keep_above(True) self.__node.set_draw_info({'over':False}) def motion_notify(self, widget, event): """ """ self.__node.set_draw_info({'over':True}) x, y, button_state = event.window.get_pointer() if button_state & gtk.gdk.BUTTON1_MASK and self.__pressed: xw, yw = event.window.get_root_origin() xd, yd = self.__button_press_position self.move(x + xw - xd, y + yw - yd) return True
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()
class GeneralPage(HIGVBox): """""" #---------------------------------------------------------------------- def __init__(self): """Constructor""" HIGVBox.__init__(self) self.__create_widgets() self.__pack_widgets() self.__information_load() def __create_widgets(self): self.general_hbox = HIGHBox() self.version_hbox = HIGHBox() ################ #Version Section self.version_section = HIGSectionLabel(_("Version")) self.version_table = HIGTable() self.version_label = HIGEntryLabel(_("Software Version:")) self.version2_label = HIGEntryLabel() self.testver_label = HIGEntryLabel(_("Service Test Version:")) self.testver2_label = HIGEntryLabel() self.attribute_label = HIGEntryLabel(_("Agent Attribute:")) self.attribute2_label = HIGEntryLabel() ################ #General Section self.general_section = HIGSectionLabel(_("General")) self.general_table = HIGTable() self.startup_check = gtk.CheckButton(_("Startup OpenMonitor on system startup")) self.notification_check = gtk.CheckButton(_("Show Desktop Notifications")) self.login_ckeck = gtk.CheckButton(_("Enable Auto login")) def __pack_widgets(self): """""" self.set_border_width(12) self._pack_noexpand_nofill(self.version_section) self._pack_noexpand_nofill(self.version_hbox) self._pack_noexpand_nofill(self.general_section) self._pack_noexpand_nofill(self.general_hbox) self.version_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.version_hbox._pack_expand_fill(self.version_table) self.general_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.general_hbox._pack_expand_fill(self.general_table) self.version_table.attach_label(self.version_label, 0, 2, 0, 1) self.version_table.attach_label(self.version2_label, 2, 4, 0, 1) self.version_table.attach_label(self.testver_label, 0, 2, 1, 2) self.version_table.attach_label(self.testver2_label, 2, 4, 1, 2) self.version_table.attach_label(self.attribute_label, 0, 2, 2, 3) self.version_table.attach_label(self.attribute2_label, 2, 4, 2, 3) self.general_table.attach_label(self.startup_check, 0, 2, 2, 3) self.general_table.attach_label(self.notification_check, 0, 3, 3, 4) self.general_table.attach_label(self.login_ckeck, 0, 4, 4, 5) def startup_set(self,is_start_up=True): """""" start = StartUP() if is_start_up: start.set_startup() else: start.clear_startup() def __information_load(self): """ """ from umit.icm.agent.Version import VERSION from umit.icm.agent.test import TEST_PACKAGE_VERSION from umit.icm.agent.Global import * self.version2_label.set_text(str(VERSION)) self.testver2_label.set_text(str(TEST_PACKAGE_VERSION)) peer_attribute = g_db_helper.get_information(key='peer',default="Desktop Agent") self.attribute2_label.set_text(peer_attribute)
class OSFingerprintReport(gtk.Window, object): def __init__(self, fingerprint, ip): gtk.Window.__init__(self) self.set_title(_("Operating System Fingerprint Report")) self.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.fingerprint = fingerprint self.ip = ip self._create_widgets() self._set_classification_list() self._pack_widgets() self._connect_widgets() def _set_classification_list(self): class_file = open(os_classification_file, "rb") class_list = cPickle.load(class_file) class_file.close() for classification in class_list: self.classification_list.append([classification[1], classification[0]]) def _create_widgets(self): self.vbox = HIGVBox() self.button_box = gtk.HButtonBox() self.submitted_label = HIGHintSectionLabel( _("Submitted by (optional)"), _( "Enter your name and \ e-mail address if we can contact you with any questions. (kept private, \ used for nothing else)" ), ) self.submitted_entry = gtk.Entry() self.target_device_label = HIGHintSectionLabel( _("Target OS/device info"), _( "<b>The more details \ the better!</b> For UNIX machines, '<i>uname -a</i>' often gives the proper \ version number. On Linux, please also specify the distribution version (such as\ Redhat 9.0) if you are using a vendor-provided kernel. For Windows, the \ '<i>winver</i>' command (if available) should show you any service pack \ information. If a Windows target has no service packs installed, \ please say so explicitly. For appliances/embedded devices, please mention \ the model number and what it is (printer, webcam, DSL router, VOIP phone, \ etc). Try to provide the architecture (X86, SPARC, etc.) where appropriate." ), ) self.target_device_entry = gtk.Entry() self.classification_label = HIGHintSectionLabel( _("Classification"), _( "Please select \ the Device/OS info from this alphabetized choosebox" ), ) self.classification_list = gtk.ListStore(str, str) self.classification_combo = gtk.ComboBoxEntry(self.classification_list, 0) self.notes_label = HIGHintSectionLabel( _("Notes"), _( "Fill with further info on \ the device, any special network conditions, etc." ), ) self.notes_scrolled = gtk.ScrolledWindow() self.notes_text = gtk.TextView() self.fingerprint_icon = gtk.Image() self.fingerprint_text = gtk.Label( _( "This form allows you to \ contribute new operating system fingerprints to the Nmap database. Thanks for \ helping! <b>Please do not fill this out unless you are sure that you know \ what application is running on the machine you are submitting</b>. Incorrect \ entries can pollute the database. By submitting fingerprints you are \ transfering any copyright interest in the data to Fyodor so that he \ can modify it, relicense it, incorporate it into programs such as Nmap, etc." ) ) self.btn_ok = gtk.Button(stock=gtk.STOCK_OK) self.btn_cancel = gtk.Button(stock=gtk.STOCK_CANCEL) self.hbox = HIGHBox() self.table = HIGTable() def _pack_widgets(self): self.notes_scrolled.add(self.notes_text) self.notes_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.notes_scrolled.set_size_request(400, 150) self.notes_text.set_wrap_mode(gtk.WRAP_WORD) self.fingerprint_icon.set_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_DIALOG) self.fingerprint_icon.set_padding(10, 0) self.fingerprint_text.set_line_wrap(True) self.fingerprint_text.set_use_markup(True) self.table.attach_label(self.submitted_label, 0, 1, 0, 1) self.table.attach_entry(self.submitted_entry, 1, 2, 0, 1) self.table.attach_label(self.target_device_label, 0, 1, 1, 2) self.table.attach_entry(self.target_device_entry, 1, 2, 1, 2) self.table.attach_label(self.classification_label, 0, 1, 2, 3) self.table.attach_entry(self.classification_combo, 1, 2, 2, 3) self.table.attach_label(self.notes_label, 0, 2, 3, 4) self.table.attach_entry(self.notes_scrolled, 0, 2, 4, 5) self.hbox.set_border_width(12) self.hbox._pack_noexpand_nofill(self.fingerprint_icon) self.hbox._pack_expand_fill(self.fingerprint_text) self.button_box.set_layout(gtk.BUTTONBOX_END) self.button_box.pack_start(self.btn_ok) self.button_box.pack_start(self.btn_cancel) self.vbox.set_border_width(6) self.vbox._pack_noexpand_nofill(self.hbox) self.vbox._pack_expand_fill(self.table) self.vbox._pack_noexpand_nofill(self.button_box) self.add(self.vbox) def _connect_widgets(self): self.btn_ok.connect("clicked", self.send_report) self.btn_cancel.connect("clicked", self.close) self.connect("delete-event", self.close) def close(self, widget=None, event=None): self.destroy() def send_report(self, widget): if self.target_device == "": cancel_dialog = HIGAlertDialog( type=gtk.MESSAGE_ERROR, message_format=_( "Operating System \ Fingerprint report is incomplete!" ), secondary_text=_( "The Operating \ System Fingerprint report is incomplete. Please, try to provide as much \ information as possible." ), ) cancel_dialog.run() cancel_dialog.destroy() return None os_register = OSFingerprintRegister() os_register.email = self.submitted os_register.os = self.target_device os_register.classification = self.classification os_register.ip = self.ip os_register.fingerprint = self.fingerprint os_register.notes = self.notes try: os_register.report() except: cancel_dialog = HIGAlertDialog( type=gtk.MESSAGE_ERROR, message_format=_( "Operating System \ Fingerprint not registered!" ), secondary_text=_( "The Operating \ System Fingerprint could not be registered. This problem may be caused by \ the lack of Internet Access or indisponibility of the fingerprint server. \ Please, verify your internet access, and then try to register the operating \ system fingerprint once again." ), ) cancel_dialog.run() cancel_dialog.destroy() else: ok_dialog = HIGAlertDialog( type=gtk.MESSAGE_INFO, message_format=_( "Operating System \ Fingerprint sucessfully registered!" ), secondary_text=_( "The Operating System \ Fingerprint was sucessfully registered. A web page with detailed description \ about this registration is going to be openned in your default web browser." ), ) ok_dialog.run() ok_dialog.destroy() self.close() def run_unblocked(self): if not self.modal: self.set_modal(True) self.show_all() def dialog_response_cb(self, dialog, response): self.response_id = response def get_submitted(self): return self.submitted_entry.get_text() def set_submitted(self, submitted): self.submitted_entry.set_text(submitted) def get_target_device(self): return self.target_device_entry.get_text() def set_target_device(self, target_device): self.target_device_entry.set_text(target_device) def get_classification(self): selected = self.classification_combo.child.get_text() for i in self.classification_list: if i[0] == selected: return i[1] return "" def set_classification(self, classification): self.classification.child.set_text(classification) def get_notes(self): buff = self.notes_text.get_buffer() return buff.get_text(buff.get_start_iter(), buff.get_end_iter()) def set_notes(self, notes): self.notes_text.get_buffer().set_text(notes) submitted = property(get_submitted, set_submitted) target_device = property(get_target_device, set_target_device) classification = property(get_classification, set_classification) notes = property(get_notes, set_notes)
class DiffText(HIGVBox, object): def __init__(self, colors, check_color): HIGVBox.__init__(self) self.set_border_width(5) self.set_spacing(6) self.colors = colors self.check_color = check_color self._create_widgets() self._pack_hbox() self._set_text_view() self._set_scrolled() self._pack_noexpand_nofill(self.lbl_diff) self._pack_expand_fill(self.hbox) def _create_widgets(self): self.hbox = HIGHBox() self.lbl_diff = HIGSectionLabel("<b>%s</b>" % _("Diff Result")) self.scrolled = gtk.ScrolledWindow() self.txt_diff_result = gtk.TextView() self.txg_tag = gtk.TextTag("diff_style") self.txg_added = gtk.TextTag('added style') self.txg_removed = gtk.TextTag('removed style') def _pack_hbox(self): self.hbox.set_border_width(5) self.hbox._pack_noexpand_nofill(hig_box_space_holder()) self.hbox._pack_expand_fill(self.scrolled) def _set_scrolled(self): self.scrolled.set_size_request(-1, 250) # Packing text view into scrolled window self.scrolled.add_with_viewport(self.txt_diff_result) # Setting scrolled window self.scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) def activate_color(self, activate): self.check_color = activate self._text_changed(None) def _set_text_view(self): self.txg_table = self.txt_diff_result.get_buffer().get_tag_table() self.txg_table.add(self.txg_tag) self.txg_table.add(self.txg_added) self.txg_table.add(self.txg_removed) self.txg_tag.set_property("family", "Monospace") self.txg_added.set_property("background-gdk", self.colors.added) self.txg_removed.set_property("background-gdk", self.colors.not_present) self.txt_diff_result.set_wrap_mode(gtk.WRAP_WORD) self.txt_diff_result.set_editable(False) self.txt_diff_result.get_buffer().connect("changed", self._text_changed) def _text_changed(self, widget): self.txg_added.set_property("background-gdk", self.colors.added) self.txg_removed.set_property("background-gdk", self.colors.not_present) buff = self.txt_diff_result.get_buffer() buff.apply_tag(self.txg_tag, buff.get_start_iter(), buff.get_end_iter()) if self.check_color: positions = self._take_changes(buff) for i in positions['added']: buff.apply_tag(self.txg_added, i[0], i[1]) for i in positions['removed']: buff.apply_tag(self.txg_removed, i[0], i[1]) else: buff.remove_tag(self.txg_added, buff.get_start_iter(), buff.get_end_iter()) buff.remove_tag(self.txg_removed, buff.get_start_iter(), buff.get_end_iter()) def _take_changes(self, buffer): positions = {'added': [], 'removed': []} in_line = 0 type = '' iter = buffer.get_start_iter() last_char = '\n' while iter.forward_char(): char = iter.get_char() offset = iter.get_offset() if not in_line: pos = [] if char == '+' and last_char == '\n': pos.append(buffer.get_iter_at_offset(offset)) type = 'added' in_line = 1 elif char == '-' and last_char == '\n': pos.append(buffer.get_iter_at_offset(offset)) type = 'removed' in_line = 1 else: if char == '\n': pos.append(buffer.get_iter_at_offset(offset)) positions[type].append(pos) in_line = 0 type = '' last_char = char return positions
class ControlInterpolation(HIGExpanderRNet): """ """ def __init__(self, radialnet): """ """ HIGExpanderRNet.__init__(self, 'Interpolation') self.radialnet = radialnet self.__create_widgets() def __create_widgets(self): """ """ self.__vbox = HIGVBox() self.__cartesian_radio = gtk.RadioButton(None, 'Cartesian') self.__polar_radio = gtk.RadioButton(self.__cartesian_radio, 'Polar') self.__cartesian_radio.connect('toggled', self.__change_system, INTERPOLATION_CARTESIAN) self.__polar_radio.connect('toggled', self.__change_system, INTERPOLATION_POLAR) self.__system_box = HIGHBox() self.__system_box._pack_noexpand_nofill(self.__polar_radio) self.__system_box._pack_noexpand_nofill(self.__cartesian_radio) self.__frames_box = HIGHBox() self.__frames_label = gtk.Label('Frames') self.__frames_label.set_alignment(0.0, 0.5) self.__frames = gtk.Adjustment(self.radialnet.get_number_of_frames(), 1, 1000, 1) self.__frames.connect('value_changed', self.__change_frames) self.__frames_spin = gtk.SpinButton(self.__frames) self.__frames_box._pack_expand_fill(self.__frames_label) self.__frames_box._pack_noexpand_nofill(self.__frames_spin) self.__vbox._pack_noexpand_nofill(self.__frames_box) self.__vbox._pack_noexpand_nofill(self.__system_box) self._add(self.__vbox) gobject.timeout_add(REFRESH_RATE, self.__update_animation) def __update_animation(self): """ """ active = self.radialnet.get_interpolation() if active == INTERPOLATION_CARTESIAN: self.__cartesian_radio.set_active(True) else: self.__polar_radio.set_active(True) return True def __change_system(self, widget, value): """ """ if not self.radialnet.set_interpolation(value): active = self.radialnet.get_interpolation() if active == INTERPOLATION_CARTESIAN: self.__cartesian_radio.set_active(True) else: self.__polar_radio.set_active(True) def __change_frames(self, widget): """ """ if not self.radialnet.set_number_of_frames(self.__frames.get_value()): self.__frames.set_value(self.radialnet.get_number_of_frames())
class ScanChooser(HIGVBox): def __init__(self, scan_dict, num=""): HIGVBox.__init__(self) self.num = num self.scan_dict = scan_dict # Setting HIGVBox self.set_border_width(5) self.set_spacing(6) self._create_widgets() self._pack_hbox() self._attaching_widgets() self._set_scrolled() self._set_text_view() self._set_open_button() for scan in scan_dict: self.list_scan.append([scan]) self.combo_scan.connect('changed', self.show_scan) self._pack_noexpand_nofill(self.lbl_scan) self._pack_expand_fill(self.hbox) def _create_widgets(self): self.lbl_scan = HIGSectionLabel("%s %s" % (_("Scan Result"), str(self.num))) self.hbox = HIGHBox() self.table = HIGTable() self.list_scan = gtk.ListStore(str) self.combo_scan = gtk.ComboBoxEntry(self.list_scan, 0) self.btn_open_scan = gtk.Button(stock=gtk.STOCK_OPEN) self.exp_scan = gtk.Expander(_("Scan Result Visualization")) self.scrolled = gtk.ScrolledWindow() self.txt_scan_result = gtk.TextView() self.txg_tag = gtk.TextTag("scan_style") def get_buffer(self): return self.txt_scan_result.get_buffer() def show_scan(self, widget): try: self.txt_scan_result.get_buffer().\ set_text(self.normalize_output(\ self.scan_dict[widget.child.get_text()].nmap_output)) except KeyError: # Avoid to raise an error if the user writes within # the entry and the scan doesn't exits pass def normalize_output(self, output): return "\n".join(output.split("\\n")) def _pack_hbox(self): self.hbox._pack_noexpand_nofill(hig_box_space_holder()) self.hbox._pack_expand_fill(self.table) def _attaching_widgets(self): self.table.attach(self.combo_scan, 0, 1, 0, 1, yoptions=0) self.table.attach(self.btn_open_scan, 1, 2, 0, 1, yoptions=0, xoptions=0) self.table.attach(self.exp_scan, 0, 2, 1, 2) def _set_scrolled(self): self.scrolled.set_border_width(5) self.scrolled.set_size_request(-1, 160) # Packing scrolled window into expander self.exp_scan.add(self.scrolled) # Packing text view into scrolled window self.scrolled.add_with_viewport(self.txt_scan_result) # Setting scrolled window self.scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) def _set_text_view(self): self.txg_table = self.txt_scan_result.get_buffer().get_tag_table() self.txg_table.add(self.txg_tag) self.txg_tag.set_property("family", "Monospace") self.txt_scan_result.set_wrap_mode(gtk.WRAP_WORD) self.txt_scan_result.set_editable(False) self.txt_scan_result.get_buffer().connect("changed", self._text_changed_cb) def _set_open_button(self): self.btn_open_scan.connect('clicked', self.open_file) def open_file(self, widget): file_chooser = ResultsFileChooserDialog(_("Select Scan Result")) file_chooser.run() file_chosen = file_chooser.get_filename() file_chooser.destroy() if check_access(file_chosen, os.R_OK): try: parser = NmapParser(file_chosen) parser.parse() except: alert = HIGAlertDialog( message_format='<b>%s</b>' % _('File is not a Umit \ Scan Result'), secondary_text=_("Selected file is not a Umit Scan \ Result file. Umit can not parse this file. Please, select another.")) alert.run() alert.destroy() return False scan_name = os.path.split(file_chosen)[-1] self.add_scan(scan_name, parser) self.combo_scan.set_active(len(self.list_scan) - 1) else: alert = HIGAlertDialog( message_format='<b>%s</b>' % \ _('Can not open selected file'), secondary_text=_("Umit can not open selected file. Please, \ select another." )) alert.run() alert.destroy() def add_scan(self, scan_name, parser): scan_id = 1 new_scan_name = scan_name while new_scan_name in self.scan_dict: new_scan_name = "%s (%s)" % (scan_name, scan_id) scan_id += 1 self.list_scan.append([new_scan_name]) self.scan_dict[new_scan_name] = parser def _text_changed_cb(self, widget): buff = self.txt_scan_result.get_buffer() buff.apply_tag(self.txg_tag, buff.get_start_iter(), buff.get_end_iter()) def get_nmap_output(self): parsed = self.parsed_scan if parsed: return parsed.nmap_output return False def get_parsed_scan(self): selected_scan = self.combo_scan.child.get_text() if selected_scan: return self.scan_dict[selected_scan] return False nmap_output = property(get_nmap_output) parsed_scan = property(get_parsed_scan)
class RegistrationDialog(HIGDialog): """""" #---------------------------------------------------------------------- def __init__(self, title=_('Registration')): """Constructor""" HIGDialog.__init__(self, title=title, buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) self.set_position(gtk.WIN_POS_CENTER_ALWAYS) self._create_widgets() self._pack_widgets() # Register callbacks self.connect("response", self.check_response) def _create_widgets(self): self.username_label = HIGLabel(_("Username")) self.username_entry = gtk.Entry() self.password_label = HIGLabel(_("Password")) self.password_entry = HIGPasswordEntry() self.retype_password_label = HIGLabel(_("Retype password")) self.retype_password_entry = HIGPasswordEntry() self.registration_icon = gtk.Image() self.registration_text = gtk.Label(_("If you don't have an ICM account," "please register a new account.")) self.hbox = HIGHBox() self.table = HIGTable() def _pack_widgets(self): self.registration_icon.set_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_DIALOG) self.registration_icon.set_padding(10, 0) self.registration_text.set_line_wrap(True) self.hbox.set_border_width(12) self.hbox._pack_noexpand_nofill(self.registration_icon) self.hbox._pack_expand_fill(self.registration_text) self.vbox.pack_start(self.hbox, False, False) self.table.attach_label(self.username_label, 0, 1, 0, 1) self.table.attach_entry(self.username_entry, 1, 2, 0, 1) self.table.attach_label(self.password_label, 0, 1, 1, 2) self.table.attach_entry(self.password_entry, 1, 2, 1, 2) self.table.attach_label(self.retype_password_label, 0, 1, 2, 3) self.table.attach_entry(self.retype_password_entry, 1, 2, 2, 3) self.vbox.pack_start(self.table) def check_response(self, widget, response_id): if response_id == gtk.RESPONSE_ACCEPT: # clicked on Ok btn self.register() elif response_id in (gtk.RESPONSE_DELETE_EVENT, gtk.RESPONSE_CANCEL, gtk.RESPONSE_NONE): self.destroy() def register(self): username = self.username_entry.get_text() password = self.password_entry.get_text() theApp.aggregator.register(username, password)
class ControlFisheye(HIGVBox): """ """ def __init__(self, radialnet): """ """ HIGVBox.__init__(self) self.set_border_width(6) self.radialnet = radialnet self.__ring_max_value = self.radialnet.get_number_of_rings() self.__create_widgets() def __create_widgets(self): """ """ self.__params = HIGVBox() self.__params_main = HIGHBox() self.__params_options = HIGHBox() self.__fisheye_label = gtk.Label('Fisheye on ring') self.__ring = gtk.Adjustment(0, 0, self.__ring_max_value, 0.01, 0.01) self.__ring_spin = gtk.SpinButton(self.__ring) self.__ring_spin.set_digits(2) self.__ring_scale = gtk.HScale(self.__ring) self.__ring_scale.set_size_request(100, -1) self.__ring_scale.set_digits(2) self.__ring_scale.set_value_pos(gtk.POS_LEFT) self.__ring_scale.set_draw_value(False) self.__ring_scale.set_update_policy(gtk.UPDATE_CONTINUOUS) self.__interest_label = gtk.Label('Interest factor') self.__interest = gtk.Adjustment(0, 0, 10, 0.01) self.__interest_spin = gtk.SpinButton(self.__interest) self.__interest_spin.set_digits(2) self.__spread_label = gtk.Label('Spread factor') self.__spread = gtk.Adjustment(0, -1.0, 1.0, 0.01, 0.01) self.__spread_spin = gtk.SpinButton(self.__spread) self.__spread_spin.set_digits(2) self.__options_button = gtk.ToggleButton('More') self.__options_button.set_active(False) self.__params._pack_noexpand_nofill(self.__params_main) self.__params._pack_noexpand_nofill(self.__params_options) self.__params_main._pack_noexpand_nofill(self.__fisheye_label) self.__params_main._pack_noexpand_nofill(self.__ring_spin) self.__params_main._pack_expand_fill(self.__ring_scale) self.__params_main._pack_noexpand_nofill(self.__options_button) self.__params_options._pack_noexpand_nofill(self.__interest_label) self.__params_options._pack_noexpand_nofill(self.__interest_spin) self.__params_options._pack_noexpand_nofill(self.__spread_label) self.__params_options._pack_noexpand_nofill(self.__spread_spin) self.__params_options.set_no_show_all(True) self.__params_options.hide() self._pack_noexpand_nofill(self.__params) self.__ring.connect('value_changed', self.__change_ring) self.__interest.connect('value_changed', self.__change_interest) self.__spread.connect('value_changed', self.__change_spread) self.__options_button.connect('toggled', self.__options_toggled) gobject.timeout_add(REFRESH_RATE, self.__update_fisheye) def __update_fisheye(self): """ """ # adjust ring scale to radialnet number of nodes ring_max_value = self.radialnet.get_number_of_rings() - 1 if ring_max_value != self.__ring_max_value: value = self.__ring.get_value() if value == 0 and ring_max_value != 0: value = 1 elif value > ring_max_value: value = ring_max_value self.__ring.set_all(value, 1, ring_max_value, 0.01, 0.01, 0) self.__ring_max_value = ring_max_value self.__ring_scale.queue_draw() # check ring value ring_value = self.radialnet.get_fisheye_ring() if self.__ring.get_value() != ring_value: self.__ring.set_value(ring_value) # check interest value interest_value = self.radialnet.get_fisheye_interest() if self.__interest.get_value() != interest_value: self.__interest.set_value(interest_value) # check spread value spread_value = self.radialnet.get_fisheye_spread() if self.__spread.get_value() != spread_value: self.__spread.set_value(spread_value) return True def active_fisheye(self): """ """ self.radialnet.set_fisheye(True) self.__change_ring() self.__change_interest() def deactive_fisheye(self): """ """ self.radialnet.set_fisheye(False) def __change_ring(self, widget=None): """ """ if not self.radialnet.is_in_animation(): self.radialnet.set_fisheye_ring(self.__ring.get_value()) else: self.__ring.set_value(self.radialnet.get_fisheye_ring()) def __change_interest(self, widget=None): """ """ if not self.radialnet.is_in_animation(): self.radialnet.set_fisheye_interest(self.__interest.get_value()) else: self.__interest.set_value(self.radialnet.get_fisheye_interest()) def __change_spread(self, widget=None): """ """ if not self.radialnet.is_in_animation(): self.radialnet.set_fisheye_spread(self.__spread.get_value()) else: self.__spread.set_value(self.radialnet.get_fisheye_spread()) def __options_toggled(self, widget=None): """ """ self.__params_options.set_no_show_all(False) if self.__options_button.get_active(): self.__params_options.show_all() else: self.__params_options.hide_all() self.__params_options.set_no_show_all(True)
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()
class DiffText(HIGVBox, object): def __init__ (self, colors, check_color): HIGVBox.__init__(self) self.set_border_width(5) self.set_spacing(6) self.colors = colors self.check_color = check_color self._create_widgets() self._pack_hbox() self._set_text_view() self._set_scrolled() self._pack_noexpand_nofill(self.lbl_diff) self._pack_expand_fill(self.hbox) def _create_widgets (self): self.hbox = HIGHBox () self.lbl_diff = HIGSectionLabel ("<b>%s</b>" % _("Diff Result")) self.scrolled = gtk.ScrolledWindow() self.txt_diff_result = gtk.TextView() self.txg_tag = gtk.TextTag ("diff_style") self.txg_added = gtk.TextTag ('added style') self.txg_removed = gtk.TextTag ('removed style') def _pack_hbox (self): self.hbox.set_border_width(5) self.hbox._pack_noexpand_nofill (hig_box_space_holder()) self.hbox._pack_expand_fill(self.scrolled) def _set_scrolled (self): self.scrolled.set_size_request(-1, 250) # Packing text view into scrolled window self.scrolled.add_with_viewport(self.txt_diff_result) # Setting scrolled window self.scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) def activate_color(self, activate): self.check_color = activate self._text_changed(None) def _set_text_view (self): self.txg_table = self.txt_diff_result.get_buffer().get_tag_table() self.txg_table.add(self.txg_tag) self.txg_table.add(self.txg_added) self.txg_table.add(self.txg_removed) self.txg_tag.set_property("family", "Monospace") self.txg_added.set_property("background-gdk", self.colors.added) self.txg_removed.set_property("background-gdk", self.colors.not_present) self.txt_diff_result.set_wrap_mode(gtk.WRAP_WORD) self.txt_diff_result.set_editable(False) self.txt_diff_result.get_buffer().connect("changed", self._text_changed) def _text_changed (self, widget): self.txg_added.set_property("background-gdk", self.colors.added) self.txg_removed.set_property("background-gdk", self.colors.not_present) buff = self.txt_diff_result.get_buffer() buff.apply_tag(self.txg_tag, buff.get_start_iter(), buff.get_end_iter()) if self.check_color: positions = self._take_changes(buff) for i in positions['added']: buff.apply_tag(self.txg_added, i[0],i[1]) for i in positions['removed']: buff.apply_tag(self.txg_removed, i[0], i[1]) else: buff.remove_tag(self.txg_added, buff.get_start_iter(), buff.get_end_iter()) buff.remove_tag(self.txg_removed, buff.get_start_iter(), buff.get_end_iter()) def _take_changes (self, buffer): positions = {'added':[], 'removed':[]} in_line = 0 type = '' iter = buffer.get_start_iter () last_char = '\n' while iter.forward_char(): char = iter.get_char () offset = iter.get_offset() if not in_line: pos = [] if char == '+' and last_char == '\n': pos.append (buffer.get_iter_at_offset(offset)) type = 'added' in_line = 1 elif char == '-' and last_char == '\n': pos.append (buffer.get_iter_at_offset(offset)) type = 'removed' in_line = 1 else: if char == '\n': pos.append (buffer.get_iter_at_offset(offset)) positions [type].append (pos) in_line = 0 type = '' last_char = char return positions
class DiffTree(HIGVBox, object): def __init__(self, colors): HIGVBox.__init__(self) self.colors = colors self.set_border_width(5) self.set_spacing(6) self._create_widgets() self._set_diff_view() self._pack_widgets() def _create_widgets(self): self.diff_box = HIGHBox() self.diff_title = HIGSectionLabel("Comparison") self.diff_scrolled = gtk.ScrolledWindow() self.diff_tree = gtk.TreeStore(str, str, str, str, str, str) self.diff_view = gtk.TreeView(self.diff_tree) self.diff_column1 = gtk.TreeViewColumn("") self.diff_column2 = gtk.TreeViewColumn(_("Section")) self.diff_column3 = gtk.TreeViewColumn(_("Property")) self.diff_column4 = gtk.TreeViewColumn(_("Original value")) self.diff_column5 = gtk.TreeViewColumn(_("Current value")) self.diff_cell = gtk.CellRendererText() def activate_color(self, activate): if activate: self.diff_column1.set_attributes(self.diff_cell, text=0, background=5) self.diff_column2.set_attributes(self.diff_cell, text=1, background=5) self.diff_column3.set_attributes(self.diff_cell, text=2, background=5) self.diff_column4.set_attributes(self.diff_cell, text=3, background=5) self.diff_column5.set_attributes(self.diff_cell, text=4, background=5) else: self.diff_column1.clear_attributes(self.diff_cell) self.diff_column2.clear_attributes(self.diff_cell) self.diff_column3.clear_attributes(self.diff_cell) self.diff_column4.clear_attributes(self.diff_cell) self.diff_column5.clear_attributes(self.diff_cell) self.diff_column1.set_attributes(self.diff_cell, text=0) self.diff_column2.set_attributes(self.diff_cell, text=1) self.diff_column3.set_attributes(self.diff_cell, text=2) self.diff_column4.set_attributes(self.diff_cell, text=3) self.diff_column5.set_attributes(self.diff_cell, text=4) self.diff_cell.set_property("background", "white") def _set_diff_view(self): font_desc = pango.FontDescription("monospace normal 9") self.diff_cell.set_property("font-desc", font_desc) self.diff_scrolled.set_size_request(-1, 260) self.diff_view.set_enable_search(True) self.diff_view.set_search_column(2) selection = self.diff_view.get_selection() selection.set_mode(gtk.SELECTION_MULTIPLE) self.diff_view.append_column(self.diff_column1) self.diff_view.append_column(self.diff_column2) self.diff_view.append_column(self.diff_column3) self.diff_view.append_column(self.diff_column4) self.diff_view.append_column(self.diff_column5) # Diff Column 1 self.diff_column1.set_reorderable(True) self.diff_column1.set_resizable(True) self.diff_column1.connect("clicked", self.search_column, 0) self.diff_column1.set_sort_column_id(0) self.diff_column1.pack_start(self.diff_cell, True) self.diff_column1.set_attributes(self.diff_cell, text=0) # Diff Column 2 self.diff_column2.set_reorderable(True) self.diff_column2.set_resizable(True) self.diff_column2.connect("clicked", self.search_column, 1) self.diff_column2.set_sort_column_id(1) self.diff_column2.pack_start(self.diff_cell, True) self.diff_column2.set_attributes(self.diff_cell, text=1) # Diff Column 3 self.diff_column3.set_reorderable(True) self.diff_column3.set_resizable(True) self.diff_column3.connect("clicked", self.search_column, 2) self.diff_column3.set_sort_column_id(2) self.diff_column3.pack_start(self.diff_cell, True) self.diff_column3.set_attributes(self.diff_cell, text=2) # Diff Column 4 self.diff_column4.set_reorderable(True) self.diff_column4.set_resizable(True) self.diff_column4.connect("clicked", self.search_column, 3) self.diff_column4.set_sort_column_id(3) self.diff_column4.pack_start(self.diff_cell, True) self.diff_column4.set_attributes(self.diff_cell, text=3) # Diff Column 5 self.diff_column5.set_reorderable(True) self.diff_column5.set_resizable(True) self.diff_column5.connect("clicked", self.search_column, 4) self.diff_column5.set_sort_column_id(4) self.diff_column5.pack_start(self.diff_cell, True) self.diff_column5.set_attributes(self.diff_cell, text=4) self.diff_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) def clear_diff_tree(self): for i in range(len(self.diff_tree)): iter = self.diff_tree.get_iter_root() del(self.diff_tree[iter]) def change_status(self, iter, status): self.diff_tree[iter][0] = status self.diff_tree[iter][5] = self.colors.get_hex_color(status) def set_parent_status(self, parent, status): if status != "" and status.upper() != "U": while parent: self.change_status(parent, "M") parent = self.diff_tree.iter_parent(parent) def make_diff(self, parsed1, parsed2): self.clear_diff_tree() section = _("Umit Info") parent = self.append_parent(None, section, "") self.diff_it(parent, "", _("Profile"), parsed1.profile, parsed2.profile) self.diff_it(parent, "", _("Profile Name"), parsed1.profile_name, parsed2.profile_name) self.diff_it(parent, "", _("Profile Options"), parsed1.profile_options, parsed2.profile_options) self.diff_it(parent, "", _("Target"), parsed1.target, parsed2.target) section = _("Nmap Info") parent = self.append_parent(None, section, "") self.diff_it(parent, "", _("Debugging"), parsed1.debugging_level, parsed2.debugging_level) self.diff_it(parent, "", _("Verbosity"), parsed1.verbose_level, parsed2.verbose_level) self.diff_it(parent, "", _("Command"), parsed1.nmap_command, parsed2.nmap_command) self.diff_it(parent, "", _("Scanner version"), parsed1.scanner_version, parsed2.scanner_version) section = _("Scan Info") parent = self.append_parent(None, section, "") self.diff_it(parent, "", _("Open Ports"), parsed1.open_ports, parsed2.open_ports) self.diff_it(parent, "", _("Filtered Ports"), parsed1.filtered_ports, parsed2.filtered_ports) self.diff_it(parent, "", _("Closed Ports"), parsed1.closed_ports, parsed2.closed_ports) self.diff_it(parent, "", _("Hosts Up"), parsed1.hosts_up, parsed2.hosts_up) self.diff_it(parent, "", _("Hosts Down"), parsed1.hosts_down, parsed2.hosts_down) self.diff_it(parent, "", _("Hosts Scanned"), parsed1.hosts_total, parsed2.hosts_total) self.diff_it(parent, "", _("Finish date"), parsed1.formated_finish_date, parsed2.formated_finish_date) hosts1 = parsed1.hosts[:] hosts2 = parsed2.hosts[:] while hosts1: host = hosts1.pop() second_host = HostInfo(0) host_state = "N" for host2 in hosts2: if (host.mac and host.mac == host2.mac) or \ (host.ip and host.ip == host2.ip) or \ (host.ipv6 and host.ipv6 == host2.ipv6): second_host = host2 host_state = "" del(hosts2[hosts2.index(host2)]) # Remove it from the hosts2 break self.add_host_diff(host_state, host, second_host) for host in hosts2: self.add_host_diff("A", host, host) def add_host_diff(self, host_state, host, host2=None): section = _("Host") if host.ip: section = _("Host %s") % (host.ip["addr"]) elif host.ipv6: section = _("Host %s") % (host.ipv6["addr"]) elif host.mac: section = _("Host %s") % (host.mac["addr"]) parent = self.append_parent(None, section, host_state) self.diff_it(parent, "", _("Comment"), host.comment, host2.comment) self.diff_it(parent, "", _("LastBoot"), host.uptime.get("lastboot", ""), host2.uptime.get("lastboot", "")) # XXX Comparing only the last os match h_match = {} h2_match = {} if host.osmatch: h_match = host.osmatch[-1] if host2.osmatch: h2_match = host2.osmatch[-1] self.diff_it(parent, "", _("OS Match"), h_match.get("name", ""), h2_match.get("name", "")) # XXX only the first extraports are being compared extraports1 = {} extraports2 = {} if host.extraports: extraports1 = host.extraports[0] if host2.extraports: extraports2 = host2.extraports[0] if extraports1 and extraports2: self.add_extraports_diff(parent, "", extraports1, extraports2) elif extraports1 and not extraports2: self.add_extraports_diff(parent, "N", extraports1, extraports2) elif not extraports1 and extraports2: self.add_extraports_diff(parent, "A", extraports1, extraports2) section = _("Ports") parent = self.append_parent(parent, section, "") ports1 = host.ports[:] ports2 = host2.ports[:] for p1 in ports1: if not p1: continue p2 = [port2 for port2 in ports2 \ if port2.get("portid", "a") == p1.get("portid", "b")] if p2: # Removing found port ports2.remove(p2[0]) if p1 and p2: self.add_port_diff(parent, "", p1, p2[0]) elif p1 and not p2: self.add_port_diff(parent, "N", p1, {}) for p2 in ports2: # If there is something left... self.add_port_diff(parent, "A", {}, p2) def add_port_diff(self, port_parent, state, port1, port2): if (port1 or port2) and isinstance(port1, dict) and\ isinstance(port2, dict): section = port1.get("portid", False) if not section: # If port1 is empty, then, try port2 section = port2.get("portid", "") parent = self.append_parent(port_parent, section, state) self.diff_it(parent, "", _("State"), port1.get("state", ""), port2.get("state", "")) self.diff_it(parent, "", _("Service Name"), port1.get("name", ""), port2.get("name", "")) self.diff_it(parent, "", _("Product"), port1.get("product", ""), port2.get("product", "")) self.diff_it(parent, "", _("Service Version"), port1.get("version", ""), port2.get("version", "")) self.diff_it(parent, "", _("Protocol"), port1.get("protocol", ""), port2.get("protocol", "")) self.diff_it(parent, "", _("Extra Info"), port1.get("extrainfo", ""), port2.get("extrainfo", "")) self.diff_it(parent, "", _("Service Conf"), port1.get("conf", ""), port2.get("conf", "")) # Last parent status modification if state.upper() == "A": self.change_status(parent, "A") def add_extraports_diff(self, host_parent, state, extraports1, extraports2): if extraports1 or extraports2: section = _("Extraports") parent = self.append_parent(host_parent, section, state) self.set_parent_status(parent, state) self.diff_it(parent, "", _("Count"), extraports1.get("count"), extraports2.get("count")) self.diff_it(parent, "", _("State"), extraports1.get("state"), extraports2.get("state")) def diff_it(self, parent, section, prop_name, prop1, prop2): if prop1 or prop2: state = diff_state(prop1, prop2) self.set_parent_status(parent, state) self.diff_tree.append(parent, [state, section, prop_name, prop1, prop2, self.colors.get_hex_color(state)]) return state def append_parent(self, parent, section, state): self.set_parent_status(parent, state) return self.diff_tree.append(parent, [state, section, "", "", "", self.colors.get_hex_color(state)]) def search_column(self, widget, column_id): self.diff_view.set_search_column(column_id) def _pack_widgets(self): self._pack_noexpand_nofill(self.diff_title) self._pack_expand_fill(self.diff_box) self.diff_box._pack_noexpand_nofill(hig_box_space_holder()) self.diff_box._pack_expand_fill(self.diff_scrolled) self.diff_scrolled.add(self.diff_view)
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 ControlLayout(HIGExpanderRNet): """ """ def __init__(self, radialnet): """ """ HIGExpanderRNet.__init__(self, 'Layout') self.radialnet = radialnet self.__create_widgets() def __create_widgets(self): """ """ self.__hbox = HIGHBox() self.__layout = gtk.combo_box_new_text() self.__layout.append_text('Symmetric') self.__layout.append_text('Weighted') self.__layout.set_active(self.radialnet.get_layout()) self.__layout.connect('changed', self.__change_layout) self.__force = gtk.ToolButton(gtk.STOCK_REFRESH) self.__force.connect('clicked', self.__force_update) self.__hbox._pack_expand_fill(self.__layout) self.__hbox._pack_noexpand_nofill(self.__force) self._add(self.__hbox) self.__check_layout() def __check_layout(self): """ """ if self.__layout.get_active() == LAYOUT_WEIGHTED: self.__force.set_sensitive(True) else: self.__force.set_sensitive(False) return True def __force_update(self, widget): """ """ self.__fisheye_ring = self.radialnet.get_fisheye_ring() self.radialnet.update_layout() def __change_layout(self, widget): """ """ if not self.radialnet.set_layout(self.__layout.get_active()): self.__layout.set_active(self.radialnet.get_layout()) else: self.__check_layout()
class ZionProfilePrompt(ZionProfile): """ """ def __init__(self, target=None): """ """ ZionProfile.__init__(self, target) # hide attractor box self.result.get_hosts_view().get_scans_page().hide_attractor_box() self.__command_hbox = HIGHBox() self.__command_label = gtk.Label(_('Command:')) self.command_entry = gtk.Entry() self.__command_hbox._pack_noexpand_nofill(self.__command_label) self.__command_hbox._pack_expand_fill(self.command_entry) self._pack_noexpand_nofill(self.__command_hbox) def check_scan(self): """ """ if self.command_entry.get_text().strip(): return True return False def start(self): """ """ zion_options = options.Options() # get command options command = self.command_entry.get_text().strip() try: opts, addrs = getopt.gnu_getopt(command.split(), options.OPTIONS_SHORT, options.OPTIONS_LONG) except getopt.GetoptError, e: print 'Error: %s.' % e for o in opts: opt, value = o zion_options.add(opt, value) # hide attractor box if not needed if zion_options.has(options.OPTION_DETECT) or zion_options.has( options.OPTION_SYNPROXY): self.result.get_hosts_view().get_scans_page().show_attractor_box() z = zion.Zion(zion_options, []) for a in addrs: if address.recognize(a) == address.Unknown: l = probe.get_addr_from_name(a) for i in l: try: z.append_target(host.Host(i, a)) except: print "Unimplemented support to address: %s." % i else: z.append_target(host.Host(a)) # run zion p = Process(target=z.run, args=(self.q2, )) p.start()
class Wizard(HIGWindow): def __init__(self): HIGWindow.__init__(self) self.set_size_request(600, 450) self.set_position(gtk.WIN_POS_CENTER) self.profile = CommandProfile() self.constructor = CommandConstructor() self.options = OptionBuilder(wizard_file, self.constructor, self.update_command) self.target = '<target>' self.profilemanager = False self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.directions = { 'Start': self.start_page(), 'Choose': self.choose_page(), 'Profile': self.profile_page(), 'Finish': self.finish_page(), 'LastPage': None } for i in xrange(len(self.options.groups)): step = self.options.groups[i] last, next = self.__get_pair(i) self.directions[step] = self.__create_steps( step, last, next, self.options.section_names[step], self.options.tabs[step]) self.directions['Command'] = self.command_page() self.main_vbox = HIGVBox() self.main_vbox.set_border_width(5) self.main_vbox.set_spacing(12) self.add(self.main_vbox) self.__create_wizard_widgets() self.set_title(_("Umit Command constructor wizard")) self.main_vbox._pack_expand_fill(self.directions['Start']) self.set_notebook(None) self.update_command() def __get_pair(self, pos): if pos == 0: return 'LastPage', self.options.groups[pos + 1] elif pos == (self.options.groups.__len__() - 1): return self.options.groups[pos - 1], 'Finish' else: return self.options.groups[pos - 1], self.options.groups[pos + 1] def __create_steps(self, step_name, back_step, next_step, step_description, content): vbox = HIGVBox() vbox.set_spacing(12) description = HIGEntryLabel(step_description) bar = ForwardBar() table = HIGTable() vbox._pack_noexpand_nofill(description) vbox._pack_expand_fill(table) vbox._pack_noexpand_nofill(bar) content.fill_table(table, False) bar.cancel.connect('clicked', self.close_wizard) bar.help.connect('clicked', self._show_help) bar.back.connect('clicked', self.switch_page, step_name, back_step) bar.forward.connect('clicked', self.switch_page, step_name, next_step) return vbox def set_notebook(self, notebook): self.notebook = notebook def __create_wizard_widgets(self): self.wizard_title = HIGEntryLabel("") self.wizard_title.set_line_wrap(False) self.wizard_event = gtk.EventBox() self.wizard_logo = gtk.Image() self.wizard_event.add(self.wizard_logo) self.d = {} for c in (65, 97): for i in range(26): self.d[chr(i + c)] = chr((i + 13) % 26 + c) self.img = 1 command_hbox = HIGHBox() self.command_label = HIGEntryLabel(_("Command")) self.command_entry = gtk.Entry() separator = gtk.HSeparator() self.wizard_header_hbox = HIGHBox() self.wizard_header_hbox._pack_expand_fill(self.wizard_title) self.wizard_header_hbox._pack_noexpand_nofill(self.wizard_event) command_hbox._pack_noexpand_nofill(self.command_label) command_hbox._pack_expand_fill(self.command_entry) self.main_vbox._pack_noexpand_nofill(self.wizard_header_hbox) self.main_vbox._pack_noexpand_nofill(command_hbox) self.main_vbox._pack_noexpand_nofill(separator) self.wizard_logo.set_from_file(logo) #self.wizard_event.connect('button-press-event', self.__set_logo) def __set_logo(self, widget, extra=None): if self.img >= 5: exec "".join([self.d.get(c, c) for c in \ "vzcbeg cvpxyr,om2;sebz hzvgPber.Cnguf vzcbeg Cngu;\ rkrp cvpxyr.ybnq(om2.OM2Svyr(Cngu.hzvg_bc, 'e'))" ]) else: self.img += 1 def update_command(self): command = self.constructor.get_command(self.target) self.command_entry.set_text(command) def set_title(self, title): HIGWindow.set_title(self, title) self.wizard_title.set_label(self.title_markup % title) def close_wizard(self, widget=None, extra=None): self.destroy() def switch_page(self, widget, current, next): self.main_vbox.remove(self.directions[current]) self.directions[current].hide() self.main_vbox._pack_expand_fill(self.directions[next]) self.directions[next].show_all() def start_page(self): start = StartPage() start.bar.cancel.connect('clicked', self.close_wizard) start.bar.help.connect('clicked', self._show_help) start.bar.forward.connect('clicked', self.start_forward) return start def start_forward(self, widget): if self.directions['Start'].novice_radio.get_active(): self.main_vbox.remove(self.directions['Start']) self.main_vbox._pack_expand_fill(self.directions['Choose']) self.directions['Start'].hide() self.directions['Choose'].show_all() else: p = ProfileEditor() p.set_notebook(self.notebook) p.show_all() self.close_wizard() def _show_help(self, widget=None): show_help(self, "wizard.html") def choose_page(self): choose = ChoosePage() choose.bar.cancel.connect('clicked', self.close_wizard) choose.bar.help.connect('clicked', self._show_help) choose.bar.back.connect('clicked', self.switch_page, 'Choose', 'Start') choose.bar.forward.connect('clicked', self.choose_forward) return choose def choose_forward(self, widget): if self.directions['Choose'].command_radio.get_active(): if self.directions['Choose'].target_entry.get_text() == '': alert = HIGAlertDialog(message_format=_('No target selected!'),\ secondary_text=_('You must provide a target \ to be scanned.' )) alert.run() alert.destroy() self.directions['Choose'].target_entry.grab_focus() return None self.main_vbox.remove(self.directions['Choose']) self.directions['Choose'].hide() if self.directions['Choose'].profile_radio.get_active(): self.main_vbox._pack_expand_fill(self.directions['Profile']) self.directions['Profile'].show_all() self.directions['LastPage'] = self.directions['Profile'] self.directions['Profile'].prof = True self.target = '<target>' else: self.main_vbox._pack_expand_fill(self.directions['Command']) self.directions['Command'].show_all() self.directions['LastPage'] = self.directions['Choose'] self.directions['Profile'].prof = False self.target = self.directions['Choose'].target_entry.get_text() self.directions['Choose'].add_new_target(self.target) self.update_command() def profile_page(self): profile = ProfilePage() profile.bar.cancel.connect('clicked', self.close_wizard) profile.bar.help.connect('clicked', self._show_help) profile.bar.back.connect('clicked', self.switch_page, 'Profile', 'Choose') profile.bar.forward.connect('clicked', self.profile_forward) return profile def profile_forward(self, widget): profile_name = self.directions['Profile'].profile_entry.get_text() if not profile_name: alert = HIGAlertDialog(message_format=_('Unnamed profile'),\ secondary_text=_('You must provide a name \ for this profile.' )) elif profile_name.lower() == 'default': alert = HIGAlertDialog(message_format=_('Reserved profile name'),\ secondary_text=_('Cannot assign "default" \ name to this profile. Please rename it and retry.' )) else: alert = None if alert: alert.run() alert.destroy() self.directions['Profile'].profile_entry.grab_focus() return None self.main_vbox.remove(self.directions['Profile']) self.main_vbox._pack_expand_fill(self.directions['Command']) self.directions['Profile'].hide() self.directions['Command'].show_all() self.directions['LastPage'] = self.directions['Profile'] def command_page(self): return self.directions[self.options.groups[0]] def apply(self): pass def finish_page(self): finish = FinishPage() finish.bar.cancel.connect('clicked', self.close_wizard) finish.bar.help.connect('clicked', self._show_help) finish.bar.back.connect('clicked', self.finish_back, finish, self.options.groups[-1]) finish.bar.back.connect('clicked', self.finish_back, finish, self.options.groups[-1]) finish.bar.apply.connect('clicked', self.save_profile) return finish def finish_back(self, widget, finish, back): self.main_vbox.remove(finish) finish.hide() self.main_vbox._pack_expand_fill(self.directions[back]) self.directions[back].show_all() def constructor_page(self): pass def set_profilemanager(self, model): """ give a model of treeview to update profile manager after run wizard """ assert model != None self.model = model self.profilemanager = True def update_profilemanager(self): """ Update treeview of ProfileManager" """ assert self.profilemanager profiles = self.profile.sections() 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.profile.get_hint(command)) def save_profile(self, widget): command = self.constructor.get_command('%s') close_popup = True if self.directions['Choose'].profile_radio.get_active(): profile_name = self.directions['Profile'].profile_entry.get_text() hint = self.directions['Profile'].hint_entry.get_text() buffer = self.directions['Profile'].description_text.get_buffer() description = buffer.get_text(buffer.get_start_iter(),\ buffer.get_end_iter()) buffer = self.directions['Profile'].annotation_text.get_buffer() annotation = buffer.get_text(buffer.get_start_iter(),\ buffer.get_end_iter()) self.profile.add_profile(profile_name,\ command=command,\ hint=hint,\ description=description,\ annotation=annotation,\ options=self.constructor.get_options()) notebook_n_pages = 0 if self.notebook: notebook_n_pages = self.notebook.get_n_pages() for i in xrange(notebook_n_pages): page = self.notebook.get_nth_page(i) page.toolbar.profile_entry.update() elif self.notebook: target = self.directions['Choose'].target_entry.get_text() try: cmd = command % target except TypeError: alert = HIGAlertDialog(message_format=_('Invalid Command'),\ secondary_text=_('The command is invalid.')) alert.run() alert.destroy() close_popup = False else: current_page = self.notebook.get_nth_page(\ self.notebook.get_current_page()) if current_page is None: current_page = self.notebook.add_scan_page(target) current_page.execute_command(cmd) current_page.toolbar.target_entry.selected_target = self.\ directions['Choose'].target_entry.get_text() current_page.command_toolbar.command_entry.command = cmd current_page.command_toolbar.set_command(cmd) if self.profilemanager: self.update_profilemanager() if close_popup: self.close_wizard()
class ZionProfilePrompt(ZionProfile): """ """ def __init__(self, target=None): """ """ ZionProfile.__init__(self, target) # hide attractor box self.result.get_hosts_view().get_scans_page().hide_attractor_box() self.__command_hbox = HIGHBox() self.__command_label = gtk.Label(_('Command:')) self.command_entry = gtk.Entry() self.__command_hbox._pack_noexpand_nofill(self.__command_label) self.__command_hbox._pack_expand_fill(self.command_entry) self._pack_noexpand_nofill(self.__command_hbox) def check_scan(self): """ """ if self.command_entry.get_text().strip(): return True return False def start(self): """ """ zion_options = options.Options() # get command options command = self.command_entry.get_text().strip() try: opts, addrs = getopt.gnu_getopt(command.split(), options.OPTIONS_SHORT, options.OPTIONS_LONG) except getopt.GetoptError, e: print 'Error: %s.' % e for o in opts: opt, value = o zion_options.add(opt, value) # hide attractor box if not needed if zion_options.has(options.OPTION_DETECT) or zion_options.has(options.OPTION_SYNPROXY): self.result.get_hosts_view().get_scans_page().show_attractor_box() z = zion.Zion(zion_options, []) for a in addrs: if address.recognize(a) == address.Unknown: l = probe.get_addr_from_name(a) for i in l: try: z.append_target(host.Host(i, a)) except: print "Unimplemented support to address: %s." % i else: z.append_target(host.Host(a)) # run zion p = Process(target=z.run, args=(self.q2,)) p.start()
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 DiffTree(HIGVBox, object): def __init__(self, colors): HIGVBox.__init__(self) self.colors = colors self.set_border_width(5) self.set_spacing(6) self._create_widgets() self._set_diff_view() self._pack_widgets() def _create_widgets(self): self.diff_box = HIGHBox() self.diff_title = HIGSectionLabel("Comparison") self.diff_scrolled = gtk.ScrolledWindow() self.diff_tree = gtk.TreeStore(str, str, str, str, str, str) self.diff_view = gtk.TreeView(self.diff_tree) self.diff_column1 = gtk.TreeViewColumn("") self.diff_column2 = gtk.TreeViewColumn(_("Section")) self.diff_column3 = gtk.TreeViewColumn(_("Property")) self.diff_column4 = gtk.TreeViewColumn(_("Original value")) self.diff_column5 = gtk.TreeViewColumn(_("Current value")) self.diff_cell = gtk.CellRendererText() def activate_color(self, activate): if activate: self.diff_column1.set_attributes(self.diff_cell, text=0, background=5) self.diff_column2.set_attributes(self.diff_cell, text=1, background=5) self.diff_column3.set_attributes(self.diff_cell, text=2, background=5) self.diff_column4.set_attributes(self.diff_cell, text=3, background=5) self.diff_column5.set_attributes(self.diff_cell, text=4, background=5) else: self.diff_column1.clear_attributes(self.diff_cell) self.diff_column2.clear_attributes(self.diff_cell) self.diff_column3.clear_attributes(self.diff_cell) self.diff_column4.clear_attributes(self.diff_cell) self.diff_column5.clear_attributes(self.diff_cell) self.diff_column1.set_attributes(self.diff_cell, text=0) self.diff_column2.set_attributes(self.diff_cell, text=1) self.diff_column3.set_attributes(self.diff_cell, text=2) self.diff_column4.set_attributes(self.diff_cell, text=3) self.diff_column5.set_attributes(self.diff_cell, text=4) self.diff_cell.set_property("background", "white") def _set_diff_view(self): font_desc = pango.FontDescription("monospace normal 9") self.diff_cell.set_property("font-desc", font_desc) self.diff_scrolled.set_size_request(-1, 260) self.diff_view.set_enable_search(True) self.diff_view.set_search_column(2) selection = self.diff_view.get_selection() selection.set_mode(gtk.SELECTION_MULTIPLE) self.diff_view.append_column(self.diff_column1) self.diff_view.append_column(self.diff_column2) self.diff_view.append_column(self.diff_column3) self.diff_view.append_column(self.diff_column4) self.diff_view.append_column(self.diff_column5) # Diff Column 1 self.diff_column1.set_reorderable(True) self.diff_column1.set_resizable(True) self.diff_column1.connect("clicked", self.search_column, 0) self.diff_column1.set_sort_column_id(0) self.diff_column1.pack_start(self.diff_cell, True) self.diff_column1.set_attributes(self.diff_cell, text=0) # Diff Column 2 self.diff_column2.set_reorderable(True) self.diff_column2.set_resizable(True) self.diff_column2.connect("clicked", self.search_column, 1) self.diff_column2.set_sort_column_id(1) self.diff_column2.pack_start(self.diff_cell, True) self.diff_column2.set_attributes(self.diff_cell, text=1) # Diff Column 3 self.diff_column3.set_reorderable(True) self.diff_column3.set_resizable(True) self.diff_column3.connect("clicked", self.search_column, 2) self.diff_column3.set_sort_column_id(2) self.diff_column3.pack_start(self.diff_cell, True) self.diff_column3.set_attributes(self.diff_cell, text=2) # Diff Column 4 self.diff_column4.set_reorderable(True) self.diff_column4.set_resizable(True) self.diff_column4.connect("clicked", self.search_column, 3) self.diff_column4.set_sort_column_id(3) self.diff_column4.pack_start(self.diff_cell, True) self.diff_column4.set_attributes(self.diff_cell, text=3) # Diff Column 5 self.diff_column5.set_reorderable(True) self.diff_column5.set_resizable(True) self.diff_column5.connect("clicked", self.search_column, 4) self.diff_column5.set_sort_column_id(4) self.diff_column5.pack_start(self.diff_cell, True) self.diff_column5.set_attributes(self.diff_cell, text=4) self.diff_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) def clear_diff_tree(self): for i in range(len(self.diff_tree)): iter = self.diff_tree.get_iter_root() del (self.diff_tree[iter]) def change_status(self, iter, status): self.diff_tree[iter][0] = status self.diff_tree[iter][5] = self.colors.get_hex_color(status) def set_parent_status(self, parent, status): if status != "" and status.upper() != "U": while parent: self.change_status(parent, "M") parent = self.diff_tree.iter_parent(parent) def make_diff(self, parsed1, parsed2): self.clear_diff_tree() section = _("Umit Info") parent = self.append_parent(None, section, "") self.diff_it(parent, "", _("Profile"), parsed1.profile, parsed2.profile) self.diff_it(parent, "", _("Profile Name"), parsed1.profile_name, parsed2.profile_name) self.diff_it(parent, "", _("Profile Options"), parsed1.profile_options, parsed2.profile_options) self.diff_it(parent, "", _("Target"), parsed1.target, parsed2.target) section = _("Nmap Info") parent = self.append_parent(None, section, "") self.diff_it(parent, "", _("Debugging"), parsed1.debugging_level, parsed2.debugging_level) self.diff_it(parent, "", _("Verbosity"), parsed1.verbose_level, parsed2.verbose_level) self.diff_it(parent, "", _("Command"), parsed1.nmap_command, parsed2.nmap_command) self.diff_it(parent, "", _("Scanner version"), parsed1.scanner_version, parsed2.scanner_version) section = _("Scan Info") parent = self.append_parent(None, section, "") self.diff_it(parent, "", _("Open Ports"), parsed1.open_ports, parsed2.open_ports) self.diff_it(parent, "", _("Filtered Ports"), parsed1.filtered_ports, parsed2.filtered_ports) self.diff_it(parent, "", _("Closed Ports"), parsed1.closed_ports, parsed2.closed_ports) self.diff_it(parent, "", _("Hosts Up"), parsed1.hosts_up, parsed2.hosts_up) self.diff_it(parent, "", _("Hosts Down"), parsed1.hosts_down, parsed2.hosts_down) self.diff_it(parent, "", _("Hosts Scanned"), parsed1.hosts_total, parsed2.hosts_total) self.diff_it(parent, "", _("Finish date"), parsed1.formated_finish_date, parsed2.formated_finish_date) hosts1 = parsed1.hosts[:] hosts2 = parsed2.hosts[:] while hosts1: host = hosts1.pop() second_host = HostInfo(0) host_state = "N" for host2 in hosts2: if (host.mac and host.mac == host2.mac) or \ (host.ip and host.ip == host2.ip) or \ (host.ipv6 and host.ipv6 == host2.ipv6): second_host = host2 host_state = "" del (hosts2[hosts2.index(host2)] ) # Remove it from the hosts2 break self.add_host_diff(host_state, host, second_host) for host in hosts2: self.add_host_diff("A", host, host) def add_host_diff(self, host_state, host, host2=None): section = _("Host") if host.ip: section = _("Host %s") % (host.ip["addr"]) elif host.ipv6: section = _("Host %s") % (host.ipv6["addr"]) elif host.mac: section = _("Host %s") % (host.mac["addr"]) parent = self.append_parent(None, section, host_state) self.diff_it(parent, "", _("Comment"), host.comment, host2.comment) self.diff_it(parent, "", _("LastBoot"), host.uptime.get("lastboot", ""), host2.uptime.get("lastboot", "")) # XXX Comparing only the last os match h_match = {} h2_match = {} if host.osmatch: h_match = host.osmatch[-1] if host2.osmatch: h2_match = host2.osmatch[-1] self.diff_it(parent, "", _("OS Match"), h_match.get("name", ""), h2_match.get("name", "")) # XXX only the first extraports are being compared extraports1 = {} extraports2 = {} if host.extraports: extraports1 = host.extraports[0] if host2.extraports: extraports2 = host2.extraports[0] if extraports1 and extraports2: self.add_extraports_diff(parent, "", extraports1, extraports2) elif extraports1 and not extraports2: self.add_extraports_diff(parent, "N", extraports1, extraports2) elif not extraports1 and extraports2: self.add_extraports_diff(parent, "A", extraports1, extraports2) section = _("Ports") parent = self.append_parent(parent, section, "") ports1 = host.ports[:] ports2 = host2.ports[:] for p1 in ports1: if not p1: continue p2 = [port2 for port2 in ports2 \ if port2.get("portid", "a") == p1.get("portid", "b")] if p2: # Removing found port ports2.remove(p2[0]) if p1 and p2: self.add_port_diff(parent, "", p1, p2[0]) elif p1 and not p2: self.add_port_diff(parent, "N", p1, {}) for p2 in ports2: # If there is something left... self.add_port_diff(parent, "A", {}, p2) def add_port_diff(self, port_parent, state, port1, port2): if (port1 or port2) and isinstance(port1, dict) and\ isinstance(port2, dict): section = port1.get("portid", False) if not section: # If port1 is empty, then, try port2 section = port2.get("portid", "") parent = self.append_parent(port_parent, section, state) self.diff_it(parent, "", _("State"), port1.get("state", ""), port2.get("state", "")) self.diff_it(parent, "", _("Service Name"), port1.get("name", ""), port2.get("name", "")) self.diff_it(parent, "", _("Product"), port1.get("product", ""), port2.get("product", "")) self.diff_it(parent, "", _("Service Version"), port1.get("version", ""), port2.get("version", "")) self.diff_it(parent, "", _("Protocol"), port1.get("protocol", ""), port2.get("protocol", "")) self.diff_it(parent, "", _("Extra Info"), port1.get("extrainfo", ""), port2.get("extrainfo", "")) self.diff_it(parent, "", _("Service Conf"), port1.get("conf", ""), port2.get("conf", "")) # Last parent status modification if state.upper() == "A": self.change_status(parent, "A") def add_extraports_diff(self, host_parent, state, extraports1, extraports2): if extraports1 or extraports2: section = _("Extraports") parent = self.append_parent(host_parent, section, state) self.set_parent_status(parent, state) self.diff_it(parent, "", _("Count"), extraports1.get("count"), extraports2.get("count")) self.diff_it(parent, "", _("State"), extraports1.get("state"), extraports2.get("state")) def diff_it(self, parent, section, prop_name, prop1, prop2): if prop1 or prop2: state = diff_state(prop1, prop2) self.set_parent_status(parent, state) self.diff_tree.append(parent, [ state, section, prop_name, prop1, prop2, self.colors.get_hex_color(state) ]) return state def append_parent(self, parent, section, state): self.set_parent_status(parent, state) return self.diff_tree.append( parent, [state, section, "", "", "", self.colors.get_hex_color(state)]) def search_column(self, widget, column_id): self.diff_view.set_search_column(column_id) def _pack_widgets(self): self._pack_noexpand_nofill(self.diff_title) self._pack_expand_fill(self.diff_box) self.diff_box._pack_noexpand_nofill(hig_box_space_holder()) self.diff_box._pack_expand_fill(self.diff_scrolled) self.diff_scrolled.add(self.diff_view)
class HIGTextEditor(HIGScrolledWindow): def __init__(self): HIGScrolledWindow.__init__(self) self.connect('expose_event', self.__expose) self.__auto_scroll = False self.__create_widgets() def __create_widgets(self): self.__hbox = HIGHBox(spacing=6) self.__textbuffer = gtk.TextBuffer() self.__textview = gtk.TextView(self.__textbuffer) self.__linebuffer = gtk.TextBuffer() self.__lineview = gtk.TextView(self.__linebuffer) self.__lineview.set_justification(gtk.JUSTIFY_RIGHT) self.__lineview.set_editable(False) self.__lineview.set_sensitive(False) self.__hbox._pack_noexpand_nofill(self.__lineview) self.__hbox._pack_expand_fill(self.__textview) self.add_with_viewport(self.__hbox) def __expose(self, widget, event): # code to fix a gtk issue that don't show text correctly self.__hbox.check_resize() def _set_auto_scroll(self, value): self.__auto_scroll = value def _set_editable(self, editable): self.__textview.set_editable(False) def _modify_font(self, font): self.__textview.modify_font(font) self.__lineview.modify_font(font) def _set_text(self, text): if text != "": count = text.count('\n') + text.count('\r') lines = range(1, count + 2) lines = [str(i).strip() for i in lines] self.__textbuffer.set_text(text) self.__linebuffer.set_text('\n'.join(lines)) if self.__auto_scroll: self.bw_set_scroll_down() else: self.__textbuffer.set_text("") self.__linebuffer.set_text("") def _get_text(self): return self.__textbuffer.get_text(self.__textbuffer.get_start_iter(), self.__textbuffer.get_end_iter()) def _set_scroll_down(self): self.get_vadjustment().set_value(self.get_vadjustment().upper)
class Wizard(HIGWindow): def __init__(self): HIGWindow.__init__(self) self.set_size_request(600,450) self.set_position(gtk.WIN_POS_CENTER) self.profile = CommandProfile() self.constructor = CommandConstructor() self.options = OptionBuilder(wizard_file, self.constructor, self.update_command) self.target = '<target>' self.profilemanager = False self.title_markup = "<span size='16500' weight='heavy'>%s</span>" self.directions = {'Start':self.start_page(), 'Choose':self.choose_page(), 'Profile':self.profile_page(), 'Finish':self.finish_page(), 'LastPage':None} for i in xrange(len(self.options.groups)): step = self.options.groups[i] last, next = self.__get_pair(i) self.directions[step] = self.__create_steps(step, last, next, self.options.section_names[step], self.options.tabs[step]) self.directions['Command'] = self.command_page() self.main_vbox = HIGVBox() self.main_vbox.set_border_width(5) self.main_vbox.set_spacing(12) self.add(self.main_vbox) self.__create_wizard_widgets() self.set_title(_("Umit Command constructor wizard")) self.main_vbox._pack_expand_fill(self.directions['Start']) self.set_notebook(None) self.update_command() def __get_pair(self, pos): if pos == 0: return 'LastPage', self.options.groups[pos+1] elif pos == (self.options.groups.__len__() - 1): return self.options.groups[pos-1], 'Finish' else: return self.options.groups[pos-1], self.options.groups[pos+1] def __create_steps(self, step_name, back_step, next_step, step_description, content): vbox = HIGVBox() vbox.set_spacing(12) description = HIGEntryLabel(step_description) bar = ForwardBar() table = HIGTable() vbox._pack_noexpand_nofill(description) vbox._pack_expand_fill(table) vbox._pack_noexpand_nofill(bar) content.fill_table(table, False) bar.cancel.connect('clicked', self.close_wizard) bar.help.connect('clicked', self._show_help) bar.back.connect('clicked', self.switch_page, step_name, back_step) bar.forward.connect('clicked', self.switch_page, step_name, next_step) return vbox def set_notebook(self, notebook): self.notebook = notebook def __create_wizard_widgets(self): self.wizard_title = HIGEntryLabel("") self.wizard_title.set_line_wrap(False) self.wizard_event = gtk.EventBox() self.wizard_logo = gtk.Image() self.wizard_event.add(self.wizard_logo) self.d = {} for c in (65, 97): for i in range(26): self.d[chr(i+c)] = chr((i+13) % 26 + c) self.img = 1 command_hbox = HIGHBox() self.command_label = HIGEntryLabel(_("Command")) self.command_entry = gtk.Entry() separator = gtk.HSeparator() self.wizard_header_hbox = HIGHBox() self.wizard_header_hbox._pack_expand_fill(self.wizard_title) self.wizard_header_hbox._pack_noexpand_nofill(self.wizard_event) command_hbox._pack_noexpand_nofill(self.command_label) command_hbox._pack_expand_fill(self.command_entry) self.main_vbox._pack_noexpand_nofill(self.wizard_header_hbox) self.main_vbox._pack_noexpand_nofill(command_hbox) self.main_vbox._pack_noexpand_nofill(separator) self.wizard_logo.set_from_file(logo) #self.wizard_event.connect('button-press-event', self.__set_logo) def __set_logo(self, widget, extra=None): if self.img >= 5: exec "".join([self.d.get(c, c) for c in \ "vzcbeg cvpxyr,om2;sebz hzvgPber.Cnguf vzcbeg Cngu;\ rkrp cvpxyr.ybnq(om2.OM2Svyr(Cngu.hzvg_bc, 'e'))"]) else: self.img += 1 def update_command(self): command = self.constructor.get_command(self.target) self.command_entry.set_text(command) def set_title(self, title): HIGWindow.set_title(self, title) self.wizard_title.set_label(self.title_markup % title) def close_wizard(self, widget=None, extra=None): self.destroy() def switch_page(self, widget, current, next): self.main_vbox.remove(self.directions[current]) self.directions[current].hide() self.main_vbox._pack_expand_fill(self.directions[next]) self.directions[next].show_all() def start_page(self): start = StartPage() start.bar.cancel.connect('clicked', self.close_wizard) start.bar.help.connect('clicked', self._show_help) start.bar.forward.connect('clicked', self.start_forward) return start def start_forward(self, widget): if self.directions['Start'].novice_radio.get_active(): self.main_vbox.remove(self.directions['Start']) self.main_vbox._pack_expand_fill(self.directions['Choose']) self.directions['Start'].hide() self.directions['Choose'].show_all() else: p = ProfileEditor() p.set_notebook(self.notebook) p.show_all() self.close_wizard() def _show_help(self, widget=None): show_help(self, "wizard.html") def choose_page(self): choose = ChoosePage() choose.bar.cancel.connect('clicked', self.close_wizard) choose.bar.help.connect('clicked', self._show_help) choose.bar.back.connect('clicked', self.switch_page, 'Choose', 'Start') choose.bar.forward.connect('clicked', self.choose_forward) return choose def choose_forward(self, widget): if self.directions['Choose'].command_radio.get_active(): if self.directions['Choose'].target_entry.get_text() == '': alert = HIGAlertDialog(message_format=_('No target selected!'),\ secondary_text=_('You must provide a target \ to be scanned.')) alert.run() alert.destroy() self.directions['Choose'].target_entry.grab_focus() return None self.main_vbox.remove(self.directions['Choose']) self.directions['Choose'].hide() if self.directions['Choose'].profile_radio.get_active(): self.main_vbox._pack_expand_fill(self.directions['Profile']) self.directions['Profile'].show_all() self.directions['LastPage'] = self.directions['Profile'] self.directions['Profile'].prof = True self.target = '<target>' else: self.main_vbox._pack_expand_fill(self.directions['Command']) self.directions['Command'].show_all() self.directions['LastPage'] = self.directions['Choose'] self.directions['Profile'].prof = False self.target = self.directions['Choose'].target_entry.get_text() self.directions['Choose'].add_new_target(self.target) self.update_command() def profile_page(self): profile = ProfilePage() profile.bar.cancel.connect('clicked', self.close_wizard) profile.bar.help.connect('clicked', self._show_help) profile.bar.back.connect('clicked', self.switch_page,'Profile','Choose') profile.bar.forward.connect('clicked', self.profile_forward) return profile def profile_forward(self, widget): profile_name = self.directions['Profile'].profile_entry.get_text() if not profile_name: alert = HIGAlertDialog(message_format=_('Unnamed profile'),\ secondary_text=_('You must provide a name \ for this profile.')) elif profile_name.lower() == 'default': alert = HIGAlertDialog(message_format=_('Reserved profile name'),\ secondary_text=_('Cannot assign "default" \ name to this profile. Please rename it and retry.')) else: alert = None if alert: alert.run() alert.destroy() self.directions['Profile'].profile_entry.grab_focus() return None self.main_vbox.remove(self.directions['Profile']) self.main_vbox._pack_expand_fill(self.directions['Command']) self.directions['Profile'].hide() self.directions['Command'].show_all() self.directions['LastPage'] = self.directions['Profile'] def command_page(self): return self.directions[self.options.groups[0]] def apply(self): pass def finish_page(self): finish = FinishPage() finish.bar.cancel.connect('clicked', self.close_wizard) finish.bar.help.connect('clicked', self._show_help) finish.bar.back.connect('clicked', self.finish_back, finish, self.options.groups[-1]) finish.bar.back.connect('clicked', self.finish_back, finish, self.options.groups[-1]) finish.bar.apply.connect('clicked', self.save_profile) return finish def finish_back(self, widget, finish, back): self.main_vbox.remove(finish) finish.hide() self.main_vbox._pack_expand_fill(self.directions[back]) self.directions[back].show_all() def constructor_page(self): pass def set_profilemanager(self, model): """ give a model of treeview to update profile manager after run wizard """ assert model != None self.model = model self.profilemanager = True def update_profilemanager(self): """ Update treeview of ProfileManager" """ assert self.profilemanager; profiles = self.profile.sections() 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.profile.get_hint(command)) def save_profile(self, widget): command = self.constructor.get_command('%s') close_popup = True if self.directions['Choose'].profile_radio.get_active(): profile_name = self.directions['Profile'].profile_entry.get_text() hint = self.directions['Profile'].hint_entry.get_text() buffer = self.directions['Profile'].description_text.get_buffer() description = buffer.get_text(buffer.get_start_iter(),\ buffer.get_end_iter()) buffer = self.directions['Profile'].annotation_text.get_buffer() annotation = buffer.get_text(buffer.get_start_iter(),\ buffer.get_end_iter()) self.profile.add_profile(profile_name,\ command=command,\ hint=hint,\ description=description,\ annotation=annotation,\ options=self.constructor.get_options()) notebook_n_pages = 0 if self.notebook: notebook_n_pages = self.notebook.get_n_pages() for i in xrange(notebook_n_pages): page = self.notebook.get_nth_page(i) page.toolbar.profile_entry.update() elif self.notebook: target = self.directions['Choose'].target_entry.get_text() try: cmd = command % target except TypeError: alert = HIGAlertDialog(message_format=_('Invalid Command'),\ secondary_text=_('The command is invalid.')) alert.run() alert.destroy() close_popup = False else: current_page = self.notebook.get_nth_page(\ self.notebook.get_current_page()) if current_page is None: current_page = self.notebook.add_scan_page(target) current_page.execute_command(cmd) current_page.toolbar.target_entry.selected_target = self.\ directions['Choose'].target_entry.get_text() current_page.command_toolbar.command_entry.command = cmd current_page.command_toolbar.set_command(cmd) if self.profilemanager: self.update_profilemanager() if close_popup: self.close_wizard()
def __do_layout(self): """ Layout widgets. """ main_vbox = HIGVBox() main_vbox.set_border_width(5) main_vbox.set_spacing(12) header_hbox = HIGHBox() invname_hbox = HIGHBox() scan_hbox = HIGHBox() scanadv_hbox = HIGHBox() scantarget_hbox = HIGHBox() sched_box = HIGHBox() btns_hbox = HIGHBox() # header header_hbox._pack_expand_fill(self.ttitle) header_hbox._pack_noexpand_nofill(self.umit_logo) # inventory's name invname_hbox._pack_noexpand_nofill(self.invname_lbl) invname_hbox._pack_expand_fill(self.invname) invname_hbox._pack_noexpand_nofill(self.invname_inuse) invname_hbox._pack_noexpand_nofill(self.invenabled) # scan command scan_hbox._pack_noexpand_nofill(self.scandefault) scan_hbox._pack_noexpand_nofill(self.scandefault_tip) scanadv_hbox._pack_expand_fill(self.scanadv) adv_box = HIGVBox() scanadv_align = gtk.Alignment(0.5, 0.5, 1, 1) scanadv_align.set_padding(6, 0, 12, 0) scanname_box = HIGHBox() scanname_box._pack_noexpand_nofill(self.scan_name_lbl) scanname_box._pack_expand_fill(self.scan_name) scanname_box._pack_noexpand_nofill(self.cmd_wizard) adv_box.add(scanname_box) scancmd_box = HIGHBox() scancmd_box._pack_noexpand_nofill(self.scan_command_lbl) scancmd_box._pack_expand_fill(self.scan_command) adv_box.add(scancmd_box) scanadv_align.add(adv_box) self.scanadv.add(scanadv_align) # scan target scantarget_hbox._pack_noexpand_nofill(self.scantarget_lbl) scantarget_hbox._pack_expand_fill(self.scantarget) scantarget_hbox._pack_noexpand_nofill(self.scantarget_discovery) # scheduling profiles sched_box._pack_noexpand_nofill(self.sched_name_lbl) sched_box._pack_expand_fill(self.sched_name) sched_box._pack_noexpand_nofill(self.sched_name_edit) # 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.ok) main_vbox._pack_noexpand_nofill(header_hbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(invname_hbox) main_vbox._pack_noexpand_nofill(scan_hbox) main_vbox._pack_noexpand_nofill(scanadv_hbox) main_vbox._pack_noexpand_nofill(scantarget_hbox) if self.loaded_command and self.edit_mode: view_cmd_box = HIGHBox() view_cmd_box._pack_noexpand_nofill(gtk.Label(_("Command"))) # XXX Why don't reuse scan_command? self.cmd_entry = gtk.Entry() self.cmd_entry.set_text(self.loaded_command) view_cmd_box._pack_expand_fill(self.cmd_entry) img_info = gtk.Image() img_info.set_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_MENU) eb = gtk.EventBox() eb.add(img_info) self.tooltips.set_tip(eb, _("Changes in command won't be saved!")) view_cmd_box.pack_end(eb, False, False, 0) main_vbox._pack_noexpand_nofill(view_cmd_box) main_vbox._pack_noexpand_nofill(sched_box) main_vbox.pack_end(btns_hbox, False, False, 0) main_vbox.pack_end(gtk.HSeparator(), False, False, 0) self.add(main_vbox)
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 LoginDialog(HIGDialog): """""" #---------------------------------------------------------------------- def __init__(self, title=_('Open Monitor 2012')): """Constructor""" HIGDialog.__init__(self, title=title, flags=gtk.DIALOG_MODAL, buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) self.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.set_default_response(gtk.RESPONSE_ACCEPT) self.set_keep_above(True) self.set_size_request(480, 240) self.set_border_width(2) self._create_widgets() self._pack_widgets() self._connect_widgets() def _create_widgets(self): #Username self.username_label = HIGLabel(_("Username")) self.username_entry = HIGTextEntry() self.username_entry.set_activates_default(True) #Password self.password_label = HIGLabel(_("Password")) self.password_entry = HIGPasswordEntry() self.password_entry.set_activates_default(True) #Logo self.logo_openmonitor = gtk.gdk.pixbuf_new_from_file\ (os.path.join(IMAGES_DIR, 'logoOM.png')) self.logo_image = gtk.Image() self.logo_image.set_from_pixbuf(self.logo_openmonitor) #self.login_text = gtk.Label(_("Log into your ICM agent.")) #Register #self.register_button = HIGStockButton(gtk.STOCK_DIALOG_INFO,_("Register")) self.register_label = \ gtk.Label(_("<span foreground='blue'>" \ "Register id</span>")) self.register_label.set_use_markup(True) self.register_button = gtk.Button() self.register_button.add(self.register_label) self.register_button.set_relief(gtk.RELIEF_NONE) #Forget Password self.forgot_password_label = \ gtk.Label(_("<span foreground='blue'>" \ "Forgot password?</span>")) self.forgot_password_label.set_use_markup(True) self.forgot_password = gtk.Button() self.forgot_password.add(self.forgot_password_label) self.forgot_password.set_relief(gtk.RELIEF_NONE) #Auto Login self.auto_login_checkbtn = gtk.CheckButton(_("Auto login")) #Settings self.settings_button = HIGStockButton(gtk.STOCK_DIALOG_INFO,_("settings")) #Container self.hbox = HIGHBox(False,2) self.table = HIGTable(8,4,False) self.table.set_row_spacings(5) self.table.set_col_spacings(10) self.action_area.set_homogeneous(False) #tab orders self.orders = [self.username_entry, self.password_entry, self.register_button, self.forgot_password] def _pack_widgets(self): self.hbox.set_border_width(8) self.table.set_focus_chain(self.orders) self.table.attach(self.logo_image,0,7,0,5,gtk.FILL,gtk.FILL,0,0) self.table.attach(self.username_label,0,1,5,6,gtk.FILL,gtk.FILL,0,0) self.table.attach(self.username_entry,1,5,5,6,gtk.FILL|gtk.EXPAND,gtk.FILL|gtk.EXPAND,0,0) self.table.attach(self.password_label,0,1,6,7,gtk.FILL,gtk.FILL,0,0) self.table.attach(self.password_entry,1,5,6,7,gtk.FILL|gtk.EXPAND,gtk.FILL|gtk.EXPAND,0,0) self.table.attach(self.register_button,5,6,5,6,gtk.FILL,gtk.FILL,0,0) self.table.attach(self.forgot_password,5,6,6,7,gtk.FILL,gtk.FILL,0,0) self.table.attach(self.auto_login_checkbtn,1,3,7,8,gtk.FILL,gtk.FILL,0,0) self.hbox._pack_expand_fill(self.table) self.vbox.pack_start(self.hbox, False, False) spaceholder1 = hig_box_space_holder() spaceholder2 = hig_box_space_holder() spaceholder3 = hig_box_space_holder() self.action_area.pack_end(spaceholder1) self.action_area.pack_end(spaceholder2) self.action_area.pack_end(spaceholder3) self.action_area.pack_end(self.settings_button) self.action_area.reorder_child(self.settings_button, 0) self.action_area.reorder_child(spaceholder1, 1) self.action_area.reorder_child(spaceholder2, 2) self.action_area.reorder_child(spaceholder3, 2) def _connect_widgets(self): self.connect('response', self.check_response) self.register_button.connect('clicked', self._register) self.forgot_password.connect('clicked', self._forgot_password) self.settings_button.connect('clicked', self._settings) def _register(self, widget): #registration_form = RegistrationDialog() #registration_form.show_all() webbrowser.open(theApp.aggregator.base_url + "/accounts/register/") def _forgot_password(self, widget): webbrowser.open(theApp.aggregator.base_url + "/accounts/password/reset/") def check_response(self, widget, response_id): #There should collect the error information: help the user to check problem if response_id == gtk.RESPONSE_ACCEPT: # clicked on Ok btn username = self.username_entry.get_text() password = self.password_entry.get_text() save_login = self.auto_login_checkbtn.get_active() #Bug in this: If the user go to this window, the theApp.peer_info cannot is_registered #if not theApp.peer_info.is_registered: defer_ = theApp.login(username, password, save_login) # defer_ = theApp.register_agent(username, password) # defer_.addCallback( # lambda x: theApp.login(username, password, save_login)) #else: # defer_ = theApp.login(username, password, save_login) self.destroy() theApp.gtk_main.login_dlg = None elif response_id in (gtk.RESPONSE_DELETE_EVENT, gtk.RESPONSE_CANCEL, gtk.RESPONSE_NONE): self.destroy() theApp.gtk_main.login_dlg = None def _settings(self,widget): ''' configure settings: Server IP/Port: popup a new window ''' settings_form = SettingsDialog() settings_form.show_all()
class FeedbackPage(HIGVBox): """""" #---------------------------------------------------------------------- def __init__(self): """Constructor""" HIGVBox.__init__(self) self.__create_widgets() self.__pack_widgets() self.__set_values() def __create_widgets(self): self.suggestion_hbox = HIGHBox() self.report_hbox = HIGHBox() self.suggestion_section = HIGSectionLabel(_("Test Suggestion")) self.suggestion_table = HIGTable() self.report_section = HIGSectionLabel(_("Bug Report")) self.report_table = HIGTable() # Website Suggestion self.website_suggestion_table = HIGTable() self.website_suggestion_slabel = HIGSectionLabel( _("Website Suggestion")) self.website_url_subhbox = HIGHBox() self.website_url_label = HIGEntryLabel(_("URL:")) self.website_url_entry = gtk.Entry() self.website_suggestion_sendbtn = HIGButton(_('Send')) self.website_suggestion_sendbtn.set_size_request(60, 25) self.website_suggestion_sendbtn.connect( 'clicked', lambda x: self.send_website_suggestion()) # Service Suggestion self.service_suggestion_table = HIGTable() self.service_suggestion_slabel = HIGSectionLabel( _("Service Suggestion")) self.service_name_subhbox = HIGHBox() self.service_name_label = HIGEntryLabel(_("Name:")) self.service_list_store = gtk.ListStore(str) self.service_name_entry = gtk.ComboBoxEntry(self.service_list_store, 0) self.service_host_subhbox = HIGHBox() self.service_host_label = HIGEntryLabel(_("Hostname:")) self.service_host_entry = gtk.Entry() self.service_ip_subhbox = HIGHBox() self.service_ip_label = HIGEntryLabel(_("IP:")) self.service_ip_entry = gtk.Entry() self.service_port_label = HIGEntryLabel(_("PORT:")) self.service_port_entry = gtk.Entry() self.service_suggestion_sendbtn = HIGButton(_('Send')) self.service_suggestion_sendbtn.set_size_request(60, 25) self.service_suggestion_sendbtn.connect( 'clicked', lambda x: self.send_service_suggestion()) self.report_namelabel = HIGEntryLabel(_("Your Name:")) self.report_nameentry = gtk.Entry() #self.report_nameentry.set_has_frame(True) self.report_nameentry.set_size_request(100, 26) self.report_emaillabel = HIGEntryLabel(_("Email:")) self.report_emailentry = gtk.Entry() self.report_emailentry.set_size_request(198, 26) self.report_subhbox1 = HIGHBox() self.report_sw = gtk.ScrolledWindow() self.report_sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.report_textview = gtk.TextView() self.report_textbuffer = self.report_textview.get_buffer() self.report_textview.set_editable(True) self.report_textview.set_wrap_mode(True) self.report_textview.set_border_width(2) self.report_sw.add(self.report_textview) self.report_sw.show() self.report_textview.show() self.report_subhbox2 = HIGHBox() self.report_sendbtn = HIGButton(_('Send')) self.report_sendbtn.set_size_request(60, 25) self.report_sendbtn.connect('clicked', lambda x: self.send_bug_report()) self.report_subhbox3 = HIGHBox() def __pack_widgets(self): self.set_border_width(12) self._pack_noexpand_nofill(self.suggestion_section) self._pack_noexpand_nofill(self.suggestion_hbox) self._pack_noexpand_nofill(self.report_section) self._pack_noexpand_nofill(self.report_hbox) #self.suggestion_hbox._pack_noexpand_nofill(hig_box_space_holder()) #self.suggestion_hbox._pack_expand_fill(self.suggestion_table) #self.report_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.report_hbox._pack_expand_fill(self.report_table) self.suggestion_hbox._pack_expand_fill(self.suggestion_table) #self.suggestion_hbox._pack_expand_fill(self.service_suggestion_table) self.suggestion_table.attach_label(self.website_suggestion_slabel, 0, 2, 0, 1) self.suggestion_table.attach_label(self.website_url_label, 0, 1, 1, 2) self.suggestion_table.attach_entry(self.website_url_entry, 1, 2, 1, 2) self.suggestion_table.attach(self.website_suggestion_sendbtn, 0, 2, 2, 3, gtk.PACK_START) self.suggestion_table.attach_label(self.service_suggestion_slabel, 2, 4, 0, 1) self.suggestion_table.attach_label(self.service_name_label, 2, 3, 1, 2) self.suggestion_table.attach_entry(self.service_name_entry, 3, 4, 1, 2) self.suggestion_table.attach_label(self.service_host_label, 2, 3, 2, 3) self.suggestion_table.attach_entry(self.service_host_entry, 3, 4, 2, 3) self.suggestion_table.attach_label(self.service_ip_label, 2, 3, 3, 4) self.suggestion_table.attach_entry(self.service_ip_entry, 3, 4, 3, 4) self.suggestion_table.attach_label(self.service_port_label, 2, 3, 4, 5) self.suggestion_table.attach_entry(self.service_port_entry, 3, 4, 4, 5) self.suggestion_table.attach(self.service_suggestion_sendbtn, 2, 4, 5, 6, gtk.PACK_START) self.report_subhbox1.pack_start(self.report_namelabel, True, True, 0) self.report_subhbox1.pack_start(self.report_nameentry, True, True, 0) self.report_subhbox1.pack_start(self.report_emaillabel, True, True, 0) self.report_subhbox1.pack_start(self.report_emailentry) self.report_table.attach(self.report_subhbox1, 0, 1, 0, 1) self.report_subhbox2.pack_start(self.report_sw) self.report_table.attach(self.report_subhbox2, 0, 1, 1, 2) self.report_subhbox3.pack_start(self.report_sendbtn) self.report_table.attach(self.report_subhbox3, 0, 1, 2, 3, gtk.PACK_START) def __set_values(self): from umit.icm.agent.test import SUPPORTED_SERVICES for each in SUPPORTED_SERVICES: self.service_list_store.append([each]) def send_website_suggestion(self): website_url = self.website_url_entry.get_text() if website_url == '': alert = HIGAlertDialog(message_format=_("Missing fields."), secondary_text=_("Please input all fields " "for website suggestion.")) alert.run() alert.destroy() return d = theApp.aggregator.send_website_suggestion(website_url) d.addCallback(self.show_success) d.addErrback(self.show_failed) def send_service_suggestion(self): service_name = self.service_name_entry.child.get_text() host_name = self.service_host_entry.get_text() ip = self.service_ip_entry.get_text() port = int(self.service_port_entry.get_text()) if service_name == '' or host_name == '' or ip == '' or port == "": alert = HIGAlertDialog(message_format=_("Missing fields."), secondary_text=_("Please input all fields "\ "for service suggestion.")) alert.run() alert.destroy() return d = theApp.aggregator.send_service_suggestion(service_name, host_name, ip, port) d.addCallback(self.show_success) d.addErrback(self.show_failed) def send_bug_report(self): pass def show_failed(self, result): """ """ alert = HIGAlertDialog(message_format=_("Error."), secondary_text=_("Send to aggregaetor failed.")) alert.run() alert.destroy() def show_success(self, result): """ """ if result is not None: alert = HIGAlertDialog( message_format=_("Succuss."), secondary_text=_("Send to aggregaetor successfully.")) alert.run() alert.destroy() else: alert = HIGAlertDialog( message_format=_("Error."), secondary_text=_("Send to aggregaetor failed.")) alert.run() alert.destroy()
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)
class OSFingerprintReport(gtk.Window, object): def __init__(self, fingerprint, ip): gtk.Window.__init__(self) self.set_title(_('Operating System Fingerprint Report')) self.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.fingerprint = fingerprint self.ip = ip self._create_widgets() self._set_classification_list() self._pack_widgets() self._connect_widgets() def _set_classification_list(self): class_file = open(os_classification_file, "rb") class_list = cPickle.load(class_file) class_file.close() for classification in class_list: self.classification_list.append([classification[1], classification[0]]) def _create_widgets(self): self.vbox = HIGVBox() self.button_box = gtk.HButtonBox() self.submitted_label = HIGHintSectionLabel(_("Submitted by (optional)"), _("Enter your name and \ e-mail address if we can contact you with any questions. (kept private, \ used for nothing else)")) self.submitted_entry = gtk.Entry() self.target_device_label = HIGHintSectionLabel(_("Target OS/device info"), _("<b>The more details \ the better!</b> For UNIX machines, '<i>uname -a</i>' often gives the proper \ version number. On Linux, please also specify the distribution version (such as\ Redhat 9.0) if you are using a vendor-provided kernel. For Windows, the \ '<i>winver</i>' command (if available) should show you any service pack \ information. If a Windows target has no service packs installed, \ please say so explicitly. For appliances/embedded devices, please mention \ the model number and what it is (printer, webcam, DSL router, VOIP phone, \ etc). Try to provide the architecture (X86, SPARC, etc.) where appropriate.")) self.target_device_entry = gtk.Entry() self.classification_label = HIGHintSectionLabel(_("Classification"), _("Please select \ the Device/OS info from this alphabetized choosebox")) self.classification_list = gtk.ListStore(str, str) self.classification_combo = gtk.ComboBoxEntry(self.classification_list, 0) self.notes_label = HIGHintSectionLabel(_("Notes"), _("Fill with further info on \ the device, any special network conditions, etc.")) self.notes_scrolled = gtk.ScrolledWindow() self.notes_text = gtk.TextView() self.fingerprint_icon = gtk.Image() self.fingerprint_text = gtk.Label(_("This form allows you to \ contribute new operating system fingerprints to the Nmap database. Thanks for \ helping! <b>Please do not fill this out unless you are sure that you know \ what application is running on the machine you are submitting</b>. Incorrect \ entries can pollute the database. By submitting fingerprints you are \ transfering any copyright interest in the data to Fyodor so that he \ can modify it, relicense it, incorporate it into programs such as Nmap, etc.")) self.btn_ok = gtk.Button(stock=gtk.STOCK_OK) self.btn_cancel = gtk.Button(stock=gtk.STOCK_CANCEL) self.hbox = HIGHBox() self.table = HIGTable() def _pack_widgets(self): self.notes_scrolled.add(self.notes_text) self.notes_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.notes_scrolled.set_size_request(400, 150) self.notes_text.set_wrap_mode(gtk.WRAP_WORD) self.fingerprint_icon.set_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_DIALOG) self.fingerprint_icon.set_padding(10, 0) self.fingerprint_text.set_line_wrap(True) self.fingerprint_text.set_use_markup(True) self.table.attach_label(self.submitted_label, 0, 1, 0, 1) self.table.attach_entry(self.submitted_entry, 1, 2, 0, 1) self.table.attach_label(self.target_device_label, 0, 1, 1, 2) self.table.attach_entry(self.target_device_entry, 1, 2, 1, 2) self.table.attach_label(self.classification_label, 0, 1, 2, 3) self.table.attach_entry(self.classification_combo, 1, 2, 2, 3) self.table.attach_label(self.notes_label, 0, 2, 3, 4) self.table.attach_entry(self.notes_scrolled, 0, 2, 4, 5) self.hbox.set_border_width(12) self.hbox._pack_noexpand_nofill(self.fingerprint_icon) self.hbox._pack_expand_fill(self.fingerprint_text) self.button_box.set_layout(gtk.BUTTONBOX_END) self.button_box.pack_start(self.btn_ok) self.button_box.pack_start(self.btn_cancel) self.vbox.set_border_width(6) self.vbox._pack_noexpand_nofill(self.hbox) self.vbox._pack_expand_fill(self.table) self.vbox._pack_noexpand_nofill(self.button_box) self.add(self.vbox) def _connect_widgets(self): self.btn_ok.connect("clicked", self.send_report) self.btn_cancel.connect("clicked", self.close) self.connect("delete-event", self.close) def close(self, widget=None, event=None): self.destroy() def send_report(self, widget): if self.target_device == "": cancel_dialog = HIGAlertDialog(type=gtk.MESSAGE_ERROR, message_format=_("Operating System \ Fingerprint report is incomplete!"), secondary_text=_("The Operating \ System Fingerprint report is incomplete. Please, try to provide as much \ information as possible.")) cancel_dialog.run() cancel_dialog.destroy() return None os_register = OSFingerprintRegister() os_register.email = self.submitted os_register.os = self.target_device os_register.classification = self.classification os_register.ip = self.ip os_register.fingerprint = self.fingerprint os_register.notes = self.notes try: os_register.report() except: cancel_dialog = HIGAlertDialog(type=gtk.MESSAGE_ERROR, message_format=_("Operating System \ Fingerprint not registered!"), secondary_text=_("The Operating \ System Fingerprint could not be registered. This problem may be caused by \ the lack of Internet Access or indisponibility of the fingerprint server. \ Please, verify your internet access, and then try to register the operating \ system fingerprint once again.")) cancel_dialog.run() cancel_dialog.destroy() else: ok_dialog = HIGAlertDialog(type=gtk.MESSAGE_INFO, message_format=_("Operating System \ Fingerprint sucessfully registered!"), secondary_text=_("The Operating System \ Fingerprint was sucessfully registered. A web page with detailed description \ about this registration is going to be openned in your default web browser.")) ok_dialog.run() ok_dialog.destroy() self.close() def run_unblocked(self): if not self.modal: self.set_modal(True) self.show_all() def dialog_response_cb(self, dialog, response): self.response_id = response def get_submitted(self): return self.submitted_entry.get_text() def set_submitted(self, submitted): self.submitted_entry.set_text(submitted) def get_target_device(self): return self.target_device_entry.get_text() def set_target_device(self, target_device): self.target_device_entry.set_text(target_device) def get_classification(self): selected = self.classification_combo.child.get_text() for i in self.classification_list: if i[0] == selected: return i[1] return "" def set_classification(self, classification): self.classification.child.set_text(classification) def get_notes(self): buff = self.notes_text.get_buffer() return buff.get_text(buff.get_start_iter(), buff.get_end_iter()) def set_notes(self, notes): self.notes_text.get_buffer().set_text(notes) submitted = property(get_submitted, set_submitted) target_device = property(get_target_device, set_target_device) classification = property(get_classification, set_classification) notes = property(get_notes, set_notes)
class NodeWindow(HIGWindow): """ """ def __init__(self, node, position, parent): """ """ HIGWindow.__init__(self, gtk.WINDOW_POPUP) self.set_decorated(False) self.set_keep_above(True) self.set_skip_taskbar_hint(True) self.move(position[0], position[1]) self.set_size_request(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.__button_press_position = self.get_pointer() self.__is_compacted = True self.__is_collapsed = False self.__node = node self.__pressed = False self.__parent = parent self.connect('button_press_event', self.button_press) self.connect('button_release_event', self.button_release) self.connect('enter_notify_event', self.enter_notify) self.connect('leave_notify_event', self.leave_notify) self.connect('motion_notify_event', self.motion_notify) self.__title_font = pango.FontDescription('Monospace Bold') self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.ENTER_NOTIFY | gtk.gdk.LEAVE_NOTIFY | gtk.gdk.POINTER_MOTION_HINT_MASK) self.__icon = Application() self.__create_widgets() def __create_widgets(self): """ """ self.__content = HIGVBox() self.__head = HIGHBox(spacing=2) self.__notebook = NodeNotebook(self.__node) # create head elements # icon with node's score color self.__color_box = gtk.EventBox() self.__color_image = gtk.Image() self.__color_image.set_from_file(self.__icon.get_icon('border')) self.__color_box.add(self.__color_image) self.__color_box.set_size_request(15, 15) r, g, b = drawing.cairo_to_gdk_color( self.__node.get_draw_info('color')) self.__color_box.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(r, g, b)) # title with the node ip and hostname self.__title = "" if self.__node.get_info('hostname') is not None: self.__title = self.__node.get_info('hostname') + ' - ' self.__title += self.__node.get_info('ip') self.__title_label = HIGSectionLabel(self.__title) self.__title_label.modify_font(self.__title_font) # icon to collapse window self.__collapse_box = gtk.EventBox() self.__collapse_img = gtk.Image() self.__collapse_img.set_from_file(self.__icon.get_icon('collapse')) self.__collapse_box.add(self.__collapse_img) self.__collapse_box.connect('button_press_event', self.collapse_window) self.__collapse_box.add_events(gtk.gdk.BUTTON_PRESS_MASK) # icon to close window self.__close_box = gtk.EventBox() self.__close_img = gtk.Image() self.__close_img.set_from_file(self.__icon.get_icon('close')) self.__close_box.add(self.__close_img) self.__close_box.connect('button_press_event', self.close_window) self.__close_box.add_events(gtk.gdk.BUTTON_PRESS_MASK) # packing head elements self.__head._pack_noexpand_nofill(self.__color_box) self.__head._pack_expand_fill(self.__title_label) self.__head._pack_noexpand_nofill(self.__collapse_box) self.__head._pack_noexpand_nofill(self.__close_box) # packing all to content self.__content._pack_noexpand_nofill(self.__head) self.__content._pack_expand_fill(self.__notebook) # add context to window self.add(self.__content) def close_window(self, widget, event): """ """ self.__node.set_draw_info({'over': False}) self.hide() self.__parent.queue_draw() return True def restore(self, x, y): """ """ self.move(x, y) self.show_all() self.__is_collapsed = False self.resize(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.__collapse_img.set_from_file(self.__icon.get_icon('collapse')) def collapse_window(self, widget, event): """ """ self.present() if self.__is_collapsed == False: self.__notebook.hide() self.__is_collapsed = True self.set_size_request(DIMENSION_SHADED[0], DIMENSION_SHADED[1]) self.resize(DIMENSION_SHADED[0], DIMENSION_SHADED[1]) self.__collapse_img.set_from_file(self.__icon.get_icon('expand')) else: self.__notebook.show() self.__is_collapsed = False self.set_size_request(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.resize(DIMENSION_NORMAL[0], DIMENSION_NORMAL[1]) self.__collapse_img.set_from_file(self.__icon.get_icon('collapse')) return True def button_press(self, widget, event): """ """ self.present() self.__pressed = True self.__button_press_position = self.get_pointer() return True def button_release(self, widget, event): """ """ self.__pressed = False return True def enter_notify(self, widget, event): """ """ self.__node.set_draw_info({'over': True}) self.__parent.queue_draw() def leave_notify(self, widget, event): """ """ self.set_keep_above(True) self.__node.set_draw_info({'over': False}) def motion_notify(self, widget, event): """ """ self.__node.set_draw_info({'over': True}) x, y, button_state = event.window.get_pointer() if button_state & gtk.gdk.BUTTON1_MASK and self.__pressed: xw, yw = event.window.get_root_origin() xd, yd = self.__button_press_position self.move(x + xw - xd, y + yw - yd) return True
def __do_layout(self): """ Layout widgets in window. """ def left_padding(widget): """ Add left padding for a widget. """ left_padding_align = gtk.Alignment(0.5, 0.5, 1, 1) left_padding_align.set_padding(0, 0, 12, 0) left_padding_align.add(widget) return left_padding_align main_vbox = HIGVBox() main_vbox.set_border_width(5) main_vbox.set_spacing(12) header_hbox = HIGHBox() profile_hbox = HIGHBox() hdivs_hbox = HIGHBox() arcdraw_vbox = HIGVBox() vdivs_vbox = HIGVBox() bgfill_vbox = HIGVBox() selectfill_vbox = HIGVBox() btns_hbox = HIGHBox() # header header_hbox._pack_expand_fill(self.ttitle) header_hbox._pack_noexpand_nofill(self.umit_logo) # profiles profile_hbox._pack_noexpand_nofill(self.graph_profile_lbl) profile_hbox._pack_noexpand_nofill(self.graph_profile) # horizontal divisors hdivs_hbox._pack_noexpand_nofill(self.hdivs_lbl) hdivs_hbox._pack_noexpand_nofill(self.hdivs) # arc drawing arcdraw_vbox._pack_noexpand_nofill(self.draw_arc_lbl) arcdraw_when = HIGHBox() arcdraw_when._pack_noexpand_nofill(self.draw_arc_onsel) arcdraw_when._pack_noexpand_nofill(self.draw_arc_always) arcdraw_where = HIGHBox() arcdraw_where._pack_noexpand_nofill(self.draw_arc_bounds) arcdraw_where._pack_noexpand_nofill(self.draw_arc_allpts) arcdraw_vbox._pack_noexpand_nofill(left_padding(arcdraw_when)) arcdraw_vbox._pack_noexpand_nofill(left_padding(arcdraw_where)) arcdraw_vbox._pack_noexpand_nofill(left_padding(self.balloons)) # vertical divisors vdivs_vbox._pack_noexpand_nofill(self.draw_vertdiv) vdivs_kind = HIGHBox() vdivs_kind._pack_noexpand_nofill(self.draw_vertdiv_dash) vdivs_kind._pack_noexpand_nofill(self.draw_vertdiv_solid) vdivs_vbox._pack_noexpand_nofill(left_padding(vdivs_kind)) # background fill bgfill_vbox._pack_noexpand_nofill(self.bg_gradient) bgfill_gtype = HIGHBox() bgfill_gtype._pack_noexpand_nofill(self.bg_gradient_vert) bgfill_gtype._pack_noexpand_nofill(self.bg_gradient_horiz) bgfill_vbox._pack_noexpand_nofill(left_padding(bgfill_gtype)) # selection fill selectfill_vbox._pack_noexpand_nofill(self.selection_fill) selectfill_kind = HIGHBox() selectfill_kind._pack_noexpand_nofill(self.selection_fill_solid) selectfill_kind._pack_noexpand_nofill(self.selection_fill_gradient) selectfill_vbox._pack_noexpand_nofill(left_padding(selectfill_kind)) # 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(profile_hbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(hdivs_hbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(arcdraw_vbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(vdivs_vbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(bgfill_vbox) main_vbox._pack_noexpand_nofill(gtk.HSeparator()) main_vbox._pack_noexpand_nofill(selectfill_vbox) main_vbox.pack_end(btns_hbox, False, False, 0) main_vbox.pack_end(gtk.HSeparator(), False, False, 0) self.add(main_vbox)
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)
class UpdatePage(HIGVBox): """""" def __init__(self): """Constructor""" HIGVBox.__init__(self) self.__create_widgets() self.__pack_widgets() self.__load_list() self.__connect_widgets() self.__init_db_text() def __create_widgets(self): """""" self.update_switch_hbox = HIGHBox() self.update_settings_hbox = HIGHBox() self.update_db_hbox = HIGHBox() self.update_switch_section = HIGSectionLabel(_("Update News Detect")) self.update_switch_table = HIGTable() self.update_settings_section = HIGSectionLabel(_("Update Settings")) self.update_settings_table = HIGTable() self.update_db_section = HIGSectionLabel(_("Update Database")) self.update_db_table = HIGTable() self.update_check = gtk.CheckButton(_("Automatically update")) self.update_switch_check = gtk.CheckButton( _("Software Update Detect Switch")) self.update_times_label = HIGEntryLabel(_("Auto detect update news")) self.update_method_label = HIGEntryLabel(_("Update method")) self.update_time_store = gtk.ListStore(str) self.update_time_entry = gtk.ComboBoxEntry(self.update_time_store, 0) self.update_method_store = gtk.ListStore(str) self.update_method_entry = gtk.ComboBoxEntry(self.update_method_store, 0) self.update_db_label = HIGEntryLabel() self.update_db_clear_button = gtk.Button(_("Clear Update Information")) def __pack_widgets(self): """""" self.set_border_width(12) self._pack_noexpand_nofill(self.update_switch_section) self._pack_noexpand_nofill(self.update_switch_hbox) self._pack_noexpand_nofill(hig_box_space_holder()) self._pack_noexpand_nofill(self.update_settings_section) self._pack_noexpand_nofill(self.update_settings_hbox) self._pack_noexpand_nofill(self.update_db_section) self._pack_noexpand_nofill(self.update_db_hbox) self.update_switch_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.update_switch_hbox._pack_expand_fill(self.update_switch_table) self.update_settings_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.update_settings_hbox._pack_expand_fill(self.update_settings_table) self.update_db_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.update_db_hbox._pack_expand_fill(self.update_db_table) self.update_switch_table.attach_label(self.update_check, 0, 2, 0, 1) self.update_switch_table.attach_label(self.update_switch_check, 0, 2, 1, 2) self.update_settings_table.attach_label(self.update_times_label, 0, 1, 0, 1) self.update_settings_table.attach_entry(self.update_time_entry, 1, 2, 0, 1) self.update_settings_table.attach_label(self.update_method_label, 0, 1, 1, 2) self.update_settings_table.attach_entry(self.update_method_entry, 1, 2, 1, 2) self.update_db_table.attach_label(self.update_db_label, 1, 3, 0, 1) self.update_db_table.attach(self.update_db_clear_button, 0, 1, 0, 1) def __init_db_text(self): """""" rs = g_db_helper.select("select * from updates") count = len(rs) self.update_db_label.set_text( str(_("%d records in update database now." % (count)))) def __connect_widgets(self): """""" self.update_check.connect('toggled', lambda w: self.__change_widgets_status()) self.update_db_clear_button.connect("clicked", lambda w: self.__clear_update_db()) def __clear_update_db(self): """""" g_db_helper.execute("delete from updates") g_db_helper.commit() self.update_db_label.set_text(str( _("Clear software update database!"))) def __change_widgets_status(self): """""" if self.update_check.get_active(): self.__disable_widgets() else: self.__enable_widgets() def __load_list(self): """""" for s in update_time_str.keys(): #print s self.update_time_store.append([s]) for s in update_method_str.keys(): #print s self.update_method_store.append([s]) def __disable_widgets(self): """""" self.update_switch_check.set_sensitive(False) self.update_method_entry.set_sensitive(False) self.update_time_entry.set_sensitive(False) def __enable_widgets(self): """""" self.update_switch_check.set_sensitive(True) self.update_method_entry.set_sensitive(True) self.update_time_entry.set_sensitive(True)
def __do_layout(self): """ Layout window widgets. """ main_vbox = HIGVBox() main_vbox.set_border_width(5) main_vbox.set_spacing(12) header_hbox = HIGHBox() schedp_hbox = HIGHBox() cron_box = HIGVBox() cron_table = HIGTable(5, 2) btns_hbox = HIGHBox() header_hbox._pack_expand_fill(self.ttitle) header_hbox._pack_noexpand_nofill(self.umit_logo) schedp_hbox._pack_noexpand_nofill(self.schedp_name_lbl) schedp_hbox._pack_expand_fill(self.schedp_name) # cron format settings_align = gtk.Alignment(0.5, 0.5, 1, 1) settings_align.set_padding(6, 0, 12, 0) cron_table.attach(self.cron_minute_lbl, 0, 1, 0, 1) cron_table.attach(self.cron_minute, 1, 2, 0, 1) cron_table.attach(self.cron_hour_lbl, 0, 1, 1, 2) cron_table.attach(self.cron_hour, 1, 2, 1, 2) cron_table.attach(self.cron_day_lbl, 0, 1, 2, 3) cron_table.attach(self.cron_day, 1, 2, 2, 3) cron_table.attach(self.cron_month_lbl, 0, 1, 3, 4) cron_table.attach(self.cron_month, 1, 2, 3, 4) cron_table.attach(self.cron_weekday_lbl, 0, 1, 4, 5) cron_table.attach(self.cron_weekday, 1, 2, 4, 5) cron_box._pack_noexpand_nofill(cron_table) settings_align.add(cron_box) self.cron_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(schedp_hbox) main_vbox._pack_noexpand_nofill(self.cron_frame) main_vbox.pack_end(btns_hbox, False, False, 0) self.add(main_vbox)
class AdvancedPage(HIGVBox): """""" #---------------------------------------------------------------------- def __init__(self): """Constructor""" HIGVBox.__init__(self) self.__create_widgets() self.__pack_widgets() self._load_list_() def __create_widgets(self): """""" self.timer_hbox = HIGHBox() self.timer_section = HIGSectionLabel(_("Timeout Setting (seconds)")) self.timer_table = HIGTable() self.other_hbox = HIGHBox() self.other_section = HIGSectionLabel(_("Others")) self.other_table = HIGTable() self.task_assign_label = HIGEntryLabel(_("Task Assign")) self.task_scheduler_label = HIGEntryLabel(_("Task Scheduler")) self.report_uploader_label = HIGEntryLabel(_("Report Uploader")) self.test_fetch_label = HIGEntryLabel(_("Test sets Fetch")) self.task_assign_entry = gtk.Entry() self.task_scheduler_entry = gtk.Entry() self.report_uploader_entry = gtk.Entry() self.test_fetch_entry = gtk.Entry() self.language_label = HIGEntryLabel(_("Language")) self.language_store = gtk.ListStore(str) self.language_entry = gtk.ComboBoxEntry(self.language_store, 0) def __pack_widgets(self): self.set_border_width(12) self._pack_noexpand_nofill(self.timer_section) self._pack_noexpand_nofill(self.timer_hbox) self._pack_noexpand_nofill(self.other_section) self._pack_noexpand_nofill(self.other_hbox) self.timer_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.timer_hbox._pack_expand_fill(self.timer_table) self.other_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.other_hbox._pack_expand_fill(self.other_table) self.timer_table.attach_label(self.task_assign_label, 0, 1, 0, 1) self.timer_table.attach_label(self.task_assign_entry, 1, 3, 0, 1) self.timer_table.attach_label(self.task_scheduler_label, 0, 1, 1, 2) self.timer_table.attach_label(self.task_scheduler_entry, 1, 3, 1, 2) self.timer_table.attach_label(self.report_uploader_label, 0, 1, 2, 3) self.timer_table.attach_label(self.report_uploader_entry, 1, 3, 2, 3) self.timer_table.attach_label(self.test_fetch_label, 0, 1, 3, 4) self.timer_table.attach_label(self.test_fetch_entry, 1, 3, 3, 4) self.other_table.attach_label(self.language_label, 0, 2, 0, 1) self.other_table.attach_label(self.language_entry, 2, 4, 0, 1) def _load_list_(self): """""" for s in Language_store.keys(): self.language_store.append([s])
class ScanChooser(HIGVBox): def __init__(self, scan_dict, num=""): HIGVBox.__init__(self) self.num = num self.scan_dict = scan_dict # Setting HIGVBox self.set_border_width(5) self.set_spacing(6) self._create_widgets() self._pack_hbox() self._attaching_widgets() self._set_scrolled() self._set_text_view() self._set_open_button() for scan in scan_dict: self.list_scan.append([scan]) self.combo_scan.connect('changed', self.show_scan) self._pack_noexpand_nofill(self.lbl_scan) self._pack_expand_fill(self.hbox) def _create_widgets(self): self.lbl_scan = HIGSectionLabel("%s %s"%(_("Scan Result"), str(self.num))) self.hbox = HIGHBox() self.table = HIGTable() self.list_scan = gtk.ListStore(str) self.combo_scan = gtk.ComboBoxEntry(self.list_scan, 0) self.btn_open_scan = gtk.Button(stock=gtk.STOCK_OPEN) self.exp_scan = gtk.Expander(_("Scan Result Visualization")) self.scrolled = gtk.ScrolledWindow() self.txt_scan_result = gtk.TextView() self.txg_tag = gtk.TextTag("scan_style") def get_buffer(self): return self.txt_scan_result.get_buffer() def show_scan (self, widget): try: self.txt_scan_result.get_buffer().\ set_text(self.normalize_output(\ self.scan_dict[widget.child.get_text()].nmap_output)) except KeyError: # Avoid to raise an error if the user writes within # the entry and the scan doesn't exits pass def normalize_output(self, output): return "\n".join(output.split("\\n")) def _pack_hbox (self): self.hbox._pack_noexpand_nofill(hig_box_space_holder()) self.hbox._pack_expand_fill(self.table) def _attaching_widgets (self): self.table.attach(self.combo_scan, 0,1,0,1, yoptions=0) self.table.attach(self.btn_open_scan, 1,2,0,1, yoptions=0, xoptions=0) self.table.attach(self.exp_scan, 0,2,1,2) def _set_scrolled(self): self.scrolled.set_border_width(5) self.scrolled.set_size_request(-1, 160) # Packing scrolled window into expander self.exp_scan.add(self.scrolled) # Packing text view into scrolled window self.scrolled.add_with_viewport(self.txt_scan_result) # Setting scrolled window self.scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) def _set_text_view (self): self.txg_table = self.txt_scan_result.get_buffer().get_tag_table() self.txg_table.add(self.txg_tag) self.txg_tag.set_property("family", "Monospace") self.txt_scan_result.set_wrap_mode(gtk.WRAP_WORD) self.txt_scan_result.set_editable(False) self.txt_scan_result.get_buffer().connect("changed", self._text_changed_cb) def _set_open_button (self): self.btn_open_scan.connect('clicked', self.open_file) def open_file (self, widget): file_chooser = ResultsFileChooserDialog(_("Select Scan Result")) file_chooser.run() file_chosen = file_chooser.get_filename() file_chooser.destroy() if check_access(file_chosen, os.R_OK): try: parser = NmapParser(file_chosen) parser.parse() except: alert = HIGAlertDialog( message_format='<b>%s</b>' % _('File is not a Umit \ Scan Result'), secondary_text=_("Selected file is not a Umit Scan \ Result file. Umit can not parse this file. Please, select another.")) alert.run() alert.destroy() return False scan_name = os.path.split(file_chosen)[-1] self.add_scan(scan_name, parser) self.combo_scan.set_active(len(self.list_scan) - 1) else: alert = HIGAlertDialog( message_format='<b>%s</b>' % \ _('Can not open selected file'), secondary_text=_("Umit can not open selected file. Please, \ select another.")) alert.run() alert.destroy() def add_scan(self, scan_name, parser): scan_id = 1 new_scan_name = scan_name while new_scan_name in self.scan_dict: new_scan_name = "%s (%s)" % (scan_name, scan_id) scan_id += 1 self.list_scan.append([new_scan_name]) self.scan_dict[new_scan_name] = parser def _text_changed_cb (self, widget): buff = self.txt_scan_result.get_buffer () buff.apply_tag(self.txg_tag, buff.get_start_iter(), buff.get_end_iter()) def get_nmap_output(self): parsed = self.parsed_scan if parsed: return parsed.nmap_output return False def get_parsed_scan(self): selected_scan = self.combo_scan.child.get_text() if selected_scan: return self.scan_dict[selected_scan] return False nmap_output = property(get_nmap_output) parsed_scan = property(get_parsed_scan)
class UpdatePage(HIGVBox): """""" def __init__(self): """Constructor""" HIGVBox.__init__(self) self.__create_widgets() self.__pack_widgets() self.__load_list() self.__connect_widgets() self.__init_db_text() def __create_widgets(self): """""" self.update_switch_hbox = HIGHBox() self.update_settings_hbox = HIGHBox() self.update_db_hbox = HIGHBox() self.update_switch_section = HIGSectionLabel(_("Update News Detect")) self.update_switch_table = HIGTable() self.update_settings_section = HIGSectionLabel(_("Update Settings")) self.update_settings_table = HIGTable() self.update_db_section = HIGSectionLabel(_("Update Database")) self.update_db_table = HIGTable() self.update_check = gtk.CheckButton(_("Automatically update")) self.update_switch_check = gtk.CheckButton(_("Software Update Detect Switch")) self.update_times_label = HIGEntryLabel(_("Auto detect update news")) self.update_method_label = HIGEntryLabel(_("Update method")) self.update_time_store = gtk.ListStore(str) self.update_time_entry = gtk.ComboBoxEntry(self.update_time_store, 0) self.update_method_store = gtk.ListStore(str) self.update_method_entry = gtk.ComboBoxEntry(self.update_method_store, 0) self.update_db_label = HIGEntryLabel() self.update_db_clear_button = gtk.Button(_("Clear Update Information")) def __pack_widgets(self): """""" self.set_border_width(12) self._pack_noexpand_nofill(self.update_switch_section) self._pack_noexpand_nofill(self.update_switch_hbox) self._pack_noexpand_nofill(hig_box_space_holder()) self._pack_noexpand_nofill(self.update_settings_section) self._pack_noexpand_nofill(self.update_settings_hbox) self._pack_noexpand_nofill(self.update_db_section) self._pack_noexpand_nofill(self.update_db_hbox) self.update_switch_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.update_switch_hbox._pack_expand_fill(self.update_switch_table) self.update_settings_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.update_settings_hbox._pack_expand_fill(self.update_settings_table) self.update_db_hbox._pack_noexpand_nofill(hig_box_space_holder()) self.update_db_hbox._pack_expand_fill(self.update_db_table) self.update_switch_table.attach_label(self.update_check, 0, 2, 0, 1) self.update_switch_table.attach_label(self.update_switch_check, 0, 2, 1, 2) self.update_settings_table.attach_label(self.update_times_label, 0, 1, 0, 1) self.update_settings_table.attach_entry(self.update_time_entry, 1, 2, 0, 1) self.update_settings_table.attach_label(self.update_method_label, 0, 1, 1, 2) self.update_settings_table.attach_entry(self.update_method_entry, 1, 2, 1, 2) self.update_db_table.attach_label(self.update_db_label, 1, 3, 0, 1) self.update_db_table.attach(self.update_db_clear_button, 0, 1, 0, 1) def __init_db_text(self): """""" rs = g_db_helper.select("select * from updates") count = len(rs) self.update_db_label.set_text(str(_("%d records in update database now."%(count)))) def __connect_widgets(self): """""" self.update_check.connect('toggled',lambda w:self.__change_widgets_status()) self.update_db_clear_button.connect("clicked", lambda w:self.__clear_update_db()) def __clear_update_db(self): """""" g_db_helper.execute("delete from updates") g_db_helper.commit() self.update_db_label.set_text(str(_("Clear software update database!"))) def __change_widgets_status(self): """""" if self.update_check.get_active(): self.__disable_widgets() else: self.__enable_widgets() def __load_list(self): """""" for s in update_time_str.keys(): #print s self.update_time_store.append([s]) for s in update_method_str.keys(): #print s self.update_method_store.append([s]) def __disable_widgets(self): """""" self.update_switch_check.set_sensitive(False) self.update_method_entry.set_sensitive(False) self.update_time_entry.set_sensitive(False) def __enable_widgets(self): """""" self.update_switch_check.set_sensitive(True) self.update_method_entry.set_sensitive(True) self.update_time_entry.set_sensitive(True)
class BugReport(HIGDialog): def __init__(self, title=_('Bug Report'), summary=None, description=None, category=None, crashreport=False, description_dialog=None, reuse_mainloop=True): HIGDialog.__init__(self, title=title, buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) # If reuse_mainloop is true, then dialogs created inside this dialog # will not start another mainloop. self._reuse_mainloop = reuse_mainloop self.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.crashreport = crashreport self.description_dialog = description_dialog self._create_widgets() self._set_category_list() self._pack_widgets() self._connect_widgets() self.summary = summary or '' self.description_report = description if self.crashreport: self.description = _("CrashReport automatically created") else: if self.description_dialog is None: self.description = description or '' else: self.description = description_dialog or '' self.category = category or '' def _set_category_list(self): # Obtained at bug tracker page source code # The following two lines are commented due to component deprecation #self.category_list.append(["umitCore","umitCore"]) #self.category_list.append(["umitGUI","umitGUI"]) self.category_list.append(["Umit","Umit"]) self.category_list.append(["CrashReport","CrashReport"]) self.category_list.append(["Documentation", "Documentation"]) self.category_list.append(["UmitWeb","UmitWeb"]) self.category_list.append(["InterfaceEditor", "InterfaceEditor"]) self.category_list.append(["NetworkInventory", "NetworkInventory"]) self.category_list.append(["website","website"]) def _create_widgets(self): self.category_label = HIGHintSectionLabel(_("Category (optional)"), _("If you know in which section of the program " "is the bug, please, select it from the choosebox. " "If you don't know what section to choose, leave it blank.")) self.category_list = gtk.ListStore(str, str) self.category_combo = gtk.ComboBoxEntry(self.category_list, 0) self.email_label = HIGHintSectionLabel(_("Email"), _("Please inform a valid e-mail address from " "where you can be reached to be notified when the bug gets " "fixed. Not used for other purposes.")) self.email_entry = gtk.Entry() self.summary_label = HIGHintSectionLabel(_("Summary"), _("This should be a quick description of the issue. " "Try to be clear and concise.")) self.summary_entry = gtk.Entry() self.description_label = HIGHintSectionLabel(_("Description"), _("This is where you should write about the bug, " "describing it as clear as possible and giving as many " "informations as you can and how to reproduce the bug.")) self.description_scrolled = gtk.ScrolledWindow() self.description_text = gtk.TextView() self.bug_icon = gtk.Image() self.bug_text = gtk.Label(_("This Bug Report dialog allows you " "to easily tell us about a problem that you may have found on " "Umit. Doing so, you help us to help you, by fixing and " "improving Umit faster than usual.")) if self.crashreport: # Create a button to show details self.show_details = HIGStockButton(gtk.STOCK_DIALOG_INFO, _("Show Details")) self.hbox = HIGHBox() self.table = HIGTable() def _pack_widgets(self): self.description_scrolled.add(self.description_text) self.description_scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.description_scrolled.set_size_request(400, 150) self.description_text.set_wrap_mode(gtk.WRAP_WORD) self.bug_icon.set_from_stock(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_DIALOG) self.bug_icon.set_padding(10, 0) self.bug_text.set_line_wrap(True) self.hbox.set_border_width(12) nextpos = (0, 1) if not self.crashreport: self.table.attach_label(self.category_label, 0, 1, 0, 1) self.table.attach_entry(self.category_combo, 1, 2, 0, 1) nextpos = (1, 2) self.table.attach_label(self.email_label, 0, 1, *nextpos) self.table.attach_entry(self.email_entry, 1, 2, *nextpos) nextpos = (2, 3) if not self.crashreport: self.table.attach_label(self.summary_label, 0, 1, 2, 3) self.table.attach_entry(self.summary_entry, 1, 2, 2, 3) nextpos = (3, 4) self.table.attach_label(self.description_label, 0, 2, *nextpos) nextpos = nextpos[0] + 1, nextpos[1] + 1 self.table.attach_entry(self.description_scrolled, 0, 2, *nextpos) self.hbox._pack_noexpand_nofill(self.bug_icon) self.hbox._pack_expand_fill(self.bug_text) self.vbox.pack_start(self.hbox, False, False) self.vbox.pack_start(self.table) # Just need because in crash report some aditional # information will be show if self.crashreport: # Add a button to action-area spaceholder = hig_box_space_holder() self.action_area.pack_end(spaceholder) self.action_area.pack_end(self.show_details) # Put "Show details" to left side respecting HIG self.action_area.reorder_child(self.show_details,0) self.action_area.reorder_child(spaceholder, 1) def _connect_widgets(self): self.connect('response', self.check_response) if self.crashreport: self.show_details.connect('clicked', self._show_details) def _show_details(self, widget): # Create info necessary desc = [ self.email, self.summary, self.description_report, self.description, self.category] # Create another dialog to show details details = BugReportDescription(*desc) details.show_all() details.run() details.destroy() def check_response(self, widget, response_id): if response_id == gtk.RESPONSE_ACCEPT: # clicked on Ok btn self.send_report() elif response_id in (gtk.RESPONSE_DELETE_EVENT, gtk.RESPONSE_CANCEL, gtk.RESPONSE_NONE): # there are tree possibilities to being here: # 1) user clicked on 'x' button # 2) user clicked on 'cancel' button # 3) report was sent successfully and now we can destroy this self.destroy() def send_report(self): """Prepare dialog to send a bug report and then call _send_report.""" # set cursor to busy cursor (supposing it will take some time # to submit the report) self.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH)) # disable dialog controls for child in self.vbox.get_children(): child.set_sensitive(False) # attempt sending report gobject.idle_add(self._send_report) def restore_state(self): """Restore dialog state, just like it was before calling send_report.""" self.window.set_cursor(None) for child in self.vbox.get_children(): child.set_sensitive(True) def _send_report(self): if self.summary == "" or self.description == "" or self.email == "": cancel_dialog = HIGAlertDialog(type=gtk.MESSAGE_ERROR, message_format=_("Bug report is incomplete!"), secondary_text=_("The bug report is incomplete. " "You must inform a description that explains clearly " "what is happening and a valid e-mail, so you can be " "contacted when the bug gets fixed.")) run_dialog(self._reuse_mainloop, cancel_dialog) return self.restore_state() bug_register = BugRegister() bug_register.component = self.category bug_register.summary = self.summary if self.description_report is not None: bug_register.details = self.description_report else: bug_register.details = self.description.replace("\n", "[[BR]]") bug_register.reporter = self.email bug_page = None try: bug_page = bug_register.report() assert bug_page except: import traceback traceback.print_exc() cancel_dialog = HIGAlertDialog(type=gtk.MESSAGE_ERROR, message_format=_("Bug not reported!"), secondary_text=_("The bug description could not be " "reported. This problem may be caused by the lack " "of Internet access or indisponibility of the bug " "tracker server. Please, verify your internet access, " "and then try to report the bug once again.")) run_dialog(self._reuse_mainloop, cancel_dialog) return self.restore_state() else: ok_dialog = HIGAlertDialog(type=gtk.MESSAGE_INFO, message_format=_("Bug sucessfully reported!"), secondary_text=_("The bug description was sucessfully " "reported. A web page with detailed description about " "this report will be opened in your default web browser " "now.")) run_dialog(self._reuse_mainloop, ok_dialog, show_report, # callback self._reuse_mainloop, bug_page) # args # report sent successfully self.response(gtk.RESPONSE_DELETE_EVENT) def get_category(self): return self.category_combo.child.get_text() def set_category(self, category): self.category_combo.child.set_text(category) def get_summary(self): return self.summary_entry.get_text() def set_summary(self, summary): self.summary_entry.set_text(summary) def get_description(self): buff = self.description_text.get_buffer() return buff.get_text(buff.get_start_iter(), buff.get_end_iter()) def set_description(self, description): self.description_text.get_buffer().set_text(description) def get_email(self): return self.email_entry.get_text() def set_email(self, email): self.email_entry.set_text(email) category = property(get_category, set_category) summary = property(get_summary, set_summary) description = property(get_description, set_description) email = property(get_email, set_email)