From 3f792924ddf4dba301d06e496ac6e29296fbd4e9 Mon Sep 17 00:00:00 2001 From: flavio Date: Fri, 09 Nov 2012 23:58:22 +0000 Subject: Gtk 3 Port Base --- (limited to 'toolkit/internals/palettewindow.py') diff --git a/toolkit/internals/palettewindow.py b/toolkit/internals/palettewindow.py index d8c4326..50fc567 100644 --- a/toolkit/internals/palettewindow.py +++ b/toolkit/internals/palettewindow.py @@ -23,41 +23,50 @@ STABLE. import logging -import gtk -import gobject -import hippo +import gi +from gi.repository import Gtk +from gi.repository import Gdk +from gi.repository import GObject +# FIXME: We do not use hippo +#import hippo -from sugar.graphics import palettegroup -from sugar.graphics import animator -from sugar.graphics import style +from sugar3.graphics import palettegroup +from sugar3.graphics import animator +from sugar3.graphics import style 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.POS_BOTTOM + gap_side = Gtk.PositionType.BOTTOM + elif a.x + a.width == b.x: - gap_side = gtk.POS_RIGHT + gap_side = Gtk.PositionType.RIGHT + elif a.x == b.x + b.width: - gap_side = gtk.POS_LEFT + gap_side = Gtk.PositionType.LEFT + elif a.y == b.y + b.height: - gap_side = gtk.POS_TOP + gap_side = Gtk.PositionType.TOP + else: gap = False if gap: - if gap_side == gtk.POS_BOTTOM or gap_side == gtk.POS_TOP: + 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.POS_RIGHT or gap_side == gtk.POS_LEFT: + (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) + (b.y + b.height) - a.y) - gap_start) if gap and gap_size > 0: return (gap_side, gap_start, gap_size) @@ -65,11 +74,11 @@ def _calculate_gap(a, b): return False -class MouseSpeedDetector(gobject.GObject): +class MouseSpeedDetector(GObject.GObject): __gsignals__ = { - 'motion-slow': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), - 'motion-fast': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), + 'motion-slow': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), + 'motion-fast': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), } _MOTION_SLOW = 1 @@ -80,7 +89,7 @@ class MouseSpeedDetector(gobject.GObject): delay in msec threshold in pixels (per tick of 'delay' msec)""" - gobject.GObject.__init__(self) + GObject.GObject.__init__(self) self._threshold = thresh self._parent = parent @@ -90,37 +99,48 @@ class MouseSpeedDetector(gobject.GObject): self._mouse_pos = None def start(self): + self.stop() self._mouse_pos = self._get_mouse_position() - self._timeout_hid = gobject.timeout_add(self._delay, self._timer_cb) + self._timeout_hid = GObject.timeout_add(self._delay, self._timer_cb) def stop(self): + if self._timeout_hid is not None: - gobject.source_remove(self._timeout_hid) + GObject.source_remove(self._timeout_hid) + self._state = None def _get_mouse_position(self): - display = gtk.gdk.display_get_default() + + display = Gdk.display_get_default() screen_, x, y, mask_ = display.get_pointer() + return (x, y) def _detect_motion(self): + oldx, oldy = self._mouse_pos (x, y) = self._get_mouse_position() 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 @@ -128,15 +148,16 @@ class MouseSpeedDetector(gobject.GObject): return True -class PaletteWindow(gtk.Window): +class PaletteWindow(Gtk.Window): __gsignals__ = { - 'popup': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), - 'popdown': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), - 'activate': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), + 'popup': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), + 'popdown': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), + 'activate': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), } - def __init__(self, **kwargs): + def __init__(self): + self._group_id = None self._invoker = None self._invoker_hids = [] @@ -152,14 +173,14 @@ class PaletteWindow(gtk.Window): self._popdown_anim = animator.Animator(0.6, 10) self._popdown_anim.add(_PopdownAnimation(self)) - gobject.GObject.__init__(self, **kwargs) + GObject.GObject.__init__(self) self.set_decorated(False) self.set_resizable(False) # Just assume xthickness and ythickness are the same self.set_border_width(self.get_style().xthickness) - accel_group = gtk.AccelGroup() + accel_group = Gtk.AccelGroup() self.set_data('sugar-accel-group', accel_group) self.add_accel_group(accel_group) @@ -176,14 +197,17 @@ class PaletteWindow(gtk.Window): self._mouse_detector.connect('motion-slow', self._mouse_slow_cb) def __destroy_cb(self, palette): + self.set_group_id(None) def set_invoker(self, invoker): + for hid in self._invoker_hids[:]: self._invoker.disconnect(hid) self._invoker_hids.remove(hid) self._invoker = invoker + if invoker is not None: self._invoker_hids.append(self._invoker.connect( 'mouse-enter', self._invoker_mouse_enter_cb)) @@ -193,20 +217,26 @@ class PaletteWindow(gtk.Window): 'right-click', self._invoker_right_click_cb)) def get_invoker(self): + return self._invoker - invoker = gobject.property(type=object, - getter=get_invoker, - setter=set_invoker) + invoker = GObject.property( + type=object, + getter=get_invoker, + setter=set_invoker) def __realize_cb(self, widget): - self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG) + + #self.window.set_type_hint(Gdk.WINDOW_TYPE_HINT_DIALOG) + self.window.set_type_hint(Gdk.WindowType.POPUP) 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(): @@ -222,30 +252,37 @@ class PaletteWindow(gtk.Window): self.popup(immediate=immediate) def is_up(self): + return self._up def set_group_id(self, group_id): + if self._group_id: group = palettegroup.get_group(self._group_id) group.remove(self) + if group_id: self._group_id = group_id group = palettegroup.get_group(group_id) group.add(self) def get_group_id(self): + return self._group_id - group_id = gobject.property(type=str, - getter=get_group_id, - setter=set_group_id) + group_id = GObject.property( + type=str, + getter=get_group_id, + setter=set_group_id) def do_size_request(self, requisition): - gtk.Window.do_size_request(self, requisition) + + Gtk.Window.do_size_request(self, requisition) requisition.width = max(requisition.width, style.GRID_CELL_SIZE * 2) def do_size_allocate(self, allocation): - gtk.Window.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 \ @@ -268,6 +305,7 @@ class PaletteWindow(gtk.Window): palette = self.get_rect() gap = _calculate_gap(palette, invoker) + else: gap = False @@ -275,18 +313,19 @@ class PaletteWindow(gtk.Window): wstyle = self.get_style() if gap: - wstyle.paint_box_gap(event.window, gtk.STATE_PRELIGHT, - gtk.SHADOW_IN, event.area, self, "palette", - 0, 0, allocation.width, allocation.height, - gap[0], gap[1], gap[2]) + wstyle.paint_box_gap(event.window, Gtk.StateType.PRELIGHT, + Gtk.ShadowType.IN, event.area, self, "palette", + 0, 0, allocation.width, allocation.height, + gap[0], gap[1], gap[2]) + else: - wstyle.paint_box(event.window, gtk.STATE_PRELIGHT, - gtk.SHADOW_IN, event.area, self, "palette", - 0, 0, allocation.width, allocation.height) + wstyle.paint_box(event.window, Gtk.StateType.PRELIGHT, + Gtk.ShadowType.IN, event.area, self, "palette", + 0, 0, allocation.width, allocation.height) # Fall trough to the container expose handler. # (Leaving out the window expose handler which redraws everything) - gtk.Bin.do_expose_event(self, event) + Gtk.Bin.do_expose_event(self, event) def update_position(self): invoker = self._invoker @@ -360,13 +399,13 @@ class PaletteWindow(gtk.Window): self.popup(immediate=True) def __enter_notify_event_cb(self, widget, event): - if event.detail != gtk.gdk.NOTIFY_INFERIOR and \ - event.mode == gtk.gdk.CROSSING_NORMAL: + if event.detail != Gdk.NotifyType.INFERIOR and \ + event.mode == Gdk.CROSSING_NORMAL: self.on_enter(event) def __leave_notify_event_cb(self, widget, event): - if event.detail != gtk.gdk.NOTIFY_INFERIOR and \ - event.mode == gtk.gdk.CROSSING_NORMAL: + if event.detail != Gdk.NotifyType.INFERIOR and \ + event.mode == Gdk.CROSSING_NORMAL: self.on_leave(event) def __show_cb(self, widget): @@ -393,7 +432,7 @@ class PaletteWindow(gtk.Window): y = win_y + rectangle.y width, height = self.size_request() - return gtk.gdk.Rectangle(x, y, width, height) + return Gdk.Rectangle(x, y, width, height) def get_palette_state(self): return self._palette_state @@ -429,13 +468,13 @@ class _PopdownAnimation(animator.Animation): self._palette.popdown(immediate=True) -class Invoker(gobject.GObject): +class Invoker(GObject.GObject): __gsignals__ = { - 'mouse-enter': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), - 'mouse-leave': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), - 'right-click': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), - 'focus-out': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])), + 'mouse-enter': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), + 'mouse-leave': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), + 'right-click': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), + 'focus-out': (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE, ([])), } ANCHORED = 0 @@ -447,12 +486,13 @@ class Invoker(gobject.GObject): LEFT = [(-1.0, 0.0, 0.0, 0.0), (-1.0, -1.0, 0.0, 1.0)] def __init__(self): - gobject.GObject.__init__(self) + GObject.GObject.__init__(self) self.parent = None - self._screen_area = gtk.gdk.Rectangle(0, 0, gtk.gdk.screen_width(), - gtk.gdk.screen_height()) + self._screen_area = Gdk.Rectangle(0, 0, + Gdk.screen_width(), + Gdk.screen_height()) self._position_hint = self.ANCHORED self._cursor_x = -1 self._cursor_y = -1 @@ -474,7 +514,7 @@ class Invoker(gobject.GObject): invoker_valign = alignment[3] if self._cursor_x == -1 or self._cursor_y == -1: - display = gtk.gdk.display_get_default() + display = Gdk.display_get_default() screen_, x, y, mask_ = display.get_pointer() self._cursor_x = x self._cursor_y = y @@ -483,9 +523,9 @@ class Invoker(gobject.GObject): rect = self.get_rect() else: dist = style.PALETTE_CURSOR_DISTANCE - rect = gtk.gdk.Rectangle(self._cursor_x - dist, - self._cursor_y - dist, - dist * 2, dist * 2) + rect = Gdk.Rectangle(self._cursor_x - dist, + self._cursor_y - dist, + dist * 2, dist * 2) palette_width, palette_height = palette_dim @@ -495,8 +535,8 @@ class Invoker(gobject.GObject): y = rect.y + rect.height * invoker_valign + \ palette_height * palette_valign - return gtk.gdk.Rectangle(int(x), int(y), - palette_width, palette_height) + return Gdk.Rectangle(int(x), int(y), + palette_width, palette_height) def _in_screen(self, rect): return rect.x >= self._screen_area.x and \ @@ -526,13 +566,16 @@ class Invoker(gobject.GObject): 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) @@ -548,8 +591,10 @@ class Invoker(gobject.GObject): 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): @@ -617,8 +662,10 @@ class Invoker(gobject.GObject): 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 @@ -637,6 +684,7 @@ class Invoker(gobject.GObject): return self._palette def set_palette(self, palette): + if self._palette is not None: self._palette.popdown(immediate=True) @@ -648,13 +696,14 @@ class Invoker(gobject.GObject): if self._palette: self._palette.props.invoker = self - palette = gobject.property( + palette = GObject.property( type=object, setter=set_palette, getter=get_palette) class WidgetInvoker(Invoker): def __init__(self, parent=None, widget=None): + Invoker.__init__(self) self._widget = None @@ -666,8 +715,10 @@ class WidgetInvoker(Invoker): self.attach_widget(parent, widget) def attach_widget(self, parent, widget=None): + if widget: self._widget = widget + else: self._widget = parent @@ -683,36 +734,41 @@ class WidgetInvoker(Invoker): 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) def get_rect(self): + allocation = self._widget.get_allocation() if self._widget.window is not None: x, y = self._widget.window.get_origin() + else: logging.warning( "Trying to position palette with invoker that's not realized.") x = 0 y = 0 - if self._widget.flags() & gtk.NO_WINDOW: + if self._widget.flags() & Gtk.NO_WINDOW: x += allocation.x y += allocation.y width = allocation.width height = allocation.height - return gtk.gdk.Rectangle(x, y, width, height) + return Gdk.Rectangle(x, y, width, height) def has_rectangle_gap(self): return True def draw_rectangle(self, event, palette): - if self._widget.flags() & gtk.NO_WINDOW: + + if self._widget.flags() & Gtk.NO_WINDOW: x, y = self._widget.allocation.x, self._widget.allocation.y + else: x = y = 0 @@ -720,18 +776,18 @@ class WidgetInvoker(Invoker): gap = _calculate_gap(self.get_rect(), palette.get_rect()) if gap: - wstyle.paint_box_gap(event.window, gtk.STATE_PRELIGHT, - gtk.SHADOW_IN, event.area, self._widget, - "palette-invoker", x, y, - self._widget.allocation.width, - self._widget.allocation.height, - gap[0], gap[1], gap[2]) + wstyle.paint_box_gap(event.window, Gtk.SateType.PRELIGHT, + Gtk.ShadowType.IN, event.area, self._widget, + "palette-invoker", x, y, + self._widget.allocation.width, + self._widget.allocation.height, + gap[0], gap[1], gap[2]) else: - wstyle.paint_box(event.window, gtk.STATE_PRELIGHT, - gtk.SHADOW_IN, event.area, self._widget, - "palette-invoker", x, y, - self._widget.allocation.width, - self._widget.allocation.height) + wstyle.paint_box(event.window, Gtk.StateType.PRELIGHT, + Gtk.ShadowType.IN, event.area, self._widget, + "palette-invoker", x, y, + self._widget.allocation.width, + self._widget.allocation.height) def __enter_notify_event_cb(self, widget, event): self.notify_mouse_enter() @@ -740,9 +796,11 @@ class WidgetInvoker(Invoker): self.notify_mouse_leave() def __button_release_event_cb(self, widget, event): + if event.button == 3: self.notify_right_click() return True + else: return False @@ -759,7 +817,7 @@ class WidgetInvoker(Invoker): def _get_widget(self): return self._widget - widget = gobject.property(type=object, getter=_get_widget, setter=None) + widget = GObject.property(type=object, getter=_get_widget, setter=None) class CanvasInvoker(Invoker): @@ -780,9 +838,9 @@ class CanvasInvoker(Invoker): self._item = parent self._motion_hid = self._item.connect('motion-notify-event', - self.__motion_notify_event_cb) + self.__motion_notify_event_cb) self._release_hid = self._item.connect('button-release-event', - self.__button_release_event_cb) + self.__button_release_event_cb) def detach(self): Invoker.detach(self) @@ -797,15 +855,16 @@ class CanvasInvoker(Invoker): if context: x, y = context.translate_to_screen(self._item) width, height = self._item.get_allocation() - return gtk.gdk.Rectangle(x, y, width, height) + return Gdk.Rectangle(x, y, width, height) else: - return gtk.gdk.Rectangle() + return Gdk.Rectangle() def __motion_notify_event_cb(self, button, event): - if event.detail == hippo.MOTION_DETAIL_ENTER: - self.notify_mouse_enter() - elif event.detail == hippo.MOTION_DETAIL_LEAVE: - self.notify_mouse_leave() + # FIXME: We do not use hippo + #if event.detail == hippo.MOTION_DETAIL_ENTER: + # self.notify_mouse_enter() + #elif event.detail == hippo.MOTION_DETAIL_LEAVE: + # self.notify_mouse_leave() return False @@ -817,7 +876,9 @@ class CanvasInvoker(Invoker): return False def get_toplevel(self): - return hippo.get_canvas_for_item(self._item).get_toplevel() + # FIXME: We do not use hippo + #return hippo.get_canvas_for_item(self._item).get_toplevel() + pass class ToolInvoker(WidgetInvoker): @@ -836,7 +897,7 @@ class ToolInvoker(WidgetInvoker): if parent is None: return WidgetInvoker._get_alignments() - if parent.get_orientation() is gtk.ORIENTATION_HORIZONTAL: + if parent.get_orientation() is Gtk.Orientation.HORIZONTAL: return self.BOTTOM + self.TOP else: return self.LEFT + self.RIGHT @@ -845,6 +906,7 @@ class ToolInvoker(WidgetInvoker): class CellRendererInvoker(Invoker): def __init__(self): + Invoker.__init__(self) self._position_hint = self.AT_CURSOR @@ -860,11 +922,11 @@ class CellRendererInvoker(Invoker): self._cell_renderer = cell_renderer self._motion_hid = tree_view.connect('motion-notify-event', - self.__motion_notify_event_cb) + self.__motion_notify_event_cb) self._leave_hid = tree_view.connect('leave-notify-event', - self.__leave_notify_event_cb) + self.__leave_notify_event_cb) self._release_hid = tree_view.connect('button-release-event', - self.__button_release_event_cb) + self.__button_release_event_cb) self.attach(cell_renderer) @@ -875,53 +937,65 @@ class CellRendererInvoker(Invoker): self._tree_view.disconnect(self._release_hid) def get_rect(self): + allocation = self._tree_view.get_allocation() if self._tree_view.window is not None: x, y = self._tree_view.window.get_origin() + else: logging.warning( "Trying to position palette with invoker that's not realized.") x = 0 y = 0 - if self._tree_view.flags() & gtk.NO_WINDOW: + if self._tree_view.flags() & Gtk.NO_WINDOW: x += allocation.x y += allocation.y width = allocation.width height = allocation.height - return gtk.gdk.Rectangle(x, y, width, height) + return Gdk.Rectangle(x, y, width, height) def __motion_notify_event_cb(self, widget, event): + if event.window != widget.get_bin_window(): return + if self._point_in_cell_renderer(event.x, event.y): tree_view = self._tree_view path, column_, x_, y_ = tree_view.get_path_at_pos(int(event.x), - int(event.y)) + int(event.y)) + if path != self.path: if self.path is not None: self._redraw_path(self.path) + if path is not None: self._redraw_path(path) + if self.palette is not None: self.palette.popdown(immediate=True) self.palette = None + self.path = path self.notify_mouse_enter() + else: if self.path is not None: self._redraw_path(self.path) + self.path = None self.notify_mouse_leave() def _redraw_path(self, path): + for column in self._tree_view.get_columns(): if self._cell_renderer in column.get_cell_renderers(): break + area = self._tree_view.get_background_area(path, column) x, y = \ self._tree_view.convert_bin_window_to_widget_coords(area.x, area.y) @@ -931,22 +1005,26 @@ class CellRendererInvoker(Invoker): self.notify_mouse_leave() def __button_release_event_cb(self, widget, event): + if event.button == 1 and self._point_in_cell_renderer(event.x, event.y): tree_view = self._tree_view path, column_, x_, y_ = tree_view.get_path_at_pos(int(event.x), - int(event.y)) + int(event.y)) self._cell_renderer.emit('clicked', path) # So the treeview receives it and knows a drag isn't going on return False + if event.button == 3 and self._point_in_cell_renderer(event.x, event.y): self.notify_right_click() return True + else: return False def _point_in_cell_renderer(self, event_x, event_y): + pos = self._tree_view.get_path_at_pos(int(event_x), int(event_y)) if pos is None: return False @@ -958,6 +1036,7 @@ class CellRendererInvoker(Invoker): cell_x, cell_width = column.cell_get_position(cell_renderer) if x > cell_x and x < (cell_x + cell_width): return True + return False return False -- cgit v0.9.1