Пример #1
0
    def __init__(self, directory, showDirectories = True, showFiles = True, showMountpoints = True, matchingPattern = None, useServiceRef = False, inhibitDirs = False, inhibitMounts = False, isTop = False, enableWrapAround = False, additionalExtensions = None, sortDate=False):
        MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent)
        GUIComponent.__init__(self)

        self.additional_extensions = additionalExtensions
        self.mountpoints = []
        self.current_directory = None
        self.current_mountpoint = None
        self.useServiceRef = useServiceRef
        self.showDirectories = showDirectories
        self.showMountpoints = showMountpoints
        self.showFiles = showFiles
        self.isTop = isTop
        # example: matching .nfi and .ts files: "^.*\.(nfi|ts)"
        self.matchingPattern = matchingPattern
        self.inhibitDirs = inhibitDirs or []
        self.inhibitMounts = inhibitMounts or []
        self.sortDate = sortDate

        self.refreshMountpoints()
        #self.changeDir(directory)
        #self.l.setFont(0, gFont("Regular", int(config.plugins.AdvancedFreePlayer.FileListFontSize.value)))
        #self.l.setItemHeight(35)
        self.serviceHandler = eServiceCenter.getInstance()

        #default values:
        self.font0 = gFont("Regular",22)
        self.font1 = gFont("Regular",16)
        self.itemHeight = 35
        self.DimText0 = (45, 1, 1020, 35, 0)
        self.DimText1 = (0, 0, 0, 0) # not used here
        self.DimPIC = (5, 4, 25, 25)
Пример #2
0
	def __init__(self, source):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.list = source
		self.l.setList(self.list)
		self.l.setFont(0, gFont("Regular", 23))
		self.l.setItemHeight(25)
Пример #3
0
   def __init__(self):
       GUIComponent.__init__(self)
       self.l = eListboxPythonMultiContent()
       self.l.setFont(0, gFont("Regular", 24))
       self.l.setFont(1, gFont("Regular", 18))
 
       self.l.setBuildFunc(self.buildEntry)
       #self.l.setItemHeight(65)
       self.l.setItemHeight(35)
       self.onSelectionChanged = [ ]
       
       try:
           self.categoryPIX = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, self.ICON_CATEGORY))
           print("loaded")
           self.searchPIX = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, self.ICON_SEARCH))
           print("loaded")
           self.newthreadPIX = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, self.ICON_NEWTHREAD))
           print("loaded")
           self.oldthreadPIX = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, self.ICON_OLDTHREAD))
           print("loaded")
       except:
           self.categoryPIX = None
           self.searchPIX = None
           self.newthreadPIX = None
           self.oldthreadPIX = None
           print("Problem with loading markers for MyList")
Пример #4
0
	def __init__(self, entries):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setFont(0, gFont("Regular", 22))
		self.l.setFont(1, gFont("Regular", 18))
		self.list = [self.buildListboxEntry(x) for x in entries]
		self.l.setList(self.list)
Пример #5
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.l = eListboxPythonMultiContent()
     self.l.setBuildFunc(self.buildList)
     self.l.setFont(0, gFont("Regular", 22))
     self.l.setFont(1, gFont("Regular", 18))
     self.l.setItemHeight(75)
	def __init__(self, enableWrapAround = True):
		GUIComponent.__init__(self)

		self.screenwidth = getDesktop(0).size().width()
		if self.screenwidth and self.screenwidth == 1920:
			self.posFont = parseFont("Regular;30", ((1,1),(1,1)))
			self.nameFont = parseFont("Regular;30", ((1,1),(1,1)))
			self.itemHeight = 40
		else:
			self.posFont = parseFont("Regular;20", ((1,1),(1,1)))
			self.nameFont = parseFont("Regular;20", ((1,1),(1,1)))
			self.itemHeight = 30

		self.posColor = 0xFFFFFF
		self.posColorSel = 0xFFFFFF
		self.nameColor = 0xFFFFFF
		self.nameColorSel = 0xFFFFFF

		self.posWidth = -1
		self.nameWidth = -1

		self.l = eListboxPythonMultiContent()
		self.l.setFont(0, self.posFont)
		self.l.setFont(1, self.nameFont)

		self.onSelectionChanged = []
Пример #7
0
	def __init__(self, eventList):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setFont(0, gFont("Regular", 18))
		self.l.setBuildFunc(self.buildResultEntry)
		self.l.setItemHeight(150)
		self.onSelectionChanged = [ ]

		self.resultlist = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/resultlist.png'), desktop = getDesktop(0))
		self.favoritePixmap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/favorite.png'), desktop = getDesktop(0))
		self.clockPixmap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/epgclock.png'), desktop = getDesktop(0))
		self.clockOverlap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/clockOverlap.png'), desktop = getDesktop(0))
		self.clockNotrecord = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/clockNotrecord.png'), desktop = getDesktop(0))
		self.noConflictPixmap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/noConflict.png'), desktop = getDesktop(0))
		self.arrowRightPixmap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/right.png'), desktop = getDesktop(0))
		self.deletePixmap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/PrimeTimeManager/images/delete.png'), desktop = getDesktop(0))
		if AUTOTIMER and config.plugins.PrimeTimeManager.UseAutotimer.value:
			self.autotimerPixmap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, 'Extensions/AutoTimer/plugin.png'), desktop = getDesktop(0))

		self.l.setList(eventList)

		self.digitList = []
		i = 0
		while i <= 10:
			name = 'Extensions/PrimeTimeManager/images/digit_' + str(i) + '.png'
			digitPixmap = LoadPixmap(cached = True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, name), desktop = getDesktop(0))
			self.digitList.append(digitPixmap)
			i += 1
Пример #8
0
	def __init__(self, list, videoMode, piconLoader, piconSize, listStyle):
		self.videoMode = videoMode
		self.piconLoader = piconLoader
		self.piconSize = piconSize
		self.baseHeight = self.piconSize.height()
		self.listStyle = listStyle
		
		GUIComponent.__init__(self)
		
		self.l = eListboxPythonMultiContent()
		self.l.setBuildFunc(self.buildTimerEntry)
		self.onSelectionChanged = [ ]
		
		if self.videoMode == MODE_SD or self.videoMode == MODE_XD:
			self.overallFontHeight = 36
		elif self.videoMode == MODE_HD:
			self.overallFontHeight = 44
		elif self.videoMode == MODE_FHD:
			self.overallFontHeight = 66
			
		self.l.setList(list)
		config.plugins.merlinEpgCenter.listItemHeight.addNotifier(self.changeHeight, initial_call = True)
		config.plugins.merlinEpgCenter.adjustFontSize.addNotifier(self.setFontSizes, initial_call = True)
		
		self.autoTimerPixmap = LoadPixmap(cached=False, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/AutoTimerSmall.png"))
Пример #9
0
	def __init__(self, path, type, update = True):
		GUIComponent.__init__(self)
		VariableText.__init__(self)
		self.type = type
# 		self.path = config.crash.debug_path.value
		if update:
			self.update(path)
Пример #10
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.l = eListboxPythonMultiContent()
     self.l.setBuildFunc(self.buildMovieSelectionListEntry)
     self.l.setFont(0, gFont("Regular", 20))                             
     self.l.setItemHeight(30)
     self.onSelectionChanged = [ ]
Пример #11
0
    def __init__(self, selChangedCB=None, timer=None, time_epoch=120, overjump_empty=True):
        self.cur_event = None
        self.cur_service = None
        self.offs = 0
        self.timer = timer
        self.onSelChanged = []
        if selChangedCB is not None:
            self.onSelChanged.append(selChangedCB)
        GUIComponent.__init__(self)
        self.l = eListboxPythonMultiContent()
        self.l.setItemHeight(54)
        self.l.setBuildFunc(self.buildEntry)
        if overjump_empty:
            self.l.setSelectableFunc(self.isSelectable)
        self.epgcache = eEPGCache.getInstance()
        self.clock_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock.png"))
        self.clock_add_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_add.png"))
        self.clock_pre_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_pre.png"))
        self.clock_post_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_post.png"))
        self.clock_prepost_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "750S/icons/epgclock_prepost.png"))
        self.time_base = None
        self.time_epoch = time_epoch
        self.list = None
        self.event_rect = None

        self.foreColor = None
        self.foreColorSelected = None
        self.borderColor = None
        self.backColor = 0x586D88
        self.backColorSelected = 0x808080
        self.foreColorService = None
        self.backColorService = None
Пример #12
0
	def __init__(self, selChangedCB=None, timer = None, time_epoch = 120, overjump_empty=True):
		self.cur_event = None
		self.cur_service = None
		self.offs = 0
		self.timer = timer
		self.onSelChanged = [ ]
		if selChangedCB is not None:
			self.onSelChanged.append(selChangedCB)
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setBuildFunc(self.buildEntry)
		self.setOverjump_Empty(overjump_empty)
		self.epgcache = eEPGCache.getInstance()
		self.clock_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock.png'))
		self.clock_add_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_add.png'))
		self.clock_pre_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_pre.png'))
		self.clock_post_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_post.png'))
		self.clock_prepost_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_prepost.png'))
		self.time_base = None
		self.time_epoch = time_epoch
		self.list = None
		self.event_rect = None

		self.foreColor = None
		self.foreColorSelected = None
		self.borderColor = None
		self.backColor = 0x586d88
		self.backColorSelected = 0x808080
		self.foreColorService = None
		self.backColorService = None
Пример #13
0
	def __init__(self, root, list_type=None, sort_type=None, show_times=None, sftitle_episode_separator = None, MovieSelectionSelf = None):
		GUIComponent.__init__(self)
#		print "[SF-Plugin] class SF:MovieList init, lstt=%x, srt=%x, sht=%s, sft=>%s<, root=%s" % ( list_type, sort_type, show_times, str(sftitle_episode_separator), str(root))
		self.list_type = list_type or self.LISTTYPE_MINIMAL
		self.show_times = show_times or self.SHOW_DURATION | self.SHOW_DIRECTORIES
		self.sort_type = sort_type or self.SORT_RECORDED
		self.sftitle_episode_separator = sftitle_episode_separator

		self.l = eListboxPythonMultiContent()

		self.tags = set()
		self.list = None
		self.sflists = None
		self.MovieSelectionSelf = MovieSelectionSelf
		self.MselTitle = ""

		if root is not None:
			self.reload(root)

		self.pdirIcon = LoadPixmap(cached=True, path=eEnv.resolve('${libdir}/enigma2/python/Plugins/Extensions/SerienFilm/icons/folder_20.png'))
		self.rdirIcon = LoadPixmap(cached=True, path=eEnv.resolve('${libdir}/enigma2/python/Plugins/Extensions/SerienFilm/icons/folder_red.png'))
		self.fupIcon = LoadPixmap(cached=True, path=eEnv.resolve('${libdir}/enigma2/python/Plugins/Extensions/SerienFilm/icons/folderup_20.png'))
		self.pdirMap = MultiContentEntryPixmapAlphaTest(pos=(0,0), size=(20,20), png=self.pdirIcon)
		self.rdirMap = MultiContentEntryPixmapAlphaTest(pos=(0,0), size=(20,20), png=self.rdirIcon)
		self.fupMap = MultiContentEntryPixmapAlphaTest(pos=(0,0), size=(20,20), png=self.fupIcon)

		self.redrawList()
		self.l.setBuildFunc(self.buildMovieListEntry)

		self.onSelectionChanged = [ ]
Пример #14
0
	def __init__(self, selChangedCB = None, timer = None, time_epoch = 120, overjump_empty = True):
		GUIComponent.__init__(self)
		self.cur_event = None
		self.cur_service = None
		self.offs = 0
		self.timer = timer
		self.last_time = time()
		self.onSelChanged = [ ]
		if selChangedCB is not None:
			self.onSelChanged.append(selChangedCB)
		self.l = eListboxPythonMultiContent()
		self.l.setBuildFunc(self.buildEntry)
		self.setOverjump_Empty(overjump_empty)
		self.epgcache = eEPGCache.getInstance()
		self.clocks =  [ LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_add.png')),
				 LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_pre.png')),
				 LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock.png')),
				 LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_prepost.png')),
				 LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'skin_default/icons/epgclock_post.png')) ]
		self.time_base = None
		self.time_epoch = time_epoch
		self.list = None
		self.select_rect = None
		self.event_rect = None
		self.service_rect = None
		self.picon_size = None
		self.currentlyPlaying = None
		self.showPicon = False
		self.showServiceTitle = True
		self.picload = ePicLoad()
		self.nowEvPix = None
		self.othEvPix = None
		self.selEvPix = None
		self.recEvPix = None
		self.curSerPix = None

		self.foreColor = 0xffffff
		self.foreColorSelected = 0xffc000
		self.borderColor = 0x464445
		self.backColor = 0x595959
		self.backColorSelected = 0x808080
		self.foreColorService = 0xffffff
		self.foreColorServiceSelected = 0xffffff
		self.backColorService = 0x000000
		self.backColorServiceSelected = 0x508050
		self.borderColorService = 0x000000
		self.foreColorNow = 0xffffff
		self.backColorNow = 0x505080
		self.foreColorRec = 0xffffff
		self.backColorRec = 0x805050
		self.serviceFont = gFont("Regular", 20)
		self.entryFontName = "Regular"
		self.entryFontSize = 18

		self.listHeight = None
		self.listWidth = None
		self.serviceBorderWidth = 1
		self.serviceNamePadding = 0
		self.eventBorderWidth = 1
		self.eventNamePadding = 0
Пример #15
0
 def __init__(self, navcore):
     GUIComponent.__init__(self)
     PerServiceBase.__init__(self, navcore, {iPlayableService.evStart: self.newService,
      iPlayableService.evEnd: self.stopEvent,
      iPlayableService.evCuesheetChanged: self.newCuesheet})
     self.instance = None
     self.__seek_position = 0
Пример #16
0
	def __init__(self):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setBuildFunc(self.buildList)
		tlf = TemplatedListFonts()
		self.l.setFont(0, gFont(tlf.face(tlf.BIG), tlf.size(tlf.BIG)))
		self.l.setFont(1, gFont(tlf.face(tlf.SMALL), tlf.size(tlf.SMALL)))
		self.l.setItemHeight(componentSizes.itemHeight(self.SKIN_COMPONENT_KEY, 77))
Пример #17
0
 def __init__(self, default=None, cachedir='/tmp/', caching=True):
     GUIComponent.__init__(self)
     self.caching = caching
     self.cachedir = cachedir
     self.default = default
     self.currentUrl = None
     self.picload = ePicLoad()
     self.picload.PictureData.get().append(self.setPixmapCB)
Пример #18
0
 def __init__(self, source):
     GUIComponent.__init__(self)
     self.l = eListboxPythonMultiContent()
     self.list = source
     self.l.setList(self.list)
     font = skin.fonts.get("ServiceInfo", ("Regular", 23, 25))
     self.l.setFont(0, gFont(font[0], font[1]))
     self.l.setItemHeight(font[2])
Пример #19
0
	def __init__(self, source):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.list = source
		self.l.setList(self.list)
                self.fontName, self.fontSize = skin.parameters.get("ServiceInfoFont", ('Regular', 23))
                self.l.setFont(0, gFont(self.fontName, self.fontSize))
		self.ItemHeight = 25
Пример #20
0
	def __init__(self, entries):
		GUIComponent.__init__(self)

		self.list = entries
		self.l = eListboxPythonMultiContent()
		self.l.setFont(0, gFont("Regular", 22))
		self.l.setBuildFunc(self.buildListboxEntry)
		self.l.setList(self.list)
Пример #21
0
	def __init__(self, source):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.list = source
		self.l.setList(self.list)
		self.fontName = "Regular"
		self.fontSize = 23
		self.ItemHeight = 25
Пример #22
0
	def __init__(self):
		GUIComponent.__init__(self)
		sizes = componentSizes[componentSizes.TIMELINE_TEXT]
		height = sizes.get(componentSizes.ITEM_HEIGHT, 25)
		self.l = eListboxPythonMultiContent()
		self.l.setSelectionClip(eRect(0, 0, 0, 0))
		self.l.setItemHeight(height);
		tlf = TemplatedListFonts()
		self.l.setFont(0, gFont(tlf.face(tlf.MEDIUM), tlf.size(tlf.MEDIUM)))
Пример #23
0
 def __init__(self, ip_address):
     GUIComponent.__init__(self)
     self.l = eListboxPythonMultiContent()        
     self.l.setFont(0, gFont("Regular", 22))
     self.l.setFont(1, gFont("Regular", 18))
     self.l.setItemHeight(100)
     self.l.setBuildFunc(self.buildMovieListEntry)
     self.onSelectionChanged = [ ]
     self.staticIP = ip_address
Пример #24
0
	def __init__(self, mode):
		GUIComponent.__init__(self)
		self.mode = mode
		self.l = eListboxPythonMultiContent()
#		self.l.setFont(0, gFont('Regular', 22))
		font, size = skin.parameters.get("TMDbListFont", ('Regular', 23))
		self.l.setFont(0, gFont(font, size))
		self.l.setItemHeight(30)
		self.l.setBuildFunc(self.buildList)
Пример #25
0
	def __init__(self):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setFont(0, gFont("Regular", 20))
		self.l.setFont(1, gFont("Regular", 18))
		self.l.setBuildFunc(self.buildEntry)
		self.l.setItemHeight(22)
		self.onSelectionChanged = [ ]
		self.mode = 0
Пример #26
0
	def __init__(self, list, session = None):
		GUIComponent.__init__(self)
		self.l = eListboxPythonConfigContent()
		self.l.setSeperation(200)
		self.timer = eTimer()
		self.list = list
		self.onSelectionChanged = [ ]
		self.current = None
		self.session = session
Пример #27
0
	def __init__(self):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setSelectionClip(eRect(0, 0, 0, 0))
		self.l.setItemHeight(25);
		self.foreColor = 0xffc000
		self.backColor = 0x000000
		self.time_base = 0
		self.time_epoch = 0
		self.font = gFont("Regular", 20)
Пример #28
0
	def __init__(self, list, enableWrapAround = False):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.list = list
		self.l.setList(list)
		self.l.setFont(0, gFont('Regular', 21))
		self.l.setItemHeight(48)
		self.onSelectionChanged = []
		self.enableWrapAround = enableWrapAround
		self.last = 0
Пример #29
0
	def __init__(self):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setSelectionClip(eRect(0,0,0,0))
		if config.skin.xres.value == 1920:
			self.l.setItemHeight(35);
			self.l.setFont(0, gFont("Regular", 30))
		else:
			self.l.setItemHeight(25);
			self.l.setFont(0, gFont("Regular", 20))
Пример #30
0
	def __init__(self):
		GUIComponent.__init__(self)

		self.list = []
		self.active_style = None
		self.selectionEnabled = True
		self._template = self._getTemplate()
		self._initialized = False

		self.buildfunc = None
		self.l = eListboxPythonMultiContent()
Пример #31
0
    def __init__(self, eventList):
        GUIComponent.__init__(self)
        self.l = eListboxPythonMultiContent()
        self.l.setFont(0, gFont("Regular", 18))
        self.l.setBuildFunc(self.buildResultEntry)
        self.l.setItemHeight(150)
        self.onSelectionChanged = []

        self.resultlist = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/resultlist.png'),
            desktop=getDesktop(0))
        self.favoritePixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/favorite.png'),
            desktop=getDesktop(0))
        self.clockPixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/epgclock.png'),
            desktop=getDesktop(0))
        self.clockOverlap = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/clockOverlap.png'),
            desktop=getDesktop(0))
        self.clockNotrecord = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/clockNotrecord.png'),
            desktop=getDesktop(0))
        self.noConflictPixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/noConflict.png'),
            desktop=getDesktop(0))
        self.arrowRightPixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/right.png'),
            desktop=getDesktop(0))
        self.deletePixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(
                SCOPE_CURRENT_PLUGIN,
                'Extensions/PrimeTimeManager/images/delete.png'),
            desktop=getDesktop(0))
        if AUTOTIMER and config.plugins.PrimeTimeManager.UseAutotimer.value:
            self.autotimerPixmap = LoadPixmap(
                cached=True,
                path=resolveFilename(SCOPE_CURRENT_PLUGIN,
                                     'Extensions/AutoTimer/plugin.png'),
                desktop=getDesktop(0))

        self.l.setList(eventList)

        self.digitList = []
        i = 0
        while i <= 10:
            name = 'Extensions/PrimeTimeManager/images/digit_' + str(
                i) + '.png'
            digitPixmap = LoadPixmap(cached=True,
                                     path=resolveFilename(
                                         SCOPE_CURRENT_PLUGIN, name),
                                     desktop=getDesktop(0))
            self.digitList.append(digitPixmap)
            i += 1
Пример #32
0
	def __init__(self):
		Element.__init__(self)
		GUIComponent.__init__(self)
Пример #33
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		self.days = (_("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun"))
		self.timer = timer
		self.onSelChanged = []
		if selChangedCB is not None:
			self.onSelChanged.append(selChangedCB)
		GUIComponent.__init__(self)
		self.type = type
		self.l = eListboxPythonMultiContent()
		self.eventItemFont = gFont("Regular", 22)
		self.eventTimeFont = gFont("Regular", 16)
		self.iconSize = 21
		self.iconDistance = 2
		self.colGap = 10
		self.skinColumns = False
		self.tw = 120
		self.dy = 0

		if type is EPG_TYPE_SINGLE:
			self.l.setBuildFunc(self.buildSingleEntry)
		elif type is EPG_TYPE_MULTI:
			self.l.setBuildFunc(self.buildMultiEntry)
		else:
			assert(type is EPG_TYPE_SIMILAR)
			self.l.setBuildFunc(self.buildSimilarEntry)
		self.epgcache = eEPGCache.getInstance()
		self.clocks = [LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/epgclock_add.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/epgclock_pre.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/epgclock.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/epgclock_prepost.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/epgclock_post.png')),

					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zapclock_add.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zapclock_pre.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zapclock.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zapclock_prepost.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zapclock_post.png')),

					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zaprecclock_add.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zaprecclock_pre.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zaprecclock.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zaprecclock_prepost.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/zaprecclock_post.png')),

					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repepgclock_add.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repepgclock_pre.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repepgclock.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repepgclock_prepost.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repepgclock_post.png')),

					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzapclock_add.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzapclock_pre.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzapclock.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzapclock_prepost.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzapclock_post.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzaprecclock_add.png')),

					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzaprecclock_pre.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzaprecclock.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzaprecclock_prepost.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/repzaprecclock_post.png')),

					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/pipclock_add.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/pipclock_pre.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/pipclock.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/pipclock_prepost.png')),
					   LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, 'icons/pipclock_post.png'))]
Пример #34
0
	def applySkin(self, desktop, parent):
		GUIComponent.applySkin(self, desktop, parent)
Пример #35
0
 def destroy(self):
     self.picloader.destroy()
     GUIComponent.destroy(self)
Пример #36
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.rows_in_column = applySkinFactor(25)
Пример #37
0
	def __init__(self, min, max):
		VariableValue.__init__(self)
		GUIComponent.__init__(self)

		self.min = min
		self.max = max
Пример #38
0
 def __init__(self):
     GUIComponent.__init__(self)
     VariableValue.__init__(self)
     self.__start = 0
     self.__end = 100
Пример #39
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.rows_in_column = 25
Пример #40
0
 def __init__(self, list):
     GUIComponent.__init__(self)
     self.l = eListboxPythonMultiContent()
     self.l.setList(list)
     self.l.setFont(0, gFont("Regular", 20))
     self.l.setFont(1, gFont("Regular", 18))
Пример #41
0
 def destroy(self):
     PerServiceBase.destroy(self)
     GUIComponent.destroy(self)
Пример #42
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.l = eListboxPythonMultiContent()
     self.l.setSelectionClip(eRect(0, 0, 0, 0))
     self.l.setItemHeight(25)
     self.l.setFont(0, gFont("Regular", 20))
Пример #43
0
 def __init__(self):
     VariableValue.__init__(self)
     GUIComponent.__init__(self)
Пример #44
0
 def applySkin(self, desktop, screen):
     rc = GUIComponent.applySkin(self, desktop, screen)
     self.listHeight = self.instance.size().height()
     self.listWidth = self.instance.size().width()
     self.setItemsPerPage()
     return rc
Пример #45
0
 def __init__(self, decoder=1, fb_width=720, fb_height=576):
     GUIComponent.__init__(self)
     self.decoder = decoder
     self.fb_width = fb_width
     self.fb_height = fb_height
Пример #46
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.picloader = PicLoader(95, 138)
Пример #47
0
	def applySkin(self, desktop, parent):
		def foregroundColorMarked(value):
			self.l.setColor(eListboxServiceContent.markedForeground, parseColor(value))
		def foregroundColorMarkedSelected(value):
			self.l.setColor(eListboxServiceContent.markedForegroundSelected, parseColor(value))
		def backgroundColorMarked(value):
			self.l.setColor(eListboxServiceContent.markedBackground, parseColor(value))
		def backgroundColorMarkedSelected(value):
			self.l.setColor(eListboxServiceContent.markedBackgroundSelected, parseColor(value))
		def foregroundColorServiceNotAvail(value):
			self.l.setColor(eListboxServiceContent.serviceNotAvail, parseColor(value))
		def foregroundColorEvent(value):
			self.l.setColor(eListboxServiceContent.eventForeground, parseColor(value))
		def colorServiceDescription(value):
			self.l.setColor(eListboxServiceContent.eventForeground, parseColor(value))
		def foregroundColorEventSelected(value):
			self.l.setColor(eListboxServiceContent.eventForegroundSelected, parseColor(value))
		def colorServiceDescriptionSelected(value):
			self.l.setColor(eListboxServiceContent.eventForegroundSelected, parseColor(value))
		def foregroundColorEventborder(value):
			self.l.setColor(eListboxServiceContent.eventborderForeground, parseColor(value))
		def foregroundColorEventborderSelected(value):
			self.l.setColor(eListboxServiceContent.eventborderForegroundSelected, parseColor(value))
		def colorEventProgressbar(value):
			self.l.setColor(eListboxServiceContent.serviceEventProgressbarColor, parseColor(value))
		def colorEventProgressbarSelected(value):
			self.l.setColor(eListboxServiceContent.serviceEventProgressbarColorSelected, parseColor(value))
		def colorEventProgressbarBorder(value):
			self.l.setColor(eListboxServiceContent.serviceEventProgressbarBorderColor, parseColor(value))
		def colorEventProgressbarBorderSelected(value):
			self.l.setColor(eListboxServiceContent.serviceEventProgressbarBorderColorSelected, parseColor(value))
		def colorServiceRecorded(value):
			self.l.setColor(eListboxServiceContent.serviceRecorded, parseColor(value))
		def colorFallbackItem(value):
			self.l.setColor(eListboxServiceContent.serviceItemFallback, parseColor(value))
		def colorServiceSelectedFallback(value):
			self.l.setColor(eListboxServiceContent.serviceSelectedFallback, parseColor(value))
		def colorServiceDescriptionFallback(value):
			self.l.setColor(eListboxServiceContent.eventForegroundFallback, parseColor(value))
		def colorServiceDescriptionSelectedFallback(value):
			self.l.setColor(eListboxServiceContent.eventForegroundSelectedFallback, parseColor(value))
		def picServiceEventProgressbar(value):
			pic = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, value))
			pic and self.l.setPixmap(self.l.picServiceEventProgressbar, pic)
		def serviceItemHeight(value):
			self.ItemHeight = int(value)
		def serviceNameFont(value):
			self.ServiceNameFont = parseFont(value, ((1,1),(1,1)))
		def serviceInfoFont(value):
			self.ServiceInfoFont = parseFont(value, ((1,1),(1,1)))
		def serviceNumberFont(value):
			self.ServiceNumberFont = parseFont(value, ((1,1),(1,1)))
		def progressbarHeight(value):
			self.l.setProgressbarHeight(int(value))
		def progressbarBorderWidth(value):
			self.l.setProgressbarBorderWidth(int(value))
		def progressBarWidth(value):
			self.progressBarWidth = int(value)
		def progressPercentWidth(value):
			self.progressPercentWidth = int(value)
		def fieldMargins(value):
			self.fieldMargins = int(value)
		def nonplayableMargins(value):
			self.l.setNonplayableMargins(int(value))
		def itemsDistances(value):
			self.l.setItemsDistances(int(value))
		for (attrib, value) in list(self.skinAttributes):
			try:
				locals().get(attrib)(value)
				self.skinAttributes.remove((attrib, value))
			except:
				pass
		return GUIComponent.applySkin(self, desktop, parent)
Пример #48
0
    def applySkin(self, desktop, parent):
        def warningWrongSkinParameter(string):
            print("[MovieList] wrong '%s' skin parameters" % string)

        def font(value):
            font = skin.parseFont(value, ((1, 1), (1, 1)))
            self.fontName = font.family
            self.fontSize = font.pointSize

        def partIconeShift(value):
            self.partIconeShift = int(value)

        def pbarShift(value):
            self.pbarShift = int(value)

        def pbarHeight(value):
            self.pbarHeight = int(value)

        def pbarLargeWidth(value):
            self.pbarLargeWidth = int(value)

        def pbarColour(value):
            self.pbarColour = skin.parseColor(value).argb()

        def pbarColourSeen(value):
            self.pbarColourSeen = skin.parseColor(value).argb()

        def pbarColourRec(value):
            self.pbarColourRec = skin.parseColor(value).argb()

        def spaceIconeText(value):
            self.spaceIconeText = int(value)

        def iconsWidth(value):
            self.iconsWidth = int(value)

        def trashShift(value):
            self.trashShift = int(value)

        def dirShift(value):
            self.dirShift = int(value)

        def spaceRight(value):
            self.spaceRight = int(value)

        def durationWidth(value):
            self.durationWidth = int(value)

        def dateWidth(value):
            self.dateWidth = int(value)
            if config.usage.time.wide.value:
                self.dateWidth = int(self.dateWidth * 1.15)

        for (attrib, value) in self.skinAttributes[:]:
            try:
                locals().get(attrib)(value)
                self.skinAttributes.remove((attrib, value))
            except:
                pass
        rc = GUIComponent.applySkin(self, desktop, parent)
        self.listHeight = self.instance.size().height()
        self.listWidth = self.instance.size().width()
        self.setFontsize()
        self.setItemsPerPage()
        return rc
Пример #49
0
	def __init__(self, text=""):
		GUIComponent.__init__(self)
		VariableText.__init__(self)
		self.setText(text)
Пример #50
0
	def __init__(self):
		GUIComponent.__init__(self)
		self.l = eListboxPythonMultiContent()
		self.l.setFont(0, gFont("Regular", 19))
		self.l.setItemHeight(186)
		self.l.setBuildFunc(self.buildList)
Пример #51
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.blinking = False
     self.setBlinkTime(500)
     self.timer = eTimer()
     self.timer.callback.append(self.blink)
Пример #52
0
 def __init__(self, navcore, eventmap):
     GUIComponent.__init__(self)
     VariableText.__init__(self)
     PerServiceBase.__init__(self, navcore, eventmap)
Пример #53
0
 def __init__(self):
     printDBG("IPTVListComponent.__init__ ----------------------------------------------------")
     GUIComponent.__init__(self)
     self.l = eListboxPythonMultiContent()
     self.l.setBuildFunc(self.buildEntry)
     self.onSelectionChanged = []
Пример #54
0
 def postWidgetCreate(self, instance):
     GUIComponent.postWidgetCreate(self, instance)
     self.setDefaultAnimationEnabled(True)
	def __init__(self, helplist, callback):
		GUIComponent.__init__(self)
		self.onSelChanged = [ ]
		self.l = eListboxPythonMultiContent()
		self.callback = callback
		self.extendedHelp = False

		l = [ ]
		for (actionmap, context, actions) in helplist:
			for (action, help) in actions:
				if hasattr(help, '__call__'):
					help = help()
				if not help:
					continue
				buttons = queryKeyBinding(context, action)

				# do not display entries which are not accessible from keys
				if not len(buttons):
					continue

				name = None
				flags = 0

				for n in buttons:
					(name, flags) = (getKeyDescription(n[0]), n[1])

					# only show entries with keys that are available on the used rc
					if name is None:
						continue

					if flags & 8: # for long keypresses, prepend l_ into the key name.
						name = (name[0], "long")

					entry = [ (actionmap, context, action, name ) ]

					if isinstance(help, list):
						self.extendedHelp = True
						print("[HelpMenuList] extendedHelpEntry found")
						x, y, w, h = skin.parameters.get("HelpMenuListExtHlp0", (0, 0, 600, 26))
						x1, y1, w1, h1 = skin.parameters.get("HelpMenuListExtHlp1", (0, 28, 600, 20))
						entry.extend((
							(eListboxPythonMultiContent.TYPE_TEXT, x, y, w, h, 0, 0, help[0]),
							(eListboxPythonMultiContent.TYPE_TEXT, x1, y1, w1, h1, 1, 0, help[1])
						))
					else:
						x, y, w, h = skin.parameters.get("HelpMenuListHlp", (0, 0, 600, 28))
						entry.append( (eListboxPythonMultiContent.TYPE_TEXT, x, y, w, h, 0, 0, help) )

					l.append(entry)

		self.l.setList(l)
		if self.extendedHelp is True:
			font = skin.fonts.get("HelpMenuListExt0", ("Regular", 24, 50))
			self.l.setFont(0, gFont(font[0], font[1]))
			self.l.setItemHeight(font[2])
			font = skin.fonts.get("HelpMenuListExt1", ("Regular", 18))
			self.l.setFont(1, gFont(font[0], font[1]))
		else:
			font = skin.fonts.get("HelpMenuList", ("Regular", 24, 38))
			self.l.setFont(0, gFont(font[0], font[1]))
			self.l.setItemHeight(font[2])
    def __init__(self,
                 selChangedCB=None,
                 timer=None,
                 time_epoch=120,
                 overjump_empty=True):
        GUIComponent.__init__(self)
        self.cur_event = None
        self.cur_service = None
        self.offs = 0
        self.timer = timer
        self.onSelChanged = []
        if selChangedCB is not None:
            self.onSelChanged.append(selChangedCB)
        self.l = eListboxPythonMultiContent()
        self.l.setBuildFunc(self.buildEntry)
        self.setOverjump_Empty(overjump_empty)
        self.epgcache = eEPGCache.getInstance()
        self.clock_pixmap = LoadPixmap(cached=True,
                                       path=resolveFilename(
                                           SCOPE_CURRENT_SKIN,
                                           'skin_default/icons/epgclock.png'))
        self.clock_add_pixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(SCOPE_CURRENT_SKIN,
                                 'skin_default/icons/epgclock_add.png'))
        self.clock_pre_pixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(SCOPE_CURRENT_SKIN,
                                 'skin_default/icons/epgclock_pre.png'))
        self.clock_post_pixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(SCOPE_CURRENT_SKIN,
                                 'skin_default/icons/epgclock_post.png'))
        self.clock_prepost_pixmap = LoadPixmap(
            cached=True,
            path=resolveFilename(SCOPE_CURRENT_SKIN,
                                 'skin_default/icons/epgclock_prepost.png'))
        self.time_base = None
        self.time_epoch = time_epoch
        self.list = None
        self.event_rect = None
        self.service_rect = None
        self.currentlyPlaying = None
        self.showPicon = False
        self.showServiceTitle = True
        self.piconSize = None
        self.picload = ePicLoad()

        self.foreColor = 0xffffff
        self.foreColorSelected = 0xffc000
        self.borderColor = 0x464445
        self.backColor = 0x595959
        self.backColorSelected = 0x808080
        self.foreColorService = 0xffffff
        self.foreColorServiceSelected = 0x000000
        self.backColorService = 0x000000
        self.backColorServiceSelected = 0xffffff
        self.borderColorService = 0x000000
        self.foreColorNow = 0xffc000
        self.backColorNow = 0x508050
        self.serviceFont = gFont("Regular", 20)
        self.entryFontName = "Regular"
        self.entryFontSize = 18

        self.listHeight = None
        self.listWidth = None
        self.serviceBorderWidth = 1
        self.serviceNamePadding = 0
        self.eventBorderWidth = 1
        self.eventNamePadding = 0
Пример #57
0
	def __init__(self, blinkTimer, listType, videoMode, piconLoader, bouquetList, currentIndex, piconSize, listStyle, epgList):
		self.blinkTimer = blinkTimer
		self.listType = listType
		self.videoMode = videoMode
		self.piconLoader = piconLoader
		self.piconSize = piconSize
		self.baseHeight = self.piconSize.height()
		self.listStyle = listStyle
		self.epgList = epgList
		
		GUIComponent.__init__(self)
		
		from Screens.InfoBar import InfoBar
		EpgCenterList.infoBarInstance = InfoBar.instance
		EpgCenterList.eServiceCenterInstance = eServiceCenter.getInstance()
		
		self.l = eListboxPythonMultiContent()
		self.l.setBuildFunc(self.buildEpgEntry)
		self.onSelectionChanged = [ ]
		
		if self.videoMode == MODE_SD or self.videoMode == MODE_XD:
			self.overallFontHeight = 36
		elif self.videoMode == MODE_HD:
			self.overallFontHeight = 44
			
		#initialize
		self.list = []
		self.mode = None
		self.similarShown = False
		
		config.plugins.merlinEpgCenter.listItemHeight.addNotifier(self.changeHeight, initial_call = True)
		config.plugins.merlinEpgCenter.adjustFontSize.addNotifier(self.setFontSizes, initial_call = True)
		
		if listType == LIST_TYPE_EPG:
			EpgCenterList.bouquetList = bouquetList
			EpgCenterList.currentBouquetIndex = currentIndex
			EpgCenterList.updateBouquetServices()
			EpgCenterList.recordTimer = NavigationInstance.instance.RecordTimer
			
		# zap timer pixmaps
		self.zap_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/zap.png"))
		self.zap_pre_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/zap_pre.png"))
		self.zap_post_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/zap_post.png"))
		self.zap_event_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/zap_event.png"))
		self.zap_repeated_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/zap_repeated.png"))
		self.zap_add_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/zap_add.png"))
		
		# record timer pixmaps
		self.timer_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/timer.png"))
		self.timer_pre_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/timer_pre.png"))
		self.timer_post_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/timer_post.png"))
		self.timer_event_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/timer_event.png"))
		self.timer_repeated_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/timer_repeated.png"))
		self.timer_add_pixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/timer_add.png"))
		
		# progress pixmaps
		self.progressPixmap = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/Progress.png"))
		self.progressPixmap_0 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/Progress_0.png"))
		self.progressPixmap_1 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/Progress_1.png"))
		self.progressPixmap_2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/Progress_2.png"))
		self.progressPixmap_3 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/Progress_3.png"))
		self.progressPixmap_4 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "Extensions/MerlinEPGCenter/images/Progress_4.png"))
		self.progressPixmapWidth = self.progressPixmap.size().width()
		
		self.epgcache = eEPGCache.getInstance()
		
		self.blinkTimer.callbacks.append(self.invalidateList)
Пример #58
0
 def applySkin(self, desktop, screen):
     if self.skinAttributes is not None:
         skin_path_prefix = getattr(screen, "skin_path", path)
         pixmap = None
         attribs = []
         for (attrib, value) in self.skinAttributes:
             if attrib == "pixmaps":
                 pixmaps = value.split(',')
                 for p in pixmaps:
                     pngfile = resolveFilename(SCOPE_ACTIVE_SKIN,
                                               p,
                                               path_prefix=skin_path_prefix)
                     if fileExists(
                             resolveFilename(SCOPE_SKIN_IMAGE,
                                             p,
                                             path_prefix=skin_path_prefix)):
                         pngfile = resolveFilename(
                             SCOPE_SKIN_IMAGE,
                             p,
                             path_prefix=skin_path_prefix)
                     elif fileExists(
                             resolveFilename(SCOPE_ACTIVE_LCDSKIN,
                                             p,
                                             path_prefix=skin_path_prefix)):
                         pngfile = resolveFilename(
                             SCOPE_ACTIVE_LCDSKIN,
                             p,
                             path_prefix=skin_path_prefix)
                     if path.exists(pngfile):
                         self.pixmaps.append(loadPixmap(pngfile, desktop))
                 if not pixmap:
                     pixmap = resolveFilename(SCOPE_ACTIVE_SKIN,
                                              pixmaps[0],
                                              path_prefix=skin_path_prefix)
                     if fileExists(
                             resolveFilename(SCOPE_SKIN_IMAGE,
                                             pixmaps[0],
                                             path_prefix=skin_path_prefix)):
                         pixmap = resolveFilename(
                             SCOPE_SKIN_IMAGE,
                             pixmaps[0],
                             path_prefix=skin_path_prefix)
                     elif fileExists(
                             resolveFilename(SCOPE_ACTIVE_LCDSKIN,
                                             pixmaps[0],
                                             path_prefix=skin_path_prefix)):
                         pixmap = resolveFilename(
                             SCOPE_ACTIVE_LCDSKIN,
                             pixmaps[0],
                             path_prefix=skin_path_prefix)
             elif attrib == "pixmap":
                 pixmap = resolveFilename(SCOPE_ACTIVE_SKIN,
                                          value,
                                          path_prefix=skin_path_prefix)
                 if fileExists(
                         resolveFilename(SCOPE_SKIN_IMAGE,
                                         value,
                                         path_prefix=skin_path_prefix)):
                     pixmap = resolveFilename(SCOPE_SKIN_IMAGE,
                                              value,
                                              path_prefix=skin_path_prefix)
                 elif fileExists(
                         resolveFilename(SCOPE_ACTIVE_LCDSKIN,
                                         value,
                                         path_prefix=skin_path_prefix)):
                     pixmap = resolveFilename(SCOPE_ACTIVE_LCDSKIN,
                                              value,
                                              path_prefix=skin_path_prefix)
             else:
                 attribs.append((attrib, value))
         if pixmap:
             attribs.append(("pixmap", pixmap))
         self.skinAttributes = attribs
     return GUIComponent.applySkin(self, desktop, screen)
Пример #59
0
 def __init__(self, path, type, update=True):
     GUIComponent.__init__(self)
     VariableText.__init__(self)
     self.type = type
     if update and path != '/media/autofs/':
         self.update(path)
Пример #60
0
 def __init__(self):
     GUIComponent.__init__(self)
     self.picload = ePicLoad()
     self.l = eListboxPythonMultiContent()
     self.l.setBuildFunc(self.buildEntry)
     self.onSelChanged = []