Merge branch 'master' of git.opendreambox.org:/git/enigma2

[enigma2.git] / skin.py

diff --git a/skin.py b/skin.py
index 4f2260d64c5578b4d349777c44ecff56b9060cb9..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, SCOPE_CURRENT_SKIN, 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,16 +26,16 @@ 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) + "/"
        dom_skins.append((mpath, xml.etree.cElementTree.parse(filename).getroot()))
 
        mpath = path.dirname(filename) + "/"
        dom_skins.append((mpath, xml.etree.cElementTree.parse(filename).getroot()))
 


@@ -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,9 +226,9 @@ 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, skin, path_prefix):
        """loads skin data like colors, windowstyle etc."""
 
 def loadSingleSkinData(desktop, skin, path_prefix):
        """loads skin data like colors, windowstyle etc."""


@@ -237,7 +244,7 @@ def loadSingleSkinData(desktop, skin, path_prefix):
                        id = 0
                if id == 0: # framebuffer
                        for res in c.findall("resolution"):
                        id = 0
                if id == 0: # framebuffer
                        for res in c.findall("resolution"):

-                               get_attr = c.attrib.get
+                               get_attr = res.attrib.get

                                xres = get_attr("xres")
                                if xres:
                                        xres = int(xres)
                                xres = get_attr("xres")
                                if xres:
                                        xres = int(xres)


@@ -256,6 +263,7 @@ def loadSingleSkinData(desktop, skin, path_prefix):
                                #print "Resolution:", xres,yres,bpp
                                from enigma import gFBDC
                                gFBDC.getInstance().setResolution(xres, yres)
                                #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
                                if bpp != 32:
                                        # load palette (not yet implemented)
                                        pass


@@ -269,7 +277,7 @@ def loadSingleSkinData(desktop, skin, path_prefix):
                                colorNames[name] = parseColor(color)
                                #print "Color:", name, color
                        else:
                                colorNames[name] = parseColor(color)
                                #print "Color:", name, color
                        else:

-                               raise ("need color and name, got %s %s" % (name, color))
+                               raise SkinError("need color and name, got %s %s" % (name, color))

 
        for c in skin.findall("fonts"):
                for font in c.findall("font"):
 
        for c in skin.findall("fonts"):
                for font in c.findall("font"):


@@ -305,8 +313,8 @@ def loadSingleSkinData(desktop, skin, path_prefix):
 
                for title in windowstyle.findall("title"):
                        get_attr = title.attrib.get
 
                for title in windowstyle.findall("title"):
                        get_attr = title.attrib.get

-                       offset = parseSize(get_attr("offset"))
-                       font = parseFont(get_attr("font"))
+                       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)


@@ -330,7 +338,7 @@ def loadSingleSkinData(desktop, skin, path_prefix):
                        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


@@ -370,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):


@@ -468,13 +477,12 @@ def readSkin(screen, skin, names, desktop):
                                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
 


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