Mercurial > libervia-desktop

changeset 38:9f45098289cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
widgets handler, core: hidden widgets can now be shown with swipes: - a couple of methods have been added to handle visible and hidden widgets - a new getOrClone method allow to recreate a widget if it already has a parent (can happen even if the widget is not shown, e.g. in a carousel) - handler now display hidden widgets of the same class as the displayed one when swiping. For instance, if a chat widget is displayed, and header input is used to show an other one, it's now possible to go back to the former by swiping. QuickWidget.onDelete method can be used to handle if a widget must be really deleted (return True) or just hidden (any other value). - handler use a subclass of Carousel for this new feature, with some adjustement so event can be passed to children without too much delay (and frustration). This may need to be adjusted again in the future. - handler.cagou_widget now give the main displayed widget in the handler - handler.changeWidget must be used when widget need to be changed (it's better to use host.switchWidget which will call it itself)
author Goffi <goffi@goffi.org>
date Sun, 28 Aug 2016 15:27:48 +0200
parents 6cf08d0ee460
children b9ee3bf81018
files src/cagou/core/cagou_main.py src/cagou/core/cagou_widget.py src/cagou/core/widgets_handler.py
diffstat 3 files changed, 181 insertions(+), 12 deletions(-) [+]
line wrap: on
line diff
--- a/src/cagou/core/cagou_main.py	Sun Aug 28 15:27:45 2016 +0200
+++ b/src/cagou/core/cagou_main.py	Sun Aug 28 15:27:48 2016 +0200
@@ -24,6 +24,7 @@
 from constants import Const as C
 from sat.core import log as logging
 log = logging.getLogger(__name__)
+from sat.core import exceptions
 from sat_frontends.quick_frontend.quick_app import QuickApp
 from sat_frontends.quick_frontend import quick_widgets
 from sat_frontends.bridge.DBus import DBusBridgeFrontend
@@ -43,6 +44,7 @@
 from kivy.uix.screenmanager import ScreenManager, Screen, FallOutTransition, RiseInTransition
 from kivy.uix.dropdown import DropDown
 from cagou_widget import CagouWidget
+from . import widgets_handler
 from .common import IconButton
 from importlib import import_module
 import os.path
@@ -205,6 +207,13 @@
         self.app.default_avatar = os.path.join(self.media_dir, "misc/default_avatar.png")
         self._plg_wids = []  # widget plugins
         self._import_plugins()
+        self._visible_widgets = {}  # visible widgets by classes
+
+    @property
+    def visible_widgets(self):
+        for w_list in self._visible_widgets.itervalues():
+            for w in w_list:
+                yield w
 
     def run(self):
         self.app.run()
@@ -306,6 +315,16 @@
 
     ## widgets handling
 
+    def getParentHandler(self, widget):
+        """Return handler holding this widget
+
+        @return (WidgetsHandler): handler
+        """
+        w_handler = widget.parent
+        while w_handler and not(isinstance(w_handler, widgets_handler.WidgetsHandler)):
+            w_handler = w_handler.parent
+        return w_handler
+
     def switchWidget(self, old, new):
         """Replace old widget by new one
 
@@ -322,14 +341,49 @@
                     break
 
         if to_change is None:
-            log.error(u"no CagouWidget found when trying to switch widget")
-        else:
-            parent = to_change.parent
-            idx = parent.children.index(to_change)
-            parent.remove_widget(to_change)
-            if isinstance(to_change, quick_widgets.QuickWidget):
-                self.widgets.deleteWidget(to_change)
-            parent.add_widget(new, index=idx)
+            raise exceptions.InternalError(u"no CagouWidget found when trying to switch widget")
+        handler = self.getParentHandler(to_change)
+        handler.changeWidget(new)
+
+    def addVisibleWidget(self, widget):
+        """declare a widget visible
+
+        for internal use only!
+        """
+        assert isinstance(widget, quick_widgets.QuickWidget)
+        log.info(u"addVisibleWidget: {}".format(', '.join([unicode(t) for t in widget.targets])))
+        self._visible_widgets.setdefault(widget.__class__, []).append(widget)
+
+    def removeVisibleWidget(self, widget):
+        """declare a widget not visible anymore
+
+        for internal use only!
+        """
+        log.info(u"removeVisibleWidget: {}".format(', '.join([unicode(t) for t in widget.targets])))
+        self._visible_widgets[widget.__class__].remove(widget)
+        log.info("remove: " + unicode(widget.targets))
+        self.widgets.deleteWidget(widget)
+
+    def getVisibleList(self, cls):
+        """get list of visible widgets for a given class
+
+        @param cls(QuickWidget class): type of widgets to get
+        @return (list[QuickWidget class]): visible widgets of this class
+        """
+        try:
+            return self._visible_widgets[cls]
+        except KeyError:
+            return []
+
+    def getOrClone(self, widget):
+        """Get a QuickWidget if it has not parent set else clone it"""
+        if widget.parent is None:
+            return widget
+        targets = list(widget.targets)
+        w = self.widgets.getOrCreateWidget(widget.__class__, targets[0], on_new_widget=None, on_existing_widget=C.WIDGET_RECREATE, profiles=widget.profiles)
+        for t in targets[1:]:
+            w.addTarget(t)
+        return w
 
     ## misc ##
 
--- a/src/cagou/core/cagou_widget.py	Sun Aug 28 15:27:45 2016 +0200
+++ b/src/cagou/core/cagou_widget.py	Sun Aug 28 15:27:48 2016 +0200
@@ -32,7 +32,7 @@
     def __init__(self, cagou_widget, plugin_info):
         self.plugin_info = plugin_info
         super(HeaderWidgetChoice, self).__init__()
-        self.bind(on_release=lambda btn, plugin_info=plugin_info: cagou_widget.switchWidget(plugin_info))
+        self.bind(on_release=lambda btn: cagou_widget.switchWidget(plugin_info))
 
 
 class HeaderWidgetCurrent(ButtonBehavior, Image):
--- a/src/cagou/core/widgets_handler.py	Sun Aug 28 15:27:45 2016 +0200
+++ b/src/cagou/core/widgets_handler.py	Sun Aug 28 15:27:48 2016 +0200
@@ -23,10 +23,14 @@
 from sat_frontends.quick_frontend import quick_widgets
 from kivy.uix.boxlayout import BoxLayout
 from kivy.uix.button import Button
+from kivy.uix.carousel import Carousel
+from kivy.metrics import dp
 from kivy import properties
 from cagou import G
 
 
+CAROUSEL_SCROLL_DISTANCE = dp(50)
+CAROUSEL_SCROLL_TIMEOUT = 80
 NEW_WIDGET_DIST = 10
 REMOVE_WIDGET_DIST = NEW_WIDGET_DIST
 
@@ -67,6 +71,107 @@
         return super(WHSplitter, self).on_touch_up(touch)
 
 
+class HandlerCarousel(Carousel):
+
+    def __init__(self, *args, **kwargs):
+        super(HandlerCarousel, self).__init__(
+            *args,
+            direction='right',
+            loop=True,
+            **kwargs)
+        self._former_slide = None
+        self.bind(current_slide=self.onSlideChange)
+        self._slides_update_lock = False
+
+    def changeWidget(self, new_widget):
+        """Change currently displayed widget
+
+        slides widgets will be updated
+        """
+        # slides update need to be blocked to avoid the update in onSlideChange
+        # which would mess the removal of current widgets
+        self._slides_update_lock = True
+        current = self.current_slide
+        for w in self.slides:
+            if w == current or w == new_widget:
+                continue
+            if isinstance(w, quick_widgets.QuickWidget):
+                G.host.widgets.deleteWidget(w)
+        self.clear_widgets()
+        self.add_widget(new_widget)
+        self._slides_update_lock = False
+        self.updateHiddenSlides()
+
+    def onSlideChange(self, handler, new_slide):
+        if isinstance(self._former_slide, quick_widgets.QuickWidget):
+            G.host.removeVisibleWidget(self._former_slide)
+        self._former_slide = new_slide
+        if isinstance(new_slide, quick_widgets.QuickWidget):
+            G.host.addVisibleWidget(new_slide)
+            self.updateHiddenSlides()
+
+    def hiddenList(self, visible_list):
+        """return widgets of same class as holded one which are hidden
+
+        @param visible_list(list[QuickWidget]): widgets visible
+        @return (iter[QuickWidget]): widgets hidden
+        """
+        added = [(w.targets, w.profiles) for w in visible_list]  # we want to avoid recreated widgets
+        for w in G.host.widgets.getWidgets(self.current_slide.__class__, profiles=self.current_slide.profiles):
+            if w in visible_list or (w.targets, w.profiles) in added:
+                continue
+            yield w
+
+    def widgets_sort(self, widget):
+        """method used as key to sort the widgets
+
+        order of the widgets when changing slide is affected
+        @param widget(QuickWidget): widget to sort
+        @return: a value which will be used for sorting
+        """
+        try:
+            return unicode(widget.target).lower()
+        except AttributeError:
+            return unicode(list(widget.targets)[0]).lower()
+
+    def updateHiddenSlides(self):
+        """adjust carousel slides according to visible widgets"""
+        if self._slides_update_lock:
+            return
+        if not isinstance(self.current_slide, quick_widgets.QuickWidget):
+            return
+        # lock must be used here to avoid recursions
+        self._slides_update_lock = True
+        visible_list = G.host.getVisibleList(self.current_slide.__class__)
+        hidden = list(self.hiddenList(visible_list))
+        slides_sorted =  sorted(hidden + [self.current_slide], key=self.widgets_sort)
+        to_remove = set(self.slides).difference({self.current_slide})
+        for w in to_remove:
+            self.remove_widget(w)
+        if hidden:
+            # no need to add more than two widgets (next and previous),
+            # as the list will be updated on each new visible widget
+            current_idx = slides_sorted.index(self.current_slide)
+            try:
+                next_slide = slides_sorted[current_idx+1]
+            except IndexError:
+                next_slide = slides_sorted[0]
+            self.add_widget(G.host.getOrClone(next_slide))
+            if len(hidden)>1:
+                previous_slide = slides_sorted[current_idx-1]
+                self.add_widget(G.host.getOrClone(previous_slide))
+
+        if len(self.slides) == 1:
+            # we block carousel with high scroll_distance to avoid swiping
+            # when the is not other instance of the widget
+            self.scroll_distance=2**32
+            self.scroll_timeout=0
+        else:
+            self.scroll_distance = CAROUSEL_SCROLL_DISTANCE
+            self.scroll_timeout=CAROUSEL_SCROLL_TIMEOUT
+        self._slides_update_lock = False
+
+
 class WidgetsHandler(BoxLayout):
 
     def __init__(self, wid=None, **kw):
@@ -77,15 +182,25 @@
         self.blh = BoxLayout(orientation="horizontal")
         self.blv = BoxLayout(orientation="vertical")
         self.blv.add_widget(WHSplitter(self))
-        self.blv.add_widget(wid)
+        self.carousel = HandlerCarousel()
+        self.blv.add_widget(self.carousel)
         self.blh.add_widget(WHSplitter(self, horizontal=False))
         self.blh.add_widget(self.blv)
         self.add_widget(self.blh)
+        self.changeWidget(wid)
 
     @property
     def default_widget(self):
         return G.host.default_wid['factory'](G.host.default_wid, None, None)
 
+    @property
+    def cagou_widget(self):
+        """get holded CagouWidget"""
+        return self.carousel.current_slide
+
+    def changeWidget(self, new_widget):
+        self.carousel.changeWidget(new_widget)
+
     def removeWidget(self, vertical):
         if vertical and self.vert_wid is not None:
             self.remove_widget(self.vert_wid)
@@ -110,6 +225,6 @@
 
     def onDelete(self):
         # when this handler is deleted, we need to delete the holded CagouWidget
-        cagou_widget = self.children[0].children[0].children[0]
+        cagou_widget = self.cagou_widget
         if isinstance(cagou_widget, quick_widgets.QuickWidget):
-            G.host.widgets.deleteWidget(cagou_widget)
+            G.host.removeVisibleWidget(cagou_widget)