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 _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 _on_draw(self, widget, cr):
"""
Draw the onboard icon.
"""
if not Gtk.cairo_should_draw_window(cr, self.get_window()):
return False
rect = Rect(0.0, 0.0, float(self.get_allocated_width()), float(self.get_allocated_height()))
color_scheme = self.get_color_scheme()
# clear background
cr.save()
cr.set_operator(cairo.OPERATOR_CLEAR)
cr.paint()
cr.restore()
# draw background color
background_rgba = [0.0, 0.0, 0.7, 0.8] # list(color_scheme.get_icon_rgba("background"))
if Gdk.Screen.get_default().is_composited():
background_rgba[3] *= 0.75
cr.set_source_rgba(*background_rgba)
corner_radius = min(rect.w, rect.h) * 0.1
roundrect_arc(cr, rect, corner_radius)
cr.fill()
# decoration frame
line_rect = rect.deflate(1)
cr.set_line_width(2)
roundrect_arc(cr, line_rect, corner_radius)
cr.stroke()
else:
cr.set_source_rgba(*background_rgba)
cr.paint()
# draw themed icon
# self._draw_themed_icon(cr, rect, color_scheme)
# FIXME
# draw dwell progress
rgba = [0.8, 0.0, 0.0, 0.5]
bg_rgba = [0.1, 0.1, 0.1, 0.5]
if color_scheme:
pass # FIXME
dwell_rect = rect.grow(0.5)
self._dwell_progress.draw(cr, dwell_rect, rgba, bg_rgba)
return True
def start_drag(self, point = None):
self._monitor_rects = None
# Find the pointer position for the occasions when we are
# not being called from an event (move button).
if not point:
rootwin = Gdk.get_default_root_window()
dunno, x_root, y_root, mask = rootwin.get_pointer()
point = (x_root, y_root)
# rmember pointer and window positions
window = self.get_drag_window()
x, y = window.get_position()
self._drag_start_pointer = point
self._drag_start_offset = [point[0] - x, point[1] - y]
self._drag_start_rect = Rect.from_position_size(window.get_position(),
window.get_size())
# not yet actually moving the window
self._drag_active = False
# get the threshold
self._drag_threshold = self.get_drag_threshold()
# check if the temporary threshold unlocking has expired
if not self.drag_protection or \
not self._temporary_unlock_time is None and \
time.time() - self._temporary_unlock_time > \
self.temporary_unlock_delay:
self._temporary_unlock_time = None
# give keyboard window a chance to react
self.on_drag_initiated()
def get_monitor_rects(screen):
"""
Screen limits, one rect per monitor. Monitors may have
different sizes and arbitrary relative positions.
"""
rects = []
if screen:
for i in range(screen.get_n_monitors()):
r = screen.get_monitor_geometry(i)
rects.append(Rect(r.x, r.y, r.width, r.height))
else:
rootwin = Gdk.get_default_root_window()
r = Rect.from_position_size(rootwin.get_position(),
(rootwin.get_width(), rootwin.get_height()))
rects.append(r)
return rects
def draw(self, context):
if self.opacity:
clip_rect = Rect.from_extents(*context.clip_extents())
for handle in self.handles:
rect = handle.get_shadow_rect()
if rect.intersects(clip_rect):
context.save()
context.rectangle(*rect.int())
context.clip()
context.push_group()
handle.draw(context)
context.pop_group_to_source()
context.paint_with_alpha(self.opacity);
context.restore()
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 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