You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1564 lines
52 KiB
Python
1564 lines
52 KiB
Python
# Copyright (C) 2007, Eduardo Silva <edsiper@gmail.com>
|
|
# Copyright (C) 2008, One Laptop Per Child
|
|
# Copyright (C) 2009, Tomeu Vizoso
|
|
# Copyright (C) 2011, Benjamin Berg <benjamin@sipsolutions.net>
|
|
# Copyright (C) 2011, Marco Pesenti Gritti <marco@marcopg.org>
|
|
#
|
|
# 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
|