Skip to content
OpenATVOpenATV Handbook
More languages

Translate automatically from English. Screenshots and search terms remain English.

Google Translate loads after you choose a language.

English original

Renderer API — widgets, attributes and inputs

A renderer connects an upstream source or converter to a visual object. render="Label" selects Components.Renderer.Label.Label; its GUI_WIDGET = eLabel supplies the native attributes. A renderer can additionally consume its own XML options before passing the remaining attributes to skin.py.

This catalogue covers the 41 matching module classes in Components/Renderer, including the Renderer base and the non-visual FrontpanelLed. Presence in that directory does not make a class an OSD widget: front-panel control has a different lifecycle, and some implementations depend on optional packages or receiver capabilities.

The common contract

Section titled “The common contract”
Interface Purpose
connect(source) Attaches the upstream Element; normal skin construction does this.
GUI_WIDGET / createWidget(parent) Selects or creates the native widget.
postWidgetCreate(instance) Initialises the instance, callbacks or content after creation.
applySkin(desktop, parent) Consumes component options and applies remaining visual attributes.
changed(what) Responds to source updates; handle clear events as well as normal changes.
onShow() / onHide() Resume/suspend updates through the Element lifecycle.
preWidgetRemove(instance) Disconnects widget callbacks before removal.

These are Python methods, not XML attribute names. The catalogue includes their exact signatures and inherited methods. Do not create a second native widget from changed(); updates should modify the existing instance.

Common data contracts

Section titled “Common data contracts”
Renderer Upstream data Extra configuration
Label text Native eLabel attributes
FixedLabel Can participate in visibility changes XML text remains fixed
Progress value and range Native eSlider attributes
Pixmap pixmap, or numeric text for an image list pixmaps="off.png,on.png" uses zero-based indexes
Listbox Native content; selection callbacks Often supplied by XmlMultiContent / TemplatedMultiContent
Canvas drawlist instructions Drawing commands carry their own text/font/colour data
PositionGauge Playback length, position and cut-list data pointer, seekPointer and native gauge attributes
RunningText text A viewport plus child label; custom options and text styling

The API recipes show complete chains and explain why an exposed property does not necessarily work in every converter mode.

Renderer catalogue

Section titled “Renderer catalogue”

Expand Arguments, defaults and skin parsing for the exact constructor and applySkin code, including base implementations. The extra-attribute list is extracted from explicit comparisons, match branches and local-handler dispatch. Nested sub-options, for example the comma-separated contents of options, are shown in the parsing code; they are not separate widget attributes.

41 entries

Source snapshot f4135659cb. Current attribute counts exclude legacy names and structural XML names. Deprecated attributes and compatibility migrations have their own reference.

AnalogClockLCD

lib/python/Components/Renderer/AnalogClockLCD.py, line 10 ↗

Class: Components.Renderer.AnalogClockLCD.AnalogClockLCD. Bases: Renderer.

Native root: eCanvas (18 current central attribute names).

Names explicitly handled in this class's applySkin: 9. bColor, fColor, hColor, linesize, linewidth, mColor, positionheight, positionwidth, sColor These can override central meanings.

Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Effective Python properties (3) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = eCanvas — Components.Renderer.AnalogClockLCD.AnalogClockLCD

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

AnalogClockLCD.__init__(self)

Implementation, line 13 ↗

def __init__(self):
	Renderer.__init__(self)
	self.fColor = gRGB(255, 255, 255, 0)
	self.bColor = gRGB(0, 0, 0, 255)
	self.forend = -1
	self.linewidth = 1
	self.positionheight = 1
	self.positionwidth = 1
	self.linesize = 10
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
AnalogClockLCD.applySkin(self, desktop, parent)

Implementation, line 23 ↗

def applySkin(self, desktop, parent):  # HINT: clock center = position="(x + linesize / 2), (y + linesize / 2)"
	attribs = []
	for attrib, what in self.skinAttributes:
		if attrib in ["fColor", "hColor", "mColor", "sColor"]:  # hand foregroundColor (compatible to old attribs 'h/m/sColor')
			self.fColor = parseColor(what)
		elif attrib == "bColor":  # hand backgroundColor
			self.bColor = parseColor(what)
		elif attrib == "linesize":  # hand length
			self.linesize = int(what)
		elif attrib == "linewidth":  # hand thickness
			self.linewidth = int(what)
		elif attrib == "positionwidth":  # oval dial width, typically >= 2 * linesize
			self.positionwidth = int(what)
		elif attrib == "positionheight":  # oval dial height, typically >= 2 * linesize
			self.positionheight = int(what)
		else:
			attribs.append((attrib, what))
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (8) and inherited methods (28)

Inherited methods

AudioIcon

lib/python/Components/Renderer/AudioIcon.py, line 7 ↗

Class: Components.Renderer.AudioIcon.AudioIcon. Bases: Renderer.

Native root: ePixmap (18 current central attribute names).

Names explicitly handled in this class's applySkin: 2. path, size These can override central meanings.

Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Effective Python properties (3) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = ePixmap — Components.Renderer.AudioIcon.AudioIcon

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

Class-level constants and option maps
searchPaths = (resolveFilename(SCOPE_GUISKIN), '/usr/share/enigma2/skin_default/')
AudioIcon.__init__(self)

Implementation, line 10 ↗

def __init__(self):
	Renderer.__init__(self)
	self.size = None
	self.nameAudioCache = {}
	self.pngname = ""
	self.path = ""
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
AudioIcon.applySkin(self, desktop, parent)

Implementation, line 17 ↗

def applySkin(self, desktop, parent):
	attribs = []
	for (attrib, value) in self.skinAttributes:
		if attrib == "path":
			self.path = join(value, "")
		else:
			attribs.append((attrib, value))
		if attrib == "size":
			value = value.split(",")
			if len(value) == 2:
				self.size = f"{value[0]}x{value[1]}"
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (4) and inherited methods (29)

Inherited methods

Canvas

Replays upstream drawlist instructions into an eCanvas; drawing commands have their own arguments.

lib/python/Components/Renderer/Canvas.py, line 5 ↗

Class: Components.Renderer.Canvas.Canvas. Bases: Renderer.

Native root: eCanvas (18 current central attribute names).

Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

Direct upstream accesses declared here: drawlist. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Effective Python properties (3) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = eCanvas — Components.Renderer.Canvas.Canvas

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

Canvas.__init__(self)

Implementation, line 8 ↗

def __init__(self):
	Renderer.__init__(self)
	self.sequence = None
	self.drawCount = 0
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (5) and inherited methods (29)

Inherited methods

ChannelNumber

lib/python/Components/Renderer/ChannelNumber.py, line 6 ↗

Class: Components.Renderer.ChannelNumber.ChannelNumber. Bases: Renderer, VariableText.

Native root: eLabel (30 current central attribute names).

Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

Direct upstream accesses declared here: serviceref. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Effective Python properties (4) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = eLabel — Components.Renderer.ChannelNumber.ChannelNumber

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

ChannelNumber.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.text = "---"
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
VariableText.__init__(self)

Implementation, line 4 ↗

def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (2) and inherited methods (33)

Inherited methods

CiModuleControl

lib/python/Components/Renderer/CiModuleControl.py, line 10 ↗

Class: Components.Renderer.CiModuleControl.CiModuleControl. Bases: Renderer, VariableText.

Native root: eLabel (30 current central attribute names).

Names explicitly handled in this class's applySkin: 1. allVisible These can override central meanings.

Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Effective Python properties (4) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = eLabel — Components.Renderer.CiModuleControl.CiModuleControl

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

CiModuleControl.__init__(self)

Implementation, line 13 ↗

def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.eDVBCIUIInstance = eDVBCI_UI.getInstance()
	self.eDVBCIUIInstance and self.eDVBCIUIInstance.ciStateChanged.get().append(self.ciModuleStateChanged)
	self.text = ""
	self.allVisible = False
	self.noVisibleState = "ciplushelper" in popen("top -n 1").read()
	self.colors = parameters.get("CiModuleControlColors", (0x007F7F7F, 0x00FFFF00, 0x0000FF00, 0x00FF2525))  # "state 0 (no module) gray", "state 1 (init module) yellow", "state 2 (module ready) green", "state -1 (error) red"
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
VariableText.__init__(self)

Implementation, line 4 ↗

def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
CiModuleControl.applySkin(self, desktop, parent)

Implementation, line 23 ↗

def applySkin(self, desktop, parent):
	attribs = self.skinAttributes[:]
	for (attrib, value) in self.skinAttributes:
		if attrib == "allVisible":
			self.allVisible = value == "1"
			attribs.remove((attrib, value))
			break
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (4) and inherited methods (32)

Inherited methods

Cover

lib/python/Components/Renderer/Cover.py, line 9 ↗

Class: Components.Renderer.Cover.Cover. Bases: Renderer.

Native root: ePixmap (18 current central attribute names).

Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

Direct upstream accesses declared here: getCurrentService, getCurrentServiceReference. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Effective Python properties (3) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = ePixmap — Components.Renderer.Cover.Cover

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

Class-level constants and option maps
EXTENSIONS = ('.jpg', '.png', '.jpeg')
Cover.__init__(self)

Implementation, line 13 ↗

def __init__(self):
	Renderer.__init__(self)
	self.nameCache = {}
	self.picname = ""
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (4) and inherited methods (30)

Inherited methods

EGclock

lib/python/Components/Renderer/EGclock.py, line 6 ↗

Class: Components.Renderer.EGclock.EGclock. Bases: VariableValue, Renderer.

Native root: eGauge (15 current central attribute names).

Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

Direct upstream accesses declared here: value. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Effective Python properties (4) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = eGauge — Components.Renderer.EGclock.EGclock

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

EGclock.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	Renderer.__init__(self)
	VariableValue.__init__(self)
VariableValue.__init__(self)

Implementation, line 4 ↗

def __init__(self):
	self.__value = 0
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (4) and inherited methods (30)

Inherited methods

EtAnalogClockLCD

lib/python/Components/Renderer/EtAnalogClockLCD.py, line 4 ↗

Class: Components.Renderer.EtAnalogClockLCD.EtAnalogClockLCD. Bases: AnalogClockLCD.

Native root: eCanvas (18 current central attribute names).

Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

Inherited Python attribute handlers
  • Components.Renderer.AnalogClockLCD.AnalogClockLCD: bColor, fColor, hColor, linesize, linewidth, mColor, positionheight, positionwidth, sColor

Inheritance does not mean every branch calls every base handler. The applySkin implementations below show delegation and precedence.

Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

Upstream accesses in base classes
  • Components.Renderer.AnalogClockLCD.AnalogClockLCD: accesses text; probes none.
Effective Python properties (3) and value/range constants

These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

GUI_WIDGET = eCanvas — Components.Renderer.AnalogClockLCD.AnalogClockLCD

Arguments, defaults and skin parsing — exact implementation

Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

AnalogClockLCD.__init__(self)

Implementation, line 13 ↗

def __init__(self):
	Renderer.__init__(self)
	self.fColor = gRGB(255, 255, 255, 0)
	self.bColor = gRGB(0, 0, 0, 255)
	self.forend = -1
	self.linewidth = 1
	self.positionheight = 1
	self.positionwidth = 1
	self.linesize = 10
Renderer.__init__(self)

Implementation, line 6 ↗

def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
GUIComponent.__init__(self)

Implementation, line 9 ↗

def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
Element.__init__(self)

Implementation, line 18 ↗

def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
AnalogClockLCD.applySkin(self, desktop, parent)

Implementation, line 23 ↗

def applySkin(self, desktop, parent):  # HINT: clock center = position="(x + linesize / 2), (y + linesize / 2)"
	attribs = []
	for attrib, what in self.skinAttributes:
		if attrib in ["fColor", "hColor", "mColor", "sColor"]:  # hand foregroundColor (compatible to old attribs 'h/m/sColor')
			self.fColor = parseColor(what)
		elif attrib == "bColor":  # hand backgroundColor
			self.bColor = parseColor(what)
		elif attrib == "linesize":  # hand length
			self.linesize = int(what)
		elif attrib == "linewidth":  # hand thickness
			self.linewidth = int(what)
		elif attrib == "positionwidth":  # oval dial width, typically >= 2 * linesize
			self.positionwidth = int(what)
		elif attrib == "positionheight":  # oval dial height, typically >= 2 * linesize
			self.positionheight = int(what)
		else:
			attribs.append((attrib, what))
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
GUIComponent.applySkin(self, desktop, parent)

Implementation, line 32 ↗

def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
GUIComponent.createWidget(self, parent)

Implementation, line 119 ↗

def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
GUIComponent.GUIcreate(self, parent)

Implementation, line 111 ↗

def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
Declared methods (0) and inherited methods (35)

    Inherited methods

    FixedLabel

    Keeps the XML label text while participating in a source/converter chain, for example for conditional visibility.

    lib/python/Components/Renderer/FixedLabel.py, line 5 ↗

    Class: Components.Renderer.FixedLabel.FixedLabel. Bases: Renderer.

    Native root: eLabel (30 current central attribute names).

    Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

    Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

    Effective Python properties (3) and value/range constants

    These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

    GUI_WIDGET = eLabel — Components.Renderer.FixedLabel.FixedLabel

    Arguments, defaults and skin parsing — exact implementation

    Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

    Renderer.__init__(self)

    Implementation, line 6 ↗

    def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
    GUIComponent.__init__(self)

    Implementation, line 9 ↗

    def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
    Element.__init__(self)

    Implementation, line 18 ↗

    def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
    GUIComponent.applySkin(self, desktop, parent)

    Implementation, line 32 ↗

    def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
    GUIComponent.createWidget(self, parent)

    Implementation, line 119 ↗

    def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
    GUIComponent.GUIcreate(self, parent)

    Implementation, line 111 ↗

    def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
    Declared methods (0) and inherited methods (31)

      Inherited methods

      FrontpanelLed

      Controls a front-panel LED rather than drawing an OSD widget. Its constructor accepts LED index, patterns and a boolean-mode flag. It has no GUIComponent/applySkin lifecycle.

      lib/python/Components/Renderer/FrontpanelLed.py, line 6 ↗

      Class: Components.Renderer.FrontpanelLed.FrontpanelLed. Bases: Element.

      No single GUI_WIDGET declaration. Inspect the construction contract below; this can be a base/helper, composite or non-visual class.

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: boolean, value. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (1) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      FrontpanelLed.__init__(self, which=0, patterns=None, boolean=True)

      Implementation, line 7 ↗

      def __init__(self, which=0, patterns=None, boolean=True):
	if not patterns:
		patterns = [(20, 0, 0xffffffff), (20, 0x55555555, 0x84fc8c04)]
	self.which = which
	self.boolean = boolean
	self.patterns = patterns
	Element.__init__(self)
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      Declared methods (2) and inherited methods (9)

      Inherited methods

      Label

      Displays upstream text. The renderer applies eLabel attributes and refreshes its text when the source changes.

      lib/python/Components/Renderer/Label.py, line 6 ↗

      Class: Components.Renderer.Label.Label. Bases: VariableText, Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: text. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.Label.Label

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Label.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (3) and inherited methods (32)

      Inherited methods

      LcdPicon

      lib/python/Components/Renderer/LcdPicon.py, line 123 ↗

      Class: Components.Renderer.LcdPicon.LcdPicon. Bases: Renderer.

      Native root: ePixmap (18 current central attribute names).

      Names explicitly handled in this class's applySkin: 2. path, size These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = ePixmap — Components.Renderer.LcdPicon.LcdPicon

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      LcdPicon.__init__(self)

      Implementation, line 126 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.PicLoad = ePicLoad()
	self.PicLoad.PictureData.get().append(self.updatePicon)
	self.piconsize = (0, 0)
	self.pngname = ""
	self.lastPath = None
	defaultName = "lcd_picon_default" if BW else "picon_default"
	pngname = findLcdPicon(defaultName)
	self.defaultpngname = None
	if not pngname:
		tmp = resolveFilename(SCOPE_GUISKIN, f"{defaultName}.png")
		if exists(tmp):
			pngname = tmp
		else:
			pngname = resolveFilename(SCOPE_SKINS, f"skin_default/{defaultName}.png")
	if getsize(pngname):
		self.defaultpngname = pngname
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      LcdPicon.applySkin(self, desktop, parent)

      Implementation, line 152 ↗

      def applySkin(self, desktop, parent):
	attribs = self.skinAttributes[:]
	for (attrib, value) in self.skinAttributes:
		if attrib == "path":
			self.addPath(value)
			attribs.remove((attrib, value))
		elif attrib == "size":
			self.piconsize = value
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (6) and inherited methods (28)

      Inherited methods

      Listbox

      Displays native list content provided upstream, commonly by XmlMultiContent or TemplatedMultiContent. It also propagates selection changes to the source.

      lib/python/Components/Renderer/Listbox.py, line 14 ↗

      Class: Components.Renderer.Listbox.Listbox. Bases: Renderer.

      Native root: eListbox (63 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: content, scrollbarMode, selectionEnabled. Attribute probes: scrollbarMode, selectionEnabled. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (8) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eListbox — Components.Renderer.Listbox.Listbox

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Listbox.__init__(self)

      Implementation, line 17 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.__content = None
	self.__selectionEnabled = True  # FIXME: The default is true already.
	self.scale = None
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      Listbox.applySkin(self, desktop, parent)

      Implementation, line 23 ↗

      def applySkin(self, desktop, parent):
	self.scale = parent.scale
	return Renderer.applySkin(self, desktop, parent)
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (18) and inherited methods (26)

      Inherited methods

      NextEpgInfo

      lib/python/Components/Renderer/NextEpgInfo.py, line 7 ↗

      Class: Components.Renderer.NextEpgInfo.NextEpgInfo. Bases: Renderer, VariableText.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: info, service. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.NextEpgInfo.NextEpgInfo

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      NextEpgInfo.__init__(self)

      Implementation, line 10 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.epgcache = eEPGCache.getInstance()
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (2) and inherited methods (33)

      Inherited methods

      NextEvent

      lib/python/Components/Renderer/NextEvent.py, line 31 ↗

      Class: Components.Renderer.NextEvent.NextEvent. Bases: Renderer, VariableText.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: info, service. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.NextEvent.NextEvent

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      NextEvent.__init__(self)

      Implementation, line 34 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.epgcache = eEPGCache.getInstance()
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (2) and inherited methods (33)

      Inherited methods

      NextEvents

      lib/python/Components/Renderer/NextEvents.py, line 7 ↗

      Class: Components.Renderer.NextEvents.NextEvents. Bases: VariableText, Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 2. lines, number These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.NextEvents.NextEvents

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      NextEvents.__init__(self)

      Implementation, line 10 ↗

      def __init__(self):
	self.lines = False
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.epgcache = eEPGCache.getInstance()
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      NextEvents.applySkin(self, desktop, parent)

      Implementation, line 16 ↗

      def applySkin(self, desktop, parent):
	self.number = 0
	attribs = []
	for (attrib, value) in self.skinAttributes:
		if attrib == "number":
			self.number = int(value)
		elif attrib == "lines":
			self.number = int(value) + 1
			self.lines = True
		else:
			attribs.append((attrib, value))
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (5) and inherited methods (31)

      Inherited methods

      Picon

      Resolves service picons and updates an ePixmap. Path and sizing decisions in applySkin supplement the native image attributes.

      lib/python/Components/Renderer/Picon.py, line 148 ↗

      Class: Components.Renderer.Picon.Picon. Bases: Renderer.

      Native root: ePixmap (18 current central attribute names).

      Names explicitly handled in this class's applySkin: 3. mode, path, size These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = ePixmap — Components.Renderer.Picon.Picon

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Picon.__init__(self)

      Implementation, line 151 ↗

      def __init__(self):
	Renderer.__init__(self)
	# self.PicLoad = ePicLoad()
	# self.PicLoad.PictureData.get().append(self.updatePicon)
	self.piconsize = (0, 0)
	self.pngname = ""
	self.lastPath = None
	self.mode = None
	self.setDefaultPicon()
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      Picon.applySkin(self, desktop, parent)

      Implementation, line 183 ↗

      def applySkin(self, desktop, parent):
	attribs = self.skinAttributes[:]
	for (attrib, value) in self.skinAttributes:
		if attrib == "path":
			self.addPath(value)
			attribs.remove((attrib, value))
		elif attrib == "mode":
			if value in ("infobar", "channelselection"):
				self.mode = value
				self.setDefaultPicon(value)
			attribs.remove((attrib, value))
		elif attrib == "size":
			self.piconsize = value
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (6) and inherited methods (28)

      Inherited methods

      PiconBg

      lib/python/Components/Renderer/PiconBg.py, line 7 ↗

      Class: Components.Renderer.PiconBg.PiconBg. Bases: Renderer.

      Native root: ePixmap (18 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = ePixmap — Components.Renderer.PiconBg.PiconBg

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      PiconBg.__init__(self)

      Implementation, line 10 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.pngname = ""
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (3) and inherited methods (29)

      Inherited methods

      Pig

      Places a live video plane using eVideoWidget. Decoder/PiP behaviour depends on Python configuration and hardware. Use OSD-only captures for documentation examples.

      lib/python/Components/Renderer/Pig.py, line 8 ↗

      Class: Components.Renderer.Pig.Pig. Bases: Renderer.

      Native root: eVideoWidget (31 current central attribute names).

      Names explicitly handled in this class's applySkin: 1. hidePip These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eVideoWidget — Components.Renderer.Pig.Pig

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Pig.__init__(self)

      Implementation, line 11 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.Position = None
	self.Size = None
	self.hidePip = True
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      Pig.applySkin(self, desktop, parent)

      Implementation, line 24 ↗

      def applySkin(self, desktop, parent):
	attribs = list(self.skinAttributes or [])
	for attrib, value in list(attribs):
		if attrib == "hidePip":
			self.hidePip = str(value).strip().lower() in ("1", "true", "yes", "on")
			attribs.remove((attrib, value))
	self.skinAttributes = attribs

	ret = Renderer.applySkin(self, desktop, parent)
	if ret and self.instance:
		self.Position = self.instance.position()
		self.Size = self.instance.size()
	return ret
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (7) and inherited methods (26)

      Inherited methods

      Pixmap

      Displays an upstream pixmap, or chooses from the comma-separated pixmaps attribute using numeric source text. A source pixmap can take precedence.

      lib/python/Components/Renderer/Pixmap.py, line 7 ↗

      Class: Components.Renderer.Pixmap.Pixmap. Bases: Renderer.

      Native root: ePixmap (18 current central attribute names).

      Names explicitly handled in this class's applySkin: 1. pixmaps These can override central meanings.

      Direct upstream accesses declared here: pixmap, text. Attribute probes: pixmap, text. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = ePixmap — Components.Renderer.Pixmap.Pixmap

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Pixmap.__init__(self)

      Implementation, line 10 ↗

      def __init__(self):
	self.pixmaps = []
	Renderer.__init__(self)
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      Pixmap.applySkin(self, desktop, parent)

      Implementation, line 14 ↗

      def applySkin(self, desktop, parent):
	attributes = []
	for (attrib, value) in self.skinAttributes:
		if attrib == "pixmaps":
			pixmaps = value.split(",")
			for pixmap in pixmaps:
				self.pixmaps.append(LoadPixmap(resolveFilename(SCOPE_GUISKIN, pixmap.strip())))
		else:
			attributes.append((attrib, value))
	self.skinAttributes = attributes
	result = Renderer.applySkin(self, desktop, parent)
	if self.pixmaps:
		self.changed((self.CHANGED_DEFAULT,))
	return result
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (4) and inherited methods (28)

      Inherited methods

      PositionGauge

      Binds playback length, position and cutlist to ePositionGauge, including seek position updates.

      lib/python/Components/Renderer/PositionGauge.py, line 5 ↗

      Class: Components.Renderer.PositionGauge.PositionGauge. Bases: Renderer.

      Native root: ePositionGauge (18 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: cutlist, length, position. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (7) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = ePositionGauge — Components.Renderer.PositionGauge.PositionGauge

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      PositionGauge.__init__(self)

      Implementation, line 8 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.__position = 0
	self.__seek_position = 0
	self.__length = 0
	self.__seek_enable = 0
	self.__cutlist = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (14) and inherited methods (27)

      Inherited methods

      PrimeTime

      lib/python/Components/Renderer/PrimeTime.py, line 11 ↗

      Class: Components.Renderer.PrimeTime.PrimeTime. Bases: Renderer, VariableText.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: event, service. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.PrimeTime.PrimeTime

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Class-level constants and option maps
      EVENT_TOLERANCE = 1200
      PrimeTime.__init__(self)

      Implementation, line 15 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.epgCache = eEPGCache.getInstance()
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (2) and inherited methods (33)

      Inherited methods

      Progress

      Displays source value within source range, with clamping and an empty-value fallback. Uses eSlider attributes.

      lib/python/Components/Renderer/Progress.py, line 6 ↗

      Class: Components.Renderer.Progress.Progress. Bases: VariableValue, Renderer.

      Native root: eSlider (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: range, value. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (5) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eSlider — Components.Renderer.Progress.Progress

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Progress.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableValue.__init__(self)
	self.__range = (0, 100)
      VariableValue.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	self.__value = 0
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (5) and inherited methods (31)

      Inherited methods

      pstrRndr

      lib/python/Components/Renderer/pstrRndr.py, line 9 ↗

      Class: Components.Renderer.pstrRndr.pstrRndr. Bases: Renderer.

      Native root: ePixmap (18 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = ePixmap — Components.Renderer.pstrRndr.pstrRndr

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      pstrRndr.__init__(self)

      Implementation, line 12 ↗

      def __init__(self):
	Renderer.__init__(self)
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      pstrRndr.applySkin(self, desktop, parent)

      Implementation, line 15 ↗

      def applySkin(self, desktop, parent):
	attribs = []
	for (attrib, value,) in self.skinAttributes:
		attribs.append((attrib, value))
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (3) and inherited methods (29)

      Inherited methods

      QRCode

      Renders upstream text as a QR code using eQRCode attributes.

      lib/python/Components/Renderer/QRCode.py, line 7 ↗

      Class: Components.Renderer.QRCode.QRCode. Bases: VariableText, Renderer.

      Native root: eQRCode (19 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: text. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eQRCode — Components.Renderer.QRCode.QRCode

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      QRCode.__init__(self)

      Implementation, line 10 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (4) and inherited methods (32)

      Inherited methods

      RatingIconLabel

      lib/python/Components/Renderer/RatingIconLabel.py, line 8 ↗

      Class: Components.Renderer.RatingIconLabel.RatingIconLabel. Bases: Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 3. colors, extendDirection, sidesMargin These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: text. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.RatingIconLabel.RatingIconLabel

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      RatingIconLabel.__init__(self)

      Implementation, line 11 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.colors = {}
	self.extendDirection = "right"
	self.sidesMargin = 20
	self.initialWidth = 0
	self.initialXPos = 0
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      RatingIconLabel.applySkin(self, desktop, parent)

      Implementation, line 22 ↗

      def applySkin(self, desktop, parent):
	attribs = []
	for (attrib, value) in self.skinAttributes:
		match attrib:
			case "colors":
				self.colors = {int(k): parseColor(v) for k, v in (item.split(":") for item in value.split(","))}
			case "extendDirection":
				self.extendDirection = value
			case "sidesMargin":
				self.sidesMargin = int(value)
			case _:
				attribs.append((attrib, value))
	self.skinAttributes = attribs
	result = Renderer.applySkin(self, desktop, parent)
	self.initialWidth = self.instance.size().width()
	self.initialXPos = self.instance.position().x()
	self.changed((self.CHANGED_DEFAULT,))
	return result
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (5) and inherited methods (28)

      Inherited methods

      Rectangle

      Draws a decorative rectangle within a renderer chain, including conditional visibility.

      lib/python/Components/Renderer/Rectangle.py, line 5 ↗

      Class: Components.Renderer.Rectangle.Rectangle. Bases: Renderer.

      Native root: eRectangle (15 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eRectangle — Components.Renderer.Rectangle.Rectangle

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Rectangle.__init__(self)

      Implementation, line 8 ↗

      def __init__(self):
	Renderer.__init__(self)
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (2) and inherited methods (30)

      Inherited methods

      Renderer

      Base class connecting GUIComponent lifecycle to the Element source graph. Use a concrete renderer in XML.

      lib/python/Components/Renderer/Renderer.py, line 5 ↗

      Class: Components.Renderer.Renderer.Renderer. Bases: GUIComponent, Element.

      No single GUI_WIDGET declaration. Inspect the construction contract below; this can be a base/helper, composite or non-visual class.

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (3) and inherited methods (29)

      Inherited methods

      RollerCharLCD

      lib/python/Components/Renderer/RollerCharLCD.py, line 8 ↗

      Class: Components.Renderer.RollerCharLCD.RollerCharLCD. Bases: VariableText, Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.RollerCharLCD.RollerCharLCD

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      RollerCharLCD.__init__(self)

      Implementation, line 11 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.moveTimerText = None
	self.delayTimer = None
	self.stringlength = 16 if BoxInfo.getItem("machinebuild") in ("vuduo", "sf4008", "beyonwizu4") else 12
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (5) and inherited methods (32)

      Inherited methods

      RollerCharLCDLong

      lib/python/Components/Renderer/RollerCharLCDLong.py, line 7 ↗

      Class: Components.Renderer.RollerCharLCDLong.RollerCharLCDLong. Bases: VariableText, Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 2. font, size These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.RollerCharLCDLong.RollerCharLCDLong

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      RollerCharLCDLong.__init__(self)

      Implementation, line 10 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.stringlength = 36
	self.moveTimerText = None
	self.delayTimer = None
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      RollerCharLCDLong.applySkin(self, desktop, parent)

      Implementation, line 17 ↗

      def applySkin(self, desktop, parent):
	attribs = []
	width = None
	fontsize = None
	for attrib, value in self.skinAttributes:
		if attrib == "size":
			width = float(value.split(",")[0])
		elif attrib == "font":
			fontsize = float(value.split(";")[1])
		attribs.append((attrib, value))

	self.skinAttributes = attribs
	if width and fontsize:
		self.stringlength = int(width / fontsize * 1.9)
	return Renderer.applySkin(self, desktop, parent)
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (6) and inherited methods (31)

      Inherited methods

      RunningText

      Composite renderer: an eWidget viewport contains an eLabel. applySkin consumes font, text appearance and movement options before forwarding remaining attributes. Its effective options exceed the eWidget table.

      lib/python/Components/Renderer/RunningText.py, line 56 ↗

      Class: Components.Renderer.RunningText.RunningText. Bases: Renderer.

      Native root: eWidget (15 current central attribute names).

      Names explicitly handled in this class's applySkin: 12. backgroundColor, borderColor, borderWidth, font, foregroundColor, halign, noWrap, options, shadowColor, shadowOffset, transparent, valign These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eWidget — Components.Renderer.RunningText.RunningText

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      RunningText.__init__(self)

      Implementation, line 59 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.type = NONE
	self.txfont = gFont("Regular", 14)
	self.soffset = (0, 0)
	self.txtflags = 0
	self.txtext = ""
	self.scroll_label = self.mTimer = self.mStartPoint = None
	self.X = self.Y = self.W = self.H = self.mStartDelay = 0
	self.mAlways = 1		# always move text
	self.mStep = 1			# moving step: 1 pixel per 1 time
	self.mStepTimeout = 50		# step timeout: 1 step per 50 milliseconds ( speed: 20 pixel per second )
	self.direction = LEFT
	self.mLoopTimeout = self.mOneShot = 0
	self.mRepeat = 0
	self.mPageDelay = self.mPageLength = 0
	self.lineHeight = 0		# for text height auto correction on dmm-enigma2
	self.mShown = 0
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      RunningText.applySkin(self, desktop, screen)

      Implementation, line 95 ↗

      def applySkin(self, desktop, screen):
	def retValue(val, limit, default, Min=False):
		try:
			if Min:
				x = min(limit, int(val))
			else:
				x = max(limit, int(val))
		except Exception:
			x = default
		return x

	def setWrapFlag(attrib, value):
		if (attrib.lower() == "wrap" and value == "0") or (attrib.lower() == "nowrap" and value != "0"):
			self.txtflags &= ~RT_WRAP
		else:
			self.txtflags |= RT_WRAP

	self.halign = valign = eLabel.alignLeft
	if self.skinAttributes:
		attribs = []
		for (attrib, value) in self.skinAttributes:
			if attrib == "font":
				self.txfont = parseFont(value, screen.scale)
			elif attrib == "foregroundColor":
				self.scroll_label.setForegroundColor(parseColor(value))
			elif attrib in ("shadowColor", "borderColor"):  # fake for openpli-enigma2
				self.scroll_label.setShadowColor(parseColor(value))
			elif attrib == "shadowOffset":
				x, y = value.split(",")
				self.soffset = (int(x), int(y))
				self.scroll_label.setShadowOffset(ePoint(self.soffset))
			elif attrib == "borderWidth":			# fake for openpli-enigma2
				self.soffset = (-int(value), -int(value))
			elif attrib == "valign" and value in ("top", "center", "bottom"):
				valign = {"top": eLabel.alignTop, "center": eLabel.alignCenter, "bottom": eLabel.alignBottom}[value]
				self.txtflags |= {"top": RT_VALIGN_TOP, "center": RT_VALIGN_CENTER, "bottom": RT_VALIGN_BOTTOM}[value]
			elif attrib == "halign" and value in ("left", "center", "right", "block"):
				self.halign = {"left": eLabel.alignLeft, "center": eLabel.alignCenter, "right": eLabel.alignRight, "block": eLabel.alignBlock}[value]
				self.txtflags |= {"left": RT_HALIGN_LEFT, "center": RT_HALIGN_CENTER, "right": RT_HALIGN_RIGHT, "block": RT_HALIGN_BLOCK}[value]
			elif attrib == "noWrap":
				setWrapFlag(attrib, value)
			elif attrib == "options":
				options = value.split(",")
				for o in options:
					if "=" in o:
						opt, val = (x.strip() for x in o.split("=", 1))
					else:
						opt, val = o.strip(), ""

					if opt == "":
						continue
					elif opt in ("wrap", "nowrap"):
						setWrapFlag(opt, val)
					elif opt == "movetype" and val in ("none", "running", "swimming"):
						self.type = {"none": NONE, "running": RUNNING, "swimming": SWIMMING}[val]
					elif opt == "direction" and val in ("left", "right", "top", "bottom"):
						self.direction = {"left": LEFT, "right": RIGHT, "top": TOP, "bottom": BOTTOM}[val]
					elif opt == "step" and val:
						self.mStep = retValue(val, 1, self.mStep)
					elif opt == "steptime" and val:
						self.mStepTimeout = retValue(val, 25, self.mStepTimeout)
					elif opt == "startdelay" and val:
						self.mStartDelay = retValue(val, 0, self.mStartDelay)
					elif opt == "pause" and val:
						self.mLoopTimeout = retValue(val, 0, self.mLoopTimeout)
					elif opt == "oneshot" and val:
						self.mOneShot = retValue(val, 0, self.mOneShot)
					elif opt == "repeat" and val:
						self.mRepeat = retValue(val, 0, self.mRepeat)
					elif opt == "always" and val:
						self.mAlways = retValue(val, 0, self.mAlways)
					elif opt == "startpoint" and val:
						self.mStartPoint = int(val)
					elif opt == "pagedelay" and val:
						self.mPageDelay = retValue(val, 0, self.mPageDelay)
					elif opt == "pagelength" and val:
						self.mPageLength = retValue(val, 0, self.mPageLength)
			else:
				attribs.append((attrib, value))
				if attrib == "backgroundColor":
					self.scroll_label.setBackgroundColor(parseColor(value))
				elif attrib == "transparent":
					self.scroll_label.setTransparent(int(value))

		self.skinAttributes = attribs
	ret = Renderer.applySkin(self, desktop, screen)

	if self.mOneShot:
		self.mOneShot = max(self.mStepTimeout, self.mOneShot)
	if self.mLoopTimeout:
		self.mLoopTimeout = max(self.mStepTimeout, self.mLoopTimeout)
	if self.mPageDelay:
		self.mPageDelay = max(self.mStepTimeout, self.mPageDelay)

	self.scroll_label.setFont(self.txfont)
	if not (self.txtflags & RT_WRAP):
		self.scroll_label.setWrap(0)
	self.scroll_label.setVAlign(valign)
	self.scroll_label.setHAlign(self.halign)
	self.scroll_label.move(ePoint(0, 0))
	self.scroll_label.resize(eSize(self.W, self.H))
	# test for auto correction text height:
	if self.direction in (TOP, BOTTOM):
		from enigma import fontRenderClass
		flh = int(fontRenderClass.getInstance().getLineHeight(self.txfont) or self.txfont.pointSize / 6 + self.txfont.pointSize)
		self.scroll_label.setText("WQq")
		if flh > self.scroll_label.calculateSize().height():
			self.lineHeight = flh
		self.scroll_label.setText("")
	return ret
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (10) and inherited methods (25)

      Inherited methods

      SingleEpgList

      lib/python/Components/Renderer/SingleEpgList.py, line 7 ↗

      Class: Components.Renderer.SingleEpgList.SingleEpgList. Bases: Renderer, VariableText.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 1. maxEvents These can override central meanings.

      Direct upstream accesses declared here: event, service. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.SingleEpgList.SingleEpgList

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      SingleEpgList.__init__(self)

      Implementation, line 10 ↗

      def __init__(self):
	self.maxEvents = 4
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.epgcache = eEPGCache.getInstance()
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      SingleEpgList.applySkin(self, desktop, parent)

      Implementation, line 16 ↗

      def applySkin(self, desktop, parent):
	attribs = self.skinAttributes[:]
	for (attrib, value) in self.skinAttributes:
		if attrib == "maxEvents":
			self.maxEvents = int(value)
			attribs.remove((attrib, value))
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (3) and inherited methods (32)

      Inherited methods

      VideoSize

      lib/python/Components/Renderer/VideoSize.py, line 10 ↗

      Class: Components.Renderer.VideoSize.VideoSize. Bases: Renderer, VariableText.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: service. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.VideoSize.VideoSize

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      VideoSize.__init__(self)

      Implementation, line 13 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (2) and inherited methods (33)

      Inherited methods

      VolumeText

      lib/python/Components/Renderer/VolumeText.py, line 30 ↗

      Class: Components.Renderer.VolumeText.VolumeText. Bases: Renderer, VariableText.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.VolumeText.VolumeText

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      VolumeText.__init__(self)

      Implementation, line 33 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.vol_timer = eTimer()
	self.vol_timer.callback.append(self.pollme)
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (5) and inherited methods (31)

      Inherited methods

      VReference

      lib/python/Components/Renderer/VReference.py, line 23 ↗

      Class: Components.Renderer.VReference.VReference. Bases: VariableText, Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: service. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.VReference.VReference

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      VReference.__init__(self)

      Implementation, line 27 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (3) and inherited methods (32)

      Inherited methods

      VRunningText

      Canvas-based moving text renderer with its own applySkin options. Do not assume it accepts exactly the same options as RunningText.

      lib/python/Components/Renderer/VRunningText.py, line 34 ↗

      Class: Components.Renderer.VRunningText.VRunningText. Bases: Renderer.

      Native root: eCanvas (18 current central attribute names).

      Names explicitly handled in this class's applySkin: 9. backgroundColor, font, foregroundColor, halign, noWrap, options, shadowColor, shadowOffset, valign These can override central meanings.

      Direct upstream accesses declared here: text. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (3) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eCanvas — Components.Renderer.VRunningText.VRunningText

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      VRunningText.__init__(self)

      Implementation, line 35 ↗

      def __init__(self):
	Renderer.__init__(self)
	self.type = NONE
	self.txfont = gFont("Regular", 14)
	self.fcolor = gRGB(RGB(255, 255, 255))
	self.bcolor = gRGB(RGB(0, 0, 0))
	self.scolor = None
	self.soffset = (0, 0)
	self.txtflags = 0  # RT_WRAP
	self.txtext = ""
	self.test_label = self.mTimer = self.mStartPoint = None
	self.X = self.Y = self.W = self.H = self.mStartDelay = 0
	self.mAlways = 1  # always move text
	self.mStep = 1		# moving step: 1 pixel per 1 time
	self.mStepTimeout = 5000  # step timeout: 1 step per 50 milliseconds ( speed: 20 pixel per second )
	self.direction = LEFT
	self.mLoopTimeout = self.mOneShot = 0
	self.mRepeat = 0
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VRunningText.applySkin(self, desktop, screen)

      Implementation, line 73 ↗

      def applySkin(self, desktop, screen):
	def retValue(val, limit, default, Min=False):
		try:
			if Min:
				x = min(limit, int(val))
			else:
				x = max(limit, int(val))
		except Exception:
			x = default
		return x

	self.halign = valign = eLabel.alignLeft
	if self.skinAttributes:
		attribs = []
		for (attrib, value) in self.skinAttributes:
			if attrib == "font":
				self.txfont = parseFont(value, screen.scale)
			elif attrib == "foregroundColor":
				self.fcolor = parseColor(value)
			elif attrib == "backgroundColor":
				self.bcolor = parseColor(value)
			elif attrib == "shadowColor":
				self.scolor = parseColor(value)
			elif attrib == "shadowOffset":
				x, y = value.split(",")
				self.soffset = (int(x), int(y))
			elif attrib == "valign" and value in ("top", "center", "bottom"):
				valign = {"top": eLabel.alignTop, "center": eLabel.alignCenter, "bottom": eLabel.alignBottom}[value]
				self.txtflags |= {"top": RT_VALIGN_TOP, "center": RT_VALIGN_CENTER, "bottom": RT_VALIGN_BOTTOM}[value]
			elif attrib == "halign" and value in ("left", "center", "right", "block"):
				self.halign = {"left": eLabel.alignLeft, "center": eLabel.alignCenter, "right": eLabel.alignRight, "block": eLabel.alignBlock}[value]
				self.txtflags |= {"left": RT_HALIGN_LEFT, "center": RT_HALIGN_CENTER, "right": RT_HALIGN_RIGHT, "block": RT_HALIGN_BLOCK}[value]
			elif attrib == "noWrap":
				if value == "0":
					self.txtflags |= RT_WRAP
				else:
					self.txtflags &= ~RT_WRAP
			elif attrib == "options":
				options = value.split(",")
				for opt in options:
					val = ""
					pos = opt.find("=")
					if pos != -1:
						val = opt[pos + 1:].strip()
						opt = opt[:pos].strip()
					if opt == "wrap":
						if val == "0":
							self.txtflags &= ~RT_WRAP
						else:
							self.txtflags |= RT_WRAP
					elif opt == "nowrap":
						if val == "0":
							self.txtflags |= RT_WRAP
						else:
							self.txtflags &= ~RT_WRAP
					elif opt == "movetype" and val in ("none", "running", "swimming"):
						self.type = {"none": NONE, "running": RUNNING, "swimming": SWIMMING}[val]
					elif opt == "direction" and val in ("left", "right", "top", "bottom"):
						self.direction = {"left": LEFT, "right": RIGHT, "top": TOP, "bottom": BOTTOM}[val]
					elif opt == "step" and val:
						#retValue(val, limit, default, Min=False)
						self.mStep = retValue(val, 1, self.mStep)
					elif opt == "steptime" and val:
						self.mStepTimeout = retValue(val, 25, self.mStepTimeout)
					elif opt == "startdelay" and val:
						self.mStartDelay = retValue(val, 0, self.mStartDelay)
					elif opt == "pause" and val:
						self.mLoopTimeout = retValue(val, 0, self.mLoopTimeout)
					elif opt == "oneshot" and val:
						self.mOneShot = retValue(val, 0, self.mOneShot)
					elif opt == "repeat" and val:
						self.mRepeat = retValue(val, 0, self.mRepeat)
					elif opt == "always" and val:
						self.mAlways = retValue(val, 0, self.mAlways)
					elif opt == "startpoint" and val:
						self.mStartPoint = int(val)
			else:
				attribs.append((attrib, value))
		self.skinAttributes = attribs
	ret = Renderer.applySkin(self, desktop, screen)
	#if self.type == RUNNING and self.direction in (LEFT,RIGHT):
	#	self.halign = eLabel.alignLeft
	#	self.txtflags = RT_HALIGN_LEFT | (self.txtflags & RT_WRAP)
	if self.mOneShot:
		self.mOneShot = max(self.mStepTimeout, self.mOneShot)
	if self.mLoopTimeout:
		self.mLoopTimeout = max(self.mStepTimeout, self.mLoopTimeout)

	self.test_label.setFont(self.txfont)
	#self.test_label.setForegroundColor(self.fcolor)
	#self.test_label.setBackgroundColor(self.bcolor)
	#if not self.scolor is None:
	#	self.test_label.setShadowColor(self.scolor)
	#	self.test_label.setShadowOffset(ePoint(self.soffset[0], self.soffset[1]))
	if not (self.txtflags & RT_WRAP):
		self.test_label.setWrap(0)
	self.test_label.setVAlign(valign)
	self.test_label.setHAlign(self.halign)
	self.test_label.move(ePoint(self.W, self.H))
	self.test_label.resize(eSize(self.W, self.H))
	#self.test_label.hide()
	#self.changed((self.CHANGED_DEFAULT,))
	return ret
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (10) and inherited methods (25)

      Inherited methods

      VtiEmuInfo

      lib/python/Components/Renderer/VtiEmuInfo.py, line 8 ↗

      Class: Components.Renderer.VtiEmuInfo.VtiEmuInfo. Bases: VariableText, Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.VtiEmuInfo.VtiEmuInfo

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      VtiEmuInfo.__init__(self)

      Implementation, line 12 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (4) and inherited methods (32)

      Inherited methods

      VtiImageVersion

      lib/python/Components/Renderer/VtiImageVersion.py, line 7 ↗

      Class: Components.Renderer.VtiImageVersion.VtiImageVersion. Bases: VariableText, Renderer.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.VtiImageVersion.VtiImageVersion

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      VtiImageVersion.__init__(self)

      Implementation, line 11 ↗

      def __init__(self):
    Renderer.__init__(self)
    VariableText.__init__(self)
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (4) and inherited methods (32)

      Inherited methods

      VVolumeText

      lib/python/Components/Renderer/VVolumeText.py, line 5 ↗

      Class: Components.Renderer.VVolumeText.VVolumeText. Bases: VolumeText.

      Native root: eLabel (30 current central attribute names).

      Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

      Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

      Effective Python properties (4) and value/range constants

      These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

      GUI_WIDGET = eLabel — Components.Renderer.VolumeText.VolumeText

      Arguments, defaults and skin parsing — exact implementation

      Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

      VolumeText.__init__(self)

      Implementation, line 33 ↗

      def __init__(self):
	Renderer.__init__(self)
	VariableText.__init__(self)
	self.vol_timer = eTimer()
	self.vol_timer.callback.append(self.pollme)
      Renderer.__init__(self)

      Implementation, line 6 ↗

      def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
      GUIComponent.__init__(self)

      Implementation, line 9 ↗

      def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
      Element.__init__(self)

      Implementation, line 18 ↗

      def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
      VariableText.__init__(self)

      Implementation, line 4 ↗

      def __init__(self):
	object.__init__(self)
	self.message = ""
	self.instance = None
	self.onChanged = []
      GUIComponent.applySkin(self, desktop, parent)

      Implementation, line 32 ↗

      def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
      GUIComponent.createWidget(self, parent)

      Implementation, line 119 ↗

      def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
      GUIComponent.GUIcreate(self, parent)

      Implementation, line 111 ↗

      def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
      Declared methods (0) and inherited methods (35)

        Inherited methods

        VWatches

        lib/python/Components/Renderer/VWatches.py, line 24 ↗

        Class: Components.Renderer.VWatches.VWatches. Bases: Renderer.

        Native root: eCanvas (18 current central attribute names).

        Names explicitly handled in this class's applySkin: 2. backgroundColor, foregroundColor These can override central meanings.

        Direct upstream accesses declared here: value. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

        Effective Python properties (3) and value/range constants

        These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

        GUI_WIDGET = eCanvas — Components.Renderer.VWatches.VWatches

        Arguments, defaults and skin parsing — exact implementation

        Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

        VWatches.__init__(self)

        Implementation, line 27 ↗

        def __init__(self):
	Renderer.__init__(self)
	self.fColor = gRGB(255, 255, 255, 0)
	self.bColor = gRGB(0, 0, 0, 255)
	self.numval = -1
        Renderer.__init__(self)

        Implementation, line 6 ↗

        def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
        GUIComponent.__init__(self)

        Implementation, line 9 ↗

        def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
        Element.__init__(self)

        Implementation, line 18 ↗

        def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
        VWatches.applySkin(self, desktop, parent)

        Implementation, line 33 ↗

        def applySkin(self, desktop, parent):
	attribs = []
	for (attrib, what) in self.skinAttributes:
		if (attrib == "foregroundColor"):
			self.fColor = parseColor(what)
		elif (attrib == "backgroundColor"):
			self.bColor = parseColor(what)
		else:
			attribs.append((attrib, what))
	self.skinAttributes = attribs
	return Renderer.applySkin(self, desktop, parent)
        GUIComponent.applySkin(self, desktop, parent)

        Implementation, line 32 ↗

        def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
        GUIComponent.createWidget(self, parent)

        Implementation, line 119 ↗

        def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
        GUIComponent.GUIcreate(self, parent)

        Implementation, line 111 ↗

        def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
        Declared methods (7) and inherited methods (28)

        Inherited methods

        VWeatherUpdater

        lib/python/Components/Renderer/VWeatherUpdater.py, line 6 ↗

        Class: Components.Renderer.VWeatherUpdater.VWeatherUpdater. Bases: Renderer.

        Native root: eLabel (30 current central attribute names).

        Names explicitly handled in this class's applySkin: 0. No named comparisons or local-handler dispatch found here; check inherited handling below. These can override central meanings.

        Direct upstream accesses declared here: none. Attribute probes: none. These are source-code accesses, not a claim that every property is required in every mode.

        Effective Python properties (3) and value/range constants

        These are Python descriptors, including inherited ones. Their usefulness as renderer outputs depends on the selected mode. Internal properties such as suspended manage lifecycle.

        GUI_WIDGET = eLabel — Components.Renderer.VWeatherUpdater.VWeatherUpdater

        Arguments, defaults and skin parsing — exact implementation

        Read the selected class first, then any base constructor or applySkin it calls. This preserves separators, defaults, validation and conditional behaviour. It is source code for reference, not a desktop Python example.

        VWeatherUpdater.__init__(self)

        Implementation, line 9 ↗

        def __init__(self):
	Renderer.__init__(self)
        Renderer.__init__(self)

        Implementation, line 6 ↗

        def __init__(self):
	Element.__init__(self)
	GUIComponent.__init__(self)
        GUIComponent.__init__(self)

        Implementation, line 9 ↗

        def __init__(self):
	self.onVisibilityChange = []
	self.instance = None
	self.visiblity = False
	self.visible = True
	self.skinAttributes = None
	self.deprecationInfo = None
        Element.__init__(self)

        Implementation, line 18 ↗

        def __init__(self):
	self.downstream_elements = CList()
	self.master = None
	self.sources = []
	self.source = None
	self.__suspended = True
	self.cache = None
	self.onChanged = []
        GUIComponent.applySkin(self, desktop, parent)

        Implementation, line 32 ↗

        def applySkin(self, desktop, parent):  # This only works with normal widgets, if you don't have a self.instance override this method.
	if not self.visible:
		self.instance.hide()
	if self.skinAttributes is None:
		result = False
	else:
		# // Workaround for values from attributes the not be set.
		#
		# The order of some attributes is crucial if they are applied. Also, an attribute may be responsible that another does not take effect and occurs at different skins.
		# It was noticed at "scrollbarSliderBorderWidth" and "scrollbarSliderForegroundColor".
		#
		# if config.skin.primary_skin.value.split("/")[0] not in ("DMConcinnity-HD"):
		# 	self.skinAttributes.sort()
		#
		# NOTE: The code above is invalid. It always returns False! It is being removed until it's need is confirmed.
		# To be correct the code could/should be one of, depending on the original intention:
		# 	if config.skin.primary_skin.value.split("/")[0] != "DMConcinnity-HD":
		# 	if config.skin.primary_skin.value.split("/")[0] == "DMConcinnity-HD":
		#
		# //
		applyAllAttributes(self.instance, desktop, self.skinAttributes, parent.scale)
		result = True
	return result
        GUIComponent.createWidget(self, parent)

        Implementation, line 119 ↗

        def createWidget(self, parent):  # Default for argument less widget constructor.
	return self.GUI_WIDGET(parent)
        GUIComponent.GUIcreate(self, parent)

        Implementation, line 111 ↗

        def GUIcreate(self, parent):  # Default implementation for only one widget per component.  Feel free to override!
	self.instance = self.createWidget(parent)
	self.postWidgetCreate(self.instance)
        Declared methods (1) and inherited methods (31)

        Inherited methods

        Inheritance and overrides

        Section titled “Inheritance and overrides”

        Use the native table as the starting point, then read the renderer’s handling. For example, RunningText’s native root is eWidget, but its font, halign, valign, shadow and movement options configure an internal label. Copying the eWidget count alone would omit those options. Conversely, copying all eLabel attributes into RunningText assumes forwarding that its implementation may not provide.

        The parser code also settles defaults and precedence. A supplied Pixmap.source.pixmap can replace an image chosen from pixmaps. Label.changed() replaces the XML text. Attributes are case-sensitive unless a particular parser explicitly normalises them.