Example #1
0
    def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
        EPGList.__init__(self, type, selChangedCB, timer)
        self.l.setBuildFunc(self.buildEPGSearchEntry)

        self.piconLoader = PiconLoader()

        sizes = componentSizes[EPGList.SKIN_COMPONENT_KEY]
        self._iconWidth = sizes.get(EPGList.SKIN_COMPONENT_ICON_WIDTH, 21)
        self._iconHeight = sizes.get(EPGList.SKIN_COMPONENT_ICON_HEIGHT, 21)
        self._iconHPos = sizes.get(EPGList.SKIN_COMPONENT_ICON_HPOS, 4)
        self._itemMargin = sizes.get(EPGList.SKIN_COMPONENT_ITEM_MARGIN, 10)

        servicelist_sizes = componentSizes["ServiceList"]
        self._picon_width = servicelist_sizes.get(ServiceList.KEY_PICON_WIDTH,
                                                  58)

        if PartnerBoxIconsEnabled:
            # Partnerbox Clock Icons
            self.remote_clock_pixmap = LoadPixmap(
                '/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock.png'
            )
            self.remote_clock_add_pixmap = LoadPixmap(
                '/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_add.png'
            )
            self.remote_clock_pre_pixmap = LoadPixmap(
                '/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_pre.png'
            )
            self.remote_clock_post_pixmap = LoadPixmap(
                '/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_post.png'
            )
            self.remote_clock_prepost_pixmap = LoadPixmap(
                '/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_prepost.png'
            )
Example #2
0
    def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
        EPGList.__init__(self, type, selChangedCB, timer)
        self.l.setBuildFunc(self.buildEPGSearchEntry)

        if PartnerBoxIconsEnabled:
            # Partnerbox Clock Icons
            self.partnerbox_clocks = [
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               'Extensions/EPGSearchicons/epgclock_add.png')),
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               'Extensions/EPGSearch/icons/epgclock_pre.png')),
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               'Extensions/EPGSearch/icons/epgclock.png')),
                LoadPixmap(
                    cached=True,
                    path=resolveFilename(
                        SCOPE_PLUGINS,
                        'Extensions/EPGSearch/icons/epgclock_prepost.png')),
                LoadPixmap(
                    cached=True,
                    path=resolveFilename(
                        SCOPE_PLUGINS,
                        'Extensions/EPGSearch/icons/epgclock_post.png')),
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               'Extensions/EPGSearchicons/epgclock_add.png'))
            ]
Example #3
0
	def __init__(self, type=EPG_TYPE_MULTI, selChangedCB=None, timer = None, hasChannelInfo=True):
		EPGList.__init__(self, type, selChangedCB, timer)
		
		sizes = componentSizes[EasyInfoEventList.SKIN_COMPONENT_KEY]
		self.channelWidth = sizes.get(EasyInfoEventList.SKIN_COMPONENT_CHANNEL_WIDTH, 120)
		self.timeWidth = sizes.get(EasyInfoEventList.SKIN_COMPONENT_TIME_WIDTH, 70)
		self.timeIndicatorWidth = sizes.get(EasyInfoEventList.SKIN_COMPONENT_TIME_FUTURE_INDICATOR_WIDTH, 10)
		self.eventNameWidth = sizes.get(EasyInfoEventList.SKIN_COMPONENT_EVENTNAME_WIDTH, 460)
		self.eventNameYOffset = sizes.get(EasyInfoEventList.SKIN_COMPONENT_EVENTNAME_OFFSET, 1)
		self.timeYOffset = sizes.get(EasyInfoEventList.SKIN_COMPONENT_TIME_OFFSET, 3)
		self.itemHeight = sizes.get(EasyInfoEventList.SKIN_COMPONENT_ITEM_HEIGHT, 50)
		self.recOffset = sizes.get(EasyInfoEventList.SKIN_COMPONENT_REC_OFFSET, 25)
		self.channelOffset = sizes.get(EasyInfoEventList.SKIN_COMPONENT_CHANNEL_OFFSET, 120)
		self.progressBarWidth = sizes.get(EasyInfoEventList.SKIN_COMPONENT_PROGRESSBAR_WIDTH, 40)
		self.progressBarHeight = sizes.get(EasyInfoEventList.SKIN_COMPONENT_PROGRESSBAR_HEIGHT, 8)
		self.remainingTimeWidth = sizes.get(EasyInfoEventList.SKIN_COMPONENT_REMAINING_TIME_WIDTH, 70)
		self.recIconSize = sizes.get(EasyInfoEventList.SKIN_COMPONENT_REC_ICON_SIZE, 16)
		self.piconWidth = 0
		self.piconHeight = 0

		tlf = TemplatedListFonts()
		self.l.setFont(0, gFont(tlf.face(tlf.MEDIUM), tlf.size(tlf.MEDIUM)))
		self.l.setFont(1, gFont(tlf.face(tlf.SMALL), tlf.size(tlf.SMALL)))
		self.l.setFont(2, gFont(tlf.face(tlf.SMALLER), tlf.size(tlf.SMALLER)))
		
		self.l.setItemHeight(self.itemHeight)
		self.l.setBuildFunc(self.buildMultiEntry)
		
		self.hasChannelInfo = hasChannelInfo
		self.nameCache = { }
Example #4
0
	def __init__(self, type=EPG_TYPE_MULTI, selChangedCB=None, timer = None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setFont(0, gFont("Regular", 20))
		self.l.setFont(1, gFont("Regular", 18))
		self.l.setItemHeight(50)
		self.l.setBuildFunc(self.buildMultiEntry)
		self.breite = 200
		MyPiconPath = "/"
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setBuildFunc(self.buildEPGSearchEntry)

		if PartnerBoxIconsEnabled:
			# Partnerbox Clock Icons
			self.remote_clock_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock.png')
			self.remote_clock_add_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_add.png')
			self.remote_clock_pre_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_pre.png')
			self.remote_clock_post_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_post.png')
			self.remote_clock_prepost_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_prepost.png')
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setBuildFunc(self.buildEPGSearchEntry)

		if PartnerBoxIconsEnabled:
			# Partnerbox Clock Icons
			self.remote_clock_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock.png')
			self.remote_clock_add_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_add.png')
			self.remote_clock_pre_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_pre.png')
			self.remote_clock_post_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_post.png')
			self.remote_clock_prepost_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_prepost.png')
Example #7
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer = None):
		EPGList.__init__(self, type, selChangedCB, timer)
		tlf = TemplatedListFonts()
		self.l.setFont(0, gFont(tlf.face(tlf.SMALL), tlf.size(tlf.SMALL)))
		self.PTpicture = LoadPixmap(cached=True, path="/usr/lib/enigma2/python/Plugins/Extensions/MerlinEPG/primetime.png")
		self.evCnt = 0

		sizes = componentSizes[MerlinEPGList.SKIN_COMPONENT_KEY]
		self._textHeight = sizes.get(MerlinEPGList.SKIN_COMPONENT_TEXT_HEIGHT, 40)
		self._iconWidth = sizes.get(MerlinEPGList.SKIN_COMPONENT_ICON_WIDTH, 21)
		self._iconHeight = sizes.get(MerlinEPGList.SKIN_COMPONENT_ICON_HEIGHT, 21)
		self._itemMargin = sizes.get(MerlinEPGList.SKIN_COMPONENT_ITEM_MARGIN, 100)
Example #8
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setBuildFunc(self.buildEPGSearchEntry)

		if PartnerBoxIconsEnabled:
			# Partnerbox Clock Icons
			self.partnerbox_clocks = [ LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'Extensions/EPGSearchicons/epgclock_add.png')),
					LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'Extensions/EPGSearch/icons/epgclock_pre.png')),
					LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'Extensions/EPGSearch/icons/epgclock.png')),
					LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'Extensions/EPGSearch/icons/epgclock_prepost.png')),
					LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'Extensions/EPGSearch/icons/epgclock_post.png')),
					LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'Extensions/EPGSearchicons/epgclock_add.png'))]
Example #9
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		if config.plugins.epgsearch.picons.value:
			self.l.setItemHeight(34)
		self.l.setFont(1, gFont("Regular", 18))
		self.l.setBuildFunc(self.buildEPGSearchEntry)
		self.picon = ePicLoad()
		self.iconSize = 21
		self.iconDistance = 2
		self.nextIcon = self.iconSize + 2 * self.iconDistance
		self.colGap = 10
		self.skinColumns = False
		self.tw = 90
		self.dy = 0
		self.piconSize = 50,30
		self.piconDistance = 5
		self.pboxDistance = 80

		def loadPixmap(name):
			pixmap = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/%s" % name))
			if pixmap is None:
				pixmap = LoadPixmap("/usr/lib/enigma2/python/Plugins/Extensions/EPGSearch/icons/%s" % name)
			return pixmap

		if PartnerBoxIconsEnabled:
			self.remote_clock_pixmap = loadPixmap("remote_epgclock.png")
			self.remote_clock_add_pixmap = loadPixmap("remote_epgclock_add.png")
			self.remote_clock_pre_pixmap = loadPixmap("remote_epgclock_pre.png")
			self.remote_clock_post_pixmap = loadPixmap("remote_epgclock_post.png")
			self.remote_clock_prepost_pixmap = loadPixmap("remote_epgclock_prepost.png")

			if PartnerBoxZapRepIcons:
				self.remote_zapclock_pixmap = loadPixmap("remote_zapclock.png")
				self.remote_zapclock_add_pixmap = loadPixmap("remote_zapclock_add.png")
				self.remote_zapclock_pre_pixmap = loadPixmap("remote_zapclock_pre.png")
				self.remote_zapclock_post_pixmap = loadPixmap("remote_zapclock_post.png")
				self.remote_zapclock_prepost_pixmap = loadPixmap("remote_zapclock_prepost.png")
				self.remote_repclock_pixmap = loadPixmap("remote_repepgclock.png")
				self.remote_repclock_add_pixmap = loadPixmap("remote_repepgclock_add.png")
				self.remote_repclock_pre_pixmap = loadPixmap("remote_repepgclock_pre.png")
				self.remote_repclock_post_pixmap = loadPixmap("remote_repepgclock_post.png")
				self.remote_repclock_prepost_pixmap = loadPixmap("remote_repepgclock_prepost.png")
				self.remote_repzapclock_pixmap = loadPixmap("remote_repzapclock.png")
				self.remote_repzapclock_add_pixmap = loadPixmap("remote_repzapclock_add.png")
				self.remote_repzapclock_pre_pixmap = loadPixmap("remote_repzapclock_pre.png")
				self.remote_repzapclock_post_pixmap = loadPixmap("remote_repzapclock_post.png")
				self.remote_repzapclock_prepost_pixmap = loadPixmap("remote_repzapclock_prepost.png")
Example #10
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		if config.plugins.epgsearch.picons.value:
			self.l.setItemHeight(34)
		self.l.setFont(1, gFont("Regular", 18))
		self.l.setBuildFunc(self.buildEPGSearchEntry)
		self.picon = ePicLoad()
		self.iconSize = 21
		self.iconDistance = 2
		self.nextIcon = self.iconSize + 2 * self.iconDistance
		self.colGap = 10
		self.skinColumns = False
		self.tw = 90
		self.dy = 0
		self.piconSize = 50,30
		self.piconDistance = 5
		self.pboxDistance = 80

		def loadPixmap(name):
			pixmap = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/%s" % name))
			if pixmap is None:
				pixmap = LoadPixmap("/usr/lib/enigma2/python/Plugins/Extensions/EPGSearch/icons/%s" % name)
			return pixmap

		if PartnerBoxIconsEnabled:
			self.remote_clock_pixmap = loadPixmap("remote_epgclock.png")
			self.remote_clock_add_pixmap = loadPixmap("remote_epgclock_add.png")
			self.remote_clock_pre_pixmap = loadPixmap("remote_epgclock_pre.png")
			self.remote_clock_post_pixmap = loadPixmap("remote_epgclock_post.png")
			self.remote_clock_prepost_pixmap = loadPixmap("remote_epgclock_prepost.png")

			if PartnerBoxZapRepIcons:
				self.remote_zapclock_pixmap = loadPixmap("remote_zapclock.png")
				self.remote_zapclock_add_pixmap = loadPixmap("remote_zapclock_add.png")
				self.remote_zapclock_pre_pixmap = loadPixmap("remote_zapclock_pre.png")
				self.remote_zapclock_post_pixmap = loadPixmap("remote_zapclock_post.png")
				self.remote_zapclock_prepost_pixmap = loadPixmap("remote_zapclock_prepost.png")
				self.remote_repclock_pixmap = loadPixmap("remote_repepgclock.png")
				self.remote_repclock_add_pixmap = loadPixmap("remote_repepgclock_add.png")
				self.remote_repclock_pre_pixmap = loadPixmap("remote_repepgclock_pre.png")
				self.remote_repclock_post_pixmap = loadPixmap("remote_repepgclock_post.png")
				self.remote_repclock_prepost_pixmap = loadPixmap("remote_repepgclock_prepost.png")
				self.remote_repzapclock_pixmap = loadPixmap("remote_repzapclock.png")
				self.remote_repzapclock_add_pixmap = loadPixmap("remote_repzapclock_add.png")
				self.remote_repzapclock_pre_pixmap = loadPixmap("remote_repzapclock_pre.png")
				self.remote_repzapclock_post_pixmap = loadPixmap("remote_repzapclock_post.png")
				self.remote_repzapclock_prepost_pixmap = loadPixmap("remote_repzapclock_prepost.png")
Example #11
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setBuildFunc(self.buildEPGSearchEntry)

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

		if PartnerBoxIconsEnabled:
			# Partnerbox Clock Icons
			self.remote_clock_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock.png')
			self.remote_clock_add_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_add.png')
			self.remote_clock_pre_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_pre.png')
			self.remote_clock_post_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_post.png')
			self.remote_clock_prepost_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_prepost.png')
Example #12
0
    def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
        EPGList.__init__(self, type, selChangedCB, timer)
        self.listSizeWidth = None
        self.screenwidth = getDesktop(0).size().width()
        if self.screenwidth and self.screenwidth == 1920:
            self.posx, self.posy, self.picx, self.picy, self.gap = skinparameter.get(
                "EpgListIcon", (2, 13, 25, 25, 2))
        else:
            self.posx, self.posy, self.picx, self.picy, self.gap = skinparameter.get(
                "EpgListIcon", (1, 11, 23, 23, 1))
        self.l.setBuildFunc(self.buildEPGSearchEntry)

        if PartnerBoxIconsEnabled:
            # Partnerbox Clock Icons
            self.partnerbox_clocks = [
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               "Extensions/EPGSearch/icons/epgclock_add.png")),
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               "Extensions/EPGSearch/icons/epgclock_pre.png")),
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               "Extensions/EPGSearch/icons/epgclock.png")),
                LoadPixmap(
                    cached=True,
                    path=resolveFilename(
                        SCOPE_PLUGINS,
                        "Extensions/EPGSearch/icons/epgclock_prepost.png")),
                LoadPixmap(
                    cached=True,
                    path=resolveFilename(
                        SCOPE_PLUGINS,
                        "Extensions/EPGSearch/icons/epgclock_post.png")),
                LoadPixmap(cached=True,
                           path=resolveFilename(
                               SCOPE_PLUGINS,
                               "Extensions/EPGSearchicons/epgclock_add.png"))
            ]
Example #13
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.listSizeWidth = None
		self.screenwidth = getDesktop(0).size().width()
		if self.screenwidth and self.screenwidth == 1920:
			self.posx, self.posy , self.picx, self.picy, self.gap = skinparameter.get("EpgListIcon", (2,13,25,25,2))
		else:
			self.posx, self.posy , self.picx, self.picy, self.gap = skinparameter.get("EpgListIcon", (1,11,23,23,1))
		self.l.setBuildFunc(self.buildEPGSearchEntry)

		if PartnerBoxIconsEnabled:
			# Partnerbox Clock Icons
			self.partnerbox_clocks = [
				LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, "Extensions/EPGSearch/icons/epgclock_add.png")),
				LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, "Extensions/EPGSearch/icons/epgclock_pre.png")),
				LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, "Extensions/EPGSearch/icons/epgclock.png")),
				LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, "Extensions/EPGSearch/icons/epgclock_prepost.png")),
				LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, "Extensions/EPGSearch/icons/epgclock_post.png")),
				LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, "Extensions/EPGSearchicons/epgclock_add.png"))
			]
Example #14
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setBuildFunc(self.buildEPGSearchEntry)

		self.piconLoader = PiconLoader()

		sizes = componentSizes[EPGList.SKIN_COMPONENT_KEY]
		self._iconWidth = sizes.get(EPGList.SKIN_COMPONENT_ICON_WIDTH, 21)
		self._iconHeight = sizes.get(EPGList.SKIN_COMPONENT_ICON_HEIGHT, 21)
		self._iconHPos = sizes.get(EPGList.SKIN_COMPONENT_ICON_HPOS, 4)
		self._itemMargin = sizes.get(EPGList.SKIN_COMPONENT_ITEM_MARGIN, 10)

		servicelist_sizes = componentSizes["ServiceList"]
		self._picon_width = servicelist_sizes.get(ServiceList.KEY_PICON_WIDTH, 58)

		if PartnerBoxIconsEnabled:
			# Partnerbox Clock Icons
			self.remote_clock_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock.png')
			self.remote_clock_add_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_add.png')
			self.remote_clock_pre_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_pre.png')
			self.remote_clock_post_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_post.png')
			self.remote_clock_prepost_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_prepost.png')
Example #15
0
	def __init__(self, session, servicelist=None):
		Screen.__init__(self, session)
		self.session = session
		self.myServices = []
		self.myBqts = []
		self.list = []
		self.srvList = servicelist
		self.CheckForEPG = eTimer()
		self.CheckForEPG.callback.append(self.CheckItNow)
		self["currCh"] = Label(_("Channel"))
		self["fullEventInfo"] = Label(" ")
		self["prg_list"] = MenuList(self.getChannels())
		self["epg_list"] = EPGList(type=EPG_TYPE_SINGLE, selChangedCB=self.onSelectionChanged, timer=session.nav.RecordTimer)
		self["actions"] = ActionMap(["OkCancelActions", "EPGSelectActions", "ColorActions", "DirectionActions", "MenuActions", "HelpActions", "InfobarActions"], {
									"ok": self.ok,
									"cancel": self.close,
									"nextBouquet": self.prgDown,
									"prevBouquet": self.prgUp,
									"nextService": self.prgPlus,
									"prevService": self.prgMinus,
									"red": self.ZapTo,
									"green": self.timerAdd,
									"blue": self.ZapForRefresh,
									"yellow": self.go2now,
									"info": self.ok,
									"menu": self.menuClicked,
									"displayHelp": self.myhelp,
									"right": self.right,
									"rightRepeated": self.right,
									"left": self.left,
									"leftRepeated": self.left,
									"up": self.up,
									"upRepeated": self.up,
									"down": self.down,
									"downRepeated": self.down,
									"showMovies": self.editCurTimer,
									"showTv": self.fullEPGlist,
									"showRadio": self.runEpgSeartch
									}, -2)
		self.onLayoutFinish.append(self.onLayoutReady)
Example #16
0
    def __init__(self,
                 session,
                 service,
                 zapFunc=None,
                 eventid=None,
                 bouquetChangeCB=None,
                 serviceChangeCB=None):
        Screen.__init__(self, session)
        self.bouquetChangeCB = bouquetChangeCB
        self.serviceChangeCB = serviceChangeCB
        self.ask_time = -1  #now
        self["key_red"] = Button("")
        self.closeRecursive = False
        self.saved_title = None
        self["Service"] = ServiceEvent()
        self["Event"] = Event()
        self.session = session
        if isinstance(service, str) and eventid != None:
            self.type = EPG_TYPE_SIMILAR
            self["key_yellow"] = Button()
            self["key_blue"] = Button()
            self["key_red"] = Button()
            self.currentService = service
            self.eventid = eventid
            self.zapFunc = None
        elif isinstance(service, eServiceReference) or isinstance(
                service, str):
            self.type = EPG_TYPE_SINGLE
            self["key_yellow"] = Button()
            self["key_blue"] = Button()
            self.currentService = ServiceReference(service)
            self.zapFunc = zapFunc
            self.sort_type = 0
            self.setSortDescription()
        else:
            self.skinName = "EPGSelectionMulti"
            self.type = EPG_TYPE_MULTI
            self["key_yellow"] = Button(
                pgettext("button label, 'previous screen'", "Prev"))
            self["key_blue"] = Button(
                pgettext("button label, 'next screen'", "Next"))
            self["now_button"] = Pixmap()
            self["next_button"] = Pixmap()
            self["more_button"] = Pixmap()
            self["now_button_sel"] = Pixmap()
            self["next_button_sel"] = Pixmap()
            self["more_button_sel"] = Pixmap()
            self["now_text"] = Label()
            self["next_text"] = Label()
            self["more_text"] = Label()
            self["date"] = Label()
            self.services = service
            self.zapFunc = zapFunc

        self["key_green"] = Button(_("Add timer"))
        self.key_green_choice = self.ADD_TIMER
        self.key_red_choice = self.EMPTY
        self["list"] = EPGList(type=self.type,
                               selChangedCB=self.onSelectionChanged,
                               timer=session.nav.RecordTimer)

        self["actions"] = ActionMap(
            ["EPGSelectActions", "OkCancelActions"],
            {
                "cancel": self.closeScreen,
                "ok": self.eventSelected,
                "timerAdd": self.timerAdd,
                "yellow": self.yellowButtonPressed,
                "blue": self.blueButtonPressed,
                "info": self.infoKeyPressed,
                "red": self.zapTo,
                "menu": self.furtherOptions,
                "nextBouquet": self.nextBouquet,  # just used in multi epg yet
                "prevBouquet": self.prevBouquet,  # just used in multi epg yet
                "nextService": self.nextService,  # just used in single epg yet
                "prevService": self.prevService,  # just used in single epg yet
                "preview": self.eventPreview,
            })
        self["actions"].csel = self
        self.onLayoutFinish.append(self.onCreate)
Example #17
0
    def __init__(self,
                 session,
                 service,
                 zapFunc=None,
                 eventid=None,
                 bouquetChangeCB=None,
                 serviceChangeCB=None,
                 isEPGBar=None,
                 switchBouquet=None,
                 EPGNumberZap=None,
                 togglePiP=None):
        Screen.__init__(self, session)
        self.screentitle = _("EPG Selection")
        self.bouquetChangeCB = bouquetChangeCB
        self.serviceChangeCB = serviceChangeCB
        self.switchBouquet = switchBouquet
        self.EPGNumberZap = EPGNumberZap
        self.togglePiP = None
        self.ask_time = -1  #now
        self["key_red"] = Button("")
        self.closeRecursive = False
        self.saved_title = None
        self["Service"] = ServiceEvent()
        self["Event"] = Event()
        if isinstance(service, str) and eventid != None:
            self.type = EPG_TYPE_SIMILAR
            self["key_yellow"] = Button()
            self["key_blue"] = Button()
            self["key_red"] = Button()
            self.currentService = service
            self.eventid = eventid
            self.zapFunc = None
        elif isEPGBar and (isinstance(service, eServiceReference)
                           or isinstance(service, str)):
            self.skinName = ["EPGSelectionEPGBar_SD"]
            if session.desktop.size().width() > 720:
                self.skinName = ["EPGSelectionEPGBar_HD"]
            self.type = EPG_TYPE_EPGBAR
            self["key_yellow"] = Button()
            self["key_blue"] = Button()
            self.currentService = ServiceReference(service)
            self.zapFunc = zapFunc
            self.togglePiP = togglePiP
            self.sort_type = 0
            self.setSortDescription()

            self["EPGBarActions"] = ActionMap(
                ["DirectionActions", "OkCancelActions", "InfobarSeekActions"],
                {
                    "cancel": self.closeScreen,
                    "ok": self.zapTo,
                    "left": self.prevService,
                    "right": self.nextService,
                    "playpauseService": self.setPiPService,
                }, -1)

            self["EPGBarActions"].csel = self

        elif isinstance(service, eServiceReference) or isinstance(
                service, str):
            self.type = EPG_TYPE_SINGLE
            self["key_yellow"] = Button()
            self["key_blue"] = Button()
            self.currentService = ServiceReference(service)
            self.zapFunc = zapFunc
            self.sort_type = 0
            self.setSortDescription()
        else:
            self.skinName = "EPGSelectionMulti"
            self.type = EPG_TYPE_MULTI
            self["key_yellow"] = Button(_("Prev"))
            self["key_blue"] = Button(_("Next"))
            self["now_button"] = Pixmap()
            self["next_button"] = Pixmap()
            self["more_button"] = Pixmap()
            self["now_button_sel"] = Pixmap()
            self["next_button_sel"] = Pixmap()
            self["more_button_sel"] = Pixmap()
            self["now_text"] = Label()
            self["next_text"] = Label()
            self["more_text"] = Label()
            self["date"] = Label()
            self.services = service
            self.zapFunc = zapFunc

        self["key_green"] = Button(_("Add timer"))
        self.key_green_choice = self.ADD_TIMER
        self.key_red_choice = self.EMPTY
        self["list"] = EPGList(type=self.type,
                               selChangedCB=self.onSelectionChanged,
                               timer=session.nav.RecordTimer)

        self["actions"] = ActionMap(
            ["EPGSelectActions", "OkCancelActions"],
            {
                "cancel": self.closeScreen,
                "ok": self.eventSelected,
                "timerAdd": self.timerAdd,
                "timerEnableDisable": self.timerEnableDisable,
                "instantToggleTimerState": self.instantToggleTimerState,
                "instantTimer": self.addInstantTimer,
                "yellow": self.yellowButtonPressed,
                "blue": self.blueButtonPressed,
                "info": self.infoKeyPressed,
                "red": self.zapTo,
                "input_date_time": self.enterDateTime,
                "nextBouquet": self.nextBouquet,  # just used in multi epg yet
                "prevBouquet": self.prevBouquet,  # just used in multi epg yet
                "nextService": self.nextService,  # just used in single epg yet
                "prevService": self.prevService,  # just used in single epg yet
            })
        self["actions"].csel = self

        if EPGNumberZap:
            self["EPGBarNumberActions"] = NumberActionMap(
                ["NumberActions"], {
                    "1": self.keyNumberGlobal,
                    "2": self.keyNumberGlobal,
                    "3": self.keyNumberGlobal,
                    "4": self.keyNumberGlobal,
                    "5": self.keyNumberGlobal,
                    "6": self.keyNumberGlobal,
                    "7": self.keyNumberGlobal,
                    "8": self.keyNumberGlobal,
                    "9": self.keyNumberGlobal,
                })

        self.onLayoutFinish.append(self.onCreate)
Example #18
0
		def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
			EPGSearchList.__init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None)
			EPGList.__init__(self, type, selChangedCB, timer)
			self.l.setBuildFunc(self.buildEPGSearchEntry)
Example #19
0
		def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
			EPGSearchList.__init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None)
			EPGList.__init__(self, type, selChangedCB, timer)
			self.l.setBuildFunc(self.buildEPGSearchEntry)
Example #20
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer = None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setFont(0, gFont("Regular", 18))
		self.PTpicture = LoadPixmap(cached=True, path="/usr/lib/enigma2/python/Plugins/Extensions/MerlinEPG/primetime.png")
		self.evCnt = 0
Example #21
0
    def __init__(self,
                 session,
                 service,
                 zapFunc=None,
                 eventid=None,
                 bouquetChangeCB=None,
                 serviceChangeCB=None,
                 parent=None):
        Screen.__init__(self, session)
        self.bouquetChangeCB = bouquetChangeCB
        self.serviceChangeCB = serviceChangeCB
        self.ask_time = -1  #now
        self["key_red"] = StaticText("")
        self.closeRecursive = False
        self.saved_title = None
        self["Service"] = ServiceEvent()
        self["Event"] = Event()
        self.session = session
        self.Console = Console()
        if isinstance(service, str) and eventid is not None:
            self.type = EPG_TYPE_SIMILAR
            self.setTitle(_("Similar EPG"))
            self["key_yellow"] = StaticText()
            self["key_blue"] = StaticText()
            self["key_red"] = StaticText()
            self.currentService = service
            self.eventid = eventid
            self.zapFunc = None
        elif isinstance(service, eServiceReference) or isinstance(
                service, str):
            self.setTitle(_("Single EPG"))
            self.type = EPG_TYPE_SINGLE
            self["key_yellow"] = StaticText()
            self["key_blue"] = StaticText(_("Select Channel"))
            self.currentService = ServiceReference(service)
            self.zapFunc = zapFunc
            self.sort_type = 0
            self.setSortDescription()
        else:
            self.setTitle(_("Multi EPG"))
            self.skinName = "EPGSelectionMulti"
            self.type = EPG_TYPE_MULTI
            if self.bouquetChangeCB == StaticText:
                self["key_yellow"] = StaticText(
                    pgettext("button label, 'previous screen'", "Prev"))
                self["key_blue"] = StaticText(
                    pgettext("button label, 'next screen'", "Next"))
            else:
                self["key_yellow"] = Button(
                    pgettext("button label, 'previous screen'", "Prev"))
                self["key_blue"] = Button(
                    pgettext("button label, 'next screen'", "Next"))
            self["now_button"] = Pixmap()
            self["next_button"] = Pixmap()
            self["more_button"] = Pixmap()
            self["now_button_sel"] = Pixmap()
            self["next_button_sel"] = Pixmap()
            self["more_button_sel"] = Pixmap()
            self["now_text"] = Label()
            self["next_text"] = Label()
            self["more_text"] = Label()
            self["date"] = Label()
            self.services = service
            self.zapFunc = zapFunc
        self.parent = parent
        if self.bouquetChangeCB == StaticText:
            self["key_green"] = StaticText(_("Add timer"))
        else:
            self["key_green"] = Button(_("Add timer"))
        self.key_green_choice = self.ADD_TIMER
        self.key_red_choice = self.EMPTY
        self["list"] = EPGList(type=self.type,
                               selChangedCB=self.onSelectionChanged,
                               timer=session.nav.RecordTimer)

        self["actions"] = ActionMap(
            ["EPGSelectActions", "OkCancelActions"],
            {
                "cancel": self.closeScreen,
                "ok": self.eventSelected,
                "timerAdd": self.timerAdd,
                "yellow": self.yellowButtonPressed,
                "blue": self.blueButtonPressed,
                "info": self.infoKeyPressed,
                "menu": self.furtherOptions,
                "nextBouquet": self.nextBouquet,  # just used in multi epg yet
                "prevBouquet": self.prevBouquet,  # just used in multi epg yet
                "nextService": self.nextService,  # just used in single epg yet
                "prevService": self.prevService,  # just used in single epg yet
                "preview": self.eventPreview,
            })

        self['colouractions'] = HelpableActionMap(
            self, 'ColorActions',
            {"red": (self.GoToTmbd, _("Search event in TMBD"))})

        self.isTMBD = fileExists(
            resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo"))
        if self.isTMBD:
            self["key_red"] = Button(_("Search TMBD"))
            self.select = True
        if not self.isTMBD:
            self["key_red"] = Button(_("TMBD Not Installed"))
            self.select = False
        try:
            from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
            description = _("Search yt-trailer for event")
        except ImportError as ie:
            pass
        else:
            if baseEPGSelection__init__ is not None:
                self["trailerActions"] = ActionMap(
                    ["InfobarActions", "InfobarTeletextActions"], {
                        "showTv": self.showTrailer,
                        "showRadio": self.showTrailerList,
                        "startTeletext": self.showConfig
                    })
        self["actions"].csel = self
        if parent and hasattr(parent, "fallbackTimer"):
            self.fallbackTimer = parent.fallbackTimer
            self.onLayoutFinish.append(self.onCreate)
        else:
            self.fallbackTimer = FallbackTimerList(self, self.onCreate)
Example #22
0
 def __init__(self,
              session,
              service,
              zapFunc=None,
              eventid=None,
              bouquetChangeCB=None,
              serviceChangeCB=None,
              parent=None):
     Screen.__init__(self, session)
     self.bouquetChangeCB = bouquetChangeCB
     self.serviceChangeCB = serviceChangeCB
     self.ask_time = -1
     self['key_red'] = Button('')
     self.closeRecursive = False
     self.saved_title = None
     self['Service'] = ServiceEvent()
     self['Event'] = Event()
     self.session = session
     if isinstance(service, str) and eventid != None:
         self.type = EPG_TYPE_SIMILAR
         self.setTitle(_('Similar EPG'))
         self['key_yellow'] = Button()
         self['key_blue'] = Button()
         self['key_red'] = Button()
         self.currentService = service
         self.eventid = eventid
         self.zapFunc = None
     elif isinstance(service, eServiceReference) or isinstance(
             service, str):
         self.setTitle(_('Single EPG'))
         self.type = EPG_TYPE_SINGLE
         self['key_yellow'] = Button()
         self['key_blue'] = Button(_('Select Channel'))
         self.currentService = ServiceReference(service)
         self.zapFunc = zapFunc
         self.sort_type = 0
         self.setSortDescription()
     else:
         self.setTitle(_('Multi EPG'))
         self.skinName = 'EPGSelectionMulti'
         self.type = EPG_TYPE_MULTI
         self['key_yellow'] = Button(
             pgettext("button label, 'previous screen'", 'Prev'))
         self['key_blue'] = Button(
             pgettext("button label, 'next screen'", 'Next'))
         self['now_button'] = Pixmap()
         self['next_button'] = Pixmap()
         self['more_button'] = Pixmap()
         self['now_button_sel'] = Pixmap()
         self['next_button_sel'] = Pixmap()
         self['more_button_sel'] = Pixmap()
         self['now_text'] = Label()
         self['next_text'] = Label()
         self['more_text'] = Label()
         self['date'] = Label()
         self.services = service
         self.zapFunc = zapFunc
     self.parent = parent
     self['key_green'] = Button(_('Add timer'))
     self.key_green_choice = self.ADD_TIMER
     self.key_red_choice = self.EMPTY
     self['list'] = EPGList(type=self.type,
                            selChangedCB=self.onSelectionChanged,
                            timer=session.nav.RecordTimer)
     self['actions'] = ActionMap(
         ['EPGSelectActions', 'OkCancelActions'], {
             'cancel': self.closeScreen,
             'ok': self.eventSelected,
             'timerAdd': self.timerAdd,
             'yellow': self.yellowButtonPressed,
             'blue': self.blueButtonPressed,
             'info': self.infoKeyPressed,
             'red': self.zapTo,
             'menu': self.furtherOptions,
             'nextBouquet': self.nextBouquet,
             'prevBouquet': self.prevBouquet,
             'nextService': self.nextService,
             'prevService': self.prevService,
             'preview': self.eventPreview
         })
     self['actions'].csel = self
     self.onLayoutFinish.append(self.onCreate)
Example #23
0
	def __init__(self, type=EPG_TYPE_SINGLE, selChangedCB=None, timer=None):
		EPGList.__init__(self, type, selChangedCB, timer)
		self.l.setFont(0, gFont("Regular", 18))
		self.PTpicture = LoadPixmap(cached=True, path="/usr/lib/enigma2/python/Plugins/Extensions/MerlinEPG/primetime.png")
		self.evCnt = 0