--- a/src/cagou/plugins/plugin_wid_chat.py	Sun Sep 25 16:06:56 2016 +0200
+++ b/src/cagou/plugins/plugin_wid_chat.py	Wed Sep 28 22:02:36 2016 +0200
@@ -27,6 +27,7 @@
 from kivy.uix.scrollview import ScrollView
 from kivy.uix.textinput import TextInput
 from kivy.uix.label import Label
+from kivy.uix.image import AsyncImage
 from kivy.metrics import dp
 from kivy.utils import escape_markup
 from kivy import properties
@@ -59,12 +60,24 @@
         super(Escape, self).__init__(text)
 
 
+class SimpleXHTMLWidgetEscapedText(Label):
+    pass
+
+class SimpleXHTMLWidgetText(Label):
+    pass
+
+class SimpleXHTMLWidgetImage(AsyncImage):
+    pass
+
 class SimpleXHTMLWidget(StackLayout):
     """widget handling simple XHTML parsing"""
     xhtml = properties.StringProperty()
     color = properties.ListProperty([1, 1, 1, 1])
     # XXX: bold is only used for escaped text
     bold = properties.BooleanProperty(False)
+    content_width = properties.NumericProperty(0)
+
+    # text/XHTML input
 
     def on_xhtml(self, instance, xhtml):
         """parse xhtml and set content accordingly
@@ -74,7 +87,7 @@
         """
         self.clear_widgets()
         if isinstance(xhtml, Escape):
-            label = Label(text=xhtml, color=self.color)
+            label = SimpleXHTMLWidgetEscapedText(text=xhtml, color=self.color)
             self.bind(color=label.setter('color'))
             self.bind(bold=label.setter('bold'))
             self.add_widget(label)
@@ -88,6 +101,118 @@
         """mark that a text need to be escaped (i.e. no markup)"""
         return Escape(text)
 
+    # sizing
+
+    def on_width(self, instance, width):
+        if len(self.children) == 1:
+            wid = self.children[0]
+            if isinstance(wid, Label):
+                try:
+                    full_width = wid._full_width
+                except AttributeError:
+                    wid.size_hint = (None, None)
+                    wid.texture_update()
+                    full_width = wid._full_width = wid.texture_size[0]
+                if full_width > width:
+                    wid.text_size = width, None
+                else:
+                    wid.text_size = None, None
+                self.content_width = wid.width + self.padding[0] + self.padding[2]
+            else:
+                wid.size_hint(1, None)
+                wid.height = 100
+                self.content_width = self.width
+        else:
+            self._do_complexe_sizing(width)
+
+    def _do_complexe_sizing(self, width):
+        try:
+            self.splitted
+        except AttributeError:
+            # XXX: to make things easier, we split labels in words
+            log.debug(u"split start")
+            children = self.children[::-1]
+            self.clear_widgets()
+            for child in children:
+                if isinstance(child, Label):
+                    log.debug(u"label before split: {}".format(child.text))
+                    styles = []
+                    tag = False
+                    new_text = []
+                    current_tag = []
+                    current_value = []
+                    current_wid = self._createText()
+                    value = False
+                    close = False
+                    # we will parse the text and create a new widget
+                    # on each new word (actually each space)
+                    # FIXME: handle '\n' and other white chars
+                    for c in child.text:
+                        if tag:
+                            # we are parsing a markup tag
+                            if c == u']':
+                                current_tag_s = u''.join(current_tag)
+                                current_style = (current_tag_s, u''.join(current_value))
+                                if close:
+                                    for idx, s in enumerate(reversed(styles)):
+                                        if s[0] == current_tag_s:
+                                            del styles[len(styles) - idx - 1]
+                                            break
+                                else:
+                                    styles.append(current_style)
+                                current_tag = []
+                                current_value = []
+                                tag = False
+                                value = False
+                                close = False
+                            elif c == u'/':
+                                close = True
+                            elif c == u'=':
+                                value = True
+                            elif value:
+                                current_value.append(c)
+                            else:
+                                current_tag.append(c)
+                            new_text.append(c)
+                        else:
+                            # we are parsing regular text
+                            if c == u'[':
+                                new_text.append(c)
+                                tag = True
+                            elif c == u' ':
+                                # new word, we do a new widget
+                                new_text.append(u' ')
+                                for t, v in reversed(styles):
+                                    new_text.append(u'[/{}]'.format(t))
+                                current_wid.text = u''.join(new_text)
+                                new_text = []
+                                self.add_widget(current_wid)
+                                log.debug(u"new widget: {}".format(current_wid.text))
+                                current_wid = self._createText()
+                                for t, v in styles:
+                                    new_text.append(u'[{tag}{value}]'.format(
+                                        tag = t,
+                                        value = u'={}'.format(v) if v else u''))
+                            else:
+                                new_text.append(c)
+                    if current_wid.text:
+                        # we may have a remaining widget after the parsing
+                        close_styles = []
+                        for t, v in reversed(styles):
+                            close_styles.append(u'[/{}]'.format(t))
+                        current_wid.text = u''.join(close_styles)
+                        self.add_widget(current_wid)
+                        log.debug(u"new widget: {}".format(current_wid.text))
+                else:
+                    # non Label widgets, we just add them
+                    self.add_widget(child)
+            self.splitted = True
+            log.debug(u"split OK")
+
+        # we now set the content width
+        # FIXME: for now we just use the full width
+        self.content_width = width
+
     # XHTML parsing methods
 
     def _callParseMethod(self, e):
@@ -113,13 +238,13 @@
             self.styles is needed to keep track of styles to remove
             should most probably be set to True
         """
-        if append_to_list:
-            self.styles.append((tag, value))
         label = self._getLabel()
         label.text += u'[{tag}{value}]'.format(
             tag = tag,
             value = u'={}'.format(value) if value else ''
             )
+        if append_to_list:
+            self.styles.append((tag, value))
 
     def _removeStyle(self, tag, remove_from_list=True):
         """remove a markup style from the label
@@ -151,14 +276,17 @@
         current styles will be closed and reopened if needed
         """
         self._closeLabel()
-        label = Label(color=self.color, markup=True)
-        self.current_wid = label
-        self.bind(color=self.current_wid.setter('color'))
-        label.bind(texture_size=label.setter('size'))
+        self.current_wid = self._createText()
         for tag, value in self.styles:
             self._addStyle(tag, value, append_to_list=False)
         self.add_widget(self.current_wid)
 
+    def _createText(self):
+        label = SimpleXHTMLWidgetText(color=self.color, markup=True)
+        self.bind(color=label.setter('color'))
+        label.bind(texture_size=label.setter('size'))
+        return label
+
     def _closeLabel(self):
         """close current style tags in current label
 
@@ -250,8 +378,19 @@
     def xhtml_em(self, elem):
         self.xhtml_generic(elem, markup='i')
 
+    def xhtml_img(self, elem):
+        try:
+            src = elem.attrib['src']
+        except KeyError:
+            log.warning(u"<img> element without src: {}".format(ET.tostring(elem)))
+            return
+        img = SimpleXHTMLWidgetImage(source=src)
+        self.current_wid = img
+        self.add_widget(img)
+
     def xhtml_p(self, elem):
-        self._addLabel()
+        if isinstance(self.current_wid, Label):
+            self.current_wid.text+="\n\n"
         self.xhtml_generic(elem)
 
     def xhtml_span(self, elem):