def __init__(self):
HIGScrolledWindow.__init__(self)
self.connect('expose_event', self.__expose)
self.__auto_scroll = False
self.__create_widgets()
def __init__(self):
HIGScrolledWindow.__init__(self)
self.connect('expose_event', self.__expose)
self.__auto_scroll = False
self.__create_widgets()
def __init__(self, node):
"""
"""
HIGScrolledWindow.__init__(self)
self.__node = node
self.__font = pango.FontDescription('Monospace')
self.__create_widgets()
def __init__(self, radialnet):
"""
"""
HIGScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.set_shadow_type(gtk.SHADOW_NONE)
self.radialnet = radialnet
self.__create_widgets()
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)
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 create_view_options(self):
self.views_enabled = []
self.scroll_window = HIGScrolledWindow()
self.scroll_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.scroll_window.set_shadow_type(gtk.SHADOW_NONE)
self.__liststore = gtk.ListStore(gobject.TYPE_BOOLEAN,
gobject.TYPE_STRING)
self.__liststore.append([None, OPTIONS[0]])
self.__liststore.append([None, OPTIONS[1]])
self.__liststore.append([None, OPTIONS[2]])
self.__liststore.append([None, OPTIONS[3]])
self.__liststore.append([None, OPTIONS[4]])
self.__liststore.append([None, OPTIONS[5]])
self.__liststore.append([None, OPTIONS[6]])
self.__cell_toggle = gtk.CellRendererToggle()
self.__cell_toggle.set_property('activatable', True)
self.__cell_toggle.connect('toggled',
self.__change_option,
self.__liststore)
self.__column_toggle = gtk.TreeViewColumn('', self.__cell_toggle)
self.__column_toggle.add_attribute(self.__cell_toggle, 'active', 0)
self.__cell_text = gtk.CellRendererText()
self.__column_text = gtk.TreeViewColumn('Enable',
self.__cell_text,
text=1)
self.__treeview = gtk.TreeView(self.__liststore)
self.__treeview.set_enable_search(True)
self.__treeview.set_search_column(1)
self.__treeview.append_column(self.__column_toggle)
self.__treeview.append_column(self.__column_text)
self.scroll_window.add_with_viewport(self.__treeview)
self.__update_options()
def __init__(self):
HIGScrolledWindow.__init__(self)
self.__auto_scroll = False
self.__create_widgets()
class ServicesPage(gtk.Notebook):
"""
"""
def __init__(self, node):
"""
"""
gtk.Notebook.__init__(self)
self.set_border_width(6)
self.set_tab_pos(gtk.POS_TOP)
self.__node = node
self.__font = pango.FontDescription('Monospace')
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__cell = gtk.CellRendererText()
# texteditor widgets
self.__texteditor = HIGTextEditor()
self.__texteditor._modify_font(self.__font)
self.__texteditor._set_editable(False)
self.__texteditor.set_border_width(0)
self.__select_combobox = gtk.combo_box_new_text()
self.__select_combobox.connect('changed', self.__change_text_value)
self.__viewer = HIGVBox(spacing=6)
self.__viewer.set_border_width(6)
self.__viewer._pack_noexpand_nofill(self.__select_combobox)
self.__viewer._pack_expand_fill(self.__texteditor)
self.__text = list()
# ports information
number_of_ports = len(self.__node.get_info('ports'))
self.__ports_label = HIGLabel('Ports (%s)' % number_of_ports)
self.__ports_scroll = HIGScrolledWindow()
self.__ports_store = gtk.TreeStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.__ports_treeview = gtk.TreeView(self.__ports_store)
for port in self.__node.get_info('ports'):
pstate = port['state']['state']
if pstate:
color = SERVICE_COLORS[port['state']['state']]
else:
# XXX port state is not always available
color = '#fff'
if port['service'].has_key('name'):
service_name = port['service']['name']
else:
service_name = '<unknown>'
if port['service'].has_key('method'):
service_method = port['service']['method']
else:
service_method = '<none>'
reference = self.__ports_store.append(None,
[port['id'],
port['protocol'],
port['state']['state'],
service_name,
service_method,
color,
True])
for key in port['state']:
self.__ports_store.append(reference,
[port['id'],
'state',
key,
port['state'][key],
'',
'white',
True])
for key in port['service']:
if key in ['servicefp', 'extrainfo']:
text = '[%d] service: %s' % (port['id'], key)
self.__select_combobox.append_text(text)
self.__text.append(port['service'][key])
value = '<special field>'
else:
value = port['service'][key]
self.__ports_store.append(reference,
[port['id'],
'service',
key,
value,
'',
'white',
True])
for script in port['scripts']:
text = '[%d] script: %s' % (port['id'], script['id'])
self.__select_combobox.append_text(text)
self.__text.append(script['output'])
self.__ports_store.append(reference,
[port['id'],
'script',
'id',
script['id'],
'<special field>',
'white',
True])
self.__ports_column = list()
for i in range(len(PORTS_HEADER)):
column = gtk.TreeViewColumn(PORTS_HEADER[i],
self.__cell,
text = i)
self.__ports_column.append(column)
self.__ports_column[i].set_reorderable(True)
self.__ports_column[i].set_resizable(True)
self.__ports_column[i].set_sort_column_id(i)
self.__ports_column[i].set_attributes(self.__cell,
text = i,
background = 5,
editable = 6)
self.__ports_treeview.append_column(self.__ports_column[i])
self.__ports_scroll.add_with_viewport(self.__ports_treeview)
# extraports information
number_of_xports = 0
self.__xports_scroll = HIGScrolledWindow()
self.__xports_store = gtk.TreeStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.__xports_treeview = gtk.TreeView(self.__xports_store)
for xports in self.__node.get_info('extraports'):
color = SERVICE_COLORS[xports['state']]
number_of_xports += xports['count']
reference = self.__xports_store.append(None,
[xports['count'],
xports['state'],
", ".join(xports['reason']),
color,
True])
for xreason in xports['all_reason']:
self.__xports_store.append(reference,
[xreason['count'],
xports['state'],
xreason['reason'],
'white',
True])
self.__xports_column = list()
for i in range(len(EXTRAPORTS_HEADER)):
column = gtk.TreeViewColumn(EXTRAPORTS_HEADER[i],
self.__cell,
text = i)
self.__xports_column.append(column)
self.__xports_column[i].set_reorderable(True)
self.__xports_column[i].set_resizable(True)
self.__xports_column[i].set_sort_column_id(i)
self.__xports_column[i].set_attributes(self.__cell,
text = i,
background = 3,
editable = 4)
self.__xports_treeview.append_column(self.__xports_column[i])
xports_label_text = 'Extraports (%s)' % number_of_xports
self.__xports_label = HIGLabel(xports_label_text)
self.__xports_scroll.add_with_viewport(self.__xports_treeview)
self.append_page(self.__ports_scroll, self.__ports_label)
self.append_page(self.__xports_scroll, self.__xports_label)
self.append_page(self.__viewer, HIGLabel('Special fields'))
if len(self.__text) > 0:
self.__select_combobox.set_active(0)
def __change_text_value(self, widget):
"""
"""
id = self.__select_combobox.get_active()
self.__texteditor._set_text(self.__text[id])
def __create_widgets(self):
"""
"""
if self.__node.get_info('trace') is None:
self.__trace_label = gtk.Label(NO_TRACE_TEXT)
self.pack_start(self.__trace_label, True, True)
else:
# add hops
hops = self.__node.get_info('trace')['hops']
ttls = [int(i['ttl']) for i in hops]
self.__cell = gtk.CellRendererText()
self.__trace_scroll = HIGScrolledWindow()
self.__trace_scroll.set_border_width(0)
self.__trace_store = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.__trace_treeview = gtk.TreeView(self.__trace_store)
count = 0
for i in range(1, max(ttls) + 1):
if i in ttls:
hop = hops[count]
count += 1
self.__trace_store.append([hop['ttl'],
hop.get('rtt',''),
hop.get('ipaddr',''),
hop.get('host',''),
HOP_COLOR['known'],
True])
else:
self.__trace_store.append([i,
'',
'<unknown>',
'',
HOP_COLOR['unknown'],
True])
self.__trace_column = list()
for i in range(len(TRACE_HEADER)):
column = gtk.TreeViewColumn(TRACE_HEADER[i],
self.__cell,
text = i)
self.__trace_column.append(column)
self.__trace_column[i].set_reorderable(True)
self.__trace_column[i].set_resizable(True)
self.__trace_column[i].set_attributes(self.__cell,
text = i,
background = 4,
editable = 5)
self.__trace_treeview.append_column(self.__trace_column[i])
self.__trace_column[0].set_sort_column_id(0)
self.__trace_scroll.add_with_viewport(self.__trace_treeview)
self.__trace_info = (self.__node.get_info('trace')['port'],
self.__node.get_info('trace')['protocol'],
len(self.__node.get_info('trace')['hops']))
self.__trace_label = HIGLabel(TRACE_TEXT % self.__trace_info)
self.__trace_label.set_use_markup(True)
self._pack_expand_fill(self.__trace_scroll)
self._pack_noexpand_nofill(self.__trace_label)
def __create_widgets(self):
"""
"""
self.__vbox = HIGVBox()
self.__vbox.set_border_width(6)
self.__cell = gtk.CellRendererText()
self.__general_frame = HIGExpanderRNet('General information')
self.__sequences_frame = HIGExpanderRNet('Sequences')
self.__os_frame = HIGExpanderRNet('Operating System')
self.__sequences_frame._add(gtk.Label('No sequence information.'))
self.__os_frame._add(gtk.Label('No OS information.'))
# general information widgets
self.__general = HIGTableRNet(3, 2)
self.__address_label = HIGSectionLabel('Address:')
self.__address_list = gtk.combo_box_entry_new_text()
self.__address_list.child.set_editable(False)
for address in self.__node.get_info('addresses'):
params = address['addrtype'], address['addr']
address_text = SYSTEM_ADDRESS_TEXT % params
if address.get('vendor', None):
address_text += " (%s)" % address['vendor']
self.__address_list.append_text(address_text)
self.__address_list.set_active(0)
self.__general._attach_next(self.__address_label,
yoptions=gtk.FILL,
xoptions=gtk.FILL)
self.__general._attach_next(self.__address_list, yoptions=gtk.FILL)
if self.__node.get_info('hostnames') is not None:
self.__hostname_label = HIGSectionLabel('Hostname:')
self.__hostname_list = gtk.combo_box_entry_new_text()
self.__hostname_list.child.set_editable(False)
for hostname in self.__node.get_info('hostnames'):
params = hostname['type'], hostname['name']
self.__hostname_list.append_text(SYSTEM_ADDRESS_TEXT % params)
self.__hostname_list.set_active(0)
self.__general._attach_next(self.__hostname_label,
yoptions=gtk.FILL,
xoptions=gtk.FILL)
self.__general._attach_next(self.__hostname_list,
yoptions=gtk.FILL)
if self.__node.get_info('uptime') is not None:
self.__uptime_label = HIGSectionLabel('Last boot:')
seconds = self.__node.get_info('uptime')['seconds']
lastboot = self.__node.get_info('uptime')['lastboot']
text = '%s (%s seconds).' % (lastboot, seconds)
self.__uptime_value = HIGLabel(text)
self.__uptime_value.set_selectable(True)
self.__uptime_value.set_line_wrap(False)
self.__general._attach_next(self.__uptime_label,
yoptions=gtk.FILL,
xoptions=gtk.FILL)
self.__general._attach_next(self.__uptime_value,
yoptions=gtk.FILL)
self.__general_frame._add(self.__general)
self.__general_frame.set_expanded(True)
# sequences information widgets
self.__sequences = HIGTableRNet(5, 3)
sequences = self.__node.get_info('sequences')
if len(sequences) > 0:
self.__sequences.attach(HIGSectionLabel('Class'), 1, 2, 0, 1)
self.__sequences.attach(HIGSectionLabel('Values'), 2, 3, 0, 1)
self.__sequences.attach(HIGSectionLabel('TCP *'), 0, 1, 1, 2)
self.__sequences.attach(HIGSectionLabel('IP ID'), 0, 1, 2, 3)
self.__sequences.attach(HIGSectionLabel('TCP Timestamp'),
0,
1,
3,
4)
# tcp sequence values
tcp = sequences['tcp']
tcp_class = HIGLabel(tcp.get('class', ''))
tcp_class.set_selectable(True)
self.__sequences.attach(tcp_class, 1, 2, 1, 2)
tcp_values = gtk.combo_box_entry_new_text()
for value in tcp['values']:
tcp_values.append_text(value)
tcp_values.set_active(0)
self.__sequences.attach(tcp_values, 2, 3, 1, 2)
tcp_note = HIGLabel()
tcp_note.set_selectable(True)
tcp_note.set_line_wrap(False)
tcp_note.set_alignment(1.0, 0.5)
if tcp['index']:
tcp_note.set_markup(
TCP_SEQ_NOTE % (tcp['index'], tcp['difficulty']))
self.__sequences.attach(tcp_note, 0, 3, 4, 5)
# ip id sequence values
ip_id = sequences['ip_id']
ip_id_class = HIGLabel(ip_id['class'])
ip_id_class.set_selectable(True)
self.__sequences.attach(ip_id_class, 1, 2, 2, 3)
ip_id_values = gtk.combo_box_entry_new_text()
for value in ip_id['values']:
ip_id_values.append_text(value)
ip_id_values.set_active(0)
self.__sequences.attach(ip_id_values, 2, 3, 2, 3)
# tcp sequence values
tcp_ts = sequences['tcp_ts']
tcp_ts_class = HIGLabel(tcp_ts['class'])
tcp_ts_class.set_selectable(True)
self.__sequences.attach(tcp_ts_class, 1, 2, 3, 4)
if tcp_ts.get('values', None) is not None:
tcp_ts_values = gtk.combo_box_entry_new_text()
for value in tcp_ts['values']:
tcp_ts_values.append_text(value)
tcp_ts_values.set_active(0)
self.__sequences.attach(tcp_ts_values, 2, 3, 3, 4)
self.__sequences_frame._add(self.__sequences)
# operating system information widgets
self.__os = gtk.Notebook()
# XXX Setting this custom positioning causes a hard gtk bug (verified
# on Windows 7 at least, likely to happen under Vista too. Used
# gtk 2.14.7 and gtk 2.12.9 both with pygtk 2.12.1).
#self.__os.set_tab_pos(gtk.POS_LEFT)
os = self.__node.get_info('os')
if os is not None:
if os.has_key('matches'):
self.__match_scroll = HIGScrolledWindow()
self.__match_store = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_INT,
gobject.TYPE_BOOLEAN)
self.__match_treeview = gtk.TreeView(self.__match_store)
for os_match in os['matches']:
if 'accuracy' not in os_match:
# this may happen with older .usr
continue
self.__match_store.append([os_match['accuracy'],
os_match['name'],
os_match['db_line'],
True])
self.__match_column = list()
for i in range(len(OSMATCH_HEADER)):
column = gtk.TreeViewColumn(OSMATCH_HEADER[i],
self.__cell,
text = i)
self.__match_column.append(column)
self.__match_column[i].set_reorderable(True)
self.__match_column[i].set_resizable(True)
self.__match_column[i].set_attributes(self.__cell,
text = i,
editable = 3)
self.__match_column[i].set_sort_column_id(i)
self.__match_treeview.append_column(self.__match_column[i])
self.__match_scroll.add_with_viewport(self.__match_treeview)
self.__os.append_page(self.__match_scroll, HIGLabel('Match'))
if os.has_key('classes'):
self.__class_scroll = HIGScrolledWindow()
self.__class_store = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.__class_treeview = gtk.TreeView(self.__class_store)
for os_class in os['classes']:
os_gen = ''
if os_class.has_key('os_gen'):
os_gen = os_class['os_gen']
self.__class_store.append([os_class['accuracy'],
os_class['vendor'],
os_class['type'],
os_class['os_family'],
os_gen,
True])
self.__class_column = list()
for i in range(len(OSCLASS_HEADER)):
column = gtk.TreeViewColumn(OSCLASS_HEADER[i],
self.__cell,
text = i)
self.__class_column.append(column)
self.__class_column[i].set_reorderable(True)
self.__class_column[i].set_resizable(True)
self.__class_column[i].set_attributes(self.__cell,
text = i,
editable = 5)
self.__class_column[i].set_sort_column_id(i)
self.__class_treeview.append_column(self.__class_column[i])
self.__class_scroll.add_with_viewport(self.__class_treeview)
self.__os.append_page(self.__class_scroll, HIGLabel('Class'))
self.__fp_viewer = HIGTextEditor()
self.__fp_viewer._modify_font(self.__font)
self.__fp_viewer._set_editable(False)
self.__fp_viewer._set_text(os['fingerprint'])
self.__fp_ports = HIGHBox()
self.__fp_label = HIGSectionLabel('Used ports:')
self.__fp_ports_list = gtk.combo_box_entry_new_text()
self.__fp_ports_list.child.set_editable(False)
self.__fp_vbox = HIGVBox()
if os.has_key('used_ports'):
used_ports = os['used_ports']
for port in used_ports:
params = port['id'], port['protocol'], port['state']
self.__fp_ports_list.append_text(USED_PORTS_TEXT % params)
self.__fp_ports_list.set_active(0)
self.__fp_ports._pack_noexpand_nofill(self.__fp_label)
self.__fp_ports._pack_expand_fill(self.__fp_ports_list)
self.__fp_vbox._pack_noexpand_nofill(self.__fp_ports)
self.__os.append_page(self.__fp_viewer, HIGLabel('Fingerprint'))
self.__fp_vbox._pack_expand_fill(self.__os)
self.__os_frame._add(self.__fp_vbox)
self.__os_frame.set_expanded(True)
self.__vbox._pack_noexpand_nofill(self.__general_frame)
self.__vbox._pack_expand_fill(self.__os_frame)
self.__vbox._pack_noexpand_nofill(self.__sequences_frame)
self.add_with_viewport(self.__vbox)
def __init__(self):
HIGScrolledWindow.__init__(self)
self.__auto_scroll = False
self.__create_widgets()
class MapperSettings(TabBox):
def __init__(self, name):
TabBox.__init__(self, name)
def _create_widgets(self):
"""
Design all
"""
self.create_interpolation()
self.create_layout()
self.create_view()
self.pack_start(self._box_interpolation, False, False)
self.pack_start(self._box_layout, False, False)
self.pack_start(self._box_view, False, False)
def create_interpolation(self):
vbox = HIGVBox()
self._box_interpolation = HIGFrame('Interpolation')
self._box_interpolation.add(vbox)
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(mapper_conf.frames,
1,
1000,
1)
self.__frames.connect('value_changed', self.__change_frames)
self.__frames_spin = gtk.SpinButton(self.__frames)
self.__frames_box._pack_noexpand_nofill(self.__frames_label)
self.__frames_box._pack_noexpand_nofill(self.__frames_spin)
vbox._pack_noexpand_nofill(self.__frames_box)
vbox._pack_noexpand_nofill(self.__system_box)
def __change_system(self, widget, value):
mapper_conf.interpolation = value
def __change_frames(self, widget):
mapper_conf.frames = int(self.__frames_spin.get_value())
def create_layout(self):
hbox = HIGHBox()
self._box_layout = HIGFrame('Layout')
self._box_layout.add(hbox)
self.__layout = gtk.combo_box_new_text()
self.__layout.append_text('Symmetric')
self.__layout.append_text('Weighted')
self.__layout.set_active(mapper_conf.layout)
self.__layout.connect('changed', self.__change_layout)
hbox._pack_noexpand_nofill(self.__layout)
def __change_layout(self, widget):
mapper_conf.layout = self.__layout.get_active()
def create_view(self):
vbox = HIGVBox()
self._box_view = HIGFrame('View')
self._box_view.add(vbox)
self.__zoom = ControlVariableWidget('Zoom',
self.__get_zoom,
self.__set_zoom,
1)
self.__ring_gap = ControlVariableWidget('Ring gap',
self.__get_ring,
self.__set_ring,
1)
self.__label = gtk.Label('Lower ring gap')
self.__label.set_alignment(0.0, 0.5)
self.__adjustment = gtk.Adjustment(mapper_conf.lower_ring,
0,
50,
1)
self.__lring_spin = gtk.SpinButton(self.__adjustment)
self.__lring_spin.connect('value_changed', self.__change_lower)
self.__lower_hbox = HIGHBox()
self.__lower_hbox._pack_noexpand_nofill(self.__label)
self.__lower_hbox._pack_noexpand_nofill(self.__lring_spin)
self.create_view_options()
vbox._pack_noexpand_nofill(self.scroll_window)
vbox._pack_noexpand_nofill(self.__zoom)
vbox._pack_noexpand_nofill(self.__ring_gap)
vbox._pack_noexpand_nofill(self.__lower_hbox)
def __change_lower(self, widget):
mapper_conf.frames = int(self.__lring_spin.get_value())
def __set_zoom(self, zoom):
if float(zoom) >= 1:
mapper_conf.zoom = float(zoom) / 100.0
def __get_zoom(self):
return int(round(mapper_conf.zoom * 100))
def __set_ring(self, value):
mapper_conf.ring = value
def __get_ring(self):
return mapper_conf.ring
def create_view_options(self):
self.views_enabled = []
self.scroll_window = HIGScrolledWindow()
self.scroll_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.scroll_window.set_shadow_type(gtk.SHADOW_NONE)
self.__liststore = gtk.ListStore(gobject.TYPE_BOOLEAN,
gobject.TYPE_STRING)
self.__liststore.append([None, OPTIONS[0]])
self.__liststore.append([None, OPTIONS[1]])
self.__liststore.append([None, OPTIONS[2]])
self.__liststore.append([None, OPTIONS[3]])
self.__liststore.append([None, OPTIONS[4]])
self.__liststore.append([None, OPTIONS[5]])
self.__liststore.append([None, OPTIONS[6]])
self.__cell_toggle = gtk.CellRendererToggle()
self.__cell_toggle.set_property('activatable', True)
self.__cell_toggle.connect('toggled',
self.__change_option,
self.__liststore)
self.__column_toggle = gtk.TreeViewColumn('', self.__cell_toggle)
self.__column_toggle.add_attribute(self.__cell_toggle, 'active', 0)
self.__cell_text = gtk.CellRendererText()
self.__column_text = gtk.TreeViewColumn('Enable',
self.__cell_text,
text=1)
self.__treeview = gtk.TreeView(self.__liststore)
self.__treeview.set_enable_search(True)
self.__treeview.set_search_column(1)
self.__treeview.append_column(self.__column_toggle)
self.__treeview.append_column(self.__column_text)
self.scroll_window.add_with_viewport(self.__treeview)
self.__update_options()
def __update_options(self):
"""
"""
model = self.__liststore
model[OPTIONS.index('address')][0] = 'address' in mapper_conf.view
model[OPTIONS.index('hostname')][0] = 'hostname' in mapper_conf.view
model[OPTIONS.index('icon')][0] = 'icon' in mapper_conf.view
model[OPTIONS.index('latency')][0] = 'latency' in mapper_conf.view
model[OPTIONS.index('ring')][0] = 'ring' in mapper_conf.view
model[OPTIONS.index('region')][0] = 'region' in mapper_conf.view
model[OPTIONS.index('slow in/out')][0] = 'slow' in mapper_conf.view
return True
def __change_option(self, cell, option, model):
"""
"""
option = int(option)
model[option][0] = not model[option][0]
if OPTIONS[option] == 'address':
if model[option][0]:
self.views_enabled.append('address')
else:
self.views_enabled.remove('address')
elif OPTIONS[option] == 'hostname':
if model[option][0]:
self.views_enabled.append('hostname')
else:
self.views_enabled.remove('hostname')
elif OPTIONS[option] == 'icon':
if model[option][0]:
self.views_enabled.append('icon')
else:
self.views_enabled.remove('icon')
elif OPTIONS[option] == 'latency':
if model[option][0]:
self.views_enabled.append('latency')
else:
self.views_enabled.remove('latency')
elif OPTIONS[option] == 'ring':
if model[option][0]:
self.views_enabled.append('ring')
else:
self.views_enabled.remove('ring')
elif OPTIONS[option] == 'region':
if model[option][0]:
self.views_enabled.append('region')
else:
self.views_enabled.remove('region')
elif OPTIONS[option] == 'slow in/out':
if model[option][0]:
self.views_enabled.append('slow')
else:
self.views_enabled.remove('slow')
mapper_conf.view = self.views_enabled
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)
