add plugin to connect via builtin modem to internet (just dm500hd yet)
[enigma2.git] / skin.py
diff --git a/skin.py b/skin.py
index 1f5c9cfc6af0d73fa1e27eec970d4d989a9e8fc5..a76f7942c0897e8dd1de8d19d6db5196bd6bedca 100644 (file)
--- a/skin.py
+++ b/skin.py
@@ -1,16 +1,17 @@
-import xml.dom.minidom
+from Tools.Profile import profile
+profile("LOAD:ElementTree")
+import xml.etree.cElementTree
 from os import path
 
 from os import path
 
+profile("LOAD:enigma_skin")
 from enigma import eSize, ePoint, gFont, eWindow, eLabel, ePixmap, eWindowStyleManager, \
 from enigma import eSize, ePoint, gFont, eWindow, eLabel, ePixmap, eWindowStyleManager, \
-       loadPNG, addFont, gRGB, eWindowStyleSkinned
-
+       addFont, gRGB, eWindowStyleSkinned
 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, SCOPE_CONFIG, fileExists
 from Tools.Import import my_import
 from Tools.Import import my_import
-
-from Tools.XMLTools import elementsWithTag, mergeText
+from Tools.LoadPixmap import LoadPixmap
 
 colorNames = dict()
 
 
 colorNames = dict()
 
@@ -24,18 +25,18 @@ def dump(x, i=0):
 
 class SkinError(Exception):
        def __init__(self, message):
 
 class SkinError(Exception):
        def __init__(self, message):
-               self.message = message
+               self.msg = message
 
        def __str__(self):
 
        def __str__(self):
-               return self.message
+               return "{%s}: %s" % (config.skin.primary_skin, self.msg)
 
 dom_skins = [ ]
 
 
 dom_skins = [ ]
 
-def loadSkin(name):
+def loadSkin(name, scope = SCOPE_SKIN):
        # read the skin
        # read the skin
-       filename = resolveFilename(SCOPE_SKIN, name)
+       filename = resolveFilename(scope, name)
        mpath = path.dirname(filename) + "/"
        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
@@ -51,25 +52,35 @@ def loadSkin(name):
 config.skin = ConfigSubsection()
 config.skin.primary_skin = ConfigText(default = "skin.xml")
 
 config.skin = ConfigSubsection()
 config.skin.primary_skin = ConfigText(default = "skin.xml")
 
+profile("LoadSkin")
+try:
+       loadSkin('skin_user.xml', SCOPE_CONFIG)
+except (SkinError, IOError, AssertionError), err:
+       print "not loading user skin: ", err
+
 try:
        loadSkin(config.skin.primary_skin.value)
 except (SkinError, IOError, AssertionError), err:
        print "SKIN ERROR:", err
        print "defaulting to standard skin..."
 try:
        loadSkin(config.skin.primary_skin.value)
 except (SkinError, IOError, AssertionError), err:
        print "SKIN ERROR:", err
        print "defaulting to standard skin..."
+       config.skin.primary_skin.value = 'skin.xml'
        loadSkin('skin.xml')
        loadSkin('skin.xml')
+
+profile("LoadSkinDefault")
 loadSkin('skin_default.xml')
 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] != '#':
@@ -81,44 +92,46 @@ 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")
-               
-               if attrib in ["pixmap", "pointer", "seek_pointer", "backgroundPixmap", "selectionPixmap"]:
+       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)
                        value = resolveFilename(SCOPE_SKIN_IMAGE, value, path_prefix=skin_path_prefix)
-               
+
                if attrib not in ignore:
                        skinAttributes.append((attrib, value))
 
                if attrib not in ignore:
                        skinAttributes.append((attrib, value))
 
-def loadPixmap(path):
-       ptr = loadPNG(path)
+def 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 == 'zPosition':
                        guiObject.setZPosition(int(value))
-               elif attrib in ["pixmap", "backgroundPixmap", "selectionPixmap"]:
-                       ptr = loadPixmap(value) # this should already have been filename-resolved.
-                       desktop.makeCompatiblePixmap(ptr)
+               elif attrib in ("pixmap", "backgroundPixmap", "selectionPixmap"):
+                       ptr = loadPixmap(value, desktop) # this should already have been filename-resolved.
                        if attrib == "pixmap":
                                guiObject.setPixmap(ptr)
                        elif attrib == "backgroundPixmap":
                        if attrib == "pixmap":
                                guiObject.setPixmap(ptr)
                        elif attrib == "backgroundPixmap":
@@ -128,14 +141,21 @@ def applySingleAttribute(guiObject, desktop, attrib, value):
                        # guiObject.setPixmapFromFile(value)
                elif attrib == "alphatest": # used by ePixmap
                        guiObject.setAlphatest(
                        # guiObject.setPixmapFromFile(value)
                elif attrib == "alphatest": # used by ePixmap
                        guiObject.setAlphatest(
-                               { "on": True,
-                                 "off": False
+                               { "on": 1,
+                                 "off": 0,
+                                 "blend": 2,
                                }[value])
                                }[value])
+               elif attrib == "scale":
+                       guiObject.setScale(1)
                elif attrib == "orientation": # used by eSlider
                        try:
                elif attrib == "orientation": # used by eSlider
                        try:
-                               guiObject.setOrientation(
-                                       { "orVertical": guiObject.orVertical,
-                                               "orHorizontal": guiObject.orHorizontal
+                               guiObject.setOrientation(*
+                                       { "orVertical": (guiObject.orVertical, False),
+                                               "orTopToBottom": (guiObject.orVertical, False),
+                                               "orBottomToTop": (guiObject.orVertical, True),
+                                               "orHorizontal": (guiObject.orHorizontal, False),
+                                               "orLeftToRight": (guiObject.orHorizontal, False),
+                                               "orRightToLeft": (guiObject.orHorizontal, True),
                                        }[value])
                        except KeyError:
                                print "oprientation must be either orVertical or orHorizontal!"
                                        }[value])
                        except KeyError:
                                print "oprientation must be either orVertical or orHorizontal!"
@@ -194,12 +214,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)
-                       ptr = loadPixmap(name)
-                       desktop.makeCompatiblePixmap(ptr)
+                       pos = parsePosition(pos, scale)
+                       ptr = loadPixmap(name, desktop)
                        guiObject.setPointer({"pointer": 0, "seek_pointer": 1}[attrib], ptr, pos)
                elif attrib == 'shadowOffset':
                        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:
@@ -208,70 +227,145 @@ 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'!"
-       
-       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):
-                               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"):
+       assert skin.tag == "skin", "root element in skin must be 'skin'!"
+
+       #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 = res.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
+                               gFBDC.getInstance().setResolution(xres, yres)
+                               desktop.resize(eSize(xres, yres))
+                               if bpp != 32:
+                                       # load palette (not yet implemented)
+                                       pass
+
+       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 SkinError("need color and name, got %s %s" % (name, color))
+
+       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 c in skin.findall("subtitles"):
+               from enigma import eWidget, eSubtitleWidget
+               scale = ((1,1),(1,1))
+               for substyle in c.findall("sub"):
+                       get_attr = substyle.attrib.get
+                       font = parseFont(get_attr("font"), scale)
+                       col = get_attr("foregroundColor")
+                       if col:
+                               foregroundColor = parseColor(col)
+                               haveColor = 1
+                       else:
+                               foregroundColor = gRGB(0xFFFFFF)
+                               haveColor = 0
+                       col = get_attr("shadowColor")
+                       if col:
+                               shadowColor = parseColor(col)
+                       else:
+                               shadowColor = gRGB(0)
+                       shadowOffset = parsePosition(get_attr("shadowOffset"), scale)
+                       face = eSubtitleWidget.__dict__[get_attr("name")]
+                       eSubtitleWidget.setFontStyle(face, font, haveColor, foregroundColor, shadowColor, shadowOffset)
+
+       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))
-                               
-                               # adapt palette
-                               desktop.makeCompatiblePixmap(png)
-                               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
+                       colorType = get_attr("name")
+                       color = parseColor(get_attr("color"))
                        try:
                        try:
-                               style.setColor(eWindowStyleSkinned.__dict__["col" + type], color)
+                               style.setColor(eWindowStyleSkinned.__dict__["col" + colorType], color)
                        except:
                        except:
-                               raise ("Unknown color %s" % (type))
-                       
+                               raise SkinError("Unknown color %s" % (colorType))
+                               #pass
+
+                       #print "  color:", type, color
+
                x = eWindowStyleManager.getInstance()
                x.setStyle(id, style)
 
                x = eWindowStyleManager.getInstance()
                x.setStyle(id, style)
 
@@ -282,14 +376,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]
@@ -305,39 +401,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
@@ -345,6 +448,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
 
@@ -352,6 +456,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
 
@@ -364,8 +469,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:]
 
@@ -385,20 +490,25 @@ 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()
-                               converter_class = my_import('.'.join(["Components", "Converter", ctype])).__dict__.get(ctype)
-                               
+                               #print "Converter:", ctype
+                               try:
+                                       parms = converter.text.strip()
+                               except:
+                                       parms = ""
+                               #print "Params:", parms
+                               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
@@ -409,54 +519,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
+                       widgetType = widget.attrib.get('type')
 
                        code = compile(codeText, "skin applet", "exec")
 
                        code = compile(codeText, "skin applet", "exec")
-                       
-                       if type == "onLayoutFinish":
+
+                       if widgetType == "onLayoutFinish":
                                screen.onLayoutFinish.append(code)
                                screen.onLayoutFinish.append(code)
+                               #print "onLayoutFinish = ", codeText
                        else:
                        else:
-                               raise SkinError("applet type '%s' unknown!" % type)
-                       
+                               raise SkinError("applet type '%s' unknown!" % widgetType)
+                               #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)