First go at refactoring zoom handling. Includes changes

by benzea for #7675.

6 files changed, 104 insertions, 95 deletions

diff --git a/src/jarabe/desktop/homewindow.py b/src/jarabe/desktop/homewindow.py
index e673414..e88fca6 100644
--- a/src/jarabe/desktop/homewindow.py
+++ b/src/jarabe/desktop/homewindow.py
@@ -40,7 +40,6 @@ class HomeWindow(gtk.Window):
         self.add_accel_group(accel_group)
 
         self._active = False
-        self._level = ShellModel.ZOOM_HOME
 
         self.set_default_size(gtk.gdk.screen_width(),
                               gtk.gdk.screen_height())
@@ -62,16 +61,14 @@ class HomeWindow(gtk.Window):
         self._mesh_box = MeshBox()
         self._transition_box = TransitionBox()
 
-        self._activate_view()
         self.add(self._home_box)
         self._home_box.show()
 
         self._transition_box.connect('completed',
                                      self._transition_completed_cb)
 
-        model = shell.get_model()
-        model.connect('notify::zoom-level', self.__zoom_level_changed_cb)
-        print model
+        shell.get_model().zoom_level_changed.connect(
+                                     self.__zoom_level_changed_cb)
 
     def _enter_notify_event_cb(self, window, event):
         if event.x != gtk.gdk.screen_width() / 2 or \
@@ -92,18 +89,18 @@ class HomeWindow(gtk.Window):
         self.disconnect(self._motion_sid)
         self.disconnect(self._enter_sid)
 
-    def _deactivate_view(self):
+    def _deactivate_view(self, level):
         group = palettegroup.get_group("default")
         group.popdown()
-        if self._level == ShellModel.ZOOM_HOME:
+        if level == ShellModel.ZOOM_HOME:
             self._home_box.suspend()
-        elif self._level == ShellModel.ZOOM_MESH:
+        elif level == ShellModel.ZOOM_MESH:
             self._mesh_box.suspend()
 
-    def _activate_view(self):
-        if self._level == ShellModel.ZOOM_HOME:
+    def _activate_view(self, level):
+        if level == ShellModel.ZOOM_HOME:
             self._home_box.resume()
-        elif self._level == ShellModel.ZOOM_MESH:
+        elif level == ShellModel.ZOOM_MESH:
             self._mesh_box.resume()
 
     def _visibility_notify_event_cb(self, window, event):
@@ -112,40 +109,55 @@ class HomeWindow(gtk.Window):
         else:
             self._activate_view()
 
-    def __zoom_level_changed_cb(self, model, pspec):
-        level = model.props.zoom_level
+    def __zoom_level_changed_cb(self, **kwargs):
+        old_level = kwargs['old_level']
+        new_level = kwargs['new_level']
+
+        self._deactivate_view(old_level)
+        self._activate_view(new_level)
+
+        if old_level != ShellModel.ZOOM_ACTIVITY and \
+           new_level != ShellModel.ZOOM_ACTIVITY:
+            self.remove(self.get_child()) 
+            self.add(self._transition_box) 
+            self._transition_box.show() 
+
+            if new_level == ShellModel.ZOOM_HOME: 
+                end_size = style.XLARGE_ICON_SIZE 
+            elif new_level == ShellModel.ZOOM_GROUP: 
+                end_size = style.LARGE_ICON_SIZE 
+            elif new_level == ShellModel.ZOOM_MESH: 
+                end_size = style.STANDARD_ICON_SIZE 
+
+            if old_level == ShellModel.ZOOM_HOME: 
+                start_size = style.XLARGE_ICON_SIZE 
+            elif old_level == ShellModel.ZOOM_GROUP: 
+                start_size = style.LARGE_ICON_SIZE 
+            elif old_level == ShellModel.ZOOM_MESH: 
+                start_size = style.STANDARD_ICON_SIZE 
+
+            self._transition_box.start_transition(start_size, end_size) 
+        else:
+            self._update_view(new_level)
+    
+    def _transition_completed_cb(self, transition_box):
+        self._update_view(shell.get_model().zoom_level)
+
+    def _update_view(self, level):
         if level == ShellModel.ZOOM_ACTIVITY:
             return
 
-        self._deactivate_view()
-        self._level = level
-        self._activate_view()
-
-        self.remove(self.get_child())    
-        self.add(self._transition_box)
-        self._transition_box.show()
-
-        if self._level == ShellModel.ZOOM_HOME:
-            size = style.XLARGE_ICON_SIZE
-        elif self._level == ShellModel.ZOOM_GROUP:
-            size = style.LARGE_ICON_SIZE
-        elif self._level == ShellModel.ZOOM_MESH:
-            size = style.STANDARD_ICON_SIZE
-            
-        self._transition_box.set_size(size)
-    
-    def _transition_completed_cb(self, transition_box):
-        current_child = self.get_child()
+        current_child = self.get_child() 
         self.remove(current_child)
 
-        if self._level == ShellModel.ZOOM_HOME:
+        if level == ShellModel.ZOOM_HOME:
             self.add(self._home_box)
             self._home_box.show()
             self._home_box.focus_search_entry()
-        elif self._level == ShellModel.ZOOM_GROUP:
+        elif level == ShellModel.ZOOM_GROUP:
             self.add(self._group_box)
             self._group_box.show()
-        elif self._level == ShellModel.ZOOM_MESH:
+        elif level == ShellModel.ZOOM_MESH:
             self.add(self._mesh_box)
             self._mesh_box.show()
             self._mesh_box.focus_search_entry()
diff --git a/src/jarabe/desktop/transitionbox.py b/src/jarabe/desktop/transitionbox.py
index 6a6f0c2..a554415 100644
--- a/src/jarabe/desktop/transitionbox.py
+++ b/src/jarabe/desktop/transitionbox.py
@@ -74,12 +74,10 @@ class TransitionBox(hippo.Canvas):
         self._box.props.background_color = style.COLOR_WHITE.get_int()
         self.set_root(self._box)
 
-        self._size = style.XLARGE_ICON_SIZE
-
         self._layout = _Layout()
         self._box.set_layout(self._layout)
 
-        self._my_icon = MyIcon(self._size)
+        self._my_icon = MyIcon(style.XLARGE_ICON_SIZE)
         self._box.append(self._my_icon)
 
         self._animator = animator.Animator(0.3)
@@ -88,10 +86,9 @@ class TransitionBox(hippo.Canvas):
     def _animation_completed_cb(self, anim):
         self.emit('completed')
 
-    def set_size(self, size):
+    def start_transition(self, start_size, end_size):
+        self._my_icon.props.size = start_size
+
         self._animator.remove_all()
-        self._animator.add(_Animation(self._my_icon, self._size, size))
+        self._animator.add(_Animation(self._my_icon, start_size, end_size))
         self._animator.start()
-        
-        self._size = size
-
diff --git a/src/jarabe/frame/zoomtoolbar.py b/src/jarabe/frame/zoomtoolbar.py
index a4c0b74..4a87905 100644
--- a/src/jarabe/frame/zoomtoolbar.py
+++ b/src/jarabe/frame/zoomtoolbar.py
@@ -43,8 +43,8 @@ class ZoomToolbar(gtk.Toolbar):
                 _('Activity'), shell.ShellModel.ZOOM_ACTIVITY)
 
         shell_model = shell.get_model()
-        self._set_zoom_level(shell_model.props.zoom_level)
-        shell_model.connect('notify::zoom-level', self.__notify_zoom_level_cb)
+        self._set_zoom_level(shell_model.zoom_level)
+        shell_model.zoom_level_changed.connect(self.__zoom_level_changed_cb)
 
     def _add_button(self, icon_name, label, zoom_level):
         if self.get_children():
@@ -67,16 +67,11 @@ class ZoomToolbar(gtk.Toolbar):
     def __level_clicked_cb(self, button, level):
         if not button.get_active():
             return
-        if shell.get_model().props.zoom_level != level:
-            if level == shell.ShellModel.ZOOM_ACTIVITY:
-                activity = shell.get_model().get_active_activity()
-                activity.get_window().activate(gtk.get_current_event_time())
-            else:
-                shell.get_model().set_zoom_level(level)
-                wnck.screen_get_default().toggle_showing_desktop(True)
-
-    def __notify_zoom_level_cb(self, model, pspec):
-        self._set_zoom_level(model.props.zoom_level)
+
+        shell.get_model().zoom_level = level
+
+    def __zoom_level_changed_cb(self, **kwargs):
+        self._set_zoom_level(kwargs['new_level'])
 
     def _set_zoom_level(self, new_level):
         logging.debug('new zoom level: %r' % new_level)
diff --git a/src/jarabe/model/shell.py b/src/jarabe/model/shell.py
index 5c7c8e0..ea6cd97 100644
--- a/src/jarabe/model/shell.py
+++ b/src/jarabe/model/shell.py
@@ -26,6 +26,7 @@ import gtk
 import dbus
 
 from sugar import wm
+from sugar import dispatch
 from sugar.graphics.xocolor import XoColor
 from sugar.presence import presenceservice
 
@@ -299,50 +300,57 @@ class ShellModel(gobject.GObject):
     ZOOM_HOME = 2
     ZOOM_ACTIVITY = 3
 
-    __gproperties__ = {
-        'zoom-level' : (int, None, None,
-                        0, 3, ZOOM_HOME,
-                        gobject.PARAM_READABLE)
-    }
-
     def __init__(self):
         gobject.GObject.__init__(self)
 
-        self._current_activity = None
-        self._zoom_level = self.ZOOM_HOME
-        self._showing_desktop = True
-        self._activities = []
-        self._active_activity = None
-        self._tabbing_activity = None
-        self._pservice = presenceservice.get_instance()
-
         self._screen = wnck.screen_get_default()
         self._screen.connect('window-opened', self._window_opened_cb)
         self._screen.connect('window-closed', self._window_closed_cb)
-        self._screen.connect('showing-desktop-changed',
-                             self._showing_desktop_changed_cb)
         self._screen.connect('active-window-changed',
                              self._active_window_changed_cb)
 
-    def set_zoom_level(self, level):
-        self._zoom_level = level
-        self.notify('zoom-level')
+        self.zoom_level_changed = dispatch.Signal()
+
+        self._desktop_level = self.ZOOM_HOME
+        self._zoom_level = self.ZOOM_HOME
+        self._current_activity = None
+        self._activities = []
+        self._active_activity = None
+        self._tabbing_activity = None
+        self._pservice = presenceservice.get_instance()
+
+        self._screen.toggle_showing_desktop(True)
 
-    def get_zoom_level(self):
-        if self._screen.get_showing_desktop():
-            return self._zoom_level
+    def _update_zoom_level(self, window):
+        if window.get_window_type() == wnck.WINDOW_DESKTOP:
+            zoom_level = self._desktop_level
         else:
-            return self.ZOOM_ACTIVITY
+            zoom_level = self.ZOOM_ACTIVITY
 
-    def do_get_property(self, pspec):
-        if pspec.name == 'zoom-level':
-            return self.get_zoom_level()                
+        if self._zoom_level != zoom_level:
+            self._zoom_level = zoom_level
+            self.zoom_level_changed.send(self, old_level=self._zoom_level,
+                                         new_level=zoom_level)
 
-    def _showing_desktop_changed_cb(self, screen):
-        showing_desktop = self._screen.get_showing_desktop()
-        if self._showing_desktop != showing_desktop:
-            self._showing_desktop = showing_desktop
-            self.notify('zoom-level')
+    def _set_zoom_level(self, new_level):
+        old_level = self.zoom_level
+        if old_level == new_level:
+            return
+
+        self._zoom_level = new_level
+        if new_level is not self.ZOOM_ACTIVITY:
+            self._desktop_level = new_level
+
+        self.zoom_level_changed.send(self, old_level=old_level,
+                                     new_level=new_level)
+
+        show_desktop = new_level is not self.ZOOM_ACTIVITY
+        self._screen.toggle_showing_desktop(show_desktop)
+
+    def _get_zoom_level(self):
+        return self._zoom_level
+
+    zoom_level = property(_get_zoom_level, _set_zoom_level)
 
     def _get_activities_with_window(self):
         ret = []
@@ -473,6 +481,8 @@ class ShellModel(gobject.GObject):
         if act is not None:
             self._set_active_activity(act)
 
+        self._update_zoom_level(window)
+
     def _add_activity(self, home_activity):
         self._activities.append(home_activity)
         self.emit('activity-added', home_activity)
diff --git a/src/jarabe/view/keyhandler.py b/src/jarabe/view/keyhandler.py
index 1e9a890..2b567bf 100644
--- a/src/jarabe/view/keyhandler.py
+++ b/src/jarabe/view/keyhandler.py
@@ -159,20 +159,16 @@ class KeyHandler(object):
         active_activity.get_window().close()
 
     def handle_zoom_mesh(self):
-        shell.get_model().set_zoom_level(ShellModel.ZOOM_MESH)
-        wnck.screen_get_default().toggle_showing_desktop(True)
+        shell.get_model().zoom_level = ShellModel.ZOOM_MESH
 
     def handle_zoom_group(self):
-        shell.get_model().set_zoom_level(ShellModel.ZOOM_GROUP)
-        wnck.screen_get_default().toggle_showing_desktop(True)
+        shell.get_model().zoom_level = ShellModel.ZOOM_GROUP
 
     def handle_zoom_home(self):
-        shell.get_model().set_zoom_level(ShellModel.ZOOM_HOME)
-        wnck.screen_get_default().toggle_showing_desktop(True)
+        shell.get_model().zoom_level = ShellModel.ZOOM_HOME
 
     def handle_zoom_activity(self):
-        activity = shell.get_model().get_active_activity()
-        activity.get_window().activate(gtk.get_current_event_time())
+        shell.get_model().zoom_level = ShellModel.ZOOM_ACTIVITY
 
     def handle_brightness_max(self):
         self._change_brightness(value=_BRIGHTNESS_MAX)
diff --git a/src/jarabe/view/launcher.py b/src/jarabe/view/launcher.py
index a8cf72a..b4f1020 100644
--- a/src/jarabe/view/launcher.py
+++ b/src/jarabe/view/launcher.py
@@ -130,7 +130,6 @@ def __launch_started_cb(home_model, home_activity):
     launch_window.show()
 
     _launchers[home_activity.get_activity_id()] = launch_window
-    shell.get_model().set_zoom_level(shell.ShellModel.ZOOM_ACTIVITY)
 
 def __launch_failed_cb(home_model, home_activity):
     if not home_activity.is_journal():