class AtspiAutoShow(object):
"""
Auto-show and hide Onboard based on at-spi focus events.
"""
# Delay from the last focus event until the keyboard is shown/hidden.
# Raise it to reduce unnecessary transitions (flickering).
# Lower it for more immediate reactions.
SHOW_REACTION_TIME = 0.0
HIDE_REACTION_TIME = 0.3
_atspi_listeners_registered = False
_focused_accessible = None
_lock_visible = False
_frozen = False
_keyboard_widget = None
def __init__(self, keyboard_widget):
self._keyboard_widget = keyboard_widget
self._auto_show_timer = Timer()
self._thaw_timer = Timer()
def cleanup(self):
self._register_atspi_listeners(False)
self._auto_show_timer.stop()
self._thaw_timer.stop()
def enable(self, enable):
self._register_atspi_listeners(enable)
if enable:
self._lock_visible = False
self._frozen = False
def is_frozen(self):
return self._frozen
def freeze(self, thaw_time = None):
"""
Stop showing and hiding the keyboard window.
thaw_time in seconds, None to freeze forever.
"""
self._frozen = True
self._thaw_timer.stop()
if not thaw_time is None:
self._thaw_timer.start(thaw_time, self._on_thaw)
# Discard pending hide/show actions.
self._auto_show_timer.stop()
def thaw(self, thaw_time = None):
"""
Allow hiding and showing the keyboard window again.
thaw_time in seconds, None to thaw immediately.
"""
self._thaw_timer.stop()
if thaw_time is None:
self._thaw()
else:
self._thaw_timer.start(thaw_time, self._on_thaw)
def _on_thaw(self):
self._thaw_timer.stop()
self._frozen = False
return False
def lock_visible(self, lock, thaw_time = 1.0):
"""
Lock window permanetly visible in response to the user showing it.
Optionally freeze hiding/showing for a limited time.
"""
# Permanently lock visible.
self._lock_visible = lock
# Temporarily stop showing/hiding.
if thaw_time:
self.freeze(thaw_time)
# Leave the window in its current state,
# discard pending hide/show actions.
self._auto_show_timer.stop()
def _register_atspi_listeners(self, register = True):
if not "Atspi" in globals():
return
if register:
#"bounds_changed"
if not self._atspi_listeners_registered:
self.atspi_connect("_listener_focus",
"focus",
self._on_atspi_global_focus)
self.atspi_connect("_listener_object_focus",
"object:state-changed:focused",
self._on_atspi_object_focus)
self.atspi_connect("_listener_caret_moved",
"object:text-caret-moved",
self._on_atspi_caret_moved)
else:
if self._atspi_listeners_registered:
self.atspi_disconnect("_listener_focus",
"focus")
self.atspi_disconnect("_listener_object_focus",
"object:state-changed:focused")
self.atspi_disconnect("_listener_caret_moved",
"object:text-caret-moved")
self._atspi_listeners_registered = register
def atspi_connect(self, attribute, event, callback):
"""
Start listening to an AT-SPI event.
Creates a new event listener for each event, since this seems
to be the only way to allow reliable deregistering of events.
"""
if hasattr(self, attribute):
listener = getattr(self, attribute)
else:
listener = None
if listener is None:
listener = Atspi.EventListener.new(callback, None)
setattr(self, attribute, listener)
listener.register(event)
def atspi_disconnect(self, attribute, event):
"""
Stop listening to AT-SPI event.
"""
listener = getattr(self, attribute)
listener.deregister(event)
def _on_atspi_caret_moved(self, event, user_data):
"""
Show the keyboard on click of an already focused text entry
(LP: 1078602). Do this only for single line text entries to
still allow clicking longer documents without having onboard show up.
"""
if config.auto_show_enabled and \
not self._keyboard_widget.is_visible():
if event.source is self._focused_accessible:
accessible = event.source
try:
state = accessible.get_state_set()
except: # private exception gi._glib.GError when gedit became unresponsive
_logger.warning("AtspiAutoShow: Invalid accessible,"
" failed to get state set")
return
if state.contains(Atspi.StateType.SINGLE_LINE):
self._on_atspi_focus(event, True)
def _on_atspi_global_focus(self, event, user_data):
self._on_atspi_focus(event, True)
def _on_atspi_object_focus(self, event, user_data):
self._on_atspi_focus(event)
def _on_atspi_focus(self, event, focus_received = False):
if config.auto_show_enabled:
accessible = event.source
focused = bool(focus_received) or bool(event.detail1) # received focus?
self._log_accessible(accessible, focused)
if accessible:
window = self._keyboard_widget.get_kbd_window()
editable = self._is_accessible_editable(accessible)
visible = focused and editable
show = visible
if focused:
self._focused_accessible = accessible
elif not focused and self._focused_accessible == accessible:
self._focused_accessible = None
else:
show = None
# show/hide the window
if not show is None:
# Always allow to show the window even when locked.
# Mitigates right click on unity-2d launcher hiding
# onboard before _lock_visible is set (Precise).
if self._lock_visible:
show = True
if not self.is_frozen():
self.show_keyboard(show)
# The active accessible changed, stop trying to
# track the position of the previous one.
# -> less erratic movement during quick focus changes
if window:
window.stop_auto_position()
# reposition the keyboard window
if show and \
self._focused_accessible and \
not self._lock_visible and \
not self.is_frozen():
if window:
window.auto_position()
def show_keyboard(self, show):
""" Begin AUTO_SHOW or AUTO_HIDE transition """
# Don't act on each and every focus message. Delay the start
# of the transition slightly so that only the last of a bunch of
# focus messages is acted on.
delay = self.SHOW_REACTION_TIME if show else \
self.HIDE_REACTION_TIME
self._auto_show_timer.start(delay, self._begin_transition, show)
def _begin_transition(self, show):
self._keyboard_widget.transition_visible_to(show)
self._keyboard_widget.commit_transition()
return False
def get_repositioned_window_rect(self, home, limit_rects,
test_clearance, move_clearance,
horizontal = True, vertical = True):
"""
Get the alternative window rect suggested by auto-show or None if
no repositioning is required.
"""
accessible = self._focused_accessible
if accessible:
try:
ext = accessible.get_extents(Atspi.CoordType.SCREEN)
except: # private exception gi._glib.GError when
# right clicking onboards unity2d launcher (Precise)
_logger.info("AtspiAutoHide: Invalid accessible,"
" failed to get extents")
return None
rect = Rect(ext.x, ext.y, ext.width, ext.height)
if not rect.is_empty() and \
not self._lock_visible:
return self._get_window_rect_for_accessible_rect( \
home, rect, limit_rects,
test_clearance, move_clearance,
horizontal, vertical)
return None
def _get_window_rect_for_accessible_rect(self, home, rect, limit_rects,
test_clearance, move_clearance,
horizontal = True, vertical = True):
"""
Find new window position based on the screen rect of the accessible.
"""
mode = "nooverlap"
x = y = None
if mode == "closest":
x, y = rect.left(), rect.bottom()
if mode == "nooverlap":
x, y = self._find_non_occluding_position(home, rect, limit_rects,
test_clearance, move_clearance,
horizontal, vertical)
if not x is None:
return Rect(x, y, home.w, home.h)
else:
return None
def _find_non_occluding_position(self, home, acc_rect, limit_rects,
test_clearance, move_clearance,
horizontal = True, vertical = True):
# The home_rect doesn't include window decoration,
# make sure to add decoration for correct clearance.
rh = home.copy()
window = self._keyboard_widget.get_kbd_window()
if window:
offset = window.get_client_offset()
rh.w += offset[0]
rh.h += offset[1]
# Leave some clearance around the accessible to account for
# window frames and position errors of firefox entries.
ra = acc_rect.apply_border(*test_clearance)
if rh.intersects(ra):
# Leave a different clearance for the new to be found positions.
ra = acc_rect.apply_border(*move_clearance)
x, y = rh.get_position()
# candidate positions
vp = []
if horizontal:
vp.append([ra.left() - rh.w, y])
vp.append([ra.right(), y])
if vertical:
vp.append([x, ra.top() - rh.h])
vp.append([x, ra.bottom()])
# limited, non-intersecting candidate rectangles
vr = []
for p in vp:
pl = self._keyboard_widget.limit_position( p[0], p[1],
self._keyboard_widget.canvas_rect,
limit_rects)
r = Rect(pl[0], pl[1], rh.w, rh.h)
if not r.intersects(ra):
vr.append(r)
# candidate with smallest center-to-center distance wins
chx, chy = rh.get_center()
dmin = None
rmin = None
for r in vr:
cx, cy = r.get_center()
dx, dy = cx - chx, cy - chy
d2 = dx * dx + dy * dy
if dmin is None or dmin > d2:
dmin = d2
rmin = r
if not rmin is None:
return rmin.get_position()
return None, None
def _is_accessible_editable(self, accessible):
""" Is this an accessible onboard should be shown for? """
try:
role = accessible.get_role()
state = accessible.get_state_set()
except: # private exception gi._glib.GError when gedit became unresponsive
_logger.info("AtspiAutoHide: Invalid accessible,"
" failed to get role and state set")
return False
if role in [Atspi.Role.TEXT,
Atspi.Role.TERMINAL,
Atspi.Role.DATE_EDITOR,
Atspi.Role.PASSWORD_TEXT,
Atspi.Role.EDITBAR,
Atspi.Role.ENTRY,
Atspi.Role.DOCUMENT_TEXT,
Atspi.Role.DOCUMENT_FRAME,
Atspi.Role.DOCUMENT_EMAIL,
Atspi.Role.SPIN_BUTTON,
Atspi.Role.COMBO_BOX,
Atspi.Role.DATE_EDITOR,
Atspi.Role.PARAGRAPH, # LibreOffice Writer
Atspi.Role.HEADER,
Atspi.Role.FOOTER,
]:
if role in [Atspi.Role.TERMINAL] or \
state.contains(Atspi.StateType.EDITABLE):
return True
return False
def _log_accessible(self, accessible, focused):
if _logger.isEnabledFor(logging.DEBUG):
msg = "At-spi focus event: focused={}, ".format(focused)
if not accessible:
msg += "accessible={}".format(accessible)
else:
name = None
role = None
role_name = None
states = None
editable = None
extents = None
try:
name = accessible.get_name()
role = accessible.get_role()
role_name = accessible.get_role_name()
state_set = accessible.get_state_set()
states = state_set.states
editable = state_set.contains(Atspi.StateType.EDITABLE) \
if state_set else None
ext = accessible.get_extents(Atspi.CoordType.SCREEN)
extents = Rect(ext.x, ext.y, ext.width, ext.height)
except: # private exception gi._glib.GError when gedit became unresponsive
pass
msg += "name={name}, role={role}({role_name}), " \
"editable={editable}, states={states}, " \
"extents={extents}]" \
.format(name=name,
role = role,
role_name = role_name,
editable = editable,
states = states,
extents = extents \
)
_logger.debug(msg)
class WindowRectTracker:
"""
Keeps track of the window rectangle when moving/resizing.
Gtk only updates the position and size asynchrounously on
configure events and hidden windows return invalid values.
Auto-show et al need valid values from get_position and
get_size at all times.
"""
def __init__(self):
self._window_rect = None
self._origin = None
self._client_offset = (0, 0)
self._screen_orientation = None
self._save_position_timer = Timer()
# init detection of screen "rotation"
screen = self.get_screen()
screen.connect('size-changed', self.on_screen_size_changed)
def cleanup(self):
self._save_position_timer.finish()
def move(self, x, y):
"""
Overload Gtk.Window.move to reliably keep track of
the window position.
"""
Gtk.Window.move(self, x, y)
def resize(self, w, h):
"""
Overload Gtk.Window.size to reliably keep track of
the window size.
"""
Gtk.Window.resize(self, w, h)
def move_resize(self, x, y, w, h):
win = self.get_window()
if win:
win.move_resize(x, y, w, h)
def get_position(self):
if self._window_rect is None:
return Gtk.Window.get_position(self)
else:
return self._window_rect.get_position()
def get_size(self):
if self._window_rect is None:
return Gtk.Window.get_size(self)
else:
return self._window_rect.get_size()
def get_origin(self):
if self._origin is None:
origin = self.get_window().get_origin()
if len(origin) == 3: # What is the first parameter for? Gdk bug?
origin = origin[1:]
return origin
else:
return self._origin
def get_client_offset(self):
return self._client_offset
def get_rect(self):
return self._window_rect
def is_visible(self):
""" This is overloaded in KbdWindow """
return Gtk.Window.get_visible(self)
def on_screen_size_changed(self, screen):
""" detect screen rotation (tablets)"""
# Give the screen time to settle, the window manager
# may block the move to previously invalid positions and
# when docked the slide transition may be drowned out by all
# the action in other processes.
Timer(1.5, self.on_screen_size_changed_delayed, screen)
def on_screen_size_changed_delayed(self, screen):
self.restore_window_rect()
def get_screen_orientation(self):
"""
Current orientation of the screen (tablet rotation).
Only the aspect ratio is taken into account at this time.
This appears to cover more cases than looking at monitor rotation,
in particular with multi-monitor screens.
"""
screen = self.get_screen()
if screen.get_width() >= screen.get_height():
return Orientation.LANDSCAPE
else:
return Orientation.PORTRAIT
def update_window_rect(self):
"""
Call this on configure event, the only time when
get_position, get_size, etc. can be trusted.
"""
visible = self.is_visible()
if visible:
pos = Gtk.Window.get_position(self)
size = Gtk.Window.get_size(self)
origin = self.get_window().get_origin()
if len(origin) == 3: # What is the first parameter for? Gdk bug?
origin = origin[1:]
self._window_rect = Rect.from_position_size(pos, size)
self._origin = origin
self._client_offset = (origin[0] - pos[0], origin[1] - pos[1])
self._screen_orientation = self.get_screen_orientation()
def restore_window_rect(self, startup = False):
"""
Restore window size and position.
"""
# Run pending save operations now, so they don't
# interfere with the window rect after it was restored.
self._save_position_timer.finish()
orientation = self.get_screen_orientation()
rect = self.read_window_rect(orientation)
self._screen_orientation = orientation
self._window_rect = rect
_logger.debug("restore_window_rect {rect}, {orientation}" \
.format(rect = rect, orientation = orientation))
# Give the derived class a chance to modify the rect,
# for example to correct the position for auto-show.
rect = self.on_restore_window_rect(rect)
self._window_rect = rect
# move/resize the window
if startup:
# gnome-shell doesn't take kindly to an initial move_resize().
# The window ends up at (0, 0) on and goes back there
# repeatedly when hiding and unhiding.
self.set_default_size(rect.w, rect.h)
self.move(rect.x, rect.y)
else:
self.move_resize(rect.x, rect.y, rect.w, rect.h)
# Initialize shadow variables with valid values so they
# don't get taken from the unreliable window.
# Fixes bad positioning of the very first auto-show.
if startup:
self._window_rect = rect.copy()
# Ignore frame dimensions; still better than asking the window.
self._origin = rect.left_top()
self._screen_orientation = self.get_screen_orientation()
def on_restore_window_rect(self, rect):
return rect
def save_window_rect(self, orientation = None, rect = None):
"""
Save window size and position.
"""
if orientation is None:
orientation = self._screen_orientation
if rect is None:
rect = self._window_rect
# Give the derived class a chance to modify the rect,
# for example to override it for auto-show.
rect = self.on_save_window_rect(rect)
self.write_window_rect(orientation, rect)
_logger.debug("save_window_rect {rect}, {orientation}" \
.format(rect = rect, orientation = orientation))
def on_save_window_rect(self, rect):
return rect
def read_window_rect(self, orientation, rect):
"""
Read orientation dependent rect.
Overload this in derived classes.
"""
raise NotImplementedError()
def write_window_rect(self, orientation, rect):
"""
Write orientation dependent rect.
Overload this in derived classes.
"""
raise NotImplementedError()
def start_save_position_timer(self):
"""
Trigger saving position and size to gsettings
Delay this a few seconds to avoid excessive disk writes.
Remember the current rect and rotation as the screen may have been
rotated when the saving happens.
"""
self._save_position_timer.start(5, self.save_window_rect,
self.get_screen_orientation(),
self.get_rect())
def stop_save_position_timer(self):
self._save_position_timer.stop()
class KbdWindow(KbdWindowBase, WindowRectTracker, Gtk.Window):
# Minimum window size (for resizing in system mode, see handle_motion())
MINIMUM_SIZE = 20
home_rect = None
def __init__(self, keyboard_widget, icp):
self._last_ignore_configure_time = None
self._last_configures = []
Gtk.Window.__init__(self,
urgency_hint = False,
width_request=self.MINIMUM_SIZE,
height_request=self.MINIMUM_SIZE)
KbdWindowBase.__init__(self, keyboard_widget, icp)
WindowRectTracker.__init__(self)
GObject.signal_new("quit-onboard", KbdWindow,
GObject.SIGNAL_RUN_LAST,
GObject.TYPE_BOOLEAN, ())
self._auto_position_poll_timer = Timer()
self.restore_window_rect(startup = True)
self.connect("map", self._on_map_event)
self.connect("unmap", self._on_unmap_event)
self.connect("delete-event", self._on_delete_event)
self.connect("configure-event", self._on_configure_event)
# Connect_after seems broken in Quantal, the callback is never called.
#self.connect_after("configure-event", self._on_configure_event_after)
self._osk_util.connect_root_property_notify(["_NET_WORKAREA"],
self._on_root_property_notify)
once = CallOnce(100).enqueue # call at most once per 100ms
if 0: #FIXME
rect_changed = lambda x: once(self._on_config_rect_changed)
config.window.position_notify_add(rect_changed)
config.window.size_notify_add(rect_changed)
dock_size_changed = lambda x: once(self._on_config_dock_size_changed)
config.window.dock_size_notify_add(dock_size_changed)
def cleanup(self):
WindowRectTracker.cleanup(self)
KbdWindowBase.cleanup(self)
if self.icp:
self.icp.cleanup()
self.icp.destroy()
self.icp = None
def _on_root_property_notify(self, property):
""" Fixme: Exceptions get lost in here."""
if property == "_NET_WORKAREA" and \
config.is_docking_enabled() and \
not config.xid_mode:
mon = self.get_docking_monitor()
new_area = self.get_monitor_workarea()
area = self._monitor_workarea.get(0)
if area:
# Only check for x changes, y is too dangerous for now,
# too easy to get the timing wrong and end up with double docks.
if area.x != new_area.x or \
area.w != new_area.w:
area.x = new_area.x
area.w = new_area.w
_logger.info("workarea changed to {}, "
"using {} for docking." \
.format(str(new_area), str(area)))
self.update_docking()
def _on_map_event(self, user_data):
pass
def _on_unmap_event(self, user_data):
# Turn off struts in case this unmap is in response to
# changes in window options, force-to-top in particular.
if config.is_docking_enabled():
self.clear_struts()
# untity starts onboard before the desktops
# workarea has settled, reset it here on hiding,
# as we know our struts are gone from this point.
self.reset_monitor_workarea()
def on_visibility_changed(self, visible):
if not self._visible and visible and \
not config.is_docking_enabled() and \
not config.xid_mode:
rect = self.get_current_rect()
if not rect is None: # shouldn't happen, fix this later
self.move_resize(*rect) # sync position
KbdWindowBase.on_visibility_changed(self, visible)
def _on_config_rect_changed(self):
""" Gsettings position or size changed """
if not config.xid_mode and \
not config.is_docking_enabled():
orientation = self.get_screen_orientation()
rect = self.read_window_rect(orientation)
# Only apply the new rect if it isn't the one we just wrote to
# gsettings. Someone has to have manually changed the values
# in gsettings to allow moving the window.
rects = list(self._written_window_rects.values())
if not any(rect == r for r in rects):
self.restore_window_rect()
def _on_config_dock_size_changed(self):
""" Gsettings size changed """
if not config.xid_mode and \
config.is_docking_enabled():
size = self.get_dock_size()
# Only apply the new rect if it isn't the one we just wrote to
# gsettings. Someone has to have manually changed the values
# in gsettings to allow moving the window.
sizes = list(self._written_dock_sizes.values())
if not any(size == sz for sz in sizes):
self.restore_window_rect()
def on_user_positioning_begin(self):
self.stop_save_position_timer()
self.keyboard_widget.freeze_auto_show()
def on_user_positioning_done(self):
self.update_window_rect()
#self.detect_docking()
if config.is_docking_enabled():
self.write_docking_size(self.get_screen_orientation(),
self.get_size())
self.update_docking()
else:
self.update_home_rect()
# Thaw auto show after a short delay to stop the window
# from hiding due to spurios focus events after a system resize.
self.keyboard_widget.thaw_auto_show(1.0)
def detect_docking(self):
if self.keyboard_widget.was_moving():
config.window.docking_enabled = False
def _on_configure_event(self, widget, event):
self.update_window_rect()
if not config.is_docking_enabled():
# Connect_after seems broken in Quantal, but we still need to
# get in after the default configure handler is done. Try to run
# _on_configure_event_after in an idle handler instead.
GLib.idle_add(self._on_configure_event_after, widget, event.copy())
def _on_configure_event_after(self, widget, event):
"""
Run this after KeyboardWidget's configure handler.
After resizing Keyboard.update_layout() has to be called before
limit_position() or the window jumps when it was close
to the opposite screen edge of the resize handle.
"""
# Configure event due to user positioning?
result = self._filter_configure_event(self._window_rect)
if result == 0:
self.update_home_rect()
def _filter_configure_event(self, rect):
"""
Returns 0 for detected user positioning/sizing.
Multiple defenses against false positives, i.e.
window movement by autoshow, screen rotation, whathaveyou.
"""
# There is no user positioning in xembed mode.
if config.xid_mode:
return -1
# There is no system provided way to move/resize in
# force-to-top mode. Solely rely on on_user_positioning_done().
if config.is_force_to_top():
return -2
# There is no user positioning for invisible windows.
if not self.is_visible():
return -3
# There is no user positioning for iconified windows.
if self.is_iconified():
return -4
# There is no user positioning for maximized windows.
if self.is_maximized():
return -5
# Remember past n configure events.
now = time.time()
max_events = 4
self._last_configures = self._last_configures[-(max_events - 1):]
# Same rect as before?
if len(self._last_configures) and \
self._last_configures[-1][0] == rect:
return 1
self._last_configures.append([rect, now])
# Only just started?
if len(self._last_configures) < max_events:
return 2
# Did we just move the window by auto-show?
if not self._last_ignore_configure_time is None and \
time.time() - self._last_ignore_configure_time < 0.5:
return 3
# Is the new window rect one of our known ones?
if self.is_known_rect(self._window_rect):
return 4
# Dragging the decorated frame doesn't produce continous
# configure-events anymore as in Oneriric (Precise).
# Disable all affected checks based on this.
# The home rect will probably get lost occasionally.
if not config.has_window_decoration():
# Less than n configure events in the last x seconds?
first = self._last_configures[0]
intervall = now - first[1]
if intervall > 1.0:
return 5
# Is there a jump > threshold in past positions?
r0 = self._last_configures[-1][0]
r1 = self._last_configures[-2][0]
dx = r1.x - r0.x
dy = r1.y - r0.y
d2 = dx * dx + dy * dy
if d2 > 50**2:
self._last_configures = [] # restart
return 6
return 0
def ignore_configure_events(self):
self._last_ignore_configure_time = time.time()
def remember_rect(self, rect):
"""
Remember the last 3 rectangles of auto-show repositioning.
Time and order of configure events is somewhat unpredictable,
so don't rely only on a single remembered rect.
"""
self._known_window_rects = self._known_window_rects[-3:]
self._known_window_rects.append(rect)
# Remembering the rects doesn't help if respositioning outside
# of the work area in compiz with force-to-top mode disabled.
# WM corrects window positions to fit into the viewable area.
# -> add timing based block
self.ignore_configure_events()
def get_known_rects(self):
"""
Return all rects that may have resulted from internal
window moves, not from user controlled drag operations.
"""
rects = list(self._known_window_rects)
co = config.window.landscape
rects.append(Rect(co.x, co.y, co.width, co.height))
co = config.window.portrait
rects.append(Rect(co.x, co.y, co.width, co.height))
rects.append(self.home_rect)
return rects
def is_known_rect(self, rect):
"""
The home rect should be updated in response to user positiong/resizing.
However we are unable to detect the end of window movement/resizing
when window decoration is enabled. Instead we check if the current
window rect is different from the ones auto-show knows and assume
the user has changed it in this case.
"""
return any(rect == r for r in self.get_known_rects())
def move_home_rect_into_view(self):
"""
Make sure the home rect is valid, move it if necessary.
This function may be called even if the window is invisible.
"""
rect = self._window_rect.copy()
x, y = rect.x, rect.y
_x, _y = self.keyboard_widget.limit_position(x, y)
if _x != x or _y != y:
self.update_home_rect()
def update_home_rect(self):
if config.is_docking_enabled():
return
# update home rect
rect = self._window_rect.copy()
# Make sure the move button stays visible
if self.can_move_into_view():
rect.x, rect.y = self.keyboard_widget.limit_position(rect.x, rect.y)
self.home_rect = rect.copy()
#self.start_save_position_timer()
# Make transitions aware of the new position,
# undoubtedly reached by user positioning.
# Else, window snaps back to the last transition position.
self.keyboard_widget.sync_transition_position(rect)
def get_home_rect(self):
"""
Get the un-repositioned rect, the one auto-show falls back to
when there is nowhere else to move.
"""
if config.is_docking_enabled():
rect = self.get_dock_rect()
else:
rect = self.home_rect
return rect
def get_visible_rect(self):
"""
Returns the rect of the visible window rect with auto-show
repositioning taken into account.
"""
home_rect = self.get_home_rect() # aware of docking
rect = home_rect
if config.is_auto_show_enabled():
r = self.get_repositioned_window_rect(home_rect)
if not r is None:
rect = r
return rect
def auto_position(self):
self.update_position()
# With docking enabled, when focusing the search entry of a
# maximized firefox window, it changes position when the work
# area shrinks and ends up below Onboard.
# -> periodically update the window position for a little while,
# this way slow systems can catch up too eventually (Nexus 7).
self._poll_auto_position_start_time = time.time()
start_delay = 0.1
self._auto_position_poll_timer.start(start_delay,
self._on_auto_position_poll,
start_delay)
def _on_auto_position_poll(self, delay):
self.update_position()
# start another timer for progressively longer intervals
delay = min(delay * 2.0, 1.0)
if time.time() + delay < self._poll_auto_position_start_time + 3.0:
self._auto_position_poll_timer.start(delay,
self._on_auto_position_poll,
delay)
return True
else:
return False
def stop_auto_position(self):
self._auto_position_poll_timer.stop()
def update_position(self):
home_rect = self.get_home_rect()
print("1", home_rect)
rect = self.get_repositioned_window_rect(home_rect)
print("2", rect)
if rect is None:
# move back home
rect = home_rect
if self.get_position() != rect.get_position():
self.keyboard_widget.transition_position_to(rect.x, rect.y)
self.keyboard_widget.commit_transition()
def get_repositioned_window_rect(self, home_rect):
clearance = config.auto_show.widget_clearance
test_clearance = clearance
move_clearance = clearance
limit_rects = None # None: all monitors
# No test clearance when docking. Make it harder to jump
# out of the dock, for example for the bottom search box
# in maximized firefox.
if config.is_docking_enabled():
test_clearance = (clearance[0], 0, clearance[2], 0)
# limit the horizontal freedom to the docking monitor
area, geom = self.get_docking_monitor_rects()
limit_rects = [area]
horizontal, vertical = self.get_repositioning_constraints()
return self.keyboard_widget.auto_show.get_repositioned_window_rect( \
home_rect, limit_rects,
test_clearance, move_clearance,
horizontal, vertical)
def reposition(self, x, y):
""" Move the window by a transition, not by user positioning. """
# remember rects to distimguish from user move/resize
w, h = self.get_size()
self.remember_rect(Rect(x, y, w, h))
self.move(x, y)
def get_repositioning_constraints(self):
"""
Return allowed respositioning directions for auto-show.
"""
if config.is_docking_enabled() and \
self.get_dock_expand():
return False, True
else:
return True, True
def get_hidden_rect(self):
"""
Returns the rect of the hidden window rect with auto-show
repositioning taken into account.
"""
if config.is_docking_enabled():
return self.get_docking_hideout_rect()
return self.get_visible_rect()
def get_current_rect(self):
"""
Returns the window rect with auto-show
repositioning taken into account.
"""
if self.is_visible():
return self.get_visible_rect()
else:
return self.get_hidden_rect()
def on_restore_window_rect(self, rect):
"""
Overload for WindowRectTracker.
"""
if not config.is_docking_enabled():
self.home_rect = rect.copy()
self.keyboard_widget.sync_transition_position(rect)
# check for alternative auto-show position
r = self.get_current_rect()
if r != rect:
# remember our rects to distinguish from user move/resize
self.remember_rect(r)
rect = r
return rect
def on_save_window_rect(self, rect):
"""
Overload for WindowRectTracker.
"""
# Ignore <rect> (self._window_rect), it may just be a temporary one
# set by auto-show. Save the user selected home_rect instead.
return self.home_rect
def read_window_rect(self, orientation):
"""
Read orientation dependent rect.
Overload for WindowRectTracker.
"""
if orientation == Orientation.LANDSCAPE:
co = config.window.landscape
else:
co = config.window.portrait
rect = Rect(co.x, co.y, co.width, co.height)
return rect
def write_window_rect(self, orientation, rect):
"""
Write orientation dependent rect.
Overload for WindowRectTracker.
"""
# There are separate rects for normal and rotated screen (tablets).
if orientation == Orientation.LANDSCAPE:
co = config.window.landscape
else:
co = config.window.portrait
# remember that we wrote this rect to gsettings
self._written_window_rects[orientation] = rect.copy()
# write to gsettings and trigger notifications
#co.settings.delay()
co.x, co.y, co.width, co.height = rect
#co.settings.apply() FIXME
def write_docking_size(self, orientation, size):
co = self.get_orientation_config_object()
expand = self.get_dock_expand()
# remember that we wrote this rect to gsettings
self._written_dock_sizes[orientation] = tuple(size)
# write to gsettings and trigger notifications
co.settings.delay()
if not expand:
co.dock_width = size[0]
co.dock_height = size[1]
co.settings.apply()
def get_orientation_config_object(self):
orientation = self.get_screen_orientation()
if orientation == Orientation.LANDSCAPE:
co = config.window.landscape
else:
co = config.window.portrait
return co
def on_transition_done(self, visible_before, visible_now):
if visible_now:
self.update_docking()
def on_screen_size_changed(self, screen):
""" Screen rotation, etc. """
if config.is_docking_enabled():
# Can't correctly position the window while struts are active
# -> turn them off for a moment
self.clear_struts()
self._was_visible = self.is_visible()
keyboard_widget = self.keyboard_widget
if keyboard_widget:
keyboard_widget.transition_visible_to(False, 0.0)
keyboard_widget.commit_transition()
WindowRectTracker.on_screen_size_changed(self, screen)
def on_screen_size_changed_delayed(self, screen):
if config.is_docking_enabled():
self.reset_monitor_workarea()
# The keyboard size may have changed, draw with the new size now,
# while it's still in the hideout, so we don't have to watch.
self.restore_window_rect()
self.keyboard_widget.process_updates()
keyboard_widget = self.keyboard_widget
if keyboard_widget and self._was_visible:
keyboard_widget.transition_visible_to(True, 0.0, 0.4)
keyboard_widget.commit_transition()
else:
self.restore_window_rect()
def limit_size(self, rect):
"""
Limits the given window rect to fit on screen.
"""
if self.keyboard_widget:
return self.keyboard_widget.limit_size(rect)
return rect
def _emit_quit_onboard(self, event, data=None):
self.emit("quit-onboard")
def _on_delete_event(self, event, data=None):
if False: #config.lockdown.disable_quit:
if self.keyboard_widget:
return True
else:
self._emit_quit_onboard(event)
def update_docking(self, force_update = False):
enable = config.is_docking_enabled()
if enable:
rect = self.get_dock_rect()
else:
rect = Rect()
shrink = config.window.docking_shrink_workarea
expand = self.get_dock_expand()
if self._docking_enabled != enable or \
(self._docking_enabled and \
(self._docking_rect != rect or \
self._shrink_work_area != shrink or \
self._dock_expand != expand)
):
self.enable_docking(enable)
self._shrink_work_area = shrink
self._dock_expand = expand
def enable_docking(self, enable):
if enable:
self._set_docking_struts(config.window.docking_shrink_workarea,
config.window.docking_edge,
self.get_dock_expand())
self.restore_window_rect() # knows about docking
else:
self.restore_window_rect()
self.clear_struts()
def clear_struts(self):
self._set_docking_struts(False)
def _set_docking_struts(self, enable, edge = None, expand = True):
if not self.get_realized():
# no window, no xid
return
win = self.get_window()
xid = win.get_xid() # requires GdkX11 import
if not enable:
self._docking_enabled = False
self._docking_edge = edge
self._docking_rect = Rect()
self._apply_struts(xid, None)
return
area, geom = self.get_docking_monitor_rects()
rect = self.get_dock_rect()
top_start_x = top_end_x = 0
bottom_start_x = bottom_end_x = 0
if edge: # Bottom
top = 0
bottom = geom.h - area.bottom() + rect.h
bottom_start_x = rect.left()
bottom_end_x = rect.right()
else: # Top
top = area.top() + rect.h
bottom = 0
top_start_x = rect.left()
top_end_x = rect.right()
struts = [0, 0, top, bottom, 0, 0, 0, 0,
top_start_x, top_end_x, bottom_start_x, bottom_end_x]
self._apply_struts(xid, struts)
self._docking_enabled = True
self._docking_edge = edge
self._docking_rect = rect
def _apply_struts(self, xid, struts = None):
if self._current_struts != struts:
if struts is None:
self._osk_struts.clear(xid)
else:
self._osk_struts.set(xid, struts)
self._current_struts = struts
def get_dock_size(self):
co = self.get_orientation_config_object()
return co.dock_width, co.dock_height
def get_dock_expand(self):
co = self.get_orientation_config_object()
return co.dock_expand
def get_dock_rect(self):
area, geom = self.get_docking_monitor_rects()
edge = config.window.docking_edge
width, height = self.get_dock_size()
rect = Rect(area.x, 0, area.w, height)
if edge: # Bottom
rect.y = area.y + area.h - height
else: # Top
rect.y = area.y
expand = self.get_dock_expand()
if expand:
rect.w = area.w
rect.x = area.x
else:
rect.w = min(width, area.w)
rect.x = rect.x + (area.w - rect.w) // 2
return rect
def get_docking_hideout_rect(self, reference_rect = None):
""" Where the keyboard goes to hide when it slides off-screen. """
area, geom = self.get_docking_monitor_rects()
rect = self.get_dock_rect()
hideout = rect
mcx, mcy = geom.get_center()
if reference_rect:
cx, cy = reference_rect.get_center()
else:
cx, cy = rect.get_center()
clearance = 10
if cy > mcy:
hideout.y = geom.bottom() + clearance # below Bottom
else:
hideout.y = geom.top() - rect.h - clearance # above Top
return hideout
def get_docking_monitor_rects(self):
screen = self.get_screen()
mon = self.get_docking_monitor()
area = self._monitor_workarea.get(mon)
if area is None:
area = self.update_monitor_workarea()
geom = screen.get_monitor_geometry(mon)
geom = Rect(geom.x, geom.y, geom.width, geom.height)
return area, geom
def get_docking_monitor(self):
screen = self.get_screen()
return screen.get_primary_monitor()
def reset_monitor_workarea(self):
self._monitor_workarea = {}
def update_monitor_workarea(self):
"""
Save the workarea, so we don't have to
check all the time if our strut is already installed.
"""
mon = self.get_docking_monitor()
area = self.get_monitor_workarea()
self._monitor_workarea[mon] = area
return area
def get_monitor_workarea(self):
screen = self.get_screen()
mon = self.get_docking_monitor()
area = screen.get_monitor_workarea(mon)
area = Rect(area.x, area.y, area.width, area.height)
return area
def is_override_redirect_mode(self):
return config.is_force_to_top() and \
self._wm_quirks.can_set_override_redirect(self)
class TouchInput:
"""
Unified handling of multi-touch sequences and conventional pointer input.
"""
GESTURE_DETECTION_SPAN = 100 # [ms] until two finger tap&drag is detected
GESTURE_DELAY_PAUSE = 3000 # [ms] Suspend delayed sequence begin for this
# amount of time after the last key press.
delay_sequence_begin = True # No delivery, i.e. no key-presses after
# gesture detection, but delays press-down.
def __init__(self):
self._input_sequences = {}
self._touch_events_enabled = self.is_touch_enabled()
self._multi_touch_enabled = config.keyboard.touch_input == \
TouchInputEnum.MULTI
self._gestures_enabled = self._touch_events_enabled
self._last_event_was_touch = False
self._last_sequence_time = 0
self._gesture = NO_GESTURE
self._gesture_begin_point = (0, 0)
self._gesture_begin_time = 0
self._gesture_detected = False
self._gesture_cancelled = False
self._num_tap_sequences = 0
self._gesture_timer = Timer()
self._order_timer = Timer()
self._queued_events = []
self.init_event_handling(
config.keyboard.event_handling == EventHandlingEnum.GTK,
False)
self._pytime_start = None
self._evtime_start = None
def cleanup(self):
if self._device_manager:
self._device_manager.disconnect("device-event",
self._device_event_handler)
self._device_manager = None
def init_event_handling(self, use_gtk, use_raw_events):
if use_gtk:
# GTK event handling
self._device_manager = None
event_mask = Gdk.EventMask.BUTTON_PRESS_MASK | \
Gdk.EventMask.BUTTON_RELEASE_MASK | \
Gdk.EventMask.POINTER_MOTION_MASK | \
Gdk.EventMask.LEAVE_NOTIFY_MASK | \
Gdk.EventMask.ENTER_NOTIFY_MASK
if self._touch_events_enabled:
event_mask |= Gdk.EventMask.TOUCH_MASK
self.add_events(event_mask)
self.connect("button-press-event", self._on_button_press_event)
self.connect("button_release_event", self._on_button_release_event)
self.connect("motion-notify-event", self._on_motion_event)
self.connect("touch-event", self._on_touch_event)
else:
# XInput event handling
self._device_manager = XIDeviceManager()
self._device_manager.connect("device-event",
self._device_event_handler)
devices = self._device_manager.get_slave_pointer_devices()
_logger.warning("listening to XInput devices: {}" \
.format([(d.name, d.id, d.get_config_string()) \
for d in devices]))
# Select events af all slave pointer devices
if use_raw_events:
event_mask = XIEventMask.RawButtonPressMask | \
XIEventMask.RawButtonReleaseMask | \
XIEventMask.RawMotionMask
if self._touch_events_enabled:
event_mask |= XIEventMask.RawTouchMask
else:
event_mask = XIEventMask.ButtonPressMask | \
XIEventMask.ButtonReleaseMask | \
XIEventMask.MotionMask
if self._touch_events_enabled:
event_mask |= XIEventMask.TouchMask
for device in devices:
device.select_events(event_mask)
self._selected_devices = devices
self._selected_device_ids = [d.id for d in devices]
self._use_raw_events = use_raw_events
def _device_event_handler(self, event):
"""
Handler for XI2 events.
"""
if not event.device_id in self._selected_device_ids:
return
#print("device {}, xi_type {}, type {}, point {} {}, xid {}" \
# .format(event.device_id, event.xi_type, event.type, event.x, event.y, event.xid_event))
win = self.get_window()
if not win:
return
# Reject initial initial presses/touch_begins outside our window.
# Allow all subsequent ones to simulate grabbing the device.
if not self._input_sequences:
# Is the hit window ours?
# Note: only initial clicks and taps supply a valid window id.
xid_event = event.xid_event
if xid_event != 0 and \
xid_event != win.get_xid():
return
# Convert from root to window relative coordinates.
# We don't get window coordinates for more than the first touch.
rx, ry = win.get_root_coords(0, 0)
event.x = event.x_root - rx
event.y = event.y_root - ry
event_type = event.xi_type
if self._use_raw_events:
if event_type == XIEventType.RawMotion:
self._on_motion_event(self, event)
elif event_type == XIEventType.RawButtonPress:
self._on_button_press_event(self, event)
elif event_type == XIEventType.RawButtonRelease:
self._on_button_release_event(self, event)
elif event_type == XIEventType.RawTouchBegin or \
event_type == XIEventType.RawTouchUpdate or \
event_type == XIEventType.RawTouchEnd:
self._on_touch_event(self, event)
else:
if event_type == XIEventType.Motion:
self._on_motion_event(self, event)
elif event_type == XIEventType.ButtonPress:
self._on_button_press_event(self, event)
elif event_type == XIEventType.ButtonRelease:
self._on_button_release_event(self, event)
elif event_type == XIEventType.TouchBegin or \
event_type == XIEventType.TouchUpdate or \
event_type == XIEventType.TouchEnd:
self._on_touch_event(self, event)
def is_touch_enabled(self):
return config.keyboard.touch_input != TouchInputEnum.NONE
def has_input_sequences(self):
""" Are any clicks/touches still ongoing? """
return bool(self._input_sequences)
def last_event_was_touch(self):
""" Was there just a touch event? """
return self._last_event_was_touch
def has_touch_source(self, event):
source_device = event.get_source_device()
source = source_device.get_source()
return source == Gdk.InputSource.TOUCHSCREEN
def _on_button_press_event(self, widget, event):
if self._touch_events_enabled and \
self.has_touch_source(event):
return
sequence = InputSequence()
sequence.init_from_button_event(event)
sequence.primary = True
self._last_event_was_touch = False
self._input_sequence_begin(sequence)
def _on_motion_event(self, widget, event):
if self._touch_events_enabled and \
self.has_touch_source(event):
return
sequence = self._input_sequences.get(POINTER_SEQUENCE)
if sequence is None:
sequence = InputSequence()
sequence.primary = True
sequence.init_from_motion_event(event)
self._last_event_was_touch = False
self._input_sequence_update(sequence)
def _on_button_release_event(self, widget, event):
sequence = self._input_sequences.get(POINTER_SEQUENCE)
if not sequence is None:
sequence.point = (event.x, event.y)
sequence.root_point = (event.x_root, event.y_root)
sequence.time = event.get_time()
self._input_sequence_end(sequence)
def _on_touch_event(self, widget, event):
if not self.has_touch_source(event):
return
touch = event.touch
id = str(touch.sequence)
self._last_event_was_touch = True
event_type = event.type
if event_type == Gdk.EventType.TOUCH_BEGIN:
if self._pytime_start == None:
self._pytime_start = time.time()
self._evtime_start = event.get_time()
#print("DOWN",time.time()-self._pytime_start,event.get_time()-self._evtime_start)
evlog.append(event)
sequence = InputSequence()
sequence.init_from_touch_event(touch, id)
if len(self._input_sequences) == 0:
sequence.primary = True
for ev, qseq in self._queued_events:
if qseq.time < event.get_time():
#print("Yielded to queued")
self._input_sequence_end(qseq)
self._queued_events.remove((ev, qseq))
self._input_sequence_begin(sequence)
elif event_type == Gdk.EventType.TOUCH_UPDATE:
sequence = self._input_sequences.get(id)
if not sequence is None:
sequence.point = (touch.x, touch.y)
sequence.root_point = (touch.x_root, touch.y_root)
sequence.time = event.get_time()
sequence.updated = time.time()
self._input_sequence_update(sequence)
else:
if event_type == Gdk.EventType.TOUCH_END:
pass
elif event_type == Gdk.EventType.TOUCH_CANCEL:
pass
#print("UP",time.time()-self._pytime_start,event.get_time()-self._evtime_start)
evlog.append(event)
sequence = self._input_sequences.get(id)
if not sequence is None:
sequence.time = event.get_time()
self._queued_events.append((Gdk.EventType.TOUCH_END,sequence))
self._order_timer.start(0.05,self._delayed_release)
def _delayed_release(self):
for ev, seq in self._queued_events:
if ev == Gdk.EventType.TOUCH_END:
#print("D:UP",time.time()-self._pytime_start,seq.time-self._evtime_start)
self._input_sequence_end(seq)
#elif ev == Gdk.EventType.TOUCH_BEGIN:
self._queued_events.clear()
return False
def _input_sequence_begin(self, sequence):
""" Button press/touch begin """
self._gesture_sequence_begin(sequence)
first_sequence = len(self._input_sequences) == 0
if first_sequence or \
self._multi_touch_enabled:
self._input_sequences[sequence.id] = sequence
if not self._gesture_detected:
if first_sequence and \
self._multi_touch_enabled and \
self.delay_sequence_begin and \
sequence.time - self._last_sequence_time > \
self.GESTURE_DELAY_PAUSE:
# Delay the first tap; we may have to stop it
# from reaching the keyboard.
self._gesture_timer.start(self.GESTURE_DETECTION_SPAN / 1000.0,
self.on_delayed_sequence_begin,
sequence, sequence.point)
else:
# Tell the keyboard right away.
self.deliver_input_sequence_begin(sequence)
self._last_sequence_time = sequence.time
def on_delayed_sequence_begin(self, sequence, point):
if not self._gesture_detected: # work around race condition
sequence.point = point # return to the original begin point
self.deliver_input_sequence_begin(sequence)
self._gesture_cancelled = True
return False
def deliver_input_sequence_begin(self, sequence):
self.on_input_sequence_begin(sequence)
sequence.delivered = True
def _input_sequence_update(self, sequence):
""" Pointer motion/touch update """
self._gesture_sequence_update(sequence)
if not sequence.state & BUTTON123_MASK or \
not self.in_gesture_detection_delay(sequence):
self._gesture_timer.finish() # don't run begin out of order
self.on_input_sequence_update(sequence)
def _input_sequence_end(self, sequence):
""" Button release/touch end """
self._gesture_sequence_end(sequence)
self._gesture_timer.finish() # run delayed sequence before end
if sequence.id in self._input_sequences:
del self._input_sequences[sequence.id]
if sequence.delivered:
self._gesture_timer.finish() # run delayed sequence before end
self.on_input_sequence_end(sequence)
if self._input_sequences:
self._discard_stuck_input_sequences()
self._last_sequence_time = sequence.time
def _discard_stuck_input_sequences(self):
"""
Input sequence handling requires guaranteed balancing of
begin, update and end events. There is no indication yet this
isn't always the case, but still, at this time it seems like a
good idea to prepare for the worst.
-> Clear out aged input sequences, so Onboard can start from a
fresh slate and not become terminally unresponsive.
"""
expired_time = time.time() - 30
for id, sequence in list(self._input_sequences.items()):
if sequence.updated < expired_time:
_logger.warning("discarding expired input sequence " + str(id))
del self._input_sequences[id]
def in_gesture_detection_delay(self, sequence):
span = sequence.time - self._gesture_begin_time
return span < self.GESTURE_DETECTION_SPAN
#FIXME later
#tap Gestures should not swallow sequences
#Drag gestures should send cancel events
def _gesture_sequence_begin(self, sequence):
return True
if self._num_tap_sequences == 0:
self._gesture = NO_GESTURE
self._gesture_detected = False
self._gesture_cancelled = False
self._gesture_begin_point = sequence.point
self._gesture_begin_time = sequence.time # event time
else:
if self.in_gesture_detection_delay(sequence) and \
not self._gesture_cancelled:
self._gesture_timer.stop() # cancel delayed sequence begin
self._gesture_detected = True
self._num_tap_sequences += 1
def _gesture_sequence_update(self, sequence):
return True
if self._gesture_detected and \
sequence.state & BUTTON123_MASK and \
self._gesture == NO_GESTURE:
point = sequence.point
dx = self._gesture_begin_point[0] - point[0]
dy = self._gesture_begin_point[1] - point[1]
d2 = dx * dx + dy * dy
# drag gesture?
if d2 >= DRAG_GESTURE_THRESHOLD2:
num_touches = len(self._input_sequences)
self._gesture = DRAG_GESTURE
self.on_drag_gesture_begin(num_touches)
return True
def _gesture_sequence_end(self, sequence):
return True
if len(self._input_sequences) == 1: # last sequence of the gesture?
if self._gesture_detected:
gesture = self._gesture
if gesture == NO_GESTURE:
# tap gesture?
elapsed = sequence.time - self._gesture_begin_time
if elapsed <= 300:
self.on_tap_gesture(self._num_tap_sequences)
elif gesture == DRAG_GESTURE:
self.on_drag_gesture_end(0)
self._num_tap_sequences = 0
def on_tap_gesture(self, num_touches):
return False
def on_drag_gesture_begin(self, num_touches):
return False
def on_drag_gesture_end(self, num_touches):
return False