extend ping test, fix configuredInterface list
[enigma2.git] / skin.py
diff --git a/skin.py b/skin.py
index 21ec62ae4cefbc733315480b117e3e64b7b96321..9eb5d4f5660b020e43f61015a6671b3ceb62560b 100644 (file)
--- a/skin.py
+++ b/skin.py
@@ -1,7 +1,6 @@
 from Tools.Profile import profile, profile_final
 from Tools.Profile import profile, profile_final
-
-profile("LOAD:minidom")
-import xml.dom.minidom
+profile("LOAD:ElementTree")
+import xml.etree.cElementTree
 from os import path
 
 profile("LOAD:enigma_skin")
 from os import path
 
 profile("LOAD:enigma_skin")
@@ -11,7 +10,7 @@ from enigma import eSize, ePoint, gFont, eWindow, eLabel, ePixmap, eWindowStyleM
 from Components.config import ConfigSubsection, ConfigText, config
 from Components.Converter.Converter import Converter
 from Components.Sources.Source import Source, ObsoleteSource
 from Components.config import ConfigSubsection, ConfigText, config
 from Components.Converter.Converter import Converter
 from Components.Sources.Source import Source, ObsoleteSource
-from Tools.Directories import resolveFilename, SCOPE_SKIN, SCOPE_SKIN_IMAGE, SCOPE_FONTS
+from Tools.Directories import resolveFilename, SCOPE_SKIN, SCOPE_SKIN_IMAGE, SCOPE_FONTS, SCOPE_CURRENT_SKIN, fileExists
 from Tools.Import import my_import
 from Tools.LoadPixmap import LoadPixmap
 
 from Tools.Import import my_import
 from Tools.LoadPixmap import LoadPixmap
 
@@ -40,7 +39,7 @@ def loadSkin(name):
        # read the skin
        filename = resolveFilename(SCOPE_SKIN, name)
        mpath = path.dirname(filename) + "/"
        # read the skin
        filename = resolveFilename(SCOPE_SKIN, name)
        mpath = path.dirname(filename) + "/"
-       dom_skins.append((mpath, xml.dom.minidom.parse(filename)))
+       dom_skins.append((mpath, xml.etree.cElementTree.parse(filename).getroot()))
 
 # we do our best to always select the "right" value
 # skins are loaded in order of priority: skin with
 
 # we do our best to always select the "right" value
 # skins are loaded in order of priority: skin with
@@ -69,17 +68,17 @@ profile("LoadSkinDefault")
 loadSkin('skin_default.xml')
 profile("LoadSkinDefaultDone")
 
 loadSkin('skin_default.xml')
 profile("LoadSkinDefaultDone")
 
-def parsePosition(str):
+def parsePosition(str, scale):
        x, y = str.split(',')
        x, y = str.split(',')
-       return ePoint(int(x), int(y))
+       return ePoint(int(x) * scale[0][0] / scale[0][1], int(y) * scale[1][0] / scale[1][1])
 
 
-def parseSize(str):
+def parseSize(str, scale):
        x, y = str.split(',')
        x, y = str.split(',')
-       return eSize(int(x), int(y))
+       return eSize(int(x) * scale[0][0] / scale[0][1], int(y) * scale[1][0] / scale[1][1])
 
 
-def parseFont(str):
+def parseFont(str, scale):
        name, size = str.split(';')
        name, size = str.split(';')
-       return gFont(name, int(size))
+       return gFont(name, int(size) * scale[0][0] / scale[0][1])
 
 def parseColor(str):
        if str[0] != '#':
 
 def parseColor(str):
        if str[0] != '#':
@@ -91,39 +90,42 @@ def parseColor(str):
 
 def collectAttributes(skinAttributes, node, skin_path_prefix=None, ignore=[]):
        # walk all attributes
 
 def collectAttributes(skinAttributes, node, skin_path_prefix=None, ignore=[]):
        # walk all attributes
-       for p in range(node.attributes.length):
-               a = node.attributes.item(p)
-               
-               # convert to string (was: unicode)
-               attrib = str(a.name)
-               # TODO: localization? as in e1?
-               value = a.value.encode("utf-8")
-               
+       for a in node.items():
+               #print a
+               attrib = a[0]
+               value = a[1]
+
                if attrib in ["pixmap", "pointer", "seek_pointer", "backgroundPixmap", "selectionPixmap"]:
                        value = resolveFilename(SCOPE_SKIN_IMAGE, value, path_prefix=skin_path_prefix)
                if attrib in ["pixmap", "pointer", "seek_pointer", "backgroundPixmap", "selectionPixmap"]:
                        value = resolveFilename(SCOPE_SKIN_IMAGE, value, path_prefix=skin_path_prefix)
-               
+
                if attrib not in ignore:
                        skinAttributes.append((attrib, value))
 
 def loadPixmap(path, desktop):
                if attrib not in ignore:
                        skinAttributes.append((attrib, value))
 
 def loadPixmap(path, desktop):
-       ptr = LoadPixmap(path, desktop)
+       cached = False
+       option = path.find("#")
+       if option != -1:
+               options = path[option+1:].split(',')
+               path = path[:option]
+               cached = "cached" in options
+       ptr = LoadPixmap(path, desktop, cached)
        if ptr is None:
                raise SkinError("pixmap file %s not found!" % (path))
        return ptr
 
        if ptr is None:
                raise SkinError("pixmap file %s not found!" % (path))
        return ptr
 
-def applySingleAttribute(guiObject, desktop, attrib, value):
+def applySingleAttribute(guiObject, desktop, attrib, value, scale = ((1,1),(1,1))):
        # and set attributes
        try:
                if attrib == 'position':
        # and set attributes
        try:
                if attrib == 'position':
-                       guiObject.move(parsePosition(value))
+                       guiObject.move(parsePosition(value, scale))
                elif attrib == 'size':
                elif attrib == 'size':
-                       guiObject.resize(parseSize(value))
+                       guiObject.resize(parseSize(value, scale))
                elif attrib == 'title':
                        guiObject.setTitle(_(value))
                elif attrib == 'text':
                        guiObject.setText(_(value))
                elif attrib == 'font':
                elif attrib == 'title':
                        guiObject.setTitle(_(value))
                elif attrib == 'text':
                        guiObject.setText(_(value))
                elif attrib == 'font':
-                       guiObject.setFont(parseFont(value))
+                       guiObject.setFont(parseFont(value, scale))
                elif attrib == 'zPosition':
                        guiObject.setZPosition(int(value))
                elif attrib in ["pixmap", "backgroundPixmap", "selectionPixmap"]:
                elif attrib == 'zPosition':
                        guiObject.setZPosition(int(value))
                elif attrib in ["pixmap", "backgroundPixmap", "selectionPixmap"]:
@@ -204,11 +206,11 @@ def applySingleAttribute(guiObject, desktop, attrib, value):
                        guiObject.setWrapAround(True)
                elif attrib == "pointer" or attrib == "seek_pointer":
                        (name, pos) = value.split(':')
                        guiObject.setWrapAround(True)
                elif attrib == "pointer" or attrib == "seek_pointer":
                        (name, pos) = value.split(':')
-                       pos = parsePosition(pos)
+                       pos = parsePosition(pos, scale)
                        ptr = loadPixmap(name, desktop)
                        guiObject.setPointer({"pointer": 0, "seek_pointer": 1}[attrib], ptr, pos)
                elif attrib == 'shadowOffset':
                        ptr = loadPixmap(name, desktop)
                        guiObject.setPointer({"pointer": 0, "seek_pointer": 1}[attrib], ptr, pos)
                elif attrib == 'shadowOffset':
-                       guiObject.setShadowOffset(parsePosition(value))
+                       guiObject.setShadowOffset(parsePosition(value, scale))
                elif attrib == 'noWrap':
                        guiObject.setNoWrap(1)
                else:
                elif attrib == 'noWrap':
                        guiObject.setNoWrap(1)
                else:
@@ -217,83 +219,122 @@ def applySingleAttribute(guiObject, desktop, attrib, value):
 # AttributeError:
                print "widget %s (%s) doesn't support attribute %s!" % ("", guiObject.__class__.__name__, attrib)
 
 # AttributeError:
                print "widget %s (%s) doesn't support attribute %s!" % ("", guiObject.__class__.__name__, attrib)
 
-def applyAllAttributes(guiObject, desktop, attributes):
+def applyAllAttributes(guiObject, desktop, attributes, scale):
        for (attrib, value) in attributes:
        for (attrib, value) in attributes:
-               applySingleAttribute(guiObject, desktop, attrib, value)
+               applySingleAttribute(guiObject, desktop, attrib, value, scale)
 
 
-def loadSingleSkinData(desktop, dom_skin, path_prefix):
+def loadSingleSkinData(desktop, skin, path_prefix):
        """loads skin data like colors, windowstyle etc."""
        """loads skin data like colors, windowstyle etc."""
-       
-       skin = dom_skin.childNodes[0]
-       assert skin.tagName == "skin", "root element in skin must be 'skin'!"
+       assert skin.tag == "skin", "root element in skin must be 'skin'!"
 
 
-       for c in elementsWithTag(skin.childNodes, "output"):
-               id = int(c.getAttribute("id") or "0")
-               if id == 0: # framebuffer
-                       for res in elementsWithTag(c.childNodes, "resolution"):
-                               xres = int(res.getAttribute("xres" or "720"))
-                               yres = int(res.getAttribute("yres" or "576"))
-                               bpp = int(res.getAttribute("bpp" or "32"))
+       #print "***SKIN: ", path_prefix
 
 
+       for c in skin.findall("output"):
+               id = c.attrib.get('id')
+               if id:
+                       id = int(id)
+               else:
+                       id = 0
+               if id == 0: # framebuffer
+                       for res in c.findall("resolution"):
+                               get_attr = c.attrib.get
+                               xres = get_attr("xres")
+                               if xres:
+                                       xres = int(xres)
+                               else:
+                                       xres = 720
+                               yres = get_attr("yres")
+                               if yres:
+                                       yres = int(yres)
+                               else:
+                                       yres = 576
+                               bpp = get_attr("bpp")
+                               if bpp:
+                                       bpp = int(bpp)
+                               else:
+                                       bpp = 32
+                               #print "Resolution:", xres,yres,bpp
                                from enigma import gFBDC
                                from enigma import gFBDC
-                               i = gFBDC.getInstance()
-                               i.setResolution(xres, yres)
-
+                               gFBDC.getInstance().setResolution(xres, yres)
                                if bpp != 32:
                                        # load palette (not yet implemented)
                                        pass
 
                                if bpp != 32:
                                        # load palette (not yet implemented)
                                        pass
 
-       for c in elementsWithTag(skin.childNodes, "colors"):
-               for color in elementsWithTag(c.childNodes, "color"):
-                       name = str(color.getAttribute("name"))
-                       color = str(color.getAttribute("value"))
-                       
-                       if not len(color):
+       for c in skin.findall("colors"):
+               for color in c.findall("color"):
+                       get_attr = color.attrib.get
+                       name = get_attr("name")
+                       color = get_attr("value")
+                       if name and color:
+                               colorNames[name] = parseColor(color)
+                               #print "Color:", name, color
+                       else:
                                raise ("need color and name, got %s %s" % (name, color))
                                raise ("need color and name, got %s %s" % (name, color))
-                               
-                       colorNames[name] = parseColor(color)
-       
-       for c in elementsWithTag(skin.childNodes, "fonts"):
-               for font in elementsWithTag(c.childNodes, "font"):
-                       filename = str(font.getAttribute("filename") or "<NONAME>")
-                       name = str(font.getAttribute("name") or "Regular")
-                       scale = int(font.getAttribute("scale") or "100")
-                       is_replacement = font.getAttribute("replacement") != ""
-                       addFont(resolveFilename(SCOPE_FONTS, filename, path_prefix=path_prefix), name, scale, is_replacement)
-       
-       for windowstyle in elementsWithTag(skin.childNodes, "windowstyle"):
+
+       for c in skin.findall("fonts"):
+               for font in c.findall("font"):
+                       get_attr = font.attrib.get
+                       filename = get_attr("filename", "<NONAME>")
+                       name = get_attr("name", "Regular")
+                       scale = get_attr("scale")
+                       if scale:
+                               scale = int(scale)
+                       else:
+                               scale = 100
+                       is_replacement = get_attr("replacement") and True or False
+                       resolved_font = resolveFilename(SCOPE_FONTS, filename, path_prefix=path_prefix)
+                       if not fileExists(resolved_font): #when font is not available look at current skin path
+                               skin_path = resolveFilename(SCOPE_CURRENT_SKIN, filename)
+                               if fileExists(skin_path):
+                                       resolved_font = skin_path
+                       addFont(resolved_font, name, scale, is_replacement)
+                       #print "Font: ", resolved_font, name, scale, is_replacement
+
+       for windowstyle in skin.findall("windowstyle"):
                style = eWindowStyleSkinned()
                style = eWindowStyleSkinned()
-               id = int(windowstyle.getAttribute("id") or "0")
-               
+               id = windowstyle.attrib.get("id")
+               if id:
+                       id = int(id)
+               else:
+                       id = 0
+               #print "windowstyle:", id
+
                # defaults
                font = gFont("Regular", 20)
                offset = eSize(20, 5)
                # defaults
                font = gFont("Regular", 20)
                offset = eSize(20, 5)
-               
-               for title in elementsWithTag(windowstyle.childNodes, "title"):
-                       offset = parseSize(title.getAttribute("offset"))
-                       font = parseFont(str(title.getAttribute("font")))
+
+               for title in windowstyle.findall("title"):
+                       get_attr = title.attrib.get
+                       offset = parseSize(get_attr("offset"), ((1,1),(1,1)))
+                       font = parseFont(get_attr("font"), ((1,1),(1,1)))
 
                style.setTitleFont(font);
                style.setTitleOffset(offset)
 
                style.setTitleFont(font);
                style.setTitleOffset(offset)
-               
-               for borderset in elementsWithTag(windowstyle.childNodes, "borderset"):
-                       bsName = str(borderset.getAttribute("name"))
-                       for pixmap in elementsWithTag(borderset.childNodes, "pixmap"):
-                               bpName = str(pixmap.getAttribute("pos"))
-                               filename = str(pixmap.getAttribute("filename"))
-                               
-                               png = loadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, filename, path_prefix=path_prefix), desktop)
-                               style.setPixmap(eWindowStyleSkinned.__dict__[bsName], eWindowStyleSkinned.__dict__[bpName], png)
-
-               for color in elementsWithTag(windowstyle.childNodes, "color"):
-                       type = str(color.getAttribute("name"))
-                       color = parseColor(color.getAttribute("color"))
-                       
+               #print "  ", font, offset
+
+               for borderset in windowstyle.findall("borderset"):
+                       bsName = str(borderset.attrib.get("name"))
+                       for pixmap in borderset.findall("pixmap"):
+                               get_attr = pixmap.attrib.get
+                               bpName = get_attr("pos")
+                               filename = get_attr("filename")
+                               if filename and bpName:
+                                       png = loadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, filename, path_prefix=path_prefix), desktop)
+                                       style.setPixmap(eWindowStyleSkinned.__dict__[bsName], eWindowStyleSkinned.__dict__[bpName], png)
+                               #print "  borderset:", bpName, filename
+
+               for color in windowstyle.findall("color"):
+                       get_attr = color.attrib.get
+                       type = get_attr("name")
+                       color = parseColor(get_attr("color"))
                        try:
                                style.setColor(eWindowStyleSkinned.__dict__["col" + type], color)
                        except:
                                raise ("Unknown color %s" % (type))
                        try:
                                style.setColor(eWindowStyleSkinned.__dict__["col" + type], color)
                        except:
                                raise ("Unknown color %s" % (type))
-                       
+                               #pass
+
+                       #print "  color:", type, color
+
                x = eWindowStyleManager.getInstance()
                x.setStyle(id, style)
 
                x = eWindowStyleManager.getInstance()
                x.setStyle(id, style)
 
@@ -304,14 +345,16 @@ def loadSkinData(desktop):
                loadSingleSkinData(desktop, dom_skin, path)
 
 def lookupScreen(name):
                loadSingleSkinData(desktop, dom_skin, path)
 
 def lookupScreen(name):
-       for (path, dom_skin) in dom_skins:
+       for (path, skin) in dom_skins:
                # first, find the corresponding screen element
                # first, find the corresponding screen element
-               skin = dom_skin.childNodes[0] 
-               for x in elementsWithTag(skin.childNodes, "screen"):
-                       if x.getAttribute('name') == name:
+               for x in skin.findall("screen"):
+                       if x.attrib.get('name', '') == name:
                                return x, path
        return None, None
 
                                return x, path
        return None, None
 
+class additionalWidget:
+       pass
+
 def readSkin(screen, skin, names, desktop):
        if not isinstance(names, list):
                names = [names]
 def readSkin(screen, skin, names, desktop):
        if not isinstance(names, list):
                names = [names]
@@ -327,39 +370,46 @@ def readSkin(screen, skin, names, desktop):
                        break
 
        # otherwise try embedded skin
                        break
 
        # otherwise try embedded skin
-       myscreen = myscreen or getattr(screen, "parsedSkin", None)
+       if myscreen is None:
+               myscreen = getattr(screen, "parsedSkin", None)
 
        # try uncompiled embedded skin
        if myscreen is None and getattr(screen, "skin", None):
 
        # try uncompiled embedded skin
        if myscreen is None and getattr(screen, "skin", None):
-               myscreen = screen.parsedSkin = xml.dom.minidom.parseString(screen.skin).childNodes[0]
+               print "Looking for embedded skin"
+               myscreen = screen.parsedSkin = xml.etree.cElementTree.fromstring(screen.skin)
 
 
-       assert myscreen is not None, "no skin for screen '" + repr(names) + "' found!"
+       #assert myscreen is not None, "no skin for screen '" + repr(names) + "' found!"
+       if myscreen is None:
+               print "No skin to read..."
+               emptySkin = "<screen></screen>"
+               myscreen = screen.parsedSkin = xml.etree.cElementTree.fromstring(emptySkin)
 
        screen.skinAttributes = [ ]
 
        screen.skinAttributes = [ ]
-       
+
        skin_path_prefix = getattr(screen, "skin_path", path)
 
        collectAttributes(screen.skinAttributes, myscreen, skin_path_prefix, ignore=["name"])
        skin_path_prefix = getattr(screen, "skin_path", path)
 
        collectAttributes(screen.skinAttributes, myscreen, skin_path_prefix, ignore=["name"])
-       
+
        screen.additionalWidgets = [ ]
        screen.renderer = [ ]
        screen.additionalWidgets = [ ]
        screen.renderer = [ ]
-       
+
        visited_components = set()
        visited_components = set()
-       
+
        # now walk all widgets
        # now walk all widgets
-       for widget in elementsWithTag(myscreen.childNodes, "widget"):
-               # ok, we either have 1:1-mapped widgets ('old style'), or 1:n-mapped 
+       for widget in myscreen.findall("widget"):
+               get_attr = widget.attrib.get
+               # ok, we either have 1:1-mapped widgets ('old style'), or 1:n-mapped
                # widgets (source->renderer).
 
                # widgets (source->renderer).
 
-               wname = widget.getAttribute('name')
-               wsource = widget.getAttribute('source')
-               
+               wname = get_attr('name')
+               wsource = get_attr('source')
 
                if wname is None and wsource is None:
                        print "widget has no name and no source!"
                        continue
 
                if wname is None and wsource is None:
                        print "widget has no name and no source!"
                        continue
-               
+
                if wname:
                if wname:
+                       #print "Widget name=", wname
                        visited_components.add(wname)
 
                        # get corresponding 'gui' object
                        visited_components.add(wname)
 
                        # get corresponding 'gui' object
@@ -367,6 +417,7 @@ def readSkin(screen, skin, names, desktop):
                                attributes = screen[wname].skinAttributes = [ ]
                        except:
                                raise SkinError("component with name '" + wname + "' was not found in skin of screen '" + name + "'!")
                                attributes = screen[wname].skinAttributes = [ ]
                        except:
                                raise SkinError("component with name '" + wname + "' was not found in skin of screen '" + name + "'!")
+                               #print "WARNING: component with name '" + wname + "' was not found in skin of screen '" + name + "'!"
 
 #                      assert screen[wname] is not Source
 
 
 #                      assert screen[wname] is not Source
 
@@ -374,6 +425,7 @@ def readSkin(screen, skin, names, desktop):
                        collectAttributes(attributes, widget, skin_path_prefix, ignore=['name'])
                elif wsource:
                        # get corresponding source
                        collectAttributes(attributes, widget, skin_path_prefix, ignore=['name'])
                elif wsource:
                        # get corresponding source
+                       #print "Widget source=", wsource
 
                        while True: # until we found a non-obsolete source
 
 
                        while True: # until we found a non-obsolete source
 
@@ -386,8 +438,8 @@ def readSkin(screen, skin, names, desktop):
                                while len(path) > 1:
                                        scr = screen.getRelatedScreen(path[0])
                                        if scr is None:
                                while len(path) > 1:
                                        scr = screen.getRelatedScreen(path[0])
                                        if scr is None:
-                                               print wsource
-                                               print name
+                                               #print wsource
+                                               #print name
                                                raise SkinError("specified related screen '" + wsource + "' was not found in screen '" + name + "'!")
                                        path = path[1:]
 
                                                raise SkinError("specified related screen '" + wsource + "' was not found in screen '" + name + "'!")
                                        path = path[1:]
 
@@ -407,20 +459,26 @@ def readSkin(screen, skin, names, desktop):
 
                        if source is None:
                                raise SkinError("source '" + wsource + "' was not found in screen '" + name + "'!")
 
                        if source is None:
                                raise SkinError("source '" + wsource + "' was not found in screen '" + name + "'!")
-                       
-                       wrender = widget.getAttribute('render')
-                       
+
+                       wrender = get_attr('render')
+
                        if not wrender:
                                raise SkinError("you must define a renderer with render= for source '%s'" % (wsource))
                        if not wrender:
                                raise SkinError("you must define a renderer with render= for source '%s'" % (wsource))
-                       
-                       for converter in elementsWithTag(widget.childNodes, "convert"):
-                               ctype = converter.getAttribute('type')
+
+                       for converter in widget.findall("convert"):
+                               ctype = converter.get('type')
                                assert ctype, "'convert'-tag needs a 'type'-attribute"
                                assert ctype, "'convert'-tag needs a 'type'-attribute"
-                               parms = mergeText(converter.childNodes).strip()
+                               #print "Converter:", ctype
+                               #parms = mergeText(converter.childNodes).strip()
+                               try:
+                                       parms = converter.text.strip()
+                               except:
+                                       parms = ""
+                               #print "Params:", ctype
                                converter_class = my_import('.'.join(["Components", "Converter", ctype])).__dict__.get(ctype)
                                converter_class = my_import('.'.join(["Components", "Converter", ctype])).__dict__.get(ctype)
-                               
+
                                c = None
                                c = None
-                               
+
                                for i in source.downstream_elements:
                                        if isinstance(i, converter_class) and i.converter_arguments == parms:
                                                c = i
                                for i in source.downstream_elements:
                                        if isinstance(i, converter_class) and i.converter_arguments == parms:
                                                c = i
@@ -431,54 +489,64 @@ def readSkin(screen, skin, names, desktop):
                                        c.connect(source)
                                else:
                                        print "reused converter!"
                                        c.connect(source)
                                else:
                                        print "reused converter!"
-       
+
                                source = c
                                source = c
-                       
+
                        renderer_class = my_import('.'.join(["Components", "Renderer", wrender])).__dict__.get(wrender)
                        renderer_class = my_import('.'.join(["Components", "Renderer", wrender])).__dict__.get(wrender)
-                       
+
                        renderer = renderer_class() # instantiate renderer
                        renderer = renderer_class() # instantiate renderer
-                       
+
                        renderer.connect(source) # connect to source
                        attributes = renderer.skinAttributes = [ ]
                        collectAttributes(attributes, widget, skin_path_prefix, ignore=['render', 'source'])
                        renderer.connect(source) # connect to source
                        attributes = renderer.skinAttributes = [ ]
                        collectAttributes(attributes, widget, skin_path_prefix, ignore=['render', 'source'])
-                       
+
                        screen.renderer.append(renderer)
 
        from Components.GUIComponent import GUIComponent
        nonvisited_components = [x for x in set(screen.keys()) - visited_components if isinstance(x, GUIComponent)]
                        screen.renderer.append(renderer)
 
        from Components.GUIComponent import GUIComponent
        nonvisited_components = [x for x in set(screen.keys()) - visited_components if isinstance(x, GUIComponent)]
-       
        assert not nonvisited_components, "the following components in %s don't have a skin entry: %s" % (name, ', '.join(nonvisited_components))
 
        # now walk additional objects
        assert not nonvisited_components, "the following components in %s don't have a skin entry: %s" % (name, ', '.join(nonvisited_components))
 
        # now walk additional objects
-       for widget in elementsWithTag(myscreen.childNodes, lambda x: x != "widget"):
-               if widget.tagName == "applet":
-                       codeText = mergeText(widget.childNodes).strip()
-                       type = widget.getAttribute('type')
+       for widget in myscreen.getchildren():
+               w_tag = widget.tag
+
+               if w_tag == "widget":
+                       continue
+
+               if w_tag == "applet":
+                       try:
+                               codeText = widget.text.strip()
+                       except:
+                               codeText = ""
+
+                       #print "Found code:"
+                       #print codeText
+                       type = widget.attrib.get('type')
 
                        code = compile(codeText, "skin applet", "exec")
 
                        code = compile(codeText, "skin applet", "exec")
-                       
+
                        if type == "onLayoutFinish":
                                screen.onLayoutFinish.append(code)
                        if type == "onLayoutFinish":
                                screen.onLayoutFinish.append(code)
+                               #print "onLayoutFinish = ", codeText
                        else:
                                raise SkinError("applet type '%s' unknown!" % type)
                        else:
                                raise SkinError("applet type '%s' unknown!" % type)
-                       
+                               #print "applet type '%s' unknown!" % type
+
                        continue
                        continue
-               
-               class additionalWidget:
-                       pass
-               
+
                w = additionalWidget()
                w = additionalWidget()
-               
-               if widget.tagName == "eLabel":
+
+               if w_tag == "eLabel":
                        w.widget = eLabel
                        w.widget = eLabel
-               elif widget.tagName == "ePixmap":
+               elif w_tag == "ePixmap":
                        w.widget = ePixmap
                else:
                        w.widget = ePixmap
                else:
-                       raise SkinError("unsupported stuff : %s" % widget.tagName)
-               
+                       raise SkinError("unsupported stuff : %s" % w_tag)
+                       #print "unsupported stuff : %s" % widget.tag
+
                w.skinAttributes = [ ]
                collectAttributes(w.skinAttributes, widget, skin_path_prefix, ignore=['name'])
                w.skinAttributes = [ ]
                collectAttributes(w.skinAttributes, widget, skin_path_prefix, ignore=['name'])
-               
+
                # applyAttributes(guiObject, widget, desktop)
                # guiObject.thisown = 0
                screen.additionalWidgets.append(w)
                # applyAttributes(guiObject, widget, desktop)
                # guiObject.thisown = 0
                screen.additionalWidgets.append(w)