# Copyright (C) 2007, Eduardo Silva # Copyright (C) 2008, One Laptop Per Child # Copyright (C) 2009, Tomeu Vizoso # Copyright (C) 2011, Benjamin Berg # Copyright (C) 2011, Marco Pesenti Gritti # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the # Free Software Foundation, Inc., 59 Temple Place - Suite 330, # Boston, MA 02111-1307, USA. """ STABLE. """ import logging import math import gi gi.require_version('SugarGestures', '1.0') from gi.repository import Gdk from gi.repository import Gtk from gi.repository import GObject from gi.repository import GLib from gi.repository import SugarGestures from sugar3.graphics import palettegroup from sugar3.graphics import animator from sugar3.graphics import style from sugar3.graphics.icon import CellRendererIcon _pointer = None def _get_pointer_position(widget): global _pointer if _pointer is None: display = widget.get_display() manager = display.get_device_manager() _pointer = manager.get_client_pointer() screen, x, y = _pointer.get_position() return (x, y) def _calculate_gap(a, b): """Helper function to find the gap position and size of widget a""" # Test for each side if the palette and invoker are # adjacent to each other. gap = True if a.y + a.height == b.y: gap_side = Gtk.PositionType.BOTTOM elif a.x + a.width == b.x: gap_side = Gtk.PositionType.RIGHT elif a.x == b.x + b.width: gap_side = Gtk.PositionType.LEFT elif a.y == b.y + b.height: gap_side = Gtk.PositionType.TOP else: gap = False if gap: if gap_side == Gtk.PositionType.BOTTOM or \ gap_side == Gtk.PositionType.TOP: gap_start = min(a.width, max(0, b.x - a.x)) gap_size = max(0, min(a.width, (b.x + b.width) - a.x) - gap_start) elif gap_side == Gtk.PositionType.RIGHT or \ gap_side == Gtk.PositionType.LEFT: gap_start = min(a.height, max(0, b.y - a.y)) gap_size = max(0, min(a.height, (b.y + b.height) - a.y) - gap_start) if gap and gap_size > 0: return (gap_side, gap_start, gap_size) else: return False class _PaletteMenuWidget(Gtk.Menu): __gtype_name__ = "SugarPaletteMenuWidget" __gsignals__ = { 'enter-notify': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'leave-notify': (GObject.SignalFlags.RUN_FIRST, None, ([])), } def __init__(self): Gtk.Menu.__init__(self) accel_group = Gtk.AccelGroup() self.sugar_accel_group = accel_group self.get_toplevel().add_accel_group(accel_group) self._popup_position = (0, 0) self._entered = False self._mouse_in_palette = False self._mouse_in_invoker = False self._up = False self._invoker = None self._menus = [] def set_accept_focus(self, focus): pass def get_origin(self): res_, x, y = self.get_toplevel().get_window().get_origin() return x, y def move(self, x, y): self._popup_position = (x, y) def set_transient_for(self, window): pass def set_invoker(self, invoker): pass def _position(self, widget, *data): return self._popup_position[0], self._popup_position[1], False def popup(self, invoker): if self._up: return # We need to track certain mouse events in order to close the palette # when the mouse leaves the palette and the invoker widget, but # GtkMenu makes our lives hard here. # # GtkMenu takes a grab on the root window, meaning that normal # enter/leave events are not sent to the relevant widgets. # However, connecting enter-notify and leave-notify events in this # GtkMenu subclass mean that we get to see the events being grabbed. # With certain filtering in place (see _enter_notify_cb and # _leave_notify_cb) we are able to accurately determine when the # mouse leaves/enters the palette menu. Some spurious events are # generated but the important thing is that the last event generated # in response to a user action is always reliable (i.e. we will # always get a leave event last if the user left the menu, # even if we get some strange enter events leading up to it). # # This is complicated with submenus; in this case the submenu takes # the grab, so we must also listen for events on any submenus of # the palette and apply the same considerations. # # The remaining challenge is tracking when the mouse enters or leaves # the invoker area. While the appropriate GtkMenu grab is active, # we do get informed of such events, however these events will only # arrive if the user has entered the menu. If the user hovers over # the invoker and then leaves the invoker without entering the palette, # we get no enter/leave event. # We work around this by tracking mouse motion events. When the mouse # moves, we compare the mouse coordinates to the region occupied by the # invoker, and this lets us track enter/leave for the invoker widget. self._invoker = invoker self._find_all_menus(self) self.realize() for menu in self._menus: if self._invoker: menu.connect('motion-notify-event', self._motion_notify_cb) menu.connect('enter-notify-event', self._enter_notify_cb) menu.connect('leave-notify-event', self._leave_notify_cb) menu.connect('button-release-event', self._button_release_event_cb) self._entered = False self._mouse_in_palette = False self._mouse_in_invoker = False Gtk.Menu.popup(self, None, None, self._position, None, 0, 0) self._up = True def popdown(self): if not self._up: return Gtk.Menu.popdown(self) for menu in self._menus: menu.disconnect_by_func(self._motion_notify_cb) menu.disconnect_by_func(self._enter_notify_cb) menu.disconnect_by_func(self._leave_notify_cb) self._up = False self._menus = [] self._invoker = None def _find_all_menus(self, menu): """ Recursively find all submenus of menu, adding them to self._menus. """ self._menus.append(menu) for child in menu.get_children(): if not isinstance(child, Gtk.MenuItem): continue submenu = child.get_submenu() if submenu and isinstance(submenu, Gtk.Menu): self._find_all_menus(submenu) def _enter_notify_cb(self, widget, event): if event.mode in (Gdk.CrossingMode.GRAB, Gdk.CrossingMode.GTK_GRAB): return False if event.get_source_device().get_source() == \ Gdk.InputSource.TOUCHSCREEN: return False if Gtk.get_event_widget(event) not in self._menus: return False self._mouse_in_palette = True self._reevaluate_state() return False def _leave_notify_cb(self, widget, event): if event.mode in (Gdk.CrossingMode.GRAB, Gdk.CrossingMode.GTK_GRAB): return False if event.get_source_device().get_source() == \ Gdk.InputSource.TOUCHSCREEN: return False if Gtk.get_event_widget(event) not in self._menus: return False self._mouse_in_palette = False self._reevaluate_state() return False def _motion_notify_cb(self, widget, event): if event.get_source_device().get_source() == \ Gdk.InputSource.TOUCHSCREEN: return False x = event.x_root y = event.y_root rect = self._invoker.get_rect() in_invoker = x >= rect.x and x < (rect.x + rect.width) \ and y >= rect.y and y < (rect.y + rect.height) if in_invoker != self._mouse_in_invoker: self._mouse_in_invoker = in_invoker self._reevaluate_state() def _button_release_event_cb(self, widget, event): x = event.x_root y = event.y_root rect = self._invoker.get_rect() in_invoker = x >= rect.x and x < (rect.x + rect.width) \ and y >= rect.y and y < (rect.y + rect.height) if in_invoker: return True def _reevaluate_state(self): if self._entered: # If we previously advised that the mouse was inside, but now the # mouse is outside both the invoker and the palette, notify that # the mouse has left. if not self._mouse_in_palette and not self._mouse_in_invoker: self._entered = False self.emit('leave-notify') else: # If we previously advised that the mouse had left, but now the # mouse is inside either the palette or the invoker, notify that # the mouse has entered. if self._mouse_in_palette or self._mouse_in_invoker: self._entered = True self.emit('enter-notify') class _PaletteWindowWidget(Gtk.Window): __gtype_name__ = 'SugarPaletteWindowWidget' __gsignals__ = { 'enter-notify': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'leave-notify': (GObject.SignalFlags.RUN_FIRST, None, ([])), } def __init__(self, palette=None): Gtk.Window.__init__(self) self._palette = palette self.set_decorated(False) self.set_resizable(False) self.set_position(Gtk.WindowPosition.NONE) context = self.get_style_context() # Just assume all borders are the same border = context.get_border(Gtk.StateFlags.ACTIVE).right self.set_border_width(border) accel_group = Gtk.AccelGroup() self.sugar_accel_group = accel_group self.add_accel_group(accel_group) self._old_alloc = None self._invoker = None self._should_accept_focus = True def set_accept_focus(self, focus): self._should_accept_focus = focus if self.get_window() is not None: self.get_window().set_accept_focus(focus) def get_origin(self): res_, x, y = self.get_window().get_origin() return x, y def do_realize(self): Gtk.Window.do_realize(self) self.get_window().set_accept_focus(self._should_accept_focus) self.set_type_hint(Gdk.WindowTypeHint.DIALOG) def do_get_preferred_width(self): minimum, natural = Gtk.Window.do_get_preferred_width(self) label_width = 0 if self._palette is not None: label_width = self._palette.get_label_width() size = max(natural, label_width + 2 * self.get_border_width(), style.GRID_CELL_SIZE * 3) return size, size def do_size_allocate(self, allocation): Gtk.Window.do_size_allocate(self, allocation) if self._old_alloc is None or \ self._old_alloc.x != allocation.x or \ self._old_alloc.y != allocation.y or \ self._old_alloc.width != allocation.width or \ self._old_alloc.height != allocation.height: self.queue_draw() # We need to store old allocation because when size_allocate # is called widget.allocation is already updated. # Gtk.Window resizing is different from normal containers: # the X window is resized, widget.allocation is updated from # the configure request handler and finally size_allocate is called. self._old_alloc = allocation def set_invoker(self, invoker): self._invoker = invoker def get_rect(self): win_x, win_y = self.get_origin() rectangle = self.get_allocation() x = win_x + rectangle.x y = win_y + rectangle.y minimum, natural = self.get_preferred_size() rect = Gdk.Rectangle() rect.x = x rect.y = y rect.width = minimum.width rect.height = natural.height return rect def do_draw(self, cr): # Fall trough to the container expose handler. # (Leaving out the window expose handler which redraws everything) Gtk.Window.do_draw(self, cr) if self._invoker is not None and self._invoker.has_rectangle_gap(): invoker = self._invoker.get_rect() palette = self.get_rect() gap = _calculate_gap(palette, invoker) else: gap = False allocation = self.get_allocation() context = self.get_style_context() context.add_class('palette') if gap: cr.save() cr.set_source_rgb(0, 0, 0) cr.rectangle(0, 0, allocation.width, allocation.height) cr.set_line_width(4) cr.stroke() cr.restore() Gtk.render_frame_gap( context, cr, 0, 0, allocation.width, allocation.height, gap[0], gap[1], gap[1] + gap[2]) else: Gtk.render_frame( context, cr, 0, 0, allocation.width, allocation.height) return False def __enter_notify_event_cb(self, widget, event): if event.mode == Gdk.CrossingMode.NORMAL and \ event.detail != Gdk.NotifyType.INFERIOR: self.emit('enter-notify') return False def __leave_notify_event_cb(self, widget, event): if event.mode != Gdk.CrossingMode.NORMAL: return False if event.detail != Gdk.NotifyType.INFERIOR: self.emit('leave-notify') def popup(self, invoker): if self.get_visible(): return self.connect('enter-notify-event', self.__enter_notify_event_cb) self.connect('leave-notify-event', self.__leave_notify_event_cb) self.show() def popdown(self): if not self.get_visible(): return self.disconnect_by_func(self.__enter_notify_event_cb) self.disconnect_by_func(self.__leave_notify_event_cb) self.hide() if hasattr(_PaletteWindowWidget, 'set_css_name'): _PaletteWindowWidget.set_css_name('palette') class MouseSpeedDetector(GObject.GObject): __gsignals__ = { 'motion-slow': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'motion-fast': (GObject.SignalFlags.RUN_FIRST, None, ([])), } _MOTION_SLOW = 1 _MOTION_FAST = 2 def __init__(self, delay, thresh): """Create MouseSpeedDetector object, delay in msec threshold in pixels (per tick of 'delay' msec)""" GObject.GObject.__init__(self) self.parent = None self._threshold = thresh self._delay = delay self._state = None self._timeout_hid = None self._mouse_pos = None def start(self): self.stop() self._mouse_pos = _get_pointer_position(self.parent) self._timeout_hid = GLib.timeout_add(self._delay, self._timer_cb) def stop(self): if self._timeout_hid is not None: GLib.source_remove(self._timeout_hid) self._timeout_hid = None self._state = None def _detect_motion(self): oldx, oldy = self._mouse_pos (x, y) = _get_pointer_position(self.parent) self._mouse_pos = (x, y) dist2 = (oldx - x) ** 2 + (oldy - y) ** 2 if dist2 > self._threshold ** 2: return True else: return False def _timer_cb(self): motion = self._detect_motion() if motion and self._state != self._MOTION_FAST: self.emit('motion-fast') self._state = self._MOTION_FAST elif not motion and self._state != self._MOTION_SLOW: self.emit('motion-slow') self._state = self._MOTION_SLOW return True class PaletteWindow(GObject.GObject): """ Base class for _ToolbarPalette and Palette. Provides basic management of child widget, invoker, and animation. """ __gsignals__ = { 'popup': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'popdown': (GObject.SignalFlags.RUN_FIRST, None, ([])), } def __init__(self, **kwargs): self._group_id = None self._invoker = None self._invoker_hids = [] self._cursor_x = 0 self._cursor_y = 0 self._alignment = None self._up = False self._widget = None self._popup_anim = animator.Animator(.5, 10) self._popup_anim.add(_PopupAnimation(self)) self._popdown_anim = animator.Animator(0.6, 10) self._popdown_anim.add(_PopdownAnimation(self)) GObject.GObject.__init__(self, **kwargs) self.set_group_id('default') self._mouse_detector = MouseSpeedDetector(200, 5) def _setup_widget(self): self._widget.connect('show', self.__show_cb) self._widget.connect('hide', self.__hide_cb) self._widget.connect('destroy', self.__destroy_cb) self._widget.connect('enter-notify', self.__enter_notify_cb) self._widget.connect('leave-notify', self.__leave_notify_cb) self._widget.connect('key-press-event', self.__key_press_event_cb) self._set_effective_group_id(self._group_id) self._widget.set_invoker(self._invoker) self._mouse_detector.connect('motion-slow', self._mouse_slow_cb) self._mouse_detector.parent = self._widget def _teardown_widget(self): self._widget.disconnect_by_func(self.__show_cb) self._widget.disconnect_by_func(self.__hide_cb) self._widget.disconnect_by_func(self.__destroy_cb) self._widget.disconnect_by_func(self.__enter_notify_cb) self._widget.disconnect_by_func(self.__leave_notify_cb) self._widget.disconnect_by_func(self.__key_press_event_cb) self._set_effective_group_id(None) def destroy(self): if self._widget is not None: self._widget.destroy() def __destroy_cb(self, palette): self._mouse_detector.disconnect_by_func(self._mouse_slow_cb) def set_invoker(self, invoker): for hid in self._invoker_hids[:]: self._invoker.disconnect(hid) self._invoker_hids.remove(hid) self._invoker = invoker if self._widget is not None: self._widget.set_invoker(invoker) if invoker is not None: self._invoker_hids.append(self._invoker.connect( 'mouse-enter', self._invoker_mouse_enter_cb)) self._invoker_hids.append(self._invoker.connect( 'mouse-leave', self._invoker_mouse_leave_cb)) self._invoker_hids.append(self._invoker.connect( 'right-click', self._invoker_right_click_cb)) self._invoker_hids.append(self._invoker.connect( 'toggle-state', self._invoker_toggle_state_cb)) def get_invoker(self): return self._invoker invoker = GObject.Property(type=object, getter=get_invoker, setter=set_invoker) def _mouse_slow_cb(self, widget): self._mouse_detector.stop() self._palette_do_popup() def _palette_do_popup(self): immediate = False if self.is_up(): self._popdown_anim.stop() return if self._group_id: group = palettegroup.get_group(self._group_id) if group and group.is_up(): immediate = True group.popdown() self.popup(immediate=immediate) def is_up(self): return self._up def _set_effective_group_id(self, group_id): if self._group_id: group = palettegroup.get_group(self._group_id) group.remove(self) if group_id: group = palettegroup.get_group(group_id) group.add(self) def set_group_id(self, group_id): self._set_effective_group_id(group_id) self._group_id = group_id def get_group_id(self): return self._group_id group_id = GObject.Property(type=str, getter=get_group_id, setter=set_group_id) def update_position(self): invoker = self._invoker if invoker is None or self._alignment is None: logging.error('Cannot update the palette position.') return if self._widget is None: return req = self._widget.size_request() if isinstance(self._widget, _PaletteMenuWidget): # on Gtk 3.10, menu at the bottom of the screen are resized # to not fall out, and report a wrong size. # measure the children and move the menu - SL #4673 total_height = 0 for child in self._widget.get_children(): child_req = child.size_request() total_height += child_req.height # need add the border line width as defined in sugar-artwork line_width = 2 total_height += line_width * 2 req.height = total_height position = invoker.get_position_for_alignment(self._alignment, req) if position is None: position = invoker.get_position(req) self._widget.move(position.x, position.y) def get_full_size_request(self): return self._widget.size_request() def popup(self, immediate=False): if self._widget is None: return if self._invoker is not None: full_size_request = self.get_full_size_request() self._alignment = self._invoker.get_alignment(full_size_request) self.update_position() try: self._widget.set_transient_for(self._invoker.get_toplevel()) except TypeError: # the expected parent window did likely change e.g. SL #4221 # popdown the Palette self.emit('popdown') return self._popdown_anim.stop() if not immediate: self._popup_anim.start() else: self._popup_anim.stop() self._widget.popup(self._invoker) # we have to invoke update_position() twice # since WM could ignore first move() request self.update_position() def popdown(self, immediate=False): self._popup_anim.stop() self._mouse_detector.stop() if not immediate: self._popdown_anim.start() else: self._popdown_anim.stop() if self._widget is not None: self._widget.popdown() def on_invoker_enter(self): self._popdown_anim.stop() self._mouse_detector.start() def on_invoker_leave(self): self._mouse_detector.stop() self.popdown() def on_enter(self): self._popdown_anim.stop() def on_leave(self): self.popdown() def _invoker_mouse_enter_cb(self, invoker): if not self._invoker.locked: self.on_invoker_enter() def _invoker_mouse_leave_cb(self, invoker): if not self._invoker.locked: self.on_invoker_leave() def _invoker_right_click_cb(self, invoker): self.popup(immediate=True) def _invoker_toggle_state_cb(self, invoker): if self.is_up(): self.popdown(immediate=True) else: self.popup(immediate=True) def __enter_notify_cb(self, widget): if not self._invoker.locked: self.on_enter() def __leave_notify_cb(self, widget): if not self._invoker.locked: self.on_leave() def __key_press_event_cb(self, window, event): if event.keyval == Gdk.KEY_Escape: self.popdown() def __show_cb(self, widget): if self._invoker is not None: self._invoker.notify_popup() self._up = True self.emit('popup') def __hide_cb(self, widget): if self._invoker: self._invoker.notify_popdown() self._up = False self.emit('popdown') def get_rect(self): win_x, win_y = self._widget.get_origin() rectangle = self._widget.get_allocation() x = win_x + rectangle.x y = win_y + rectangle.y minimum, natural_ = self._widget.get_preferred_size() rect = Gdk.Rectangle() rect.x = x rect.y = y rect.width = minimum.width rect.height = minimum.height return rect class _PopupAnimation(animator.Animation): def __init__(self, palette): animator.Animation.__init__(self, 0.0, 1.0) self._palette = palette def next_frame(self, current): if current == 1.0: self._palette.popup(immediate=True) class _PopdownAnimation(animator.Animation): def __init__(self, palette): animator.Animation.__init__(self, 0.0, 1.0) self._palette = palette def next_frame(self, current): if current == 1.0: self._palette.popdown(immediate=True) class Invoker(GObject.GObject): __gtype_name__ = 'SugarPaletteInvoker' __gsignals__ = { 'mouse-enter': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'mouse-leave': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'right-click': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'toggle-state': (GObject.SignalFlags.RUN_FIRST, None, ([])), 'focus-out': (GObject.SignalFlags.RUN_FIRST, None, ([])), } ANCHORED = 0 AT_CURSOR = 1 BOTTOM = [(0.0, 0.0, 0.0, 1.0), (-1.0, 0.0, 1.0, 1.0)] RIGHT = [(0.0, 0.0, 1.0, 0.0), (0.0, -1.0, 1.0, 1.0)] TOP = [(0.0, -1.0, 0.0, 0.0), (-1.0, -1.0, 1.0, 0.0)] LEFT = [(-1.0, 0.0, 0.0, 0.0), (-1.0, -1.0, 0.0, 1.0)] def __init__(self): GObject.GObject.__init__(self) self.parent = None self._screen_area = Gdk.Rectangle() self._screen_area.x = self._screen_area.y = 0 self._screen_area.width = Gdk.Screen.width() self._screen_area.height = Gdk.Screen.height() self._position_hint = self.ANCHORED self._cursor_x = -1 self._cursor_y = -1 self._palette = None self._cache_palette = True self._toggle_palette = False self._lock_palette = False self.locked = False def attach(self, parent): self.parent = parent def detach(self): self.parent = None if self._palette is not None: self._palette.destroy() self._palette = None def _get_position_for_alignment(self, alignment, palette_dim): palette_halign = alignment[0] palette_valign = alignment[1] invoker_halign = alignment[2] invoker_valign = alignment[3] if self._cursor_x == -1 or self._cursor_y == -1: position = _get_pointer_position(self.parent) (self._cursor_x, self._cursor_y) = position if self._position_hint is self.ANCHORED: rect = self.get_rect() else: dist = style.PALETTE_CURSOR_DISTANCE rect = Gdk.Rectangle() rect.x = self._cursor_x - dist rect.y = self._cursor_y - dist rect.width = rect.height = dist * 2 palette_width, palette_height = palette_dim.width, palette_dim.height x = rect.x + rect.width * invoker_halign + \ palette_width * palette_halign y = rect.y + rect.height * invoker_valign + \ palette_height * palette_valign rect = Gdk.Rectangle() rect.x = int(x) rect.y = int(y) rect.width = palette_width rect.height = palette_height return rect def _in_screen(self, rect): return rect.x >= self._screen_area.x and \ rect.y >= self._screen_area.y and \ rect.x + rect.width <= self._screen_area.width and \ rect.y + rect.height <= self._screen_area.height def _get_area_in_screen(self, rect): """Return area of rectangle visible in the screen""" x1 = max(rect.x, self._screen_area.x) y1 = max(rect.y, self._screen_area.y) x2 = min(rect.x + rect.width, self._screen_area.x + self._screen_area.width) y2 = min(rect.y + rect.height, self._screen_area.y + self._screen_area.height) return (x2 - x1) * (y2 - y1) def _get_alignments(self): if self._position_hint is self.AT_CURSOR: return [(0.0, 0.0, 1.0, 1.0), (0.0, -1.0, 1.0, 0.0), (-1.0, -1.0, 0.0, 0.0), (-1.0, 0.0, 0.0, 1.0)] else: return self.BOTTOM + self.RIGHT + self.TOP + self.LEFT def get_position_for_alignment(self, alignment, palette_dim): rect = self._get_position_for_alignment(alignment, palette_dim) if self._in_screen(rect): return rect else: return None def get_position(self, palette_dim): alignment = self.get_alignment(palette_dim) rect = self._get_position_for_alignment(alignment, palette_dim) # In case our efforts to find an optimum place inside the screen # failed, just make sure the palette fits inside the screen if at all # possible. rect.x = max(0, rect.x) rect.y = max(0, rect.y) rect.x = min(rect.x, self._screen_area.width - rect.width) rect.y = min(rect.y, self._screen_area.height - rect.height) return rect def get_alignment(self, palette_dim): best_alignment = None best_area = -1 for alignment in self._get_alignments(): pos = self._get_position_for_alignment(alignment, palette_dim) if self._in_screen(pos): return alignment area = self._get_area_in_screen(pos) if area > best_area: best_alignment = alignment best_area = area # Palette horiz/vert alignment ph = best_alignment[0] pv = best_alignment[1] # Invoker horiz/vert alignment ih = best_alignment[2] iv = best_alignment[3] rect = self.get_rect() screen_area = self._screen_area if best_alignment in self.LEFT or best_alignment in self.RIGHT: dtop = rect.y - screen_area.y dbottom = screen_area.y + screen_area.height - rect.y - rect.width iv = 0 # Set palette_valign to align to screen on the top if dtop > dbottom: pv = -float(dtop) / palette_dim.height # Set palette_valign to align to screen on the bottom else: pv = -float(palette_dim.height - dbottom - rect.height) \ / palette_dim.height elif best_alignment in self.TOP or best_alignment in self.BOTTOM: dleft = rect.x - screen_area.x dright = screen_area.x + screen_area.width - rect.x - rect.width ih = 0 if palette_dim.width == 0: ph = 0 else: # Set palette_halign to align to screen on left if dleft > dright: ph = -float(dleft) / palette_dim.width # Set palette_halign to align to screen on right else: ph = -float(palette_dim.width - dright - rect.width) \ / palette_dim.width return (ph, pv, ih, iv) def has_rectangle_gap(self): return False def draw_rectangle(self, event, palette): pass def notify_popup(self): pass def notify_popdown(self): self._cursor_x = -1 self._cursor_y = -1 def _ensure_palette_exists(self): if self.parent and self.palette is None: palette = self.parent.create_palette() if palette is not None: self.palette = palette def notify_mouse_enter(self): self._ensure_palette_exists() self.emit('mouse-enter') def notify_mouse_leave(self): self.emit('mouse-leave') def notify_right_click(self, x=None, y=None): ''' Notify the palette invoker of a right click and expand the palette as required. The x and y args should be that of where the event happened, relative to the root of the screen. Args x (float): the x coord of the event relative to the root of the screen, eg. :class:`Gdk.EventTouch.x_root` y (float): the y coord of the event relative to the root of the screen, eg. :class:`Gdk.EventTouch.y_root` ''' self._ensure_palette_exists() self._process_event(x, y) self.emit('right-click') def notify_toggle_state(self): self._ensure_palette_exists() self.emit('toggle-state') def _process_event(self, x, y): if x is None or y is None: return self._cursor_x = x self._cursor_y = y def get_palette(self): return self._palette def set_palette(self, palette): if self._palette is not None: self._palette.popdown(immediate=True) self._palette.props.invoker = None # GTK pops down the palette before it invokes the actions on the # menu item. We need to postpone destruction of the palette until # after all signals have propagated from the menu item to the # palette owner. GLib.idle_add(lambda old_palette=self._palette: old_palette.destroy(), priority=GLib.PRIORITY_LOW) self._palette = palette if self._palette is not None: self._palette.props.invoker = self self._palette.connect('popdown', self.__palette_popdown_cb) palette = GObject.Property( type=object, setter=set_palette, getter=get_palette) def get_cache_palette(self): return self._cache_palette def set_cache_palette(self, cache_palette): self._cache_palette = cache_palette cache_palette = GObject.Property(type=object, setter=set_cache_palette, getter=get_cache_palette) """Whether the invoker will cache the palette after its creation. Defaults to True. """ def get_toggle_palette(self): return self._toggle_palette def set_toggle_palette(self, toggle_palette): self._toggle_palette = toggle_palette toggle_palette = GObject.Property(type=object, setter=set_toggle_palette, getter=get_toggle_palette) """Whether the invoker will popup/popdown the Palette on button left click/touch tap. Defaults to False. """ def get_lock_palette(self): return self._lock_palette def set_lock_palette(self, lock_palette): self._lock_palette = lock_palette lock_palette = GObject.Property(type=object, setter=set_lock_palette, getter=get_lock_palette) """Whether the invoker will lock the Palette and ignore mouse events. Defaults to False. """ def __palette_popdown_cb(self, palette): if not self.props.cache_palette: self.set_palette(None) def primary_text_clicked(self): """Implemented by invokers that can be clicked""" pass class WidgetInvoker(Invoker): def __init__(self, parent=None, widget=None): Invoker.__init__(self) self._widget = None self._expanded = False self._pointer_position = (-1, -1) self._enter_hid = None self._leave_hid = None self._release_hid = None self._click_hid = None self._touch_hid = None self._draw_hid = None self._long_pressed_recognized = False self._long_pressed_hid = None self._long_pressed_controller = SugarGestures.LongPressController() if parent or widget: self.attach_widget(parent, widget) def attach_widget(self, parent, widget=None): if widget: self._widget = widget else: self._widget = parent self._pointer_position = _get_pointer_position(self._widget) self.notify('widget') self._enter_hid = self._widget.connect('enter-notify-event', self.__enter_notify_event_cb) self._leave_hid = self._widget.connect('leave-notify-event', self.__leave_notify_event_cb) if GObject.signal_lookup('clicked', self._widget) != 0: self._click_hid = self._widget.connect('clicked', self.__click_event_cb) self._touch_hid = self._widget.connect('touch-event', self.__touch_event_cb) self._release_hid = \ self._widget.connect('button-release-event', self.__button_release_event_cb) self._draw_hid = self._widget.connect_after('draw', self.__drawing_cb) self._long_pressed_hid = self._long_pressed_controller.connect( 'pressed', self.__long_pressed_event_cb, self._widget) self._long_pressed_controller.attach( self._widget, SugarGestures.EventControllerFlags.NONE) self.attach(parent) def detach(self): Invoker.detach(self) self._widget.disconnect(self._enter_hid) self._widget.disconnect(self._leave_hid) self._widget.disconnect(self._release_hid) self._widget.disconnect(self._draw_hid) if self._click_hid: self._widget.disconnect(self._click_hid) self._widget.disconnect(self._touch_hid) self._long_pressed_controller.detach(self._widget) self._long_pressed_controller.disconnect(self._long_pressed_hid) def get_rect(self): allocation = self._widget.get_allocation() window = self._widget.get_window() if window is not None: res_, x, y = window.get_origin() else: logging.warning( "Trying to position palette with invoker that's not realized.") x = 0 y = 0 if not self._widget.get_has_window(): x += allocation.x y += allocation.y rect = Gdk.Rectangle() rect.x = x rect.y = y rect.width = allocation.width rect.height = allocation.height return rect def has_rectangle_gap(self): return True def draw_rectangle(self, cr, palette): allocation = self.parent.get_allocation() context = self.parent.get_style_context() context.add_class('toolitem') context.add_class('palette-down') gap = _calculate_gap(self.get_rect(), palette.get_rect()) if gap: Gtk.render_frame_gap(context, cr, 0, 0, allocation.width, allocation.height, gap[0], gap[1], gap[1] + gap[2]) def __enter_notify_event_cb(self, widget, event): if (event.x_root, event.y_root) == self._pointer_position: self._pointer_position = (-1, -1) return False if event.mode == Gdk.CrossingMode.NORMAL: self.notify_mouse_enter() def __leave_notify_event_cb(self, widget, event): if event.mode == Gdk.CrossingMode.NORMAL: self.notify_mouse_leave() def __touch_event_cb(self, button, event): if event.type == Gdk.EventType.TOUCH_END: if self._long_pressed_recognized: self._long_pressed_recognized = False return True return False def __click_event_cb(self, button): event = Gtk.get_current_event() if not event: # not an event from a user interaction, this can be when # the clicked event is emitted on a 'active' property # change of ToggleToolButton for example return if event and button != Gtk.get_event_widget(event): # another special case for the ToggleToolButton: this handles # the case where we select an item and the active property # of the other one changes to 'False' return if self.props.lock_palette and not self.locked: self.locked = True if hasattr(self.parent, 'set_expanded'): self.parent.set_expanded(True) if self.props.toggle_palette: self.notify_toggle_state() def __button_release_event_cb(self, widget, event): if event.button == 1 and not self._click_hid: if self.props.lock_palette and not self.locked: self.locked = True if hasattr(self.parent, 'set_expanded'): self.parent.set_expanded(True) if self.props.toggle_palette: self.notify_toggle_state() elif event.button == 3: self.notify_right_click(event.x_root, event.y_root) return True else: return False def __long_pressed_event_cb(self, controller, x, y, widget): self._long_pressed_recognized = True self.notify_right_click(x, y) def get_toplevel(self): return self._widget.get_toplevel() def notify_popup(self): Invoker.notify_popup(self) self._widget.queue_draw() def notify_popdown(self): self.locked = False Invoker.notify_popdown(self) self._widget.queue_draw() def _get_widget(self): return self._widget widget = GObject.Property(type=object, getter=_get_widget, setter=None) def __drawing_cb(self, widget, cr): if not self.props.lock_palette: return False alloc = widget.get_allocation() arrow_size = style.TOOLBAR_ARROW_SIZE / 2 y = alloc.height - arrow_size x = (alloc.width - arrow_size) / 2 context = widget.get_style_context() context.add_class('toolitem') if self.locked: Gtk.render_arrow(context, cr, 0, x, y, arrow_size) else: Gtk.render_arrow(context, cr, math.pi, x, y, arrow_size) class CursorInvoker(Invoker): def __init__(self, parent=None): Invoker.__init__(self) self._position_hint = self.AT_CURSOR self._pointer_position = (-1, -1) self._enter_hid = None self._leave_hid = None self._release_hid = None self._item = None self._long_pressed_recognized = False self._long_pressed_hid = None self._long_pressed_controller = SugarGestures.LongPressController() if parent: self.attach(parent) def attach(self, parent): Invoker.attach(self, parent) self._item = parent self._pointer_position = _get_pointer_position(self.parent) self._enter_hid = self._item.connect('enter-notify-event', self.__enter_notify_event_cb) self._leave_hid = self._item.connect('leave-notify-event', self.__leave_notify_event_cb) self._release_hid = self._item.connect('button-release-event', self.__button_release_event_cb) self._long_pressed_hid = self._long_pressed_controller.connect( 'pressed', self.__long_pressed_event_cb, self._item) self._long_pressed_controller.attach( self._item, SugarGestures.EventControllerFlags.NONE) def detach(self): Invoker.detach(self) self._item.disconnect_by_func(self.__enter_notify_event_cb) self._item.disconnect_by_func(self.__leave_notify_event_cb) self._item.disconnect_by_func(self.__button_release_event_cb) self._long_pressed_controller.detach(self._item) self._long_pressed_controller.disconnect(self._long_pressed_hid) def get_default_position(self): return self.AT_CURSOR def get_rect(self): window = self._item.get_window() allocation = self._item.get_allocation() rect = Gdk.Rectangle() rect.x, rect.y = window.get_root_coords(allocation.x, allocation.y) rect.width = allocation.width rect.height = allocation.height return rect def __enter_notify_event_cb(self, button, event): if (event.x_root, event.y_root) == self._pointer_position: self._pointer_position = (-1, -1) return False if event.mode == Gdk.CrossingMode.NORMAL: self.notify_mouse_enter() return False def __leave_notify_event_cb(self, button, event): if event.mode == Gdk.CrossingMode.NORMAL: self.notify_mouse_leave() return False def __button_release_event_cb(self, button, event): # check if the release is done outside of the parent widget alloc = self._item.get_allocation() if not (0 < event.x < alloc.width and 0 < event.y < alloc.height): return False if self._long_pressed_recognized: self._long_pressed_recognized = False return True if event.button == 1: if self.props.toggle_palette: self.notify_toggle_state() if event.button == 3: self.notify_right_click(event.x_root, event.y_root) return True else: return False def __long_pressed_event_cb(self, controller, x, y, widget): self._long_pressed_recognized = True x, y = widget.get_window().get_root_coords(x, y) self.notify_right_click(x, y) def get_toplevel(self): return self._item.get_toplevel() class ToolInvoker(WidgetInvoker): ''' A palette invoker for toolbar buttons and other items. This invoker will properly align the palette so that is perpendicular to the toolbar (a horizontal toolbar will spawn a palette going downwards). It also draws the highlights specific to a toolitem. For :class:`sugar3.graphics.toolbutton.ToolButton` and subclasses, you should not use the toolinvoker directly. Instead, just subclass the tool button and override the `create_palette` function. Args: parent (Gtk.Widget): toolitem to connect invoker to ''' def __init__(self, parent=None): WidgetInvoker.__init__(self) self._tool = None if parent: self.attach_tool(parent) def attach_tool(self, widget): ''' Attach a toolitem to the invoker. Same behaviour as passing the `parent` argument to the constructor. Args: widget (Gtk.Widget): toolitem to connect invoker to ''' self._tool = widget self.attach_widget(widget, widget.get_child()) def _get_alignments(self): parent = self._widget.get_parent() if parent is None: return WidgetInvoker._get_alignments(self) if parent.get_orientation() is Gtk.Orientation.HORIZONTAL: return self.BOTTOM + self.TOP else: return self.LEFT + self.RIGHT def primary_text_clicked(self): self._widget.emit('clicked') def notify_popup(self): WidgetInvoker.notify_popup(self) self._tool.queue_draw() def notify_popdown(self): WidgetInvoker.notify_popdown(self) self._tool.queue_draw() class TreeViewInvoker(Invoker): def __init__(self): Invoker.__init__(self) self._tree_view = None self._motion_hid = None self._release_hid = None self._long_pressed_hid = None self._position_hint = self.AT_CURSOR self._long_pressed_controller = SugarGestures.LongPressController() self._tree_view = None self._path = None self._column = None self.palette = None def attach_treeview(self, tree_view): self._tree_view = tree_view self._motion_hid = tree_view.connect('motion-notify-event', self.__motion_notify_event_cb) self._release_hid = tree_view.connect('button-release-event', self.__button_release_event_cb) self._long_pressed_hid = self._long_pressed_controller.connect( 'pressed', self.__long_pressed_event_cb, tree_view) self._long_pressed_controller.attach( tree_view, SugarGestures.EventControllerFlags.NONE) Invoker.attach(self, tree_view) def detach(self): Invoker.detach(self) self._tree_view.disconnect(self._motion_hid) self._tree_view.disconnect(self._release_hid) self._long_pressed_controller.detach(self._tree_view) self._long_pressed_controller.disconnect(self._long_pressed_hid) def get_rect(self): return self._tree_view.get_background_area(self._path, self._column) def get_toplevel(self): return self._tree_view.get_toplevel() def __motion_notify_event_cb(self, widget, event): here = self._tree_view.get_path_at_pos(int(event.x), int(event.y)) if here is None: if self._path is not None: self.notify_mouse_leave() self._path = None self._column = None return path, column, x_, y_ = here if path != self._path or column != self._column: self._redraw_cell(self._path, self._column) self._redraw_cell(path, column) self._path = path self._column = column if self.palette is not None: self.palette.popdown(immediate=True) self.palette = None self.notify_mouse_enter() def _redraw_cell(self, path, column): area = self._tree_view.get_background_area(path, column) x, y = \ self._tree_view.convert_bin_window_to_widget_coords(area.x, area.y) self._tree_view.queue_draw_area(x, y, area.width, area.height) def __button_release_event_cb(self, widget, event): x, y = int(event.x), int(event.y) here = self._tree_view.get_path_at_pos(x, y) if here is None: return False path, column, cell_x, cell_y = here self._path = path self._column = column if event.button == 1: # left mouse button if self.palette is not None: self.palette.popdown(immediate=True) # NOTE: we don't use columns with more than one cell cellrenderer = column.get_cells()[0] if cellrenderer is not None and \ isinstance(cellrenderer, CellRendererIcon): cellrenderer.emit('clicked', path) # So the treeview receives it and knows a drag isn't going on return False elif event.button == 3: # right mouse button self._ensure_palette_exists() self.notify_right_click(event.x_root, event.y_root) return True else: return False def __long_pressed_event_cb(self, controller, x, y, widget): path, column, x_, y_ = self._tree_view.get_path_at_pos(x, y) self._path = path self._column = column self._ensure_palette_exists() self.notify_right_click(x, y) def _ensure_palette_exists(self): if hasattr(self._tree_view, 'create_palette'): self.palette = self._tree_view.create_palette( self._path, self._column) else: self.palette = None def notify_popdown(self): Invoker.notify_popdown(self) self.palette = None