signal Standby-state into session globals

[enigma2.git] / skin.py

diff --git a/skin.py b/skin.py
index 201e5012ea56a24f08cfdeeb910b582ebb516fa5..a37716f1e1f2be0ddbbcacbe4fe206063d33e4b3 100644 (file)
--- a/skin.py
+++ b/skin.py
@@ -1,4 +1,4 @@
-from Tools.Profile import profile, profile_final
+from Tools.Profile import profile

 profile("LOAD:ElementTree")
 import xml.etree.cElementTree
 from os import path
 profile("LOAD:ElementTree")
 import xml.etree.cElementTree
 from os import path


@@ -10,12 +10,10 @@ 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, fileExists
+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.LoadPixmap import LoadPixmap
 
 from Tools.Import import my_import
 from Tools.LoadPixmap import LoadPixmap
 

-from Tools.XMLTools import elementsWithTag, mergeText
-

 colorNames = dict()
 
 def dump(x, i=0):
 colorNames = dict()
 
 def dump(x, i=0):


@@ -28,18 +26,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.etree.cElementTree.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


@@ -56,6 +54,11 @@ config.skin = ConfigSubsection()
 config.skin.primary_skin = ConfigText(default = "skin.xml")
 
 profile("LoadSkin")
 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:
 try:
        loadSkin(config.skin.primary_skin.value)
 except (SkinError, IOError, AssertionError), err:


@@ -68,17 +71,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] != '#':


@@ -95,7 +98,7 @@ def collectAttributes(skinAttributes, node, skin_path_prefix=None, ignore=[]):
                attrib = a[0]
                value = a[1]
 
                attrib = a[0]
                value = a[1]
 

-               if attrib in ["pixmap", "pointer", "seek_pointer", "backgroundPixmap", "selectionPixmap"]:
+               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:
                        value = resolveFilename(SCOPE_SKIN_IMAGE, value, path_prefix=skin_path_prefix)
 
                if attrib not in ignore:


@@ -113,22 +116,22 @@ def loadPixmap(path, desktop):
                raise SkinError("pixmap file %s not found!" % (path))
        return ptr
 
                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"]:
+               elif attrib in ("pixmap", "backgroundPixmap", "selectionPixmap"):

                        ptr = loadPixmap(value, desktop) # this should already have been filename-resolved.
                        if attrib == "pixmap":
                                guiObject.setPixmap(ptr)
                        ptr = loadPixmap(value, desktop) # this should already have been filename-resolved.
                        if attrib == "pixmap":
                                guiObject.setPixmap(ptr)


@@ -145,9 +148,13 @@ def applySingleAttribute(guiObject, desktop, attrib, value):
                                }[value])
                elif attrib == "orientation": # used by eSlider
                        try:
                                }[value])
                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!"


@@ -206,11 +213,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:


@@ -219,98 +226,119 @@ 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.getroot()

        assert skin.tag == "skin", "root element in skin must be 'skin'!"
 
        #print "***SKIN: ", path_prefix
 
        assert skin.tag == "skin", "root element in skin must be 'skin'!"
 
        #print "***SKIN: ", path_prefix
 

-       for c in skin.getiterator("output"):
-               id = int(c.get('id') or "0")
+       for c in skin.findall("output"):
+               id = c.attrib.get('id')
+               if id:
+                       id = int(id)
+               else:
+                       id = 0

                if id == 0: # framebuffer
                if id == 0: # framebuffer

-                       for res in c.getiterator("resolution"):
-                               xres = int(res.get("xres" or "720"))
-                               yres = int(res.get("yres" or "576"))
-                               bpp = int(res.get("bpp" or "32"))
-
+                       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
                                #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 skin.getiterator("colors"):
-               for color in c.getiterator("color"):
-                       name = str(color.get("name"))
-                       color = str(color.get("value"))
-
-                       if not len(color):
-                               raise ("need color and name, got %s %s" % (name, color))
-
-                       colorNames[name] = parseColor(color)
-                       #print "Color:", name, color
-
-       for c in skin.getiterator("fonts"):
-               for font in c.getiterator("font"):
-                       filename = str(font.attrib.get("filename", "<NONAME>"))
-                       name = str(font.get("name", "Regular"))
-                       scale = int(font.get("scale", "100"))
-                       is_replacement = font.get("replacement") != ""
+       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
                        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

-                               pos = config.skin.primary_skin.value.rfind('/')
-                               if pos != -1:
-                                       skin_path = resolveFilename(SCOPE_SKIN, config.skin.primary_skin.value[:pos+1]+filename, path_prefix=path_prefix)
-                                       if fileExists(skin_path):
-                                               resolved_font = 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
 
                        addFont(resolved_font, name, scale, is_replacement)
                        #print "Font: ", resolved_font, name, scale, is_replacement
 

-       for windowstyle in skin.getiterator("windowstyle"):
+       for windowstyle in skin.findall("windowstyle"):

                style = eWindowStyleSkinned()
                style = eWindowStyleSkinned()

-               id = int(windowstyle.attrib.get("id","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)
 
                #print "windowstyle:", id
 
                # defaults
                font = gFont("Regular", 20)
                offset = eSize(20, 5)
 

-               for title in windowstyle.getiterator("title"):
-                       offset = parseSize(title.get("offset"))
-                       font = parseFont(str(title.get("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)
                #print "  ", font, offset
 
 
                style.setTitleFont(font);
                style.setTitleOffset(offset)
                #print "  ", font, offset
 

-               for borderset in windowstyle.getiterator("borderset"):
-                       bsName = str(borderset.get("name"))
-                       for pixmap in borderset.getiterator("pixmap"):
-                               bpName = str(pixmap.get("pos"))
-                               filename = str(pixmap.get("filename"))
-
-                               png = loadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, filename, path_prefix=path_prefix), desktop)
-                               style.setPixmap(eWindowStyleSkinned.__dict__[bsName], eWindowStyleSkinned.__dict__[bpName], png)
+               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
 
                                #print "  borderset:", bpName, filename
 

-               for color in windowstyle.getiterator("color"):
-                       type = str(color.get("name"))
-                       color = parseColor(color.get("color"))
-
+               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:
                        try:
                                style.setColor(eWindowStyleSkinned.__dict__["col" + type], color)
                        except:

-                               raise ("Unknown color %s" % (type))
+                               raise SkinError("Unknown color %s" % (type))

                                #pass
 
                        #print "  color:", type, color
                                #pass
 
                        #print "  color:", type, color


@@ -325,14 +353,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.getroot()
-               for x in skin.getiterator("screen"):
-                       if x.get('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]


@@ -348,7 +378,8 @@ 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):


@@ -361,7 +392,6 @@ def readSkin(screen, skin, names, desktop):
                emptySkin = "<screen></screen>"
                myscreen = screen.parsedSkin = xml.etree.cElementTree.fromstring(emptySkin)
 
                emptySkin = "<screen></screen>"
                myscreen = screen.parsedSkin = xml.etree.cElementTree.fromstring(emptySkin)
 

-

        screen.skinAttributes = [ ]
 
        skin_path_prefix = getattr(screen, "skin_path", path)
        screen.skinAttributes = [ ]
 
        skin_path_prefix = getattr(screen, "skin_path", path)


@@ -374,20 +404,19 @@ def readSkin(screen, skin, names, desktop):
        visited_components = set()
 
        # now walk all widgets
        visited_components = set()
 
        # now walk all widgets

-       for widget in myscreen.getiterator("widget"):
+       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).
 
                # ok, we either have 1:1-mapped widgets ('old style'), or 1:n-mapped
                # widgets (source->renderer).
 

-               wname = widget.get('name')
-               wsource = widget.get('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:
 
                if wname is None and wsource is None:
                        print "widget has no name and no source!"
                        continue
 
                if wname:

-

                        #print "Widget name=", wname
                        visited_components.add(wname)
 
                        #print "Widget name=", wname
                        visited_components.add(wname)
 


@@ -439,22 +468,21 @@ 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.get('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 widget.getiterator("convert"):
+                       for converter in widget.findall("convert"):

                                ctype = converter.get('type')
                                assert ctype, "'convert'-tag needs a 'type'-attribute"
                                #print "Converter:", ctype
                                ctype = converter.get('type')
                                assert ctype, "'convert'-tag needs a 'type'-attribute"
                                #print "Converter:", ctype

-                               #parms = mergeText(converter.childNodes).strip()

                                try:
                                        parms = converter.text.strip()
                                except:
                                        parms = ""
                                try:
                                        parms = converter.text.strip()
                                except:
                                        parms = ""

-                               #print "Params:", ctype
-                               converter_class = my_import('.'.join(["Components", "Converter", ctype])).__dict__.get(ctype)
+                               #print "Params:", parms
+                               converter_class = my_import('.'.join(("Components", "Converter", ctype))).__dict__.get(ctype)

 
                                c = None
 
 
                                c = None
 


@@ -471,7 +499,7 @@ def readSkin(screen, skin, names, desktop):
 
                                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
 


@@ -483,16 +511,16 @@ def readSkin(screen, skin, names, desktop):
 
        from Components.GUIComponent import GUIComponent
        nonvisited_components = [x for x in set(screen.keys()) - visited_components if isinstance(x, GUIComponent)]
 
        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
        for widget in myscreen.getchildren():
        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 myscreen.getchildren():

+               w_tag = widget.tag

 
 

-               if widget.tag == "widget":
+               if w_tag == "widget":

                        continue
 
                        continue
 

-               if widget.tag == "applet":
+               if w_tag == "applet":

                        try:
                                codeText = widget.text.strip()
                        except:
                        try:
                                codeText = widget.text.strip()
                        except:


@@ -500,7 +528,7 @@ def readSkin(screen, skin, names, desktop):
 
                        #print "Found code:"
                        #print codeText
 
                        #print "Found code:"
                        #print codeText

-                       type = widget.get('type')
+                       type = widget.attrib.get('type')

 
                        code = compile(codeText, "skin applet", "exec")
 
 
                        code = compile(codeText, "skin applet", "exec")
 


@@ -513,17 +541,14 @@ def readSkin(screen, skin, names, desktop):
 
                        continue
 
 
                        continue
 

-               class additionalWidget:
-                       pass
-

                w = additionalWidget()
 
                w = additionalWidget()
 

-               if widget.tag == "eLabel":
+               if w_tag == "eLabel":

                        w.widget = eLabel
                        w.widget = eLabel

-               elif widget.tag == "ePixmap":
+               elif w_tag == "ePixmap":

                        w.widget = ePixmap
                else:
                        w.widget = ePixmap
                else:

-                       raise SkinError("unsupported stuff : %s" % widget.tag)
+                       raise SkinError("unsupported stuff : %s" % w_tag)

                        #print "unsupported stuff : %s" % widget.tag
 
                w.skinAttributes = [ ]
                        #print "unsupported stuff : %s" % widget.tag
 
                w.skinAttributes = [ ]