def run(self):
window.set_keep_above(True)
window.set_app_paintable(True)
window.add_events(gtk.gdk.POINTER_MOTION_MASK)
window.add_events(gtk.gdk.BUTTON_PRESS_MASK)
window.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
window.connect("expose-event", lambda w, e: getCurrentCoord(w))
window.connect("expose-event", redraw)
# window.connect("realize", realize_win)
window.connect("key-press-event", keyPress)
window.connect("motion-notify-event", motionNotify)
window.connect("button-press-event", buttonPress)
window.connect("button-release-event", buttonRelease)
window.connect('check-resize', resizemainwin)
window.connect("destroy", gtk.main_quit)
window.connect("delete-event", delete_event)
statusicon.connect('activate', status_clicked )
statusicon.connect('popup-menu', on_right_click)
window.show_all()
while 1:
a= gtk.events_pending()
print(a)
print(gtk.get_current_event())
gtk.main_iteration()
def mode_flip_action_activated_cb(self, flip_action):
"""Callback: mode "flip" action activated.
:param flip_action: the gtk.Action which was activated
Mode classes are looked up via `canvasevent.ModeRegistry` based on the
name of the action: flip actions are named after the RadioActions they
nominally control, with "Flip" prepended. Activating a FlipAction has
the effect of flipping a mode off if it is currently active, or on if
another mode is active. Mode flip actions are the usual actions bound
to keypresses since being able to toggle off with the same key is
useful.
Because these modes are intended for keyboard activation, they are
instructed to ignore the initial keyboard modifier state when entered.
See also: `canvasevent.SpringLoadedModeMixin`.
"""
flip_action_name = flip_action.get_name()
assert flip_action_name.startswith("Flip")
# Find the corresponding gtk.RadioAction
action_name = flip_action_name.replace("Flip", "", 1)
mode_class = canvasevent.ModeRegistry.get_mode_class(action_name)
if mode_class is None:
warn('"%s" not registered: check imports' % action_name, Warning)
return
# If a mode object of this exact class is active, pop the stack.
# Otherwise, instantiate and enter.
if self.modes.top.__class__ is mode_class:
self.modes.pop()
flip_action.keyup_callback = lambda *a: None # suppress repeats
else:
mode = mode_class(ignore_modifiers=True)
if flip_action.keydown:
flip_action.__pressed = True
# Change what happens on a key-up after a short while.
# Distinguishes long presses from short.
timeout = getattr(mode, "keyup_timeout", 500)
cb = self._modeflip_change_keyup_callback
ev = gtk.get_current_event()
if ev is not None:
ev = ev.copy()
if timeout > 0:
# Queue a change of key-up callback after the timeout
gobject.timeout_add(timeout, cb, mode, flip_action, ev)
def _continue_mode_early_keyup_cb(*a):
# Record early keyup, but otherwise keep in mode
flip_action.__pressed = False
flip_action.keyup_callback = _continue_mode_early_keyup_cb
else:
# Key-up exits immediately
def _exit_mode_early_keyup_cb(*a):
if mode is self.modes.top:
self.modes.pop()
flip_action.keyup_callback = _exit_mode_early_keyup_cb
self.modes.context_push(mode)
def begin_move():
global header_button_down, header_button_down_x, header_button_down_y
event = gtk.get_current_event()
window.begin_move_drag(1,
int(round(0.5 + event.x_root)), int(round(event.y_root)),
event.time)
def add_event_clicked_callback(self, button):
""" Add event button pressed. """
menu = self.__addEventMenu
x, y = self.__get_widget_xy_position(button, menu)
self.__toggle_window_close()
event = gtk.get_current_event()
menu.popup(None, None, lambda menu: (x, y, True), event.button, event.time)
def image_button_clicked(button):
event=gtk.get_current_event()
if event.state & gtk.gdk.CONTROL_MASK:
self.use_current_position(button)
return True
else:
self.play_from_here(button)
return True
def _popup_menu_selected(self, menuitem, togglebutton, action, keyword):
event = gtk.get_current_event()
allow_similar = False
if (event.state & gtk.gdk.CONTROL_MASK
or event.state & gtk.gdk.MOD1_MASK):
allow_similar = True
with Window(hide_current=True, allow_similar=allow_similar):
self._action(action, keyword)
togglebutton.props.active = False
def _popup_menu_selected(self, menuitem, togglebutton, action, keyword):
event = gtk.get_current_event()
allow_similar = False
if (event.state & gtk.gdk.CONTROL_MASK
or event.state & gtk.gdk.MOD1_MASK):
allow_similar = True
with Window(hide_current=True, allow_similar=allow_similar):
self._action(action, keyword)
togglebutton.props.active = False
def popup_pan_menu(self, tv, event=None, *args):
debug("popup_pan_menu (self, tv, *args):", 5)
self.tv = tv
if not event:
event = gtk.get_current_event()
t = (event and hasattr(event, 'time') and getattr(event, 'time') or 0)
btn = (event and hasattr(event, 'button') and getattr(event, 'button')
or 0)
self.panpop.popup(None, None, None, btn, t)
return True
def _action_favorite(widget, id_):
event = gtk.get_current_event()
allow_similar = (event.state & gtk.gdk.MOD1_MASK
or event.state & gtk.gdk.SHIFT_MASK)
with Window(allow_similar=allow_similar):
# ids is not defined to prevent to add suffix
Action.exec_keyword('tree_open', {
'model': self.menu_screen.model_name,
'id': id_,
})
def activate(menuitem, action, atype):
rec = load(record)
action = Action.evaluate(action, atype, rec)
data = {"model": model, "id": rec.id, "ids": [rec.id]}
event = gtk.get_current_event()
allow_similar = False
if event.state & gtk.gdk.CONTROL_MASK or event.state & gtk.gdk.MOD1_MASK:
allow_similar = True
with Window(hide_current=True, allow_similar=allow_similar):
Action._exec_action(action, data, {})
def popup_pan_menu (self, tv, event=None, *args):
debug("popup_pan_menu (self, tv, *args):",5)
self.tv = tv
if not event:
event = gtk.get_current_event()
t = (event and hasattr(event,'time') and getattr(event,'time')
or 0)
btn = (event and hasattr(event,'button') and getattr(event,'button')
or 0)
self.panpop.popup(None,None,None,btn,t)
return True
def __sig_switch(self, treeview, path, column):
if column._type == 'button':
return
allow_similar = False
event = gtk.get_current_event()
if (event.state & gtk.gdk.MOD1_MASK
or event.state & gtk.gdk.SHIFT_MASK):
allow_similar = True
with Window(allow_similar=allow_similar):
if not self.screen.row_activate() and self.children_field:
if treeview.row_expanded(path):
treeview.collapse_row(path)
else:
treeview.expand_row(path, False)
def __sig_switch(self, treeview, path, column):
if column._type == 'button':
return
allow_similar = False
event = gtk.get_current_event()
if (event.state & gtk.gdk.MOD1_MASK
or event.state & gtk.gdk.SHIFT_MASK):
allow_similar = True
with Window(allow_similar=allow_similar):
if not self.screen.row_activate() and self.children_field:
if treeview.row_expanded(path):
treeview.collapse_row(path)
else:
treeview.expand_row(path, False)
def icon_clicked(self, widget):
event = gtk.get_current_event()
#Dialog mode
if self.client.get_int(group, 'mode') == 0:
if self.dialog.flags() & gtk.VISIBLE:
self.dialog.hide()
else:
self.dialog_config(event.button)
#Docklet mode
else:
self.dialog_config(event.button)
def activate(menuitem, action, atype):
rec = load(record)
action = Action.evaluate(action, atype, rec)
data = {
'model': model,
'id': rec.id,
'ids': [rec.id],
}
event = gtk.get_current_event()
allow_similar = False
if (event.state & gtk.gdk.CONTROL_MASK
or event.state & gtk.gdk.MOD1_MASK):
allow_similar = True
with Window(hide_current=True, allow_similar=allow_similar):
Action._exec_action(action, data, rec.get_context())
def on_click(self, obj, event=None):
if not event:
event = gtk.get_current_event()
if event.button < 3:
if not self.init:
button = self.left
if event.button == 2:
button = self.middle
if button == 1:
self.popup_gtk_menu(self.gtk['umenu'], 0, event.time)
return True
elif button < 3:
self.change_group(button - 1)
else:
self.popup_gtk_menu(self.cmenu, 0, event.time)
return True
return False
def validate_and_next(self, new):
"""Validate the current annotation and display the next one.
"""
i = self.index
annotation = self.annotations[i]
batch=object()
event = gtk.get_current_event()
if event.state & gtk.gdk.CONTROL_MASK:
# Control-key is held. Split the annotation.
if new > annotation.fragment.begin and new < annotation.fragment.end:
self.controller.split_annotation(annotation, new)
self.message(_("Split annotation #%(current)d into #%(current)d and #%(next)d") % {
'current': i + 1,
'next': i + 2
})
else:
self.message(_("Cannot split annotation #%(current)d: out of bounds.") % {
'current': i + 1,
})
return True
if new != annotation.fragment.begin:
self.controller.notify('EditSessionStart', element=annotation, immediate=True)
annotation.fragment.begin = new
self.controller.notify('AnnotationEditEnd', annotation=annotation, batch=batch)
self.controller.notify('EditSessionEnd', element=annotation)
self.undo_button.set_sensitive(True)
# Update previous annotation end.
if i > 0:
annotation = self.annotations[i - 1]
if new != annotation.fragment.end:
self.controller.notify('EditSessionStart', element=annotation, immediate=True)
annotation.fragment.end = new
self.controller.notify('AnnotationEditEnd', annotation=annotation, batch=batch)
self.controller.notify('EditSessionEnd', element=annotation)
self.message(_("Changed cut between #%(first)d and %(second)d") % { 'first': i + 1,
'second': i + 2 })
else:
self.message(_("Changed begin time for first annotation"))
self.set_index(i + 1)
return True
def on_left_click(self, icon):
event = gtk.get_current_event()
volumes = self.monitor.get_volumes()
pprint(volumes)
popup = gtk.Menu()
for volume in volumes:
pprint(
dict((i, volume.get_identifier(i))
for i in volume.enumerate_identifiers()))
if self.is_internal(volume):
continue
menu = gtk.MenuItem(volume.get_name() + ' (' +
volume.get_drive().get_name() + ')')
submenu = gtk.Menu()
menu.set_submenu(submenu)
popup.append(menu)
# XXX: Show something if `not volume.can_mount`.
if volume.get_mount() is None:
submenu.append(self.mk_menu_item('Mount', self.mount, volume))
submenu.append(
self.mk_menu_item('Mount and Open', self.mount_and_open,
volume))
else:
submenu.append(
self.mk_menu_item('Open', self.open_volume, volume))
submenu.append(
self.mk_menu_item('Unmount', self.unmount, volume))
if len(popup) == 0:
dummy_item = gtk.MenuItem('No volumes detected')
dummy_item.set_sensitive(False)
popup.add(dummy_item)
popup.show_all()
popup.popup(None, None, gtk.status_icon_position_menu, event.button,
event.time, icon)
def action_keyword(self, ids):
if not ids:
return
ctx = self.group.context.copy()
if 'active_ids' in ctx:
del ctx['active_ids']
if 'active_id' in ctx:
del ctx['active_id']
event = gtk.get_current_event()
allow_similar = False
if (event.state & gtk.gdk.CONTROL_MASK
or event.state & gtk.gdk.MOD1_MASK):
allow_similar = True
with Window(hide_current=True, allow_similar=allow_similar):
return Action.exec_keyword('graph_open', {
'model': self.model,
'id': ids[0],
'ids': ids,
}, context=ctx, warning=False)
def action_keyword(self, ids):
if not ids:
return
ctx = self.group._context.copy()
if 'active_ids' in ctx:
del ctx['active_ids']
if 'active_id' in ctx:
del ctx['active_id']
event = gtk.get_current_event()
allow_similar = False
if (event.state & gtk.gdk.CONTROL_MASK
or event.state & gtk.gdk.MOD1_MASK):
allow_similar = True
with Window(hide_current=True, allow_similar=allow_similar):
return Action.exec_keyword('graph_open', {
'model': self.model,
'id': ids[0],
'ids': ids,
}, context=ctx, warning=False)
def __show_main_menu(self, widget):
global settings
menu = gtk.Menu()
menu_item = gtk.ImageMenuItem(gtk.STOCK_ADD)
menu_item.connect("activate", self.__edit_file, os.path.join(settings.get_notes_dir(), "index.muse"))
menu.append(menu_item)
menu_item = gtk.SeparatorMenuItem()
menu.append(menu_item)
wiki_list.update_wiki_list()
file_list = wiki_list.get_wiki_list()
length = len(file_list)
max_menu_item = settings.max_main_menu_item
if length > max_menu_item:
length = 10
for fname in file_list[0:length]:
wiki = MuseWiki(fname)
item_label = wiki.get_title()
menu_item = gtk.MenuItem(item_label)
menu_item.connect("activate", self.__view_file, fname)
menu.append(menu_item)
if len(file_list) > max_menu_item:
sub_menu = gtk.Menu()
for fname in file_list[max_menu_item:len(file_list)]:
wiki = MuseWiki(fname)
item_label = wiki.get_title()
menu_item = gtk.MenuItem(item_label)
menu_item.connect("activate", self.__view_file, fname)
sub_menu.append(menu_item)
menu_item = gtk.MenuItem(u"更多笔记")
menu_item.set_submenu(sub_menu)
menu.append(menu_item)
menu_item = gtk.SeparatorMenuItem()
menu.append(menu_item)
menu_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
menu_item.connect("activate", self.__main_quit)
menu.append(menu_item)
menu.show_all()
event = gtk.get_current_event()
if event:
menu.popup(None, None, gtk.status_icon_position_menu,
event.button, event.time, widget)
def on_left_click(self, icon):
event = gtk.get_current_event()
volumes = self.monitor.get_volumes()
pprint(volumes)
popup = gtk.Menu()
for volume in volumes:
pprint(dict((i, volume.get_identifier(i))
for i in volume.enumerate_identifiers()))
if self.is_internal(volume):
continue
menu = gtk.MenuItem(volume.get_name() +
' (' + volume.get_drive().get_name() + ')')
submenu = gtk.Menu()
menu.set_submenu(submenu)
popup.append(menu)
# XXX: Show something if `not volume.can_mount`.
if volume.get_mount() is None:
submenu.append(self.mk_menu_item('Mount', self.mount, volume))
submenu.append(self.mk_menu_item('Mount and Open',
self.mount_and_open, volume))
else:
submenu.append(
self.mk_menu_item('Open', self.open_volume, volume))
submenu.append(
self.mk_menu_item('Unmount', self.unmount, volume))
if len(popup) == 0:
dummy_item = gtk.MenuItem('No volumes detected')
dummy_item.set_sensitive(False)
popup.add(dummy_item)
popup.show_all()
popup.popup(None, None, gtk.status_icon_position_menu, event.button,
event.time, icon)
def activate(self, text=None):
if self._window.is_active():
return
try:
time = gtk.get_current_event().time
except:
LOGGER.warning("Using bogus timestamp.")
time = gtk.get_current_event_time()
workspace = self._window.get_workspace()
if workspace != None and workspace.is_virtual():
if not self._window.is_in_viewport(workspace):
pos_x = workspace.get_viewport_x() + self._window.get_geometry()[0]
pos_y = workspace.get_viewport_y() + self._window.get_geometry()[1]
self._window.get_screen().move_viewport(pos_x, pos_y)
if hasattr(self._window.get_workspace(), 'activate') and self._window.get_workspace() != self._window.get_screen().get_active_workspace():
self._window.get_workspace().activate(time)
self._window.activate(time)
def _changed(self, editable):
"""
The entry changed callback: Here we have to be sure to use
**UNICODE** (unicode()) for the entered text
"""
# @text is UTF-8
text = editable.get_text()
text = text.decode("UTF-8")
if not text:
self.data_controller.cancel_search()
# See if it was a deleting key press
curev = gtk.get_current_event()
if curev and curev.keyval in (self.key_book["Delete"],
self.key_book["BackSpace"]):
self._back_key_press()
return
pane = self._pane_for_widget(self.current)
if not self.get_in_text_mode() and self._reset_to_toplevel:
self.soft_reset(pane)
self.data_controller.search(pane, key=text, context=text,
text_mode=self.get_in_text_mode())
def _force_drag_start(self):
# Attempt to force a drag to start, using the current event.
# XXX: This is only used by the picker mode, which needs to begin
# picking straight away in enter even if this is in response to an
# action activation.
event = gtk.get_current_event()
if event is None:
logger.warning("no event")
return
if self.in_drag:
return
tdw = self.doc.tdw
# Duck-profile the starting event. If it's a keypress event or a
# button-press event, or anything that quacks like those, we can
# attempt the grab and start the drag if it succeeded.
if hasattr(event, "keyval"):
if event.keyval != self._start_keyval:
self._start_keyval = event.keyval
self._start_drag(tdw, event)
elif (hasattr(event, "x") and hasattr(event, "y")
and hasattr(event, "button")):
self._start_drag(tdw, event)
if self.in_drag:
# Grab succeeded
self.last_x = event.x
self.last_y = event.y
# For the toolbar button, and for menus, it's a button-release
# event.
# Record which button is being pressed at start
if isinstance(event.button, int):
# PyGTK supplies the actual button number ...
self._start_button = event.button
else:
# ... but GI+GTK3 supplies a <void at 0xNNNNNNNN> object
# when the event comes from gtk.get_current_event() :(
self._start_button = None
def _force_drag_start(self):
# Attempt to force a drag to start, using the current event.
# XXX: This is only used by the picker mode, which needs to begin
# picking straight away in enter even if this is in response to an
# action activation.
event = gtk.get_current_event()
if event is None:
logger.warning("no event")
return
if self.in_drag:
return
tdw = self.doc.tdw
# Duck-profile the starting event. If it's a keypress event or a
# button-press event, or anything that quacks like those, we can
# attempt the grab and start the drag if it succeeded.
if hasattr(event, "keyval"):
if event.keyval != self._start_keyval:
self._start_keyval = event.keyval
self._start_drag(tdw, event)
elif (hasattr(event, "x") and hasattr(event, "y")
and hasattr(event, "button")):
self._start_drag(tdw, event)
if self.in_drag:
# Grab succeeded
self.last_x = event.x
self.last_y = event.y
# For the toolbar button, and for menus, it's a button-release
# event.
# Record which button is being pressed at start
if isinstance(event.button, int):
# PyGTK supplies the actual button number ...
self._start_button = event.button
else:
# ... but GI+GTK3 supplies a <void at 0xNNNNNNNN> object
# when the event comes from gtk.get_current_event() :(
self._start_button = None
def begin_resize(*args):
event = gtk.get_current_event()
window.begin_resize_drag(gtk.gdk.WINDOW_EDGE_SOUTH,
event.button,
int(round(0.5 + event.x_root)), int(round(event.y_root)),
event.time)
def __init__(self, obj, name, args):
SignalEvent.__init__(self, obj, name, args)
ev = gtk.get_current_event()
self.x = ev.x
self.y = ev.y
def __init__(self, obj, name, args):
SignalEvent.__init__(self, obj, name, args)
ev = gtk.get_current_event()
self.x = ev.x
self.y = ev.y
