PenTest/nmap
1
0
Fork 0
mirror of https://github.com/nmap/nmap.git synced 2025-12-06 12:41:29 +00:00
Code Issues Projects Releases Wiki Activity
Files
24b26317c77fb6ea3db64d47f6be177af89eb6ba
nmap/zenmap/radialnet/gui/ControlWidget.py
dmiller 24b26317c7 Merge #2088: Update Zenmap to Python 3 and PyGObject 
Note: Ndiff build will be broken until subsequent changes are made.
Deprecation warnings will need to be addressed in future changes.
Closes #2088
2022-12-07 20:34:03 +00:00

1273 lines
41 KiB
Python
Raw Blame History

# vim: set fileencoding=utf-8 :
# ***********************IMPORTANT NMAP LICENSE TERMS************************
# * *
# * The Nmap Security Scanner is (C) 1996-2022 Nmap Software LLC ("The Nmap *
# * Project"). Nmap is also a registered trademark of the Nmap Project. *
# * *
# * This program is distributed under the terms of the Nmap Public Source *
# * License (NPSL). The exact license text applying to a particular Nmap *
# * release or source code control revision is contained in the LICENSE *
# * file distributed with that version of Nmap or source code control *
# * revision. More Nmap copyright/legal information is available from *
# * https://nmap.org/book/man-legal.html, and further information on the *
# * NPSL license itself can be found at https://nmap.org/npsl/ . This *
# * header summarizes some key points from the Nmap license, but is no *
# * substitute for the actual license text. *
# * *
# * Nmap is generally free for end users to download and use themselves, *
# * including commercial use. It is available from https://nmap.org. *
# * *
# * The Nmap license generally prohibits companies from using and *
# * redistributing Nmap in commercial products, but we sell a special Nmap *
# * OEM Edition with a more permissive license and special features for *
# * this purpose. See https://nmap.org/oem/ *
# * *
# * If you have received a written Nmap license agreement or contract *
# * stating terms other than these (such as an Nmap OEM license), you may *
# * choose to use and redistribute Nmap under those terms instead. *
# * *
# * The official Nmap Windows builds include the Npcap software *
# * (https://npcap.com) for packet capture and transmission. It is under *
# * separate license terms which forbid redistribution without special *
# * permission. So the official Nmap Windows builds may not be *
# * redistributed without special permission (such as an Nmap OEM *
# * license). *
# * *
# * Source is provided to this software because we believe users have a *
# * right to know exactly what a program is going to do before they run it. *
# * This also allows you to audit the software for security holes. *
# * *
# * Source code also allows you to port Nmap to new platforms, fix bugs, *
# * and add new features. You are highly encouraged to submit your *
# * changes as a Github PR or by email to the dev@nmap.org mailing list *
# * for possible incorporation into the main distribution. Unless you *
# * specify otherwise, it is understood that you are offering us very *
# * broad rights to use your submissions as described in the Nmap Public *
# * Source License Contributor Agreement. This is important because we *
# * fund the project by selling licenses with various terms, and also *
# * because the inability to relicense code has caused devastating *
# * problems for other Free Software projects (such as KDE and NASM). *
# * *
# * The free version of Nmap is distributed in the hope that it will be *
# * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of *
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Warranties, *
# * indemnification and commercial support are all available through the *
# * Npcap OEM program--see https://nmap.org/oem/ *
# * *
# ***************************************************************************/
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, GLib, Gdk, GObject
import math
import radialnet.util.geometry as geometry
from radialnet.bestwidgets.boxes import *
from radialnet.core.Coordinate import PolarCoordinate
import radialnet.gui.RadialNet as RadialNet
from radialnet.bestwidgets.expanders import BWExpander
OPTIONS = ['address',
'hostname',
'icon',
'latency',
'ring',
'region',
'slow in/out']
REFRESH_RATE = 500
class ControlWidget(BWVBox):
"""
"""
def __init__(self, radialnet):
"""
"""
BWVBox.__init__(self)
self.set_border_width(6)
self.radialnet = radialnet
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__action = ControlAction(self.radialnet)
self.__interpolation = ControlInterpolation(self.radialnet)
self.__layout = ControlLayout(self.radialnet)
self.__view = ControlView(self.radialnet)
self.bw_pack_start_noexpand_nofill(self.__action)
self.bw_pack_start_noexpand_nofill(self.__interpolation)
self.bw_pack_start_noexpand_nofill(self.__layout)
self.bw_pack_start_noexpand_nofill(self.__view)
class ControlAction(BWExpander):
"""
"""
def __init__(self, radialnet):
"""
"""
BWExpander.__init__(self, _('Action'))
self.set_expanded(True)
self.radialnet = radialnet
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__tbox = BWTable(1, 4)
self.__tbox.bw_set_spacing(0)
self.__vbox = BWVBox()
self.__jump_to = Gtk.RadioToolButton(group=None,
stock_id=Gtk.STOCK_JUMP_TO)
self.__jump_to.set_tooltip_text('Change focus')
self.__jump_to.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_JUMP_TO)
self.__info = Gtk.RadioToolButton(group=self.__jump_to,
stock_id=Gtk.STOCK_INFO)
self.__info.set_tooltip_text('Show information')
self.__info.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_INFO)
self.__group = Gtk.RadioToolButton(group=self.__jump_to,
stock_id=Gtk.STOCK_ADD)
self.__group.set_tooltip_text('Group children')
self.__group.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_GROUP)
self.__region = Gtk.RadioToolButton(group=self.__jump_to,
stock_id=Gtk.STOCK_SELECT_COLOR)
self.__region.set_tooltip_text('Fill region')
self.__region.connect('toggled',
self.__change_pointer,
RadialNet.POINTER_FILL)
self.__region_color = Gtk.ComboBoxText.new()
self.__region_color.append_text(_('Red'))
self.__region_color.append_text(_('Yellow'))
self.__region_color.append_text(_('Green'))
self.__region_color.connect('changed', self.__change_region)
self.__region_color.set_active(self.radialnet.get_region_color())
self.__tbox.bw_attach_next(self.__jump_to)
self.__tbox.bw_attach_next(self.__info)
self.__tbox.bw_attach_next(self.__group)
self.__tbox.bw_attach_next(self.__region)
self.__vbox.bw_pack_start_noexpand_nofill(self.__tbox)
self.__vbox.bw_pack_start_noexpand_nofill(self.__region_color)
self.bw_add(self.__vbox)
self.__jump_to.set_active(True)
self.__region_color.set_no_show_all(True)
self.__region_color.hide()
def __change_pointer(self, widget, pointer):
"""
"""
if pointer != self.radialnet.get_pointer_status():
self.radialnet.set_pointer_status(pointer)
if pointer == RadialNet.POINTER_FILL:
self.__region_color.show()
else:
self.__region_color.hide()
def __change_region(self, widget):
"""
"""
self.radialnet.set_region_color(self.__region_color.get_active())
class ControlVariableWidget(Gtk.DrawingArea):
"""
"""
def __init__(self, name, value, update, increment=1):
"""
"""
Gtk.DrawingArea.__init__(self)
self.__variable_name = name
self.__value = value
self.__update = update
self.__increment_pass = increment
self.__radius = 6
self.__increment_time = 100
self.__pointer_position = 0
self.__active_increment = False
self.__last_value = self.__value()
self.connect('draw', self.draw)
self.connect('button_press_event', self.button_press)
self.connect('button_release_event', self.button_release)
self.connect('motion_notify_event', self.motion_notify)
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK |
Gdk.EventMask.BUTTON_RELEASE_MASK |
Gdk.EventMask.POINTER_MOTION_HINT_MASK |
Gdk.EventMask.POINTER_MOTION_MASK)
GLib.timeout_add(REFRESH_RATE, self.verify_value)
def verify_value(self):
"""
"""
if self.__value() != self.__last_value:
self.__last_value = self.__value()
self.queue_draw()
return True
def button_press(self, widget, event):
"""
"""
self.__active_increment = False
pointer = self.get_pointer()
if self.__button_is_clicked(pointer) and event.button == 1:
event.window.set_cursor(Gdk.Cursor(Gdk.CursorType.HAND2))
self.__active_increment = True
self.__increment_value()
def button_release(self, widget, event):
"""
"""
event.window.set_cursor(Gdk.Cursor(Gdk.CursorType.LEFT_PTR))
self.__active_increment = False
self.__pointer_position = 0
self.queue_draw()
def motion_notify(self, widget, event):
"""
Drawing callback
@type widget: GtkWidget
@param widget: Gtk widget superclass
@type event: GtkEvent
@param event: Gtk event of widget
@rtype: boolean
@return: Indicator of the event propagation
"""
if self.__active_increment:
xc, yc = self.__center_of_widget
x, _ = self.get_pointer()
if x - self.__radius > 0 and x + self.__radius < 2 * xc:
self.__pointer_position = x - xc
self.queue_draw()
def draw(self, widget, context):
"""
Drawing callback
@type widget: GtkWidget
@param widget: Gtk widget superclass
@type context: cairo.Context
@param context: cairo context class
@rtype: boolean
@return: Indicator of the event propagation
"""
self.set_size_request(100, 30)
self.__draw(context)
return True
def __draw(self, context):
"""
"""
allocation = self.get_allocation()
self.__center_of_widget = (allocation.width // 2,
allocation.height // 2)
xc, yc = self.__center_of_widget
# draw line
context.set_line_width(1)
context.set_dash([1, 2])
context.move_to(self.__radius,
yc + self.__radius)
context.line_to(2 * xc - 5,
yc + self.__radius)
context.stroke()
# draw text
context.set_dash([1, 0])
context.set_font_size(10)
context.move_to(5, yc - self.__radius)
context.show_text(self.__variable_name)
width = context.text_extents(str(self.__value()))[2]
context.move_to(2 * xc - width - 5, yc - self.__radius)
context.show_text(str(self.__value()))
context.set_line_width(1)
context.stroke()
# draw node
context.arc(xc + self.__pointer_position,
yc + self.__radius,
self.__radius, 0, 2 * math.pi)
if self.__active_increment:
context.set_source_rgb(0.0, 0.0, 0.0)
else:
context.set_source_rgb(1.0, 1.0, 1.0)
context.fill_preserve()
context.set_source_rgb(0.0, 0.0, 0.0)
context.stroke()
def __button_is_clicked(self, pointer):
"""
"""
xc, yc = self.__center_of_widget
center = (xc, yc + self.__radius)
return geometry.is_in_circle(pointer, 6, center)
def __increment_value(self):
"""
"""
self.__update(self.__value() + self.__pointer_position / 4)
self.queue_draw()
if self.__active_increment:
GLib.timeout_add(self.__increment_time,
self.__increment_value)
def set_value_function(self, value):
"""
"""
self.__value = value
def set_update_function(self, update):
"""
"""
self.__update = update
class ControlVariable(BWHBox):
"""
"""
def __init__(self, name, get_function, set_function, increment=1):
"""
"""
BWHBox.__init__(self, spacing=0)
self.__increment_pass = increment
self.__increment_time = 200
self.__increment = False
self.__name = name
self.__get_function = get_function
self.__set_function = set_function
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__control = ControlVariableWidget(self.__name,
self.__get_function,
self.__set_function,
self.__increment_pass)
self.__left_button = Gtk.Button()
self.__left_button.set_size_request(20, 20)
self.__left_arrow = Gtk.Image.new_from_icon_name("pan-start-symbolic",
Gtk.IconSize.BUTTON);
self.__left_button.add(self.__left_arrow)
self.__left_button.connect('pressed',
self.__pressed,
-self.__increment_pass)
self.__left_button.connect('released', self.__released)
self.__right_button = Gtk.Button()
self.__right_button.set_size_request(20, 20)
self.__right_arrow = Gtk.Image.new_from_icon_name("pan-end-symbolic",
Gtk.IconSize.BUTTON);
self.__right_button.add(self.__right_arrow)
self.__right_button.connect('pressed',
self.__pressed,
self.__increment_pass)
self.__right_button.connect('released', self.__released)
self.bw_pack_start_noexpand_nofill(self.__left_button)
self.bw_pack_start_expand_fill(self.__control)
self.bw_pack_start_noexpand_nofill(self.__right_button)
def __pressed(self, widget, increment):
"""
"""
self.__increment = True
self.__increment_function(increment)
def __increment_function(self, increment):
"""
"""
if self.__increment:
self.__set_function(self.__get_function() + increment)
self.__control.verify_value()
GLib.timeout_add(self.__increment_time,
self.__increment_function,
increment)
def __released(self, widget):
"""
"""
self.__increment = False
class ControlFisheye(BWVBox):
"""
"""
def __init__(self, radialnet):
"""
"""
BWVBox.__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 = BWHBox()
self.__fisheye_label = Gtk.Label.new(_('<b>Fisheye</b> on ring'))
self.__fisheye_label.set_use_markup(True)
self.__ring = Gtk.Adjustment.new(0, 0, self.__ring_max_value, 0.01, 0.01, 0)
self.__ring_spin = Gtk.SpinButton(adjustment=self.__ring)
self.__ring_spin.set_digits(2)
self.__ring_scale = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL, adjustment=self.__ring)
self.__ring_scale.set_size_request(100, -1)
self.__ring_scale.set_digits(2)
self.__ring_scale.set_value_pos(Gtk.PositionType.LEFT)
self.__ring_scale.set_draw_value(False)
self.__interest_label = Gtk.Label.new(_('with interest factor'))
self.__interest = Gtk.Adjustment.new(0, 0, 10, 0.01, 0, 0)
self.__interest_spin = Gtk.SpinButton(adjustment=self.__interest)
self.__interest_spin.set_digits(2)
self.__spread_label = Gtk.Label.new(_('and spread factor'))
self.__spread = Gtk.Adjustment.new(0, -1.0, 1.0, 0.01, 0.01, 0)
self.__spread_spin = Gtk.SpinButton(adjustment=self.__spread)
self.__spread_spin.set_digits(2)
self.__params.bw_pack_start_noexpand_nofill(self.__fisheye_label)
self.__params.bw_pack_start_noexpand_nofill(self.__ring_spin)
self.__params.bw_pack_start_expand_fill(self.__ring_scale)
self.__params.bw_pack_start_noexpand_nofill(self.__interest_label)
self.__params.bw_pack_start_noexpand_nofill(self.__interest_spin)
self.__params.bw_pack_start_noexpand_nofill(self.__spread_label)
self.__params.bw_pack_start_noexpand_nofill(self.__spread_spin)
self.bw_pack_start_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)
GLib.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.configure(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())
class ControlInterpolation(BWExpander):
"""
"""
def __init__(self, radialnet):
"""
"""
BWExpander.__init__(self, _('Interpolation'))
self.radialnet = radialnet
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__vbox = BWVBox()
self.__cartesian_radio = Gtk.RadioButton(group=None,
label=_('Cartesian'))
self.__polar_radio = Gtk.RadioButton(group=self.__cartesian_radio,
label=_('Polar'))
self.__cartesian_radio.connect('toggled',
self.__change_system,
RadialNet.INTERPOLATION_CARTESIAN)
self.__polar_radio.connect('toggled',
self.__change_system,
RadialNet.INTERPOLATION_POLAR)
self.__system_box = BWHBox()
self.__system_box.bw_pack_start_noexpand_nofill(self.__polar_radio)
self.__system_box.bw_pack_start_noexpand_nofill(self.__cartesian_radio)
self.__frames_box = BWHBox()
self.__frames_label = Gtk.Label.new(_('Frames'))
self.__frames_label.set_alignment(0.0, 0.5)
self.__frames = Gtk.Adjustment.new(
self.radialnet.get_number_of_frames(), 1, 1000, 1, 0, 0)
self.__frames.connect('value_changed', self.__change_frames)
self.__frames_spin = Gtk.SpinButton(adjustment=self.__frames)
self.__frames_box.bw_pack_start_expand_fill(self.__frames_label)
self.__frames_box.bw_pack_start_noexpand_nofill(self.__frames_spin)
self.__vbox.bw_pack_start_noexpand_nofill(self.__frames_box)
self.__vbox.bw_pack_start_noexpand_nofill(self.__system_box)
self.bw_add(self.__vbox)
GLib.timeout_add(REFRESH_RATE, self.__update_animation)
def __update_animation(self):
"""
"""
active = self.radialnet.get_interpolation()
if active == RadialNet.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 == RadialNet.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 ControlLayout(BWExpander):
"""
"""
def __init__(self, radialnet):
"""
"""
BWExpander.__init__(self, _('Layout'))
self.radialnet = radialnet
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__hbox = BWHBox()
self.__layout = Gtk.ComboBoxText()
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.bw_pack_start_expand_fill(self.__layout)
self.__hbox.bw_pack_start_noexpand_nofill(self.__force)
self.bw_add(self.__hbox)
self.__check_layout()
def __check_layout(self):
"""
"""
if self.__layout.get_active() == RadialNet.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 ControlRingGap(BWVBox):
"""
"""
def __init__(self, radialnet):
"""
"""
BWVBox.__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.new(_('Lower ring gap'))
self.__label.set_alignment(0.0, 0.5)
self.__adjustment = Gtk.Adjustment.new(
self.radialnet.get_min_ring_gap(), 0, 50, 1, 0, 0)
self.__spin = Gtk.SpinButton(adjustment=self.__adjustment)
self.__spin.connect('value_changed', self.__change_lower)
self.__lower_hbox = BWHBox()
self.__lower_hbox.bw_pack_start_expand_fill(self.__label)
self.__lower_hbox.bw_pack_start_noexpand_nofill(self.__spin)
self.bw_pack_start_noexpand_nofill(self.__radius)
self.bw_pack_start_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())
class ControlOptions(BWScrolledWindow):
"""
"""
def __init__(self, radialnet):
"""
"""
BWScrolledWindow.__init__(self)
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
self.set_shadow_type(Gtk.ShadowType.NONE)
self.radialnet = radialnet
self.enable_labels = True
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__liststore = Gtk.ListStore.new([bool, str])
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(cell_renderer=self.__cell_toggle)
self.__column_toggle.add_attribute(self.__cell_toggle, 'active', 0)
self.__column_toggle.set_cell_data_func(self.__cell_toggle, self.__cell_toggle_data_method)
self.__cell_text = Gtk.CellRendererText()
self.__column_text = Gtk.TreeViewColumn(title=None,
cell_renderer=self.__cell_text,
text=1)
self.__column_text.set_cell_data_func(self.__cell_text, self.__cell_text_data_method)
self.__treeview = Gtk.TreeView.new_with_model(self.__liststore)
self.__treeview.set_enable_search(True)
self.__treeview.set_search_column(1)
self.__treeview.set_headers_visible(False)
self.__treeview.append_column(self.__column_toggle)
self.__treeview.append_column(self.__column_text)
self.add_with_viewport(self.__treeview)
GObject.timeout_add(REFRESH_RATE, self.__update_options)
def __cell_toggle_data_method(self, column, cell, model, it, data):
if not self.enable_labels and model.get_value(it, 1) == 'hostname':
cell.set_property('activatable', False)
else:
cell.set_property('activatable', True)
def __cell_text_data_method(self, column, cell, model, it, data):
if not self.enable_labels and model.get_value(it, 1) == 'hostname':
cell.set_property('strikethrough', True)
else:
cell.set_property('strikethrough', False)
def __update_options(self):
"""
"""
model = self.__liststore
model[OPTIONS.index('address')][0] = self.radialnet.get_show_address()
model[OPTIONS.index('hostname')][0] = self.enable_labels and \
self.radialnet.get_show_hostname()
model[OPTIONS.index('icon')][0] = self.radialnet.get_show_icon()
model[OPTIONS.index('latency')][0] = self.radialnet.get_show_latency()
model[OPTIONS.index('ring')][0] = self.radialnet.get_show_ring()
model[OPTIONS.index('region')][0] = self.radialnet.get_show_region()
model[OPTIONS.index('slow in/out')][0] = \
self.radialnet.get_slow_inout()
return True
def __change_option(self, cell, option, model):
"""
"""
option = int(option)
model[option][0] = not model[option][0]
if OPTIONS[option] == 'address':
self.radialnet.set_show_address(model[option][0])
if model[option][0]:
model[OPTIONS.index('hostname')][0] = self.radialnet.get_show_hostname()
else:
model[OPTIONS.index('hostname')][0] = False
self.enable_labels = model[option][0]
elif OPTIONS[option] == 'hostname':
self.radialnet.set_show_hostname(model[option][0])
elif OPTIONS[option] == 'icon':
self.radialnet.set_show_icon(model[option][0])
elif OPTIONS[option] == 'latency':
self.radialnet.set_show_latency(model[option][0])
elif OPTIONS[option] == 'ring':
self.radialnet.set_show_ring(model[option][0])
elif OPTIONS[option] == 'region':
self.radialnet.set_show_region(model[option][0])
elif OPTIONS[option] == 'slow in/out':
self.radialnet.set_slow_inout(model[option][0])
class ControlView(BWExpander):
"""
"""
def __init__(self, radialnet):
"""
"""
BWExpander.__init__(self, _('View'))
self.set_expanded(True)
self.radialnet = radialnet
self.__create_widgets()
def __create_widgets(self):
"""
"""
self.__vbox = BWVBox(spacing=0)
self.__zoom = ControlVariable(_('Zoom'),
self.radialnet.get_zoom,
self.radialnet.set_zoom)
self.__ring_gap = ControlRingGap(self.radialnet)
self.__navigation = ControlNavigation(self.radialnet)
self.__options = ControlOptions(self.radialnet)
self.__options.set_border_width(0)
self.__vbox.bw_pack_start_expand_nofill(self.__options)
self.__vbox.bw_pack_start_noexpand_nofill(self.__navigation)
self.__vbox.bw_pack_start_noexpand_nofill(self.__zoom)
self.__vbox.bw_pack_start_noexpand_nofill(self.__ring_gap)
self.bw_add(self.__vbox)
class ControlNavigation(Gtk.DrawingArea):
"""
"""
def __init__(self, radialnet):
"""
"""
Gtk.DrawingArea.__init__(self)
self.radialnet = radialnet
self.__rotate_node = PolarCoordinate()
self.__rotate_node.set_coordinate(40, 90)
self.__center_of_widget = (50, 50)
self.__moving = None
self.__centering = False
self.__rotating = False
self.__move_pass = 100
self.__move_position = (0, 0)
self.__move_addition = [(-1, 0),
(-1, -1),
(0, -1),
(1, -1),
(1, 0),
(1, 1),
(0, 1),
(-1, 1)]
self.__move_factor = 1
self.__move_factor_limit = 20
self.__rotate_radius = 6
self.__move_radius = 6
self.__rotate_clicked = False
self.__move_clicked = None
self.connect('draw', self.draw)
self.connect('button_press_event', self.button_press)
self.connect('button_release_event', self.button_release)
self.connect('motion_notify_event', self.motion_notify)
self.connect('enter_notify_event', self.enter_notify)
self.connect('leave_notify_event', self.leave_notify)
self.connect('key_press_event', self.key_press)
self.connect('key_release_event', self.key_release)
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK |
Gdk.EventMask.BUTTON_RELEASE_MASK |
Gdk.EventMask.ENTER_NOTIFY_MASK |
Gdk.EventMask.LEAVE_NOTIFY_MASK |
Gdk.EventMask.KEY_PRESS_MASK |
Gdk.EventMask.KEY_RELEASE_MASK |
Gdk.EventMask.POINTER_MOTION_HINT_MASK |
Gdk.EventMask.POINTER_MOTION_MASK)
self.__rotate_node.set_coordinate(40, self.radialnet.get_rotation())
def key_press(self, widget, event):
"""
"""
# key = Gdk.keyval_name(event.keyval)
self.queue_draw()
return True
def key_release(self, widget, event):
"""
"""
# key = Gdk.keyval_name(event.keyval)
self.queue_draw()
return True
def enter_notify(self, widget, event):
"""
"""
return False
def leave_notify(self, widget, event):
"""
"""
self.queue_draw()
return False
def button_press(self, widget, event):
"""
Drawing callback
@type widget: GtkWidget
@param widget: Gtk widget superclass
@type event: GtkEvent
@param event: Gtk event of widget
@rtype: boolean
@return: Indicator of the event propagation
"""
pointer = self.get_pointer()
direction = False
if self.__rotate_is_clicked(pointer):
event.window.set_cursor(Gdk.Cursor(Gdk.CursorType.HAND2))
self.__rotating = True
direction = self.__move_is_clicked(pointer)
if direction is not None and self.__moving is None:
event.window.set_cursor(Gdk.Cursor(Gdk.CursorType.HAND2))
self.__moving = direction
self.__move_in_direction(direction)
if self.__center_is_clicked(pointer):
event.window.set_cursor(Gdk.Cursor(Gdk.CursorType.HAND2))
self.__centering = True
self.__move_position = (0, 0)
self.radialnet.set_translation(self.__move_position)
self.queue_draw()
return False
def button_release(self, widget, event):
"""
Drawing callback
@type widget: GtkWidget
@param widget: Gtk widget superclass
@type event: GtkEvent
@param event: Gtk event of widget
@rtype: boolean
@return: Indicator of the event propagation
"""
self.__moving = None # stop moving
self.__centering = False
self.__rotating = False # stop rotate
self.__move_factor = 1
event.window.set_cursor(Gdk.Cursor(Gdk.CursorType.LEFT_PTR))
self.queue_draw()
return False
def motion_notify(self, widget, event):
"""
Drawing callback
@type widget: GtkWidget
@param widget: Gtk widget superclass
@type event: GtkEvent
@param event: Gtk event of widget
@rtype: boolean
@return: Indicator of the event propagation
"""
xc, yc = self.__center_of_widget
x, y = self.get_pointer()
status = not self.radialnet.is_in_animation()
status = status and not self.radialnet.is_empty()
if self.__rotating and status:
r, t = self.__rotate_node.get_coordinate()
t = math.degrees(math.atan2(yc - y, x - xc))
if t < 0:
t = 360 + t
self.radialnet.set_rotation(t)
self.__rotate_node.set_coordinate(r, t)
self.queue_draw()
return False
def draw(self, widget, context):
"""
Drawing callback
@type widget: GtkWidget
@param widget: Gtk widget superclass
@type context: cairo.Context
@param context: cairo context class
@rtype: boolean
@return: Indicator of the event propagation
"""
self.set_size_request(120, 130)
self.__draw(context)
return False
def __draw_rotate_control(self, context):
"""
"""
xc, yc = self.__center_of_widget
r, t = self.__rotate_node.get_coordinate()
x, y = self.__rotate_node.to_cartesian()
# draw text
context.set_font_size(10)
context.move_to(xc - 49, yc - 48)
context.show_text(_("Navigation"))
width = context.text_extents(str(int(t)))[2]
context.move_to(xc + 49 - width - 2, yc - 48)
context.show_text(str(round(t, 1)))
context.set_line_width(1)
context.stroke()
# draw arc
context.set_dash([1, 2])
context.arc(xc, yc, 40, 0, 2 * math.pi)
context.set_source_rgb(0.0, 0.0, 0.0)
context.set_line_width(1)
context.stroke()
# draw node
context.set_dash([1, 0])
context.arc(xc + x, yc - y, self.__rotate_radius, 0, 2 * math.pi)
if self.__rotating:
context.set_source_rgb(0.0, 0.0, 0.0)
else:
context.set_source_rgb(1.0, 1.0, 1.0)
context.fill_preserve()
context.set_source_rgb(0.0, 0.0, 0.0)
context.set_line_width(1)
context.stroke()
return False
def __draw_move_control(self, context):
"""
"""
xc, yc = self.__center_of_widget
pc = PolarCoordinate()
context.set_dash([1, 1])
context.arc(xc, yc, 23, 0, 2 * math.pi)
context.set_source_rgb(0.0, 0.0, 0.0)
context.set_line_width(1)
context.stroke()
for i in range(8):
pc.set_coordinate(23, 45 * i)
x, y = pc.to_cartesian()
context.set_dash([1, 1])
context.move_to(xc, yc)
context.line_to(xc + x, yc - y)
context.stroke()
context.set_dash([1, 0])
context.arc(
xc + x, yc - y, self.__move_radius, 0, 2 * math.pi)
if i == self.__moving:
context.set_source_rgb(0.0, 0.0, 0.0)
else:
context.set_source_rgb(1.0, 1.0, 1.0)
context.fill_preserve()
context.set_source_rgb(0.0, 0.0, 0.0)
context.set_line_width(1)
context.stroke()
context.arc(xc, yc, 6, 0, 2 * math.pi)
if self.__centering:
context.set_source_rgb(0.0, 0.0, 0.0)
else:
context.set_source_rgb(1.0, 1.0, 1.0)
context.fill_preserve()
context.set_source_rgb(0.0, 0.0, 0.0)
context.set_line_width(1)
context.stroke()
return False
def __draw(self, context):
"""
Drawing method
"""
# Getting allocation reference
allocation = self.get_allocation()
self.__center_of_widget = (allocation.width // 2,
allocation.height // 2)
self.__draw_rotate_control(context)
self.__draw_move_control(context)
return False
def __move_in_direction(self, direction):
"""
"""
if self.__moving is not None:
bx, by = self.__move_position
ax, ay = self.__move_addition[direction]
self.__move_position = (bx + self.__move_factor * ax,
by + self.__move_factor * ay)
self.radialnet.set_translation(self.__move_position)
if self.__move_factor < self.__move_factor_limit:
self.__move_factor += 1
GObject.timeout_add(self.__move_pass,
self.__move_in_direction,
direction)
return False
def __rotate_is_clicked(self, pointer):
"""
"""
xn, yn = self.__rotate_node.to_cartesian()
xc, yc = self.__center_of_widget
center = (xc + xn, yc - yn)
return geometry.is_in_circle(pointer, self.__rotate_radius, center)
def __center_is_clicked(self, pointer):
"""
"""
return geometry.is_in_circle(pointer, self.__move_radius,
self.__center_of_widget)
def __move_is_clicked(self, pointer):
"""
"""
xc, yc = self.__center_of_widget
pc = PolarCoordinate()
for i in range(8):
pc.set_coordinate(23, 45 * i)
x, y = pc.to_cartesian()
center = (xc + x, yc - y)
if geometry.is_in_circle(pointer, self.__move_radius, center):
return i
return None
Reference in New Issue View Git Blame Copy Permalink