filter \n and \t in short description title

[enigma2.git] / skin.py

diff --git a/skin.py b/skin.py
index 7c075b0db6913c5b8732575b461515080415dedf..6baf6b71df836215a2b33558066287fbfab484b0 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):


@@ -31,13 +29,13 @@ class SkinError(Exception):
                self.message = message
 
        def __str__(self):
                self.message = message
 
        def __str__(self):

-               return self.message
+               return "{%s}: %s" % (config.skin.primary_skin, self.message)

 
 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] != '#':


@@ -113,19 +116,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"]:


@@ -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)


@@ -255,8 +262,8 @@ def loadSingleSkinData(desktop, skin, path_prefix):
                                        bpp = 32
                                #print "Resolution:", xres,yres,bpp
                                from enigma import gFBDC
                                        bpp = 32
                                #print "Resolution:", xres,yres,bpp
                                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


@@ -266,12 +273,11 @@ def loadSingleSkinData(desktop, skin, path_prefix):
                        get_attr = color.attrib.get
                        name = get_attr("name")
                        color = get_attr("value")
                        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:
                        if name and color:
                                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"):


@@ -307,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)


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


@@ -354,6 +360,9 @@ def lookupScreen(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]


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


@@ -382,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)


@@ -408,7 +417,6 @@ def readSkin(screen, skin, names, desktop):
                        continue
 
                if wname:
                        continue
 
                if wname:

-

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


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


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


@@ -504,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:


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

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

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


@@ -534,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 = [ ]