Python skin.parseColor函数代码示例

	def __init__(self):
		Renderer.__init__(self)
		self.backgroundColor = parseColor("#ff000000")
		self.nocColor = parseColor("#008f8f8f")
		self.emmColor = parseColor("#00bab329")
		self.ecmColor = parseColor("#00009a00")
		self.font = gFont("Regular", 20)

	def readTimer(self, showTitle=True):
		current_time = int(time.time())
		deltimer = 0
		timerList = []

		timers = self.database.getAllTimer(current_time if self.filter else None)
		for timer in timers:
			(serie, staffel, episode, title, start_time, stbRef, webChannel, eit, activeTimer) = timer
			if int(start_time) < int(current_time):
				deltimer += 1
				timerList.append((serie, staffel, episode, title, start_time, webChannel, "1", 0, bool(activeTimer)))
			else:
				timerList.append((serie, staffel, episode, title, start_time, webChannel, "0", eit, bool(activeTimer)))

		if showTitle:
			self['title'].instance.setForegroundColor(parseColor("foreground"))
			if self.filter:
				self['title'].setText("Timer-Liste: %s ausstehende Timer" % len(timerList))
			else:
				self['title'].setText("Timer-Liste: %s abgeschlossene und %s ausstehende Timer" % (deltimer, len(timerList ) -deltimer))

		if config.plugins.serienRec.recordListView.value == 0:
			timerList.sort(key=lambda t : t[4])
		elif config.plugins.serienRec.recordListView.value == 1:
			timerList.sort(key=lambda t : t[4])
			timerList.reverse()

		self.chooseMenuList.setList(map(self.buildList, timerList))
		if len(timerList) == 0:
			if showTitle:
				self['title'].instance.setForegroundColor(parseColor("foreground"))
				self['title'].setText("Serien Timer - 0 Serien in der Aufnahmeliste.")

		self.getCover()

 def go(self):
     if len(self.subtitle) == 0:
         printDEBUG("Subtitles not loaded, timer disabled.")
     else:
         printDEBUG("Enable loaded %d subtitles" % len(self.subtitle))
         self.enablesubtitle = True
         self.timer = eTimer()
         self.timer.callback.append(self.timerEvent)
         self.timer.start(200, False)
     printDEBUG("Playing: " + str(self.rootID) + ":0:0:0:0:0:0:0:0:0:" + self.openmovie)
     root = eServiceReference(self.rootID, 0, self.openmovie)
     root.setName (self.movieTitle)
     self.session.nav.playService(root)
     myConfig.PlayerOn.value = True
     self.stateplay = "Play"
     self["afpSubtitles"].instance.move(ePoint(0,self.fontpos))
     self["afpSubtitles"].instance.setForegroundColor(parseColor(self.fontcolor_list[self.fontcolor_nr]))
     self["afpSubtitles"].instance.setBackgroundColor(parseColor(self.backgroundcolor_list[self.fontbackground_nr]))
     self["afpSubtitles"].instance.setFont(gFont(self.fonttype_list[self.fonttype_nr], self.fontsize))
     self.SubtitleLineHeight = int(fontRenderClass.getInstance().getLineHeight(self["afpSubtitles"].instance.getFont()))
     if self.SubtitleLineHeight > self.fontsize:
         printDEBUG("SubtitleLineHeight calculated: %d" % self.SubtitleLineHeight)
     else:
         self.SubtitleLineHeight = int(self.fontsize * 1.1)
         printDEBUG("SubtitleLineHeight assumed: %d" % self.SubtitleLineHeight)
     self.ToggleInfobar()

 def setPreviewFont(self, myIndex):
     if not 'font' in self.root[self.currentScreenID][myIndex].attrib:
         self["PreviewFont"].setText('')
         return
     #### Now we know we have font, so we can preview it :)
     myfont = self.root[self.currentScreenID][myIndex].attrib['font']
     #print myfont
     try:
         self["PreviewFont"].instance.setFont(gFont(myfont.split(';')[0], int(myfont.split(';')[1])))
     except:
         printDEBUG("Missing font '%s' definition in skin.xml" % self.root[self.currentScreenID][myIndex].attrib['font'])
     if 'text' in self.root[self.currentScreenID][myIndex].attrib:
         self["PreviewFont"].setText('%s' % self.root[self.currentScreenID][myIndex].attrib['text'])
     else:
         self["PreviewFont"].setText(_('Sample Text'))
     if 'foregroundColor' in self.root[self.currentScreenID][myIndex].attrib:
         try:
             self["PreviewFont"].instance.setForegroundColor(parseColor(self.root[self.currentScreenID][myIndex].attrib['foregroundColor']))            
         except:
             printDEBUG("Missing color '%s' definition in skin.xml" % self.root[self.currentScreenID][myIndex].attrib['foregroundColor'])
     else:
         self["PreviewFont"].instance.setForegroundColor(parseColor("#00ffffff"))            
     if 'backgroundColor' in self.root[self.currentScreenID][myIndex].attrib:
         try:
             self["PreviewFont"].instance.setBackgroundColor(parseColor(self.root[self.currentScreenID][myIndex].attrib['backgroundColor']))            
         except:
             printDEBUG("Missing color '%s' definition in skin.xml" % self.root[self.currentScreenID][myIndex].attrib['backgroundColor'])

	def applySkin(self, desktop, parent):

		attribs = [ ]
		from enigma import eSize

		def parseSize(str):
			x, y = str.split(',')
			return eSize(int(x), int(y))

		for (attrib, value) in self.skinAttributes:
			if attrib == "size":
				self.instance.setSize(parseSize(value))
				attribs.append((attrib,value))
			elif attrib == "nocColor":
			        self.nocColor = parseColor(value)
			elif attrib == "emmColor":
				self.emmColor = parseColor(value)
			elif attrib == "ecmColor":
				self.ecmColor = parseColor(value)
			elif attrib == "font":
				self.font = parseFont(value, ((1,1),(1,1)))
			elif attrib == "backgroundColor":
				self.backgroundColor = parseColor(value)
				self.instance.clear(self.backgroundColor)
				attribs.append((attrib,value))
			else:
				attribs.append((attrib,value))
		self.skinAttributes = attribs
		return Renderer.applySkin(self, desktop, parent)

	def __init__(self):
		Renderer.__init__(self)
		self.backgroundColor = parseColor("transparent")
		self.nocColor = parseColor("#00aaaaaa")
		self.emmColor = parseColor("#00aaaaaa")
		self.ecmColor = parseColor("#0056c856")
		self.font = gFont("Pro_Display", 17)

	def applySkin(self, desktop, screen):
		if self.skinAttributes is not None:
			foregroundColor = None
			backgroundColor = None
			attribs = [ ]
			for (attrib, value) in self.skinAttributes:
				if attrib == "foregroundColors":
					colors = value.split(',')
					for color in colors:
						self.foreColors.append(parseColor(color))
					if not foregroundColor:
						foregroundColor = colors[0]
				elif attrib == "backgroundColors":
					colors = value.split(',')
					for color in colors:
						self.backColors.append(parseColor(color))
					if not backgroundColor:
						backgroundColor = colors[0]
				elif attrib == "backgroundColor":
					backgroundColor = value
				elif attrib == "foregroundColor":
					foregroundColor = value
				else:
					attribs.append((attrib,value))
			if foregroundColor:
				attribs.append(("foregroundColor",foregroundColor))
			if backgroundColor:
				attribs.append(("backgroundColor",backgroundColor))
			self.skinAttributes = attribs
		return GUIComponent.applySkin(self, desktop, screen)

	def applySkin(self, desktop, parent):
		attribs = []
		for (attrib, value) in self.skinAttributes:
			if attrib == "NumberOfItems":
				self.numberOfItems = int(value)
				attribs.append((attrib, value))
			if attrib == "noLabel":
				self.hideLabel = int(value)
				attribs.append((attrib, value))
			if attrib == "numOfSpaces":
				self.numOfSpaces = int(value)
				attribs.append((attrib, value))
			if attrib == "timeColor":
				self.timecolor = self.hex2strColor(parseColor(value).argb())
				attribs.append((attrib, value))
			if attrib == "labelColor":
				self.labelcolor = self.hex2strColor(parseColor(value).argb())
				attribs.append((attrib, value))
			if attrib == "foregroundColor":
				self.foregroundColor = self.hex2strColor(parseColor(value).argb())
				attribs.append((attrib, value))
		for (attrib, value) in attribs:
			self.skinAttributes.remove((attrib, value))
		self.timecolor = self.formatColorString(self.timecolor)
		self.labelcolor  = self.formatColorString(self.labelcolor)
		self.foregroundColor  = self.formatColorString(self.foregroundColor)
		return Renderer.applySkin(self, desktop, parent)

	def keyOK(self):
		if self.modus == "list":
			if self.loading:
				return

			check = self['menu_list'].getCurrent()
			if check is None:
				return

			(serien_name, serien_id) = self.getSeriesNameID()
			if config.plugins.serienRec.activateNewOnThisSTBOnly.value:
				boxID = None
			else:
				boxID = config.plugins.serienRec.BoxID.value

			if self.database.addMarker(str(serien_id), serien_name, '', boxID, 0):
				SRLogger.writeLog("\nSerien Marker für ' %s ' wurde angelegt" % serien_name, True)
				self['title'].setText("Serie '- %s -' zum Serien Marker hinzugefügt." % serien_name)
				self['title'].instance.setForegroundColor(parseColor("green"))
				if config.plugins.serienRec.tvplaner_full_check.value:
					config.plugins.serienRec.tvplaner_last_full_check.value = int(0)
					config.plugins.serienRec.tvplaner_last_full_check.save()
					SerienRecorder.configfile.save()
				if config.plugins.serienRec.openMarkerScreen.value:
					from SerienRecorderMarkerScreen import serienRecMarker
					self.session.open(serienRecMarker, serien_name)
			else:
				self['title'].setText("Serie '- %s -' existiert bereits im Serien Marker." % serien_name)
				self['title'].instance.setForegroundColor(parseColor("red"))

 def __init__(self):
     Renderer.__init__(self)
     self.foregroundColor = parseColor('#ffffff')
     self.backgroundColor = parseColor('#171717')
     self.emmColor = parseColor('#f23d21')
     self.ecmColor = parseColor('#389416')
     self.font = gFont('Regular', 20)

 def __init__(self):
     Renderer.__init__(self)
     self.backgroundColor = parseColor('#ff000000')
     self.emmColor = parseColor('#00aaaaaa')
     self.clGrey = parseColor('#00aaaaaa')
     self.ecmColor = parseColor('#0056c856')
     self.font = gFont('Regular', 20)

	def applySkin(self, desktop, parent):
		attribs = [ ]
		if self.skinAttributes is not None:
			attribs = [ ]
			for (attrib, value) in self.skinAttributes:
				if attrib == "foregroundColorMarked":
					self.l.setColor(eListboxServiceContent.markedForeground, parseColor(value))
				elif attrib == "foregroundColorMarkedSelected":
					self.l.setColor(eListboxServiceContent.markedForegroundSelected, parseColor(value))
				elif attrib == "backgroundColorMarked":
					self.l.setColor(eListboxServiceContent.markedBackground, parseColor(value))
				elif attrib == "backgroundColorMarkedSelected":
					self.l.setColor(eListboxServiceContent.markedBackgroundSelected, parseColor(value))
				elif attrib == "foregroundColorServiceNotAvail":
					self.l.setColor(eListboxServiceContent.serviceNotAvail, parseColor(value))
				elif attrib == "serviceItemHeight":
					self.ItemHeight = int(value)
				elif attrib == "serviceNameFont":
					self.ServiceNameFont = parseFont(value, ((1,1),(1,1)))
				elif attrib == "serviceInfoFont":
					self.ServiceInfoFont = parseFont(value, ((1,1),(1,1)))
				elif attrib == "serviceNumberFont":
					self.ServiceNumberFont = parseFont(value, ((1,1),(1,1)))
				else:
					attribs.append((attrib, value))
		self.skinAttributes = attribs
		return GUIComponent.applySkin(self, desktop, parent)

	def applySkin(self, desktop, parent):
		attribs = []
		if self.skinAttributes is not None:
			for (attrib, value) in self.skinAttributes:
				if attrib == "posFont":
					self.posFont = parseFont(value, ((1,1),(1,1)))
					self.l.setFont(0, self.posFont)
				elif attrib == "nameFont":
					self.nameFont = parseFont(value, ((1,1),(1,1)))
					self.l.setFont(1, self.nameFont)
				elif attrib == "posWidth":
					self.posWidth = int(value)
				elif attrib == "nameWidth":
					self.nameWidth = int(value)
				elif attrib == "posColor":
					self.posColor = parseColor(value).argb()
				elif attrib == "posColorSel":
					self.posColorSel = parseColor(value).argb()
				elif attrib == "nameColor":
					self.nameColor = parseColor(value).argb()
				elif attrib == "nameColorSel":
					self.nameColorSel = parseColor(value).argb()
				elif attrib == "itemHeight":
					self.itemHeight = int(value)
				else:
					attribs.append((attrib, value))
		self.readPlaylist()
		self.refreshList()
		self.setItemHeight()
		self.skinAttributes = attribs
		return GUIComponent.applySkin(self, desktop, parent)

	def buildList(self, entry):
		(Serie, Staffel, Sender, UTCTime, ID, MarkerFlag) = entry

		icon = imageNone = "%simages/black.png" % SerienRecorder.serienRecMainPath
		imageNeu = "%simages/neu.png" % SerienRecorder.serienRecMainPath

		if MarkerFlag == 1:
			setFarbe = parseColor('green').argb()
		elif MarkerFlag == 2:
			setFarbe = parseColor('red').argb()
		else:
			setFarbe = parseColor('foreground').argb()

		if str(Staffel).isdigit() and int(Staffel) == 1:
			icon = imageNeu

		foregroundColor = parseColor('foreground').argb()

		Staffel = "Staffel %s" % str(Staffel)
		WochenTag = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
		xtime = time.strftime(WochenTag[time.localtime(int(UTCTime)).tm_wday]+ ", %d.%m.%Y", time.localtime(int(UTCTime)))

		if config.plugins.serienRec.showPicons.value != "0":
			picon = loadPNG(imageNone)
			if Sender and self.serviceRefs.get(Sender):
				# Get picon by reference or by name
				piconPath = self.piconLoader.getPicon(self.serviceRefs.get(Sender)[0] if config.plugins.serienRec.showPicons.value == "1" else self.serviceRefs.get(Sender)[1])
				if piconPath:
					self.picloader = PicLoader(80 * skinFactor, 40 * skinFactor)
					picon = self.picloader.load(piconPath)
					self.picloader.destroy()

			return [entry,
					(eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, 10, 5, 80 * skinFactor, 40 * skinFactor, picon),
					(eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, 340 * skinFactor, 15 * skinFactor, 30
					 * skinFactor, 30 * skinFactor, loadPNG(icon)),
					(eListboxPythonMultiContent.TYPE_TEXT, 110 * skinFactor, 3, 200 * skinFactor, 26 * skinFactor, 0,
					 RT_HALIGN_LEFT | RT_VALIGN_CENTER, Sender, foregroundColor, foregroundColor),
					(eListboxPythonMultiContent.TYPE_TEXT, 110 * skinFactor, 29 * skinFactor, 200 * skinFactor, 18
					 * skinFactor, 0, RT_HALIGN_LEFT | RT_VALIGN_CENTER, xtime),
					(eListboxPythonMultiContent.TYPE_TEXT, 375 * skinFactor, 3, 500 * skinFactor, 26 * skinFactor, 0,
					 RT_HALIGN_LEFT | RT_VALIGN_CENTER, Serie, setFarbe, setFarbe),
					(eListboxPythonMultiContent.TYPE_TEXT, 375 * skinFactor, 29 * skinFactor, 500 * skinFactor, 18
					 * skinFactor, 0, RT_HALIGN_LEFT | RT_VALIGN_CENTER, Staffel)
					]
		else:
			return [entry,
					(eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, 15, 15 * skinFactor, 30 * skinFactor, 30
					 * skinFactor, loadPNG(icon)),
					(eListboxPythonMultiContent.TYPE_TEXT, 50 * skinFactor, 3, 200 * skinFactor, 26 * skinFactor, 0,
					 RT_HALIGN_LEFT | RT_VALIGN_CENTER, Sender, foregroundColor, foregroundColor),
					(eListboxPythonMultiContent.TYPE_TEXT, 50 * skinFactor, 29 * skinFactor, 200 * skinFactor, 18
					 * skinFactor, 0, RT_HALIGN_LEFT | RT_VALIGN_CENTER, xtime),
					(eListboxPythonMultiContent.TYPE_TEXT, 300 * skinFactor, 3, 500 * skinFactor, 26 * skinFactor, 0,
					 RT_HALIGN_LEFT | RT_VALIGN_CENTER, Serie, setFarbe, setFarbe),
					(eListboxPythonMultiContent.TYPE_TEXT, 300 * skinFactor, 29 * skinFactor, 500 * skinFactor, 18
					 * skinFactor, 0, RT_HALIGN_LEFT | RT_VALIGN_CENTER, Staffel)
					]

	def calendar(self):
		monthname = (
		_('January'),
		_('February'),
		_('March'),
		_('April'),
		_('May'),
		_('June'),
		_('July'),
		_('August'),
		_('September'),
		_('October'),
		_('November'),
		_('December'))

		i = 1
		ir = 0
		d1 = datetime.date(self.year, self.month, 1)
		d2 = d1.weekday()

		if self.month == 12:
			sdt1 = datetime.date(self.year + 1, 1, 1) - datetime.timedelta(1)
		else:
			sdt1 = datetime.date(self.year, self.month + 1, 1) - datetime.timedelta(1)
		self.monthday = int(sdt1.day)
		self.monthname = monthname[self.month - 1]
		self["monthname"].setText(str(self.year)+' '+str(self.monthname))

		for x in range(42):
			self['d' + str(x)].setText('')
			self['d' + str(x)].instance.clearForegroundColor()
			self['d' + str(x)].instance.clearBackgroundColor()
			if (x + 7) % 7 == 0:
				ir += 1
				self['wn' + str(ir)].setText('')
			if x >= d2 and i <= self.monthday:
				r = datetime.datetime(self.year, self.month, i)
				wn1 = r.isocalendar()[1]
				self['wn' + str(ir - 1)].setText('%0.2d' % wn1)
				self['d' + str(x)].setText(str(i))
				self['d' + str(x)].instance.setForegroundColor(parseColor('white'))
				if datetime.date(self.year, self.month, i) == datetime.date.today():
					self['d' + str(x)].instance.setBackgroundColor(parseColor('green'))
				if datetime.date(self.year, self.month, i).weekday() == 5:
					self['d' + str(x)].instance.setForegroundColor(parseColor('yellow'))
				if datetime.date(self.year, self.month, i).weekday() == 6:
					self['d' + str(x)].instance.setForegroundColor(parseColor('red'))
				i = i + 1

		self.date()
		self.datepeople()
		self.monthpeople()
		self.sign()
		self.holiday()
		self.description()