def row_activated_handler(self, lBox, lBoxRow):
collector = self.engine.get_collector(lBoxRow.get_name())
if (self.get_selection_mode() == Gtk.SelectionMode.SINGLE):
self.select_row(lBoxRow)
self.attached_gui.create_config_window(Gdk.Event(), collector)
if (self.get_selection_mode() == Gtk.SelectionMode.MULTIPLE):
if (lBoxRow.get_name() !=
self.attached_gui.get_current_config_window_name()):
no_collectors_active = True
for i in self.collectorStatus:
if (self.collectorStatus[i] == True):
no_collectors_active = False
self.toggle_clicked_row(lBoxRow)
if (no_collectors_active):
self.attached_gui.create_config_window(
Gdk.Event(), collector)
elif (lBoxRow.get_name() ==
self.attached_gui.get_current_config_window_name()):
self.toggle_clicked_row(lBoxRow)
for c in self.collectorStatus:
if (self.collectorStatus[c] == True):
collector = self.engine.get_collector(c)
self.attached_gui.create_config_window(
Gdk.Event(), collector)
break
if (not self.attached_gui.is_config_window_active()):
self.attached_gui.create_config_window(Gdk.Event(), collector)
self.update_row_colors(Gdk.Event(), lBoxRow)
def test_debug_mode_eventhandler(self):
"""Run keybinding and mouse click in debug mode and therefore log it."""
# Keybinding
event = Gdk.Event().new(Gdk.EventType.KEY_PRESS)
event.keyval = Gdk.keyval_from_name("j")
self.vimiv["library"].treeview.emit("key_press_event", event)
last_line = self.read_log(string=False)[-1]
self.assertEqual(last_line, "%-15s %s\n" % ("[key]", "j: scroll_lib j"))
# Mouse click
event = Gdk.Event().new(Gdk.EventType.BUTTON_PRESS)
event.button = 1
self.vimiv["window"].emit("button_press_event", event)
last_line = self.read_log(string=False)[-1]
self.assertEqual(last_line, "%-15s %s\n" % ("[key]", "Button1: next"))
def propagate_button_press_event(parent, event, *data):
"""Propagates a button-press-event from the widget parent
to the first Gtk.Button or Gtk.EventBox child encountered"""
parent_alloc = parent.get_allocation()
x = parent_alloc.x + int(event.x)
y = parent_alloc.y + int(event.y)
children = parent.get_children()
while children:
for child in children:
child_alloc = child.get_allocation()
if child_alloc.x <= x <= child_alloc.x + child_alloc.width and \
child_alloc.y <= y <= child_alloc.y + child_alloc.height:
if isinstance(child, Gtk.Button) or isinstance(
child, Gtk.EventBox):
cevent = Gdk.Event()
cevent.type = Gdk.EventType.FOCUS_CHANGE
cevent.send_event = True
cevent.in_ = True
cevent.window = event.window
child.emit('button-press-event', cevent, *data)
return True
else:
if hasattr(child, 'get_children') and callable(
child.get_children):
children = child.get_children()
else:
None
else:
children = None
return False
def _emit_key_press(self, key, state=0):
event = Gdk.Event().new(Gdk.EventType.KEY_PRESS)
event.state = state
event.keyval = Gdk.keyval_from_name(key)
event.window = self._ui_terminal.get_window()
event.send_event = True
self._ui_terminal.emit("key-press-event", event)
def emulate_focus_out_event(self):
tstamp = Gdk.CURRENT_TIME
Gdk.keyboard_ungrab(tstamp)
Gdk.pointer_ungrab(tstamp)
fevent = Gdk.Event(Gdk.EventType.FOCUS_CHANGE)
self.emit('focus-out-event', fevent)
def renew_GPS(self):
del self.daemon
try:
daemon = gps.gps(host=self.host,
port=self.port,
mode=gps.WATCH_ENABLE | gps.WATCH_JSON
| gps.WATCH_SCALED,
verbose=self.debug)
self.watch(daemon, self.device)
except SocketError:
w = Gtk.MessageDialog(parent=self.window,
type=Gtk.MessageType.ERROR,
flags=Gtk.DialogFlags.DESTROY_WITH_PARENT,
buttons=Gtk.ButtonsType.OK)
w.set_title('Socket Error')
w.set_markup(
"Failed to connect to gpsd socket. Make sure that gpsd is running."
)
w.run()
w.destroy()
except KeyboardInterrupt:
print("Keyboard interrupt")
self.window.emit('delete_event', Gdk.Event(Gdk.NOTHING))
w.run()
w.destroy()
def cb_entry_flush_timeout(self):
event = Gdk.Event(Gdk.EventType.FOCUS_CHANGE)
event.focus_change.in_ = True
event.focus_change.window = self._treeview.get_window()
self._dialog_hide(event)
self._entry_flush_timeout = 0
return False
def destroy_top_window(self):
if self.top_window is None:
return
w = self.top_window
if not w.emit("delete-event", Gdk.Event(Gdk.EventType.DELETE)):
w.destroy()
self.top_window = None
def real_start_interactive_search(self, device, keybinding):
"""
Pops up the interactive search entry. If keybinding is TRUE then
the user started this by typing the start_interactive_search
keybinding. Otherwise, it came from just typing
"""
if (self._search_window.get_visible()):
return True
self.ensure_interactive_directory()
if keybinding:
self._search_entry.set_text("")
self._position_func()
self._search_window.show()
if self._search_entry_changed_id == 0:
self._search_entry_changed_id = \
self._search_entry.connect("changed", self.delayed_changed)
# Grab focus without selecting all the text
self._search_entry.grab_focus()
self._search_entry.set_position(-1)
# send focus-in event
event = Gdk.Event(Gdk.EventType.FOCUS_CHANGE)
event.focus_change.in_ = True
event.focus_change.window = self._search_window.get_window()
self._search_entry.emit('focus-in-event', event)
# search first matching iter
self.delayed_changed(self._search_entry)
# uncomment when deleting delayed_changed
# self.search_init(self._search_entry)
return True
def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
GeneralTab(widgets)
HintTab(widgets)
SoundTab(widgets)
# All side panels can be show/hide from View menu now, so no need to do the same from preferences
# We can re enable this after implementing install/uninstall functionality in the future...
# PanelTab(widgets)
ThemeTab(widgets)
SaveTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE))
if e.keyval == Gdk.KEY_Escape else None)
def initialize(widgets):
""" :Description: Initialises the various tabs for each section of configurable artifacts
"""
GeneralTab(widgets)
# All side panels can be show/hide from View menu now, so no need to do the same from preferences
# We can re enable this after implementing install/uninstall functionality in the future...
# PanelTab(widgets)
uistuff.keepWindowSize("preferencesdialog", widgets["preferences_dialog"])
notebook = widgets["preferences_notebook"]
def switch_page(widget, page, page_num):
global hint_tab, theme_tab, sound_tab, save_tab
if page_num == 1 and hint_tab is None:
hint_tab = HintTab(widgets)
elif page_num == 3 and theme_tab is None:
theme_tab = ThemeTab(widgets)
elif page_num == 4 and sound_tab is None:
sound_tab = SoundTab(widgets)
elif page_num == 5 and save_tab is None:
save_tab = SaveTab(widgets)
notebook.connect("switch_page", switch_page)
def delete_event(widget, _):
widgets["preferences_dialog"].hide()
return True
widgets["preferences_dialog"].connect("delete-event", delete_event)
widgets["preferences_dialog"].connect(
"key-press-event",
lambda w, e: w.event(Gdk.Event(Gdk.EventType.DELETE)) if e.keyval == Gdk.KEY_Escape else None)
def test_key_press_event(self):
event = Gdk.Event()
event.key.type = Gdk.EventType.KEY_PRESS
event.keyval = Gdk.KEY_Up
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.keyval = Gdk.KEY_Down
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.keyval = Gdk.KEY_Left
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.keyval = Gdk.KEY_Right
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.state = Gdk.ModifierType.CONTROL_MASK
event.keyval = Gdk.KEY_Up
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.keyval = Gdk.KEY_Down
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.keyval = Gdk.KEY_Left
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.keyval = Gdk.KEY_Right
self.diagram.emit("key-press-event", event)
self.refresh_gui()
event.state = 0
self.diagram.focus = True
event.keyval = Gdk.KEY_Delete
self.diagram.emit("key-press-event", event)
self.refresh_gui()
def do_key_press_event(self, event):
if not self.is_fullscreen and event.keyval == Gdk.KEY_F11:
self.fullscreen()
self.is_fullscreen = True
return True
if self.is_fullscreen and event.keyval == Gdk.KEY_Escape:
self.unfullscreen()
self.is_fullscreen = False
return True
# There's an issue in pygobject3 where it thinks there's a type
# mismatch between Gdk.EventKey and Gdk.Event. This is the workaround.
n = Gdk.Event()
n.type = event.type
n.window = event.window
n.send_event = event.send_event
n.time = event.time
n.state = event.state
n.keyval = event.keyval
n.length = event.length
n.string = event.string
n.hardware_keycode = event.hardware_keycode
n.group = event.group
n.is_modifier = event.is_modifier
return self.chain(n)
def test_button_release_event(self):
event = Gdk.Event().new(Gdk.EventType.BUTTON_PRESS)
event.button = 1
event.state = Gdk.ModifierType.BUTTON1_MASK
self.diagram.emit("button_press_event", event)
self.refresh_gui()
self.diagram.emit("button_release_event", event)
self.refresh_gui()
def test_event(self):
event = Gdk.Event()
event.key.type = Gdk.EventType.KEY_PRESS
event.state = Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD2_MASK
event.keyval = Gdk.KEY_a
self.main_window.emit("key-press-event", event)
self.main_window.emit("check-resize")
self.main_window.emit("delete_event", event)
def test_item_reconnect(self):
# Setting the stage:
ci1 = self.create(items.ClassItem, UML.Class)
ci2 = self.create(items.ClassItem, UML.Class)
a = self.create(items.AssociationItem)
self.connect(a, a.head, ci1)
self.connect(a, a.tail, ci2)
self.assertTrue(a.subject)
self.assertTrue(a.head_end.subject)
self.assertTrue(a.tail_end.subject)
the_association = a.subject
# The act: perform button press event and button release
view = self.component_registry.get(UIComponent,
"diagrams").get_current_view()
self.assertSame(self.diagram.canvas, view.canvas)
p = view.get_matrix_i2v(a).transform_point(*a.head.pos)
event = Gdk.Event()
event.x, event.y, event.type, event.state = (
p[0],
p[1],
Gdk.EventType.BUTTON_PRESS,
0,
)
view.do_event(event)
self.assertSame(the_association, a.subject)
event = Gdk.Event()
event.x, event.y, event.type, event.state = (
p[0],
p[1],
Gdk.EventType.BUTTON_RELEASE,
0,
)
view.do_event(event)
self.assertSame(the_association, a.subject)
def kp( s, bb, k, kc ):
e = Gdk.Event()
e.type = Gdk.EventType.KEY_PRESS
e.keyval = k
e.window = s.w.get_root_window()
e.hardware_keycode = kc
#print(e.keyval,e.hardware_keycode,e.send_event)
s.w.emit( 'key-press-event', e )
def testAutozoom(self, mock_dialog_run):
mock_dialog_run.side_effect = lambda: Gtk.ResponseType.CLOSE
azd = autozoom.AutozoomDialog(self.mw, self.f)
self.assertEqual(azd.minsize_entry.get_text(), "1e-13")
azd.minsize_entry.set_text("1")
azd.emit("focus-out-event", Gdk.Event())
self.assertEqual(azd.minsize, 1)
def test_enter_leave_event(self):
event = Gdk.Event().new(Gdk.EventType.BUTTON_PRESS)
event.button = 1
event.state = Gdk.ModifierType.BUTTON1_MASK
self.comment.emit("enter_notify_event", self.comment, event)
self.refresh_gui()
self.comment.emit("leave_notify_event", self.comment, event)
self.refresh_gui()
def send_message(self,socket,dest_xid,message):
event = Gdk.Event(Gdk.CLIENT_EVENT)
event.window = socket.get_window() # needs sending Gdk window
event.message_type = Gdk.atom_intern('Gladevcp') # change to any text you like
event.data_format = 8 # 8 bit (char) data (options: long,short)
event.data = message # must be exactly 20 char bytes (options: 5 long or 10 short)
event.send_event = True # signals this was sent explicedly
event.send_client_message(dest_xid) # uses destination XID window number
def quit_callback(self, action, parameter):
for window in self.get_windows():
cancelled = window.emit("delete-event",
Gdk.Event(Gdk.EventType.DELETE))
if cancelled:
return
window.destroy()
self.quit()
def video_complete(self, pid, status):
self.spinner.stop()
self.running = False
if status == 0:
self.error = False
else:
self.error = True
self.dialog.emit('delete_event', Gdk.Event())
def test_event(self):
event = Gdk.Event.new(Gdk.EventType.CONFIGURE)
self.assertEqual(event.type, Gdk.EventType.CONFIGURE)
self.assertEqual(event.send_event, 0)
event = Gdk.Event()
event.type = Gdk.EventType.SCROLL
self.assertRaises(AttributeError, lambda: getattr(event, 'foo_bar'))
def test_item_reconnect(self):
# Setting the stage:
ci1 = self.create(ClassItem, UML.Class)
ci2 = self.create(ClassItem, UML.Class)
a = self.create(AssociationItem)
self.connect(a, a.head, ci1)
self.connect(a, a.tail, ci2)
assert a.subject
assert a.head_end.subject
assert a.tail_end.subject
the_association = a.subject
# The act: perform button press event and button release
view = self.component_registry.get(UIComponent,
"diagrams").get_current_view()
assert self.diagram is view.model
p = view.get_matrix_i2v(a).transform_point(*a.head.pos)
event = Gdk.Event()
event.x, event.y, event.type, event.state = (
p[0],
p[1],
Gdk.EventType.BUTTON_PRESS,
0,
)
view.event(event)
assert the_association is a.subject
event = Gdk.Event()
event.x, event.y, event.type, event.state = (
p[0],
p[1],
Gdk.EventType.BUTTON_RELEASE,
0,
)
view.event(event)
assert the_association is a.subject
def _button_press_event(self, obj, event):
if not obj:
return
# keyb_device = event.device
event = Gdk.Event(Gdk.EventType.FOCUS_CHANGE)
event.focus_change.in_ = True
event.focus_change.window = self._treeview.get_window()
self._dialog_hide(event)
def show_error(self, message, secondary):
self.error = True
error_dlg = hig.ErrorAlert(transient_for=self,
primary=message,
secondary=secondary)
error_dlg.run()
error_dlg.destroy()
event = Gdk.Event(Gdk.EventType.DELETE)
self.emit('delete_event', event)
def test_events(self):
gdkevent = Gdk.Event()
gdkevent.key.type = Gdk.EventType.BUTTON_PRESS
self.workarea.add_diagram(self.create_diagram())
tab = self.workarea.get_nth_page(self.workarea.get_current_page())
hbox = self.workarea.get_tab_label(tab)
label = hbox.get_children()[0]
button = hbox.get_children()[1]
button.emit("clicked")
def test_motion_notify_event(self):
event = Gdk.Event().new(Gdk.EventType.BUTTON_PRESS)
event.button = 1
event.state = Gdk.ModifierType.BUTTON1_MASK
self.comment.emit("motion_notify_event", self.comment, event)
self.refresh_gui()
event.state = Gdk.ModifierType.SHIFT_MASK | Gdk.ModifierType.MOD2_MASK
self.comment.emit("motion_notify_event", self.comment, event)
self.refresh_gui()
def test_add_number_via_keypress(self):
"""Add a number to the numstr by keypress."""
self.assertFalse(self.vimiv["eventhandler"].num_str)
event = Gdk.Event().new(Gdk.EventType.KEY_PRESS)
event.keyval = Gdk.keyval_from_name("2")
self.vimiv["library"].treeview.emit("key_press_event", event)
self.assertEqual(self.vimiv["eventhandler"].num_str, "2")
# Clear as it might interfere
self.vimiv["eventhandler"].num_clear()
def test_key_press_modifier(self):
"""Press key with modifier."""
before = self.vimiv["library"].show_hidden
event = Gdk.Event().new(Gdk.EventType.KEY_PRESS)
event.keyval = Gdk.keyval_from_name("h")
event.state = Gdk.ModifierType.CONTROL_MASK
self.vimiv["library"].treeview.emit("key_press_event", event)
after = self.vimiv["library"].show_hidden
self.assertNotEqual(before, after)
