libervia-desktop: cagou/core/simple

comparison cagou/core/simple_xhtml.py @ 491:203755bbe0fe

massive refactoring from camelCase -> snake_case. See backend commit log for more details

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:44:32 +0200
parents	3c9ba4a694ef
children

comparison

equal deleted inserted replaced

-:962d17c4078c
+:203755bbe0fe
 def on_parent(self, instance, parent):
 if parent is not None:
 self.font_size = parent.font_size
-def _addUrlMarkup(self, text):
+def _add_url_markup(self, text):
 text_elts = []
 idx = 0
 links = 0
 while True:
 m = sat_strings.RE_URL.search(text[idx:])
 def on_text(self, instance, text):
 # do NOT call the method if self.markup is set
 # this would result in infinite loop (because self.text
 # is changed if an URL is found, and in this case markup too)
 if text and not self.markup:
-self._addUrlMarkup(text)
+self._add_url_markup(text)
 def on_ref_press(self, ref):
 url = self.ref_urls[ref]
 G.local_platform.open_url(url, self)
 self.add_widget(label)
 else:
 xhtml = ET.fromstring(xhtml.encode())
 self.current_wid = None
 self.styles = []
-self._callParseMethod(xhtml)
+self._call_parse_method(xhtml)
 if len(self.children) > 1:
 self._do_split_labels()
 def escape(self, text):
 """mark that a text need to be escaped (i.e. no markup)"""
 styles = []
 tag = False
 new_text = []
 current_tag = []
 current_value = []
-current_wid = self._createText()
+current_wid = self._create_text()
 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
 new_text.append('[/{}]'.format(t))
 current_wid.text = ''.join(new_text)
 new_text = []
 self.add_widget(current_wid)
 log.debug("new widget: {}".format(current_wid.text))
-current_wid = self._createText()
+current_wid = self._create_text()
 for t, v in styles:
 new_text.append('[{tag}{value}]'.format(
 tag = t,
 value = '={}'.format(v) if v else ''))
 else:
 self.splitted = True
 log.debug("split OK")
 # XHTML parsing methods
-def _callParseMethod(self, e):
+def _call_parse_method(self, e):
 """Call the suitable method to parse the element
 self.xhtml_[tag] will be called if it exists, else
 self.xhtml_generic will be used
 @param e(ET.Element): element to parse
 except AttributeError:
 log.warning(f"Unhandled XHTML tag: {e.tag}")
 method = self.xhtml_generic
 method(e)
-def _addStyle(self, tag, value=None, append_to_list=True):
+def _add_style(self, tag, value=None, append_to_list=True):
 """add a markup style to label
 @param tag(unicode): markup tag
 @param value(unicode): markup value if suitable
 @param append_to_list(bool): if True style we be added to self.styles
 self.styles is needed to keep track of styles to remove
 should most probably be set to True
 """
-label = self._getLabel()
+label = self._get_label()
 label.text += '[{tag}{value}]'.format(
 tag = tag,
 value = '={}'.format(value) if value else ''
 )
 if append_to_list:
 self.styles.append((tag, value))
-def _removeStyle(self, tag, remove_from_list=True):
+def _remove_style(self, tag, remove_from_list=True):
 """remove a markup style from the label
 @param tag(unicode): markup tag to remove
 @param remove_from_list(bool): if True, remove from self.styles too
 should most probably be set to True
 """
-label = self._getLabel()
+label = self._get_label()
 label.text += '[/{tag}]'.format(
 tag = tag
 )
 if remove_from_list:
 for rev_idx, style in enumerate(reversed(self.styles)):
 if style[0] == tag:
 tag_idx = len(self.styles) - 1 - rev_idx
 del self.styles[tag_idx]
 break
-def _getLabel(self):
+def _get_label(self):
 """get current Label if it exists, or create a new one"""
 if not isinstance(self.current_wid, Label):
-self._addLabel()
+self._add_label()
 return self.current_wid
-def _addLabel(self):
+def _add_label(self):
 """add a new Label
 current styles will be closed and reopened if needed
 """
-self._closeLabel()
+self._close_label()
-self.current_wid = self._createText()
+self.current_wid = self._create_text()
 for tag, value in self.styles:
-self._addStyle(tag, value, append_to_list=False)
+self._add_style(tag, value, append_to_list=False)
 self.add_widget(self.current_wid)
-def _createText(self):
+def _create_text(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):
+def _close_label(self):
 """close current style tags in current label
 needed when you change label to keep style between
 different widgets
 """
 if isinstance(self.current_wid, Label):
 for tag, value in reversed(self.styles):
-self._removeStyle(tag, remove_from_list=False)
+self._remove_style(tag, remove_from_list=False)
-def _parseCSS(self, e):
+def _parse_css(self, e):
 """parse CSS found in "style" attribute of element
 self._css_styles will be created and contained markup styles added by this method
 @param e(ET.Element): element which may have a "style" attribute
 """
 log.warning(f"Unhandled CSS: {prop}")
 else:
 method(e, value)
 self._css_styles = self.styles[styles_limit:]
-def _closeCSS(self):
+def _close_css(self):
 """removed CSS styles
 styles in self._css_styles will be removed
 and the attribute will be deleted
 """
 for tag, __ in reversed(self._css_styles):
-self._removeStyle(tag)
+self._remove_style(tag)
 del self._css_styles
 def xhtml_generic(self, elem, style=True, markup=None):
 """Generic method for adding HTML elements
 if markup is not None:
 if isinstance(markup, str):
 tag, value = markup, None
 else:
 tag, value = markup
-self._addStyle(tag, value)
+self._add_style(tag, value)
 style_ = 'style' in elem.attrib and style
 if style_:
-self._parseCSS(elem)
+self._parse_css(elem)
 # then content
 if elem.text:
-self._getLabel().text += escape_markup(elem.text)
+self._get_label().text += escape_markup(elem.text)
 # we parse the children
 for child in elem:
-self._callParseMethod(child)
+self._call_parse_method(child)
 # closing CSS style and markup
 if style_:
-self._closeCSS()
+self._close_css()
 if markup is not None:
-self._removeStyle(tag)
+self._remove_style(tag)
 # and the tail, which is regular text
 if elem.tail:
-self._getLabel().text += escape_markup(elem.tail)
+self._get_label().text += escape_markup(elem.tail)
 # method handling XHTML elements
 def xhtml_br(self, elem):
-label = self._getLabel()
+label = self._get_label()
 label.text+='\n'
 self.xhtml_generic(elem, style=False)
 def xhtml_em(self, elem):
 self.xhtml_generic(elem, markup='i')
 self.xhtml_generic(elem, markup='b')
 # methods handling CSS properties
 def css_color(self, elem, value):
-self._addStyle("color", css_color.parse(value))
+self._add_style("color", css_color.parse(value))
 def css_text_decoration(self, elem, value):
 if value == 'underline':
-self._addStyle('u')
+self._add_style('u')
 elif value == 'line-through':
-self._addStyle('s')
+self._add_style('s')
 else:
 log.warning("unhandled text decoration: {}".format(value))

Mercurial > libervia-desktop

comparison cagou/core/simple_xhtml.py @ 491:203755bbe0fe