PositionerSetup/plugin.py: fix modulation, fix nim selection list size

[enigma2.git] / skin.py

diff --git a/skin.py b/skin.py
index ed48546e798f8e2fe64326c6f8e4381a93bee690..97954715c4d94f6a1f765cfb4ec708f8aa88f8d0 100644 (file)
--- a/skin.py
+++ b/skin.py
@@ -1,16 +1,20 @@
-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, fileExists

 from Tools.Import import my_import
 from Tools.Import import my_import

+from Tools.LoadPixmap import LoadPixmap

 
 

-from Tools.XMLTools import elementsWithTag, mergeText
+from Tools.XMLTools import mergeText

 
 colorNames = dict()
 
 
 colorNames = dict()
 


@@ -35,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


@@ -51,6 +55,7 @@ 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(config.skin.primary_skin.value)
 except (SkinError, IOError, AssertionError), err:
 try:
        loadSkin(config.skin.primary_skin.value)
 except (SkinError, IOError, AssertionError), err:


@@ -59,19 +64,21 @@ except (SkinError, IOError, AssertionError), err:
        config.skin.primary_skin.value = 'skin.xml'
        loadSkin('skin.xml')
 
        config.skin.primary_skin.value = '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] != '#':


@@ -83,44 +90,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")
-               
+       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))
 
                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 in ["pixmap", "backgroundPixmap", "selectionPixmap"]:
                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)
+                       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":


@@ -130,8 +139,9 @@ 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])
                elif attrib == "orientation": # used by eSlider
                        try:
                                }[value])
                elif attrib == "orientation": # used by eSlider
                        try:


@@ -196,12 +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)
-                       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:


@@ -210,86 +219,123 @@ 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 = 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
                                from enigma import gFBDC

-                               i = gFBDC.getInstance()
-                               i.setResolution(xres, yres)
-
+                               gFBDC.getInstance().setResolution(xres, yres)
+                               desktop.resize(eSize(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))
-                               
-                               # 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
+                       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)
 


@@ -300,14 +346,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]


@@ -323,39 +371,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


@@ -363,6 +418,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
 


@@ -370,6 +426,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
 


@@ -382,8 +439,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:]
 


@@ -403,20 +460,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


@@ -427,54 +490,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)