def _forward_event_to_parent(self, widget, event):
event.window = self.parent.window
parent_x, parent_y = widget.translate_coordinates(self.parent,
int(event.x),
int(event.y))
event.x, event.y = float(parent_x), float(parent_y)
gtk.main_do_event(event)
def drawing_event(gobj, eventType, x, y):
ev = gtk.gdk.Event(eventType)
ev.x = x
ev.y = y
ev.window = gobj.window
ev.set_screen(gobj.get_screen())
gtk.main_do_event(ev)
def entry_keypress_cb(self, widget, event): prefix = self.get_text() if event.keyval == KEY_TAB and not event.state & MOD_MASK and ( prefix and not self.get_selection_bounds() and self.get_position() == len(prefix) and not self.completed): liststore = self.completion_getter(prefix) if len(liststore) == 0: # Users can press Tab twice in this circumstance to confirm. self.completed = True if len(liststore) == 1: self.set_text(liststore[0][0]) self.set_position(-1) self.completed = True else: self.completing = prefix self.completion.set_model(liststore) self.completion.complete() # GtkEntryCompletion apparently needs a little nudge gtk.main_do_event(gtk.gdk.Event(gtk.gdk.KEY_PRESS)) return True else: self.completion.set_model(None) return False
def on_click_anywhere(w_ev,data=None):
if w_ev.type != gtk.gdk.BUTTON_PRESS:
gtk.main_do_event(w_ev)
return
if hash(w_ev)==hash(ev) and w_ev.x==orig_ev.x and w_ev.y==orig_ev.y:
# this check exists because the function would be triggered by
# the click on the previewer color. Because hash is not enough,
# we must check if we moved too (the event was copied because it
# will be modified internally)
return
if w_ev.window not in (self.palette.window,(self.grayscalePalette and self.grayscalePalette.window),self.noColor.window):
# clicked outside of the palette, restore original color
colorWidget.set_color(*self._prevColor)
self.palette.disconnect(self._mouseOverPalette_id)
self.palette.disconnect(self.palette_leave_id)
self.noColor.disconnect(self._mouseOverNoColor_id)
self.noColor.disconnect(self.noColor_leave_id)
if self.grayscalePalette:
self.grayscalePalette.disconnect(self._mouseOverGrayscale_id)
self.grayscalePalette.disconnect(self.grayscalePalette_leave_id)
self.toggle_picker_icon(False)
gtk.gdk.event_handler_set(gtk.main_do_event)
for widget in self._previewersSignals:
# reconnect all the previewers 'onclick' signals
self._previewersSignals[widget]['clicked_id'] = widget.connect('clicked',self.on_previewer_clicked)
gtk.main_do_event(w_ev)
def cb_any_event(event, onboard):
# Update layout on keyboard group changes
# XkbStateNotify maps to gtk.gdk.NOTHING
# https://bugzilla.gnome.org/show_bug.cgi?id=156948
if event.type == gtk.gdk.NOTHING:
onboard.update_layout()
gtk.main_do_event(event)
def _filter_callback(self, event):
if event.type in [
gdk.BUTTON_PRESS, gdk.BUTTON_RELEASE, gdk.KEY_PRESS,
gdk.KEY_RELEASE, gdk.MOTION_NOTIFY, gdk.SCROLL
]:
self._idle = 0
gtk.main_do_event(event)
def fake_button_press(window):
event = gtk.gdk.Event(gtk.gdk.BUTTON_PRESS)
event.button = 1
event.window = window
event.x = 0.5
event.y = 0.5
gtk.main_do_event(event)
def _emit_box_event(self, event):
# Fake an event such that the FloatBox can pick up the newly
# created widget.
x, y = self.box._translate_event_coordinates(event)
event.window = self.box.window
event.x = float(x)
event.y = float(y)
gtk.main_do_event(event)
def _event_handler(self, event):
# Separate method so we can use return inside
self._check_event(event)
self._times.append(event.get_time())
gtk.main_do_event(event)
last_time = self._times.pop()
if last_time > self._last_time:
self._last_time = last_time
def tooltip_handler(event):
gtk.main_do_event(event)
if event.type == gdk.MOTION_NOTIFY:
# print "leave", time.time()
update_tooltip()
elif event.type == gdk.LEAVE_NOTIFY:
# print "leave", time.time()
hide_tooltip()
def tooltip_handler(event):
gtk.main_do_event(event)
if event.type == gdk.MOTION_NOTIFY:
# print "leave", time.time()
update_tooltip()
elif event.type == gdk.LEAVE_NOTIFY:
# print "leave", time.time()
hide_tooltip()
def send_backspace(widget):
event = gtk.gdk.Event(gtk.gdk.KEY_PRESS)
event.keyval = int(keysyms.BackSpace)
event.hardware_keycode = 22
event.window = widget.window
# widget.event(event)
gtk.main_do_event(event)
refresh_gui(DELAY)
def send_delete(widget):
event = gtk.gdk.Event(gtk.gdk.KEY_PRESS)
event.keyval = int(keysyms.Delete)
event.hardware_keycode = 107
event.window = widget.window
gtk.main_do_event(event)
# widget.event(event)
refresh_gui(DELAY)
def _emit_box_event(self, event):
# Fake an event such that the FloatBox can pick up the newly
# created widget.
x, y = self.box._translate_event_coordinates(event)
event.window = self.box.window
event.x = float(x)
event.y = float(y)
gtk.main_do_event(event)
def _filter_callback(self, event):
if event.type in [gdk.BUTTON_PRESS,
gdk.BUTTON_RELEASE,
gdk.KEY_PRESS,
gdk.KEY_RELEASE,
gdk.MOTION_NOTIFY,
gdk.SCROLL]:
self._idle = 0
gtk.main_do_event(event)
def eventHandler(self, event): """ Intercepts GTK calls, to attempt to launch sugarbot. Attempts to launch sugarbot at every gdk.Event emitted. """ if event is not None: gtk.main_do_event(event) self.tryToLaunchSugarbotActivity()
def fix(type_):
ev = gtk.gdk.Event(gtk.gdk.KEY_PRESS)
ev.window = WINDOW.window
import time
ev.time = long(time.time())
ev.state = 65363
ev.keyval = 114
gtk.main_do_event(ev)
def __event(self, event):
if event.type != gtk.gdk.SCROLL:
event.x += self.__dx
event.y += self.__dy
# modifying event.window is a necessary evil, made okay because
# nobody else should tie to any TreeViewHints events ever.
event.window = self.__target.get_bin_window()
gtk.main_do_event(event)
return True
def eventHandler(self,event=None):
""" Intercepts all GDK events. We then send them off to a separate
handler method (to keep things clean), and then have GTK execute
whatever the event is supposed to do.
"""
if event is not None:
gtk.main_do_event(event)
self.handleEvent(event)
if event.type is not gtk.gdk.EXPOSE:
self.idletime = 0
return True
def event_handler(event):
if event.type == gdk.KEY_PRESS:
if event.keyval == gtk.keysyms.q:
self.quit()
elif event.keyval == gtk.keysyms.p:
self.submit()
elif self.msg and event.keyval == gtk.keysyms.a:
self.approve(self.msg)
elif self.msg and event.keyval == gtk.keysyms.d:
self.discard(self.msg)
elif self.msg and event.keyval == gtk.keysyms.s:
self.skip(self.msg)
gtk.main_do_event(event)
def event_handler(event):
if event.type == gdk.KEY_PRESS:
if event.keyval == gtk.keysyms.q:
self.quit()
elif event.keyval == gtk.keysyms.p:
self.submit()
elif self.msg and event.keyval == gtk.keysyms.a:
self.approve(self.msg)
elif self.msg and event.keyval == gtk.keysyms.d:
self.discard(self.msg)
elif self.msg and event.keyval == gtk.keysyms.s:
self.skip(self.msg)
gtk.main_do_event(event)
def test_tooltip_overlapping_widgets():
'''
Ensure that the correct tooltip is shown when two widgets inside a
``gtk.Layout`` overlaps each other.
:bug: #550345
'''
b1 = gtk.Button('1')
b1.set_size_request(100, 100)
b1.set_tooltip_text('button1')
b2 = gtk.Button('2')
b2.set_size_request(100, 100)
b2.set_tooltip_text('button2')
# Note that in this layout b2 overlaps b1.
layout = gtk.Layout()
layout.set_size_request(400, 400)
layout.put(b1, 0, 0)
layout.put(b2, 50, 0)
win = gtk.Window()
win.add(layout)
win.show_all()
# By setting the timeout to 0 the tooltip should show after one
# iteration of the mainloop.
settings = gtk.settings_get_default()
settings.set_property('gtk-tooltip-timeout', 0)
# Simulate a motion notify over the second button on a location
# where it overlaps the first button.
ev = gdk.Event(gdk.MOTION_NOTIFY)
ev.window = win.window
ev.x = ev.x_root = 80.0
ev.y = ev.y_root = 10.0
ev.is_hint = False
# GTK gets the motion notify event and shows the tooltip in
# response.
gtk.main_do_event(ev)
gtk.main_iteration()
# Find the tooltip window in the toplevel list.
tooltip_win = None
for w in gtk.window_list_toplevels():
if w.name == 'gtk-tooltip':
tooltip_win = w
# The tooltip label shown should be the second buttons.
tooltip_label = tooltip_win.get_child().get_child().get_children()[1]
assert tooltip_label.get_text() == 'button2'
def key_press(ww, e):
if editing: return
keyname = gtk.gdk.keyval_name(e.keyval)
# Modifier keys to ignore.
mods = ["Control_L", "Control_R",
"Shift_L", "Shift_R",
"Alt_L", "Alt_R",
"Meta_L", "Meta_R",
"Up", "Down", "Left", "Right",
]
if keyname in mods:
return True
if (keyname == "Caps_Lock") or (keyname == "VoidSymbol"):
global w
kbwin = w.get_data("kbwin")
if kbwin.get_visible():
kbwin.hide()
else:
kbwin.show_all()
return True
if (keyname == "BackSpace") or (keyname == "Delete"):
do_str("drop")
do_update()
return True
if (keyname == "Escape"):
do_str("clear")
do_update()
return True
if (keyname == "Return") or (keyname == "KP_Enter"):
do_str("dup")
do_update()
return True
if (keyname == "d") and (e.state & gtk.gdk.CONTROL_MASK):
#w.hide()
w.iconify()
return True
sm = ww.get_model()
it = sm.get_iter_first()
sm.remove(it)
path = sm.get_string_from_iter(sm.append())
ww.set_cursor(path, ww.get_column(1), True)
gtk.main_do_event(e.copy())
return True
def entry_keypress_cb(self, widget, event):
if event.keyval == self.KEY_TAB:
liststore = self.completion_getter(self.get_text())
if len(liststore) == 1:
self.set_text(liststore[0][0])
self.set_position(-1)
else:
self.completion.set_model(liststore)
self.completion.complete()
gtk.main_do_event(gtk.gdk.Event(gtk.gdk.KEY_PRESS))
return True
else:
self.completion.set_model(None)
return False
def event_handler(self, event):
"""
Handle mouse events
"""
if event.type == gtk.gdk.BUTTON_PRESS:
if event.button != 1:
print "Canceled by the user"
exit(EXIT_CANCEL)
# grab the keyboard only when selection started
gtk.gdk.keyboard_grab(self.root)
self.started = True
self.start_x = int(event.x)
self.start_y = int(event.y)
self.move(self.x, self.y)
elif event.type == gtk.gdk.KEY_RELEASE:
if gtk.gdk.keyval_name(event.keyval) == "Escape":
print "Canceled by the user"
exit(EXIT_CANCEL)
elif event.type == gtk.gdk.MOTION_NOTIFY:
if not self.started:
return
self.set_rect_size(event)
self.draw()
if self.width > 3 and self.height > 3:
self.resize(self.width, self.height)
self.move(self.x, self.y)
self.show_all()
elif event.type == gtk.gdk.BUTTON_RELEASE:
if not self.started:
return
self.set_rect_size(event)
self.ungrab()
self.hide()
gobject.timeout_add(100, self.screenshot)
else:
gtk.main_do_event(event)
def event_handler(self, event):
"""
Handle mouse events
"""
if event.type == gtk.gdk.BUTTON_PRESS:
if event.button != 1:
print "Canceled by the user"
exit(EXIT_CANCEL)
# grab the keyboard only when selection started
gtk.gdk.keyboard_grab(self.root)
self.started = True
self.start_x = int(event.x)
self.start_y = int(event.y)
self.move(self.x, self.y)
elif event.type == gtk.gdk.KEY_RELEASE:
if gtk.gdk.keyval_name(event.keyval) == "Escape":
print "Canceled by the user"
exit(EXIT_CANCEL)
elif event.type == gtk.gdk.MOTION_NOTIFY:
if not self.started:
return
self.set_rect_size(event)
self.draw()
if self.width > 3 and self.height > 3:
self.resize(self.width, self.height)
self.move(self.x, self.y)
self.show_all()
elif event.type == gtk.gdk.BUTTON_RELEASE:
if not self.started:
return
self.set_rect_size(event)
self.ungrab()
self.hide()
gobject.timeout_add(100, self.screenshot)
else:
gtk.main_do_event(event)
def __event(self, event):
if not self.__view:
return True
# hack: present the main window on key press
if event.type == gtk.gdk.BUTTON_PRESS:
# hack: present is overridden to present all windows.
# bypass to only select one
gtk.Window.present(get_top_parent(self.__view))
if event.type != gtk.gdk.SCROLL:
event.x += self.__dx
event.y += self.__dy
# modifying event.window is a necessary evil, made okay because
# nobody else should tie to any TreeViewHints events ever.
event.window = self.__view.get_bin_window()
gtk.main_do_event(event)
return True
def event_handler(event):
if (event.type == gdk.KEY_PRESS and
event.state & gdk.CONTROL_MASK and
event.keyval == gtk.keysyms.q):
os._exit(0)
gtk.main_do_event(event)
def event_handler(event):
if (event.type == gdk.KEY_PRESS
and event.state & gdk.CONTROL_MASK
and event.keyval == gtk.keysyms.q):
os._exit(0)
gtk.main_do_event(event)
def on_any_event(self, event):
if event.type == gtk.gdk.MOTION_NOTIFY: return
elif event.type == gtk.gdk.BUTTON_RELEASE:
self.clicked_menu.popup(None,None,gtk.status_icon_position_menu,1,event.time,self.statusIcon)
gtk.main_do_event(event)
def _on_event(event):
if gtk.gdk.MOTION_NOTIFY == event.type:
self.cursor_handler.refresh()
gtk.main_do_event(event)
def _on_event(event):
if gtk.gdk.MOTION_NOTIFY == event.type:
self.cursor_handler.refresh()
gtk.main_do_event(event)
def _event_handler(self, event):
# Separate method so we can use return inside
self._check_event(event)
gtk.main_do_event(event)
def _event_handler(self, event):
# Separate method so we can use return inside
self._check_event(event)
gtk.main_do_event(event)
def myfilter(ev, data=None):
print("ev %s" % (ev.type,))
if ev.type == gtk.gdk.CONFIGURE:
self.ev = ev
gtk.main_quit()
gtk.main_do_event(ev)
def allGDKeventHandler(self, event, data=None):
doPrint = 0
if data is not None: # this is keybinder "activated" or menu "hide"
if (data == menu_item): # this is # menu "hide" calling
# this is a result of the menu_item "hide" below;
# set all shortcut keys to "released";
# but this may run before we execute our `on_activate`
# so reset by calling a callback after certain time
glib.timeout_add(500, self.reset_keystatus_cb)
# reset listening of menu_item; maybe not needed?
#~ if self.chideid != -1:
#~ menu_item.get_parent().disconnect(self.chideid)
#~ self.chideid = -1
else: # this is keybinder "activated" calling
# set all shortcut keys to "pressed":
for tkey in self.keystatus.keys():
self.keystatus[tkey] = 1
# listen to master `menu_item`' window?
# it's parent Menu fires, but has data: None!
# fix here: simply pass menu_item as (otherwise
# useless) data
if self.chideid == -1:
self.chideid = menu_item.get_parent().connect(
"hide", self.allGDKeventHandler, menu_item)
doPrint = 1
else: # data is None - this is Gdk event
# event.keyval: 65513;
# gtk.gdk.keyval_name(event.keyval): 'Alt_L'
# tkey = 'Alt'
# but problem with tkey = 'c'; keyval_name = 'Escape'
# so work only with numeric keyvals:
# 65513 Alt_L; 65514 Alt_R; 65507 Control_L; 65508 Control_R; 99 c
# but then numeric comparison (as of now) cannot adapt to other
# shortcuts that <Ctrl><Alt><c>!!
if event.type == gtk.gdk.KEY_RELEASE:
# old string comparison:
#~ for tkey in self.keystatus.keys():
#~ if tkey in gtk.gdk.keyval_name(event.keyval):
#~ self.keystatus[tkey] = 0
# numeric comparison:
if event.keyval == 65513 or event.keyval == 65514:
self.keystatus['Alt'] = 0
if event.keyval == 65507 or event.keyval == 65508:
self.keystatus['Control'] = 0
if event.keyval == 99:
self.keystatus['c'] = 0
doPrint = 2
elif event.type == gtk.gdk.KEY_PRESS:
# old string comparison:
#~ for tkey in self.keystatus.keys():
#~ if tkey in gtk.gdk.keyval_name(event.keyval):
#~ self.keystatus[tkey] = 1
# numeric comparison:
if event.keyval == 65513 or event.keyval == 65514:
self.keystatus['Alt'] = 1
if event.keyval == 65507 or event.keyval == 65508:
self.keystatus['Control'] = 1
if event.keyval == 99:
self.keystatus['c'] = 1
doPrint = 2
# MUST have main_do_event at end,
# else Gnome stops responding to keypresses!
gtk.main_do_event(event)
# at end, print for debug (if commenting, leave the pass at end)
if doPrint > 0:
#~ print "allGDK", self.isAnyShortcutKeyHeld(), self.keystatus, hex(id(self.keystatus))
#~ if doPrint > 1:
#~ print event.keyval, gtk.gdk.keyval_name(event.keyval),
#~ print event #, menu_item.get_parent().get_parent()
pass
