--- 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)