Ticket #1447: 0001-Added-Close-button-to-activity-launcher-rewrote-lay.patch

src/jarabe/model/shell.py

@@ -572 +572 @@
                 home_activity.get_type())
             home_activity.props.launching = False
             self._remove_activity(home_activity)
+            self.emit('launch-failed', home_activity)
         else:
             logging.error('Model for activity id %s does not exist.',
                 activity_id)
 
-        self.emit('launch-failed', home_activity)
-
+    def notify_activity_ended(self, activity_id):
+        home_activity = self.get_activity_by_id(activity_id)
+        if home_activity:
+            if home_activity.props.launching:
+                logging.debug('Activity %s (%s) ended while still launching, '\
+                              'assuming it failed.', activity_id,
+                              home_activity.get_type())
+                self.notify_launch_failed(activity_id)
+            else:
+                logging.debug("Activity %s ended", activity_id) 
+                self._remove_activity(home_activity)
+        else:
+            # The activity may have already been removed when its window closed.
+            pass
+    
     def _check_activity_launched(self, activity_id):
         home_activity = self.get_activity_by_id(activity_id)
 

src/jarabe/view/launcher.py

@@ -15 +15 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 import logging
+from gettext import gettext as _
+
+import math
 
 import gtk
 import hippo
 import gobject
 
 from sugar import wm
+from sugar.presence import presenceservice
 from sugar.graphics import style
 from sugar.graphics import animator
 from sugar.graphics.xocolor import XoColor
+from sugar.graphics.icon import Icon
+from sugar.graphics.icon import CanvasIcon
 
 from jarabe.model import shell
-from jarabe.view.pulsingicon import CanvasPulsingIcon
+
+XOCOLOR_WHITE = XoColor("#ffffff,#ffffff")
+XOCOLOR_GRAY = XoColor('%s,%s' % (style.COLOR_BUTTON_GREY.get_svg(),
+                                  style.COLOR_WHITE.get_svg()))
+
+
+def _parse_svgcolor(str):
+    r = int(str[1:3], 16)
+    g = int(str[3:5], 16)
+    b = int(str[5:7], 16)
+    return r, g, b
+    
+def _parse_xocolor(xocolor):
+    stroke = _parse_svgcolor(xocolor.get_stroke_color())
+    fill = _parse_svgcolor(xocolor.get_fill_color())
+    return stroke, fill
+
+def _format_xocolor(stroke_rgb, fill_rgb):
+    return XoColor("#%02x%02x%02x,#%02x%02x%02x" % (stroke_rgb + fill_rgb))
+
+def _blend_rgb(a, b, current):
+    return (a[0] + (b[0] - a[0]) * current,
+            a[1] + (b[1] - a[1]) * current,
+            a[2] + (b[2] - a[2]) * current)
+    
+def _blend_xocolor(a, b, current):
+    stroke_a, fill_a = _parse_xocolor(a)
+    stroke_b, fill_b = _parse_xocolor(b)
+    stroke_c = _blend_rgb(stroke_a, stroke_b, current)
+    fill_c = _blend_rgb(fill_a, fill_b, current)
+    return _format_xocolor(stroke_c, fill_c)
+
+
+class _Layout(gobject.GObject, hippo.CanvasLayout):
+    __gtype_name__ = 'SugarLauncherLayout'
+    def __init__(self):
+        gobject.GObject.__init__(self)
+        self._box = None
+        
+        self._child_mode = []
+
+    # Note to reviewer:
+    # The child mode is kept in an array that parallels the children of the CanvasBox.
+    # This disallows objects from being deleted or hidden as the arrays would get out of sync.
+    # Is there a better way to attach a layout mode to each child?
+    def append_mode(self, child, mode):
+        self._child_mode.append(mode)
+
+    def do_set_box(self, box):
+        self._box = box
+
+    def do_get_height_request(self, for_width):
+        return 0, 0
+
+    def do_get_width_request(self):
+        return 0, 0
+
+    def do_allocate(self, x, y, width, height,
+                    req_width, req_height, origin_changed):
+        
+        circle_angle = -math.pi/2
+        circle_radius = min(width, height) * 0.4
+        
+        center_bottom_y = height * 3 / 4
+
+        i = 0
+        for child in self._box.get_layout_children():
+            mode = self._child_mode[i]
+            i += 1
+            
+            if mode == 'center-bottom':                    
+                min_width, child_width = child.get_width_request()
+                min_height, child_height = child.get_height_request(child_width)
+                
+                center_bottom_y -= (child_height + style.DEFAULT_SPACING) / 2
+                
+        i = 0
+        for child in self._box.get_layout_children():
+            min_width, child_width = child.get_width_request()
+            min_height, child_height = child.get_height_request(child_width)
+
+            mode = self._child_mode[i]
+            i += 1
+
+            if mode == 'center':                  
+                child.allocate(x + (width - child_width) / 2, 
+                               y + (height - child_height) / 2,
+                               child_width, child_height, origin_changed)
+            
+            if mode == 'center-bottom':                    
+                child.allocate(x + (width - child_width) / 2, 
+                               y + center_bottom_y,
+                               child_width, child_height, origin_changed)
+                center_bottom_y += child_height + style.DEFAULT_SPACING
+
+class _ZoomAnimation(animator.Animation):
+    def __init__(self, icon, start_size, end_size):
+        animator.Animation.__init__(self, 0.0, 1.0)
+
+        self._icon = icon
+        self._start_size = start_size
+        self._end_size = end_size
+        
+    def next_frame(self, current):
+        size = self._start_size + (self._end_size - self._start_size) * current
+        self._icon.props.size = int(size)
+    
+class _PulseAnimation(animator.Animation):
+    def __init__(self, icon, start_color, middle_color):
+        animator.Animation.__init__(self, 0.0, 1.0)
+
+        self._icon = icon
+        self._start_color = start_color
+        self._middle_color = middle_color
+        
+    def do_frame(self, t, duration, easing):
+        f = math.sin((t / duration) * math.pi)
+        color = _blend_xocolor(self._start_color, self._middle_color, f)
+        self._icon.xo_color = color
 
 class LaunchWindow(gtk.Window):
     def __init__(self, activity_id, icon_path, icon_color):
         gobject.GObject.__init__(self)
 
+        self._activity_id = activity_id
+        self._home_activity = None
+
+        self._icon_color = icon_color
+        
         self.props.type_hint = gtk.gdk.WINDOW_TYPE_HINT_NORMAL
         self.props.decorated = False
 
+        self._layout = _Layout()
+
+        self._box = hippo.CanvasBox()
+        self._box.set_layout(self._layout)
+
+        self._activity_icon = CanvasIcon(file_name=icon_path,
+                                         xo_color=self._icon_color)
+        self._box.append(self._activity_icon)
+        self._layout.append_mode(self._activity_icon, 'center')
+
+        self._error_text = hippo.CanvasText(text='',
+                                xalign=hippo.ALIGNMENT_CENTER,
+                                font_desc=style.FONT_BOLD.get_pango_desc(),
+                                color=style.COLOR_BUTTON_GREY.get_int())
+        self._box.append(self._error_text)
+        self._layout.append_mode(self._error_text, 'center-bottom')
+
+        button = gtk.Button(label=_('Stop'))
+        button.connect('clicked', self.__close_button_clicked_cb)
+        button.props.image = Icon(icon_name='activity-stop',
+                                  icon_size=gtk.ICON_SIZE_BUTTON)
+        self._close_button = hippo.CanvasWidget(widget=button,
+                                                xalign=hippo.ALIGNMENT_CENTER)
+        self._box.append(self._close_button)
+        self._layout.append_mode(self._close_button, 'center-bottom')
+
+        self._box.set_child_visible(self._error_text, False)       
+        self._box.set_child_visible(self._close_button, False)
+
         canvas = hippo.Canvas()
         canvas.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color())
-        self.add(canvas)
-        canvas.show()
-
-        self._activity_id = activity_id
-        self._box = LaunchBox(activity_id, icon_path, icon_color)
         canvas.set_root(self._box)
+        canvas.show()
+        self.add(canvas)
 
         self.connect('realize', self.__realize_cb)
 
         screen = gtk.gdk.screen_get_default()
         screen.connect('size-changed', self.__size_changed_cb)
-
         self._update_size()
+        
+        anim = animator.Animator(1.0)
+        anim.add(_PulseAnimation(self._activity_icon, 
+                                 self._icon_color, XOCOLOR_GRAY))          
+        anim.add(_ZoomAnimation(self._activity_icon, 
+                                style.STANDARD_ICON_SIZE, style.XLARGE_ICON_SIZE))          
+        anim.start()
+
+        self._timeout_id = gobject.timeout_add(3000, self._pulse_icon)
+
+    def _pulse_icon(self):
+        anim = animator.Animator(1.0)
+        anim.add(_PulseAnimation(self._activity_icon, 
+                                 self._icon_color, XOCOLOR_GRAY))          
+        anim.start()
+        return True
 
     def show(self):
         self.present()
-        self._box.zoom_in()
 
     def _update_size(self):
         self.resize(gtk.gdk.screen_width(), gtk.gdk.screen_height())
@@ -66 +235 @@
     def __size_changed_cb(self, screen):
         self._update_size()
 
-class LaunchBox(hippo.CanvasBox):
-    def __init__(self, activity_id, icon_path, icon_color):
-        gobject.GObject.__init__(self, orientation=hippo.ORIENTATION_VERTICAL)
+    def show_failed(self, home_activity):
+        logging.debug("Displaying failure message on launcher")
+        
+        gobject.source_remove(self._timeout_id)
+        
+        self._home_activity = home_activity
 
-        self._activity_id = activity_id
-        self._activity_icon = CanvasPulsingIcon(
-            file_name=icon_path,
-            pulse_color=icon_color,
-            background_color=style.COLOR_WHITE.get_gdk_color())
-        self.append(self._activity_icon, hippo.PACK_EXPAND)
-
-        # FIXME support non-xo colors in CanvasPulsingIcon
-        self._activity_icon.props.base_color = \
-            XoColor('%s,%s' % (style.COLOR_BUTTON_GREY.get_svg(),
-                               style.COLOR_TRANSPARENT.get_svg()))
-
-        self._animator = animator.Animator(1.0)
-
-        self._home = shell.get_model()
-        self._home.connect('active-activity-changed',
-                           self.__active_activity_changed_cb)
-
-        self.connect('destroy', self.__destroy_cb)
-
-    def __destroy_cb(self, box):
-        self._activity_icon.props.pulsing = False
-        self._home.disconnect_by_func(self.__active_activity_changed_cb)
-
-    def zoom_in(self):
-        self._activity_icon.props.size = style.STANDARD_ICON_SIZE
-
-        self._animator.remove_all()
-        self._animator.add(_Animation(self._activity_icon,
-                                      style.STANDARD_ICON_SIZE,
-                                      style.XLARGE_ICON_SIZE))
-        self._animator.start()
-        self._activity_icon.props.pulsing = True
-
-    def __active_activity_changed_cb(self, model, activity):
-        if activity.get_activity_id() == self._activity_id:
-            self._activity_icon.props.paused = False
-        else:
-            self._activity_icon.props.paused = True
-
-class _Animation(animator.Animation):
-    def __init__(self, icon, start_size, end_size):
-        animator.Animation.__init__(self, 0.0, 1.0)
+        self._box.set_child_visible(self._error_text, True)       
+        self._box.set_child_visible(self._close_button, True)
 
-        self._icon = icon
-        self.start_size = start_size
-        self.end_size = end_size
+        self._error_text.props.text = _('%s failed to start.') % \
+                                        home_activity.get_activity_name()
 
-    def next_frame(self, current):
-        d = (self.end_size - self.start_size) * current
-        self._icon.props.size = int(self.start_size + d)
+    def __close_button_clicked_cb(self, button):
+        _destroy_launcher(self._home_activity)
 
 _launchers = {}
 
@@ -131 +260 @@
     model.connect('launch-completed', __launch_completed_cb)
 
 def add_launcher(activity_id, icon_path, icon_color):
-
     if activity_id in _launchers:
         return
 
@@ -145 +273 @@
                  home_activity.get_icon_color())
 
 def __launch_failed_cb(home_model, home_activity):
-    _destroy_launcher(home_activity)
+    activity_id = home_activity.get_activity_id()
+
+    if activity_id in _launchers:
+        _launchers[activity_id].show_failed(home_activity)
+    else:
+        logging.error('Launcher for %s is missing', activity_id)
 
 def __launch_completed_cb(home_model, home_activity):
     _destroy_launcher(home_activity)

src/jarabe/view/service.py

@@ -98 +98 @@
     def NotifyLaunchFailure(self, activity_id):
         shell.get_model().notify_launch_failed(activity_id)
 
+    @dbus.service.method(_DBUS_SHELL_IFACE,
+                         in_signature="s", out_signature="")
+    def NotifyActivityEnded(self, activity_id):
+        shell.get_model().notify_activity_ended(activity_id)
+
     @dbus.service.signal(_DBUS_OWNER_IFACE, signature="s")
     def ColorChanged(self, color):
         pass