use correct voltage/tone settings

[enigma2.git] / skin.py

diff --git a/skin.py b/skin.py
index 201e5012ea56a24f08cfdeeb910b582ebb516fa5..97954715c4d94f6a1f765cfb4ec708f8aa88f8d0 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,11 +10,11 @@ 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, 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
+from Tools.XMLTools import mergeText

 
 colorNames = dict()
 
 
 colorNames = dict()
 


@@ -39,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.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


@@ -68,17 +68,17 @@ profile("LoadSkinDefault")
 loadSkin('skin_default.xml')
 profile("LoadSkinDefaultDone")
 
 loadSkin('skin_default.xml')
 profile("LoadSkinDefaultDone")
 

-def parsePosition(str):
+def parsePosition(str, scale):

        x, y = str.split(',')
        x, y = str.split(',')

-       return ePoint(int(x), int(y))
+       return ePoint(int(x) * scale[0][0] / scale[0][1], int(y) * scale[1][0] / scale[1][1])

 
 

-def parseSize(str):
+def parseSize(str, scale):

        x, y = str.split(',')
        x, y = str.split(',')

-       return eSize(int(x), int(y))
+       return eSize(int(x) * scale[0][0] / scale[0][1], int(y) * scale[1][0] / scale[1][1])

 
 

-def parseFont(str):
+def parseFont(str, scale):

        name, size = str.split(';')
        name, size = str.split(';')

-       return gFont(name, int(size))
+       return gFont(name, int(size) * scale[0][0] / scale[0][1])

 
 def parseColor(str):
        if str[0] != '#':
 
 def parseColor(str):
        if str[0] != '#':


@@ -113,19 +113,19 @@ 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 in ["pixmap", "backgroundPixmap", "selectionPixmap"]:
                elif attrib == 'zPosition':
                        guiObject.setZPosition(int(value))
                elif attrib in ["pixmap", "backgroundPixmap", "selectionPixmap"]:


@@ -206,11 +206,11 @@ def applySingleAttribute(guiObject, desktop, attrib, value):
                        guiObject.setWrapAround(True)
                elif attrib == "pointer" or attrib == "seek_pointer":
                        (name, pos) = value.split(':')
                        guiObject.setWrapAround(True)
                elif attrib == "pointer" or attrib == "seek_pointer":
                        (name, pos) = value.split(':')

-                       pos = parsePosition(pos)
+                       pos = parsePosition(pos, scale)

                        ptr = loadPixmap(name, desktop)
                        guiObject.setPointer({"pointer": 0, "seek_pointer": 1}[attrib], ptr, pos)
                elif attrib == 'shadowOffset':
                        ptr = loadPixmap(name, desktop)
                        guiObject.setPointer({"pointer": 0, "seek_pointer": 1}[attrib], ptr, pos)
                elif attrib == 'shadowOffset':

-                       guiObject.setShadowOffset(parsePosition(value))
+                       guiObject.setShadowOffset(parsePosition(value, scale))

                elif attrib == 'noWrap':
                        guiObject.setNoWrap(1)
                else:
                elif attrib == 'noWrap':
                        guiObject.setNoWrap(1)
                else:


@@ -219,94 +219,115 @@ 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):
+       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)
-                       #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("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:


@@ -325,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.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 +371,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 +385,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 +397,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,12 +461,12 @@ 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


@@ -483,16 +505,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 +522,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 +535,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 = [ ]