#######################################
# Cool TV Guide by Coolman #
# EPG-Plugin for Enigma2 #
# Coded by Coolman (c) 2010 #
# #
# Version: V2.1.2 #
#######################################
# -*- coding: utf-8 -*-
from skin import parseColor
from os import environ as os_environ
from Components.config import config, ConfigClock, ConfigSubsection, ConfigYesNo, ConfigSubList, ConfigDateTime, ConfigInteger, ConfigSelection, ConfigText, ConfigEnableDisable, KEY_LEFT, KEY_RIGHT, KEY_0, getConfigListEntry, ConfigNumber, ConfigSequence, ConfigBoolean
from Components.Pixmap import Pixmap
from Components.Button import Button
from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap
from Components.AVSwitch import AVSwitch
from Components.HTMLComponent import HTMLComponent
from Components.GUIComponent import GUIComponent
from Components.EpgList import Rect, EPGList
from Components.Sources.Event import Event
from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
from Components.SystemInfo import SystemInfo
from Components.TimerList import TimerList
from Components.ConfigList import ConfigList, ConfigListScreen
from Components.MenuList import MenuList
from Components.UsageConfig import defaultMoviePath
from Components.Label import Label
from Components.Language import language
from Screens.Console import Console
from Plugins.Plugin import PluginDescriptor
from Screens.ChoiceBox import ChoiceBox
from Screens.Screen import Screen
from Screens.EventView import EventViewSimple, EventViewBase
from Screens.TimeDateInput import TimeDateInput
from Screens.TimerEntry import TimerEntry
from Screens.EpgSelection import EPGSelection
from Screens.TimerEdit import TimerSanityConflict
from Screens.LocationBox import MovieLocationBox
from Screens.MessageBox import MessageBox
from Screens.MovieSelection import getPreferredTagEditor
from Screens.ChannelSelection import BouquetSelector
from Tools.Directories import resolveFilename, fileExists, SCOPE_CURRENT_SKIN, SCOPE_PLUGINS, SCOPE_LANGUAGE
from RecordTimer import RecordTimerEntry, parseEvent, AFTEREVENT
from ServiceReference import ServiceReference
from Tools.LoadPixmap import LoadPixmap
from enigma import eEPGCache, eListbox, gFont, eListboxPythonMultiContent, RT_HALIGN_LEFT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, RT_VALIGN_TOP, RT_WRAP, eRect, ePicLoad, getDesktop, eTimer, eServiceCenter, eServiceReference
from time import localtime, time, strftime, mktime
from Tools.Directories import *
from datetime import datetime
import gettext
try:
from Plugins.Extensions.IMDb.plugin import IMDB, IMDBEPGSelection
except ImportError:
IMDB = None
Session = None
Servicelist = None
cool_bouquets = [ ]
man_bouquets = None
bouquetSel = None
epg_bouquet = None
dlg_stack = [ ]
def localeInit():
lang = language.getLanguage()[:2] # getLanguage returns e.g. "fi_FI" for "language_country"
os_environ["LANGUAGE"] = lang # Enigma doesn't set this (or LC_ALL, LC_MESSAGES, LANG). gettext needs it!
gettext.bindtextdomain("CoolTVGuide", resolveFilename(SCOPE_PLUGINS, "Extensions/CoolTVGuide/locale"))
def _(txt):
t = gettext.dgettext("CoolTVGuide", txt)
if t == txt:
print "[CoolTVGuide] fallback to default translation for", txt
t = gettext.gettext(txt)
return t
localeInit()
language.addCallback(localeInit)
#################################################################################
config.misc.Cool_TV_Guide=ConfigSubsection()
config.misc.Cool_TV_Guide.Cool_Red = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "Zap")
config.misc.Cool_TV_Guide.Cool_RedLong = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "Zap + Exit")
config.misc.Cool_TV_Guide.Cool_Green = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "Timer")
config.misc.Cool_TV_Guide.Cool_GreenLong = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "AutoTimer")
config.misc.Cool_TV_Guide.Cool_Yellow = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "CoolSwitch")
config.misc.Cool_TV_Guide.Cool_YellowLong = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "Bouquetlist")
config.misc.Cool_TV_Guide.Cool_Blue = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "Search")
config.misc.Cool_TV_Guide.Cool_BlueLong = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "IMDb Search")
config.misc.Cool_TV_Guide.Cool_OK = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "Channel Info")
config.misc.Cool_TV_Guide.Cool_OKLong = ConfigSelection(choices = [("Zap",_("Zap")), ("Zap + Exit", _("Zap + Exit")), ("Search", _("Search")), ("IMDb Search", _("IMDb Search")), ("CoolSwitch", _("CoolSwitch")), ("Channel Info", _("Channel Info")), ("Timer", _("Timer")), ("QuickRec", _("QuickRec")), ("AutoTimer", _("AutoTimer")), ("Primetime", _("Primetime")), ("Bouquet +", _("Bouquet +")), ("Bouquet -", _("Bouquet -")), ("Bouquetlist", _("Bouquetlist")), ("...", _("..."))], default = "...")
config.misc.Cool_TV_Guide.Cool_Info = ConfigSelection(choices = [("Cool Single Guide", _("Cool Single Guide")), ("Cool TV<>Multi Guide", _("Cool TV<>Multi Guide")), ("Channel Info", _("Channel Info")), ("View Single EPG", _("View Single EPG")), ("...", _("..."))], default = "Cool Single Guide")
config.misc.Cool_TV_Guide.Cool_InfoLong = ConfigSelection(choices = [("Cool Single Guide", _("Cool Single Guide")), ("Cool TV<>Multi Guide", _("Cool TV<>Multi Guide")), ("Channel Info", _("Channel Info")), ("View Single EPG", _("View Single EPG")), ("...", _("..."))], default = "Cool TV<>Multi Guide")
config.misc.Cool_TV_Guide.cool_BlankLine = ConfigSelection(default=" ", choices = [(" ", _(" "))])
config.misc.Cool_TV_Guide.prev_time=ConfigClock(default = time())
config.misc.Cool_TV_Guide.Cool3D = ConfigSelection(choices = [("No", _("No")), ("Standard", _("Standard")), ("SkinDesign", _("SkinDesign")), ("MyDesign", _("MyDesign"))], default = "No")
config.misc.Cool_TV_Guide.CoolPrimetime1 = ConfigInteger(default=20, limits=(0, 23))
config.misc.Cool_TV_Guide.CoolPrimetime2 = ConfigInteger(default=0, limits=(0, 59))
config.misc.Cool_TV_Guide.autostart_bouquet = ConfigSelection(choices = [("No", _("No")), ("Yes", _("Yes"))], default = "No")
config.misc.Cool_TV_Guide.CoolPiconON = ConfigSelection(choices = [("No", _("No")), ("Yes", _("Yes"))], default = "Yes")
config.misc.Cool_TV_Guide.CoolPiconPath = ConfigSelection(choices = [("Picon", _("Picon")), ("CoolPicon", _("CoolPicon"))], default = "Picon")
config.misc.Cool_TV_Guide.CoolPicoON = ConfigSelection(choices = [("No", _("No")), ("Yes", _("Yes"))], default = "Yes")
config.misc.Cool_TV_Guide.CoolPicoPath = ConfigSelection(choices = [("Picon", _("Picon")), ("CoolPicon", _("CoolPicon"))], default = "Picon")
config.misc.Cool_TV_Guide.channel1 = ConfigSelection(choices = [("No", _("No")), ("Yes", _("Yes"))], default = "No")
config.misc.Cool_TV_Guide.coolswitch = ConfigSelection(choices = [("60", _("60")), ("30", _("30"))], default = "60")
config.misc.Cool_TV_Guide.prev_time_period=ConfigInteger(default=180, limits=(60,300))
config.misc.Cool_TV_Guide.Cool_Fontsize = ConfigInteger(default=18, limits=(10, 30))
config.misc.Cool_TV_Guide.Cool_Left_Fontsize = ConfigInteger(default=22, limits=(10, 30))
config.misc.Cool_TV_Guide.Cool_Timeline = ConfigInteger(default=20, limits=(10, 30))
config.misc.Cool_TV_Guide.PiconHeight = ConfigInteger(default=60, limits=(40, 80))
config.misc.Cool_TV_Guide.PiconItemHeight = ConfigInteger(default=60, limits=(40, 80))
config.misc.Cool_TV_Guide.CoolPicoHeight = ConfigInteger(default=30, limits=(10, 60))
config.misc.Cool_TV_Guide.CoolPicoItemHeight = ConfigInteger(default=30, limits=(10, 60))
config.misc.Cool_TV_Guide.cool_left8 = ConfigInteger(default=110, limits=(50, 250))
config.misc.Cool_TV_Guide.cool_left16 = ConfigInteger(default=190, limits=(10, 250))
config.misc.Cool_TV_Guide.overjump = ConfigBoolean(default=False)
config.misc.Cool_TV_Guide.CoolMultiSwitch = ConfigSelection(choices = [("No", _("No")), ("Yes", _("Yes"))], default = "No")
#################################################################################
class CoolSingleGuide(EPGSelection):
def __init__(self, session, service, zapFunc=None, bouquetChangeCB=None, serviceChangeCB=None):
EPGSelection.__init__(self, session, service, zapFunc, bouquetChangeCB, serviceChangeCB)
skinpath = str(resolveFilename)
CoolWide = getDesktop(0).size().width()
if CoolWide == 720:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolSingleGuide_720.xml"
elif CoolWide == 1024:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolSingleGuide_1024.xml"
else:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolSingleGuide_1280.xml"
Cool = open(skin)
self.skin = Cool.read()
Cool.close()
class SingleEPG(EPGSelection):
def __init__(self, session, service, zapFunc=None, bouquetChangeCB=None, serviceChangeCB=None):
EPGSelection.__init__(self, session, service, zapFunc, bouquetChangeCB, serviceChangeCB)
self.skinName = "EPGSelection"
class CoolViewSimple(Screen, EventViewBase):
def __init__(self, session, Event, Ref, callback=None, similarEPGCB=None):
Screen.__init__(self, session)
self.skinName = "EventView"
EventViewBase.__init__(self, Event, Ref, callback, similarEPGCB)
self["key_blue"].setText(_("Search"))
self["Coolman"] = HelpableActionMap(self, "CoolTVGuideActions",
{
"CoolBlue": (self.CoolSearch, _("show your Setup")),
})
def CoolSearch(self):
try:
from Plugins.Extensions.EPGSearch.EPGSearch import EPGSearch
except ImportError:
EPGSearch = None
try:
cur = CoolList.getCurrent()
event = cur[0]
name = event.getEventName()
except:
name = ''
if EPGSearch is not None:
self.session.open(EPGSearch, name , False)
class CoolEPGList(EPGList):
searchCoolPicon = 1
searchCoolPico = 1
if config.misc.Cool_TV_Guide.CoolPiconPath.value == "CoolPicon":
searchCoolPicon = 2
if config.misc.Cool_TV_Guide.CoolPicoPath.value == "CoolPicon":
searchCoolPico = 2
if searchCoolPicon == 1:
searchCoolPiconPaths = ['/usr/share/enigma2/picon/',
'/etc/picon/',
'/media/cf/picon/',
'/var/etc/picon/',
'/media/usb/picon/']
if searchCoolPico == 1:
searchCoolPicoPaths = ['/usr/share/enigma2/picon/coolpico/',
'/etc/picon/coolpico/',
'/media/cf/picon/coolpico/',
'/var/etc/picon/coolpico/',
'/media/usb/picon/coolpico/']
if searchCoolPicon == 2:
searchCoolPiconPaths = ['/usr/share/enigma2/coolpicon/',
'/etc/coolpicon/',
'/media/cf/coolpicon/',
'/var/etc/coolpicon/',
'/media/usb/coolpicon/']
if searchCoolPico == 2:
searchCoolPicoPaths = ['/usr/share/enigma2/coolpicon/coolpico/',
'/etc/coolpicon/coolpico/',
'/media/cf/coolpicon/coolpico/',
'/var/etc/coolpicon/coolpico/',
'/media/usb/coolpicon/coolpico/']
def __init__(self, selChangedCB=None, timer = None, time_epoch = 120, overjump_empty=False):
self.cur_event = None
self.cur_service = None
self.offs = 0
self.timer = timer
self.onSelChanged = [ ]
self.type = CoolEPGList
if selChangedCB is not None:
self.onSelChanged.append(selChangedCB)
GUIComponent.__init__(self)
self.l = eListboxPythonMultiContent()
self.curr_refcool = None
self.coolheight = 40
self.l.setBuildFunc(self.buildEntry)
self.setOverjump_Empty(overjump_empty)
self.epgcache = eEPGCache.getInstance()
self.SDCoolNow = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolNow.png')
self.SDCoolBack = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolBack.png')
self.SDCoolSelect = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolSelect.png')
self.SDCoolRec = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolRec.png')
self.SDCoolNowS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolNowS.png')
self.SDCoolBackS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolBackS.png')
self.SDCoolSelectS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolSelectS.png')
self.SDCoolRecS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolRecS.png')
self.SDCoolPicons = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolPicon.png')
self.SDCoolPiconsSelect = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolPiconSelect.png')
self.SDCoolPiconsS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolPiconS.png')
self.SDCoolPiconsSelectS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/SkinDesign/CoolPiconSelectS.png')
self.MDCoolNow = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolNow.png')
self.MDCoolBack = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolBack.png')
self.MDCoolSelect = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolSelect.png')
self.MDCoolRec = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolRec.png')
self.MDCoolNowS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolNowS.png')
self.MDCoolBackS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolBackS.png')
self.MDCoolSelectS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolSelectS.png')
self.MDCoolRecS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolRecS.png')
self.MDCoolPicons = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolPicon.png')
self.MDCoolPiconsSelect = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolPiconSelect.png')
self.MDCoolPiconsS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolPiconS.png')
self.MDCoolPiconsSelectS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/MyDesign/CoolPiconSelectS.png')
self.CoolNow = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolNow.png')
self.CoolBack = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolBack.png')
self.CoolSelect = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolSelect.png')
self.CoolRec = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolRec.png')
self.CoolNowS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolNowS.png')
self.CoolBackS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolBackS.png')
self.CoolSelectS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolSelectS.png')
self.CoolRecS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolRecS.png')
self.CoolPicons = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolPicon.png')
self.CoolPiconsSelect = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolPiconSelect.png')
self.CoolPiconsS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolPiconS.png')
self.CoolPiconsSelectS = LoadPixmap(cached=True, path='/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/Cool3D/Standard/CoolPiconSelectS.png')
self.time_base = None
self.time_epoch = time_epoch
self.list = None
self.event_rect = None
self.nowForeColor = 0xffffff
self.nowForeColorSelected = 0x000000
self.foreColor = 0xffffff
self.foreColorSelected = 0x000000
self.borderColor = 0xC0C0C0
self.backColor = 0x2D455E
self.backColorSelected = 0xC0C0C0
self.nowBackColor = 0x00825F
self.nowBackColorSelected = 0x4800FF
self.foreColorService = 0xffffff
self.backColorService = 0x000000
def applySkin(self, desktop, screen):
if self.skinAttributes is not None:
attribs = [ ]
for (attrib, value) in self.skinAttributes:
if attrib == "EntryForegroundColor":
self.foreColor = parseColor(value).argb()
elif attrib == "EntryForegroundColorSelected":
self.foreColorSelected = parseColor(value).argb()
elif attrib == "EntryNowForegroundColorSelected":
self.nowForeColorSelected = parseColor(value).argb()
elif attrib == "EntryNowForegroundColor":
self.nowForeColor = parseColor(value).argb()
elif attrib == "EntryBorderColor":
self.borderColor = parseColor(value).argb()
elif attrib == "EntryBackgroundColor":
self.backColor = parseColor(value).argb()
elif attrib == "EntryNowBackgroundColor":
self.nowBackColor = parseColor(value).argb()
elif attrib == "EntryBackgroundColorSelected":
self.backColorSelected = parseColor(value).argb()
elif attrib == "EntryNowBackgroundColorSelected":
self.nowBackColorSelected = parseColor(value).argb()
elif attrib == "ServiceNameForegroundColor":
self.foreColorService = parseColor(value).argb()
elif attrib == "ServiceNameBackgroundColor":
self.backColorService = parseColor(value).argb()
else:
attribs.append((attrib,value))
self.skinAttributes = attribs
rc = GUIComponent.applySkin(self, desktop, screen)
self.setItemsPerPage()
return rc
def isSelectable(self, service, sname, event_list):
return (event_list and len(event_list) and True) or False
def setOverjump_Empty(self, overjump_empty):
if overjump_empty:
self.l.setSelectableFunc(self.isSelectable)
def setEpoch(self, epoch):
self.offs = 0
self.time_epoch = epoch
self.fillCoolTVGuide(None)
def setEpoch2(self, epoch):
self.offs = 0
self.time_epoch = epoch
def getEventFromId(self, service, eventid):
event = None
if self.epgcache is not None and eventid is not None:
event = self.epgcache.lookupEventId(service.ref, eventid)
return event
def moveToService(self,serviceref):
if serviceref is not None:
for x in range(len(self.list)):
if self.list[x][0] == serviceref.toString():
self.instance.moveSelectionTo(x)
break
def getIndexFromService(self, serviceref):
if serviceref is not None:
for x in range(len(self.list)):
if self.list[x][0] == serviceref.toString():
return x
def setCurrentIndex(self, index):
if self.instance is not None:
self.instance.moveSelectionTo(index)
def getCurrent(self):
if self.cur_service is None:
return ( None, None )
old_service = self.cur_service #(service, service_name, events)
events = self.cur_service[2]
refstr = self.cur_service[0]
if self.cur_event is None or not events or not len(events):
return ( None, ServiceReference(refstr) )
event = events[self.cur_event] #(event_id, event_title, begin_time, duration)
eventid = event[0]
service = ServiceReference(refstr)
event = self.getEventFromId(service, eventid)
return ( event, service )
def connectSelectionChanged(func):
if not self.onSelChanged.count(func):
self.onSelChanged.append(func)
def disconnectSelectionChanged(func):
self.onSelChanged.remove(func)
def serviceChanged(self):
cur_sel = self.l.getCurrentSelection()
if cur_sel:
self.findBestEvent()
def findBestEvent(self):
old_service = self.cur_service #(service, service_name, events)
cur_service = self.cur_service = self.l.getCurrentSelection()
last_time = 0;
time_base = self.getTimeBase()
if old_service and self.cur_event is not None:
events = old_service[2]
cur_event = events[self.cur_event] #(event_id, event_title, begin_time, duration)
last_time = cur_event[2]
if last_time < time_base:
last_time = time_base
if cur_service:
self.cur_event = 0
events = cur_service[2]
if events and len(events):
if last_time:
best_diff = 0
best = len(events) #set invalid
idx = 0
for event in events: #iterate all events
ev_time = event[2]
if ev_time < time_base:
ev_time = time_base
diff = abs(ev_time-last_time)
if (best == len(events)) or (diff < best_diff):
best = idx
best_diff = diff
idx += 1
if best != len(events):
self.cur_event = best
else:
self.cur_event = None
self.selEntry(0)
def selectionChanged(self):
for x in self.onSelChanged:
if x is not None:
x()
GUI_WIDGET = eListbox
def setItemsPerPage(self):
global Cool16
ItemHeight = None
Cool16 = config.misc.Cool_TV_Guide.CoolPicoItemHeight.value
if not config.misc.Cool_TV_Guide.coolswitch.value == "30":
self.l.setItemHeight(config.misc.Cool_TV_Guide.PiconItemHeight.value)
self.coolheight = config.misc.Cool_TV_Guide.PiconItemHeight.value
if config.misc.Cool_TV_Guide.coolswitch.value == "30":
self.coolheight = Cool16
self.l.setItemHeight(Cool16)
def setServiceFontsize(self):
self.l.setFont(0, gFont("Regular", config.misc.Cool_TV_Guide.Cool_Left_Fontsize.value))
def setEventFontsize(self):
self.l.setFont(1, gFont("Regular", config.misc.Cool_TV_Guide.Cool_Fontsize.value))
def postWidgetCreate(self, instance):
instance.setWrapAround(True)
instance.selectionChanged.get().append(self.serviceChanged)
instance.setContent(self.l)
self.l.setSelectionClip(eRect(0,0,0,0), False)
self.setServiceFontsize()
self.setEventFontsize()
def preWidgetRemove(self, instance):
instance.selectionChanged.get().remove(self.serviceChanged)
instance.setContent(None)
def recalcEntrySize(self):
esize = self.l.getItemSize()
width = esize.width()
height = esize.height()
xpos = 0;
if self.coolheight >=40:
global ItemHeight
w = config.misc.Cool_TV_Guide.cool_left8.value;
ItemHeight = height;
if self.coolheight <40:
w = config.misc.Cool_TV_Guide.cool_left16.value;
self.service_rect = Rect(xpos, 0, w, height)
xpos += w;
w = width - xpos;
self.event_rect = Rect(xpos, 0, w, height)
def calcEntryPosAndWidthHelper(self, stime, duration, start, end, width):
xpos = (stime - start) * width / (end - start)
ewidth = (stime + duration - start) * width / (end - start) + 1
ewidth -= xpos;
if xpos < 0:
ewidth += xpos;
xpos = 0;
if (xpos+ewidth) > width:
ewidth = width - xpos
return xpos, ewidth
def calcEntryPosAndWidth(self, event_rect, time_base, time_epoch, ev_start, ev_duration):
xpos, width = self.calcEntryPosAndWidthHelper(ev_start, ev_duration, time_base, time_base + time_epoch * 60, event_rect.width())
return xpos+event_rect.left(), width
def buildEntry(self, service, service_name, events):
if service == self.cur_service[0]:
piconbkcolor = 0x000000
else:
piconbkcolor = 0x000000
r1=self.service_rect
r2=self.event_rect
foreColor = self.foreColor
foreColorSelected = self.foreColorSelected
backColor = self.backColor
backColorSelected = self.backColorSelected
borderColor = self.borderColor
backColorService = self.backColorService
backColorOrig = self.backColor # normale Eventsfarbe
CoolEvent = 1
if config.misc.Cool_TV_Guide.Cool3D.value != "No":
CoolEvent = 2
if self.curr_refcool.toString() == service:
# backColor = 0x516b96
# backColorOrig = 0x516b96
backColorService = 0x516b96
res = [ None ]
coolpicon = self.findCoolPicon(service, service_name)
coolpico = self.findCoolPico(service, service_name)
CoolCenter1 = (config.misc.Cool_TV_Guide.PiconItemHeight.value - config.misc.Cool_TV_Guide.PiconHeight.value) / 2
CoolCenter2 = (config.misc.Cool_TV_Guide.CoolPicoItemHeight.value - config.misc.Cool_TV_Guide.CoolPicoHeight.value) / 2
if CoolEvent == 1:
if coolpicon is None and self.coolheight >=40:
res.append(MultiContentEntryText(
pos = (r1.left()+1,r1.top()+1),
size = (r1.width()-2, r1.height()-2),
font = 0, flags = RT_HALIGN_CENTER | RT_VALIGN_CENTER,
text = service_name,
color = self.foreColorService,
border_width = 1, border_color = borderColor,
backcolor = backColorService, backcolor_sel = backColorService)) #backcolor_sel= Event left select
elif self.coolheight >=40:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+CoolCenter1),
size = (r1.width()-2, r1.height()-2),
png = LoadPixmap(coolpicon),
backcolor = piconbkcolor,
backcolor_sel = 0))
if coolpico is None and self.coolheight <40:
res.append(MultiContentEntryText(
pos = (r1.left()+1,r1.top()+1),
size = (r1.width()-2, r1.height()-2),
font = 0, flags = RT_HALIGN_CENTER | RT_VALIGN_CENTER,
text = service_name,
color = self.foreColorService,
border_width = 1, border_color = borderColor,
backcolor = backColorService, backcolor_sel = backColorService)) #backcolor_sel= Event left select
elif self.coolheight <40:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+CoolCenter2),
size = (r1.width()-2, r1.height()-2),
png = LoadPixmap(coolpico),
backcolor = piconbkcolor,
backcolor_sel = 0))
if events:
start = self.time_base+self.offs*self.time_epoch*60
end = start + self.time_epoch * 60
left = r2.left()
top = r2.top()
width = r2.width()
height = r2.height()
coolflags = RT_HALIGN_LEFT | RT_VALIGN_CENTER
thepraefix = " "
if self.coolheight > 30:
coolflags = RT_HALIGN_CENTER | RT_VALIGN_CENTER | RT_WRAP
thepraefix = ""
# if service == self.cur_service[0]:
# backColorSelected = self.backColorSelected
now = int(time())
for ev in events: #(event_id, event_title, begin_time, duration)
rec=ev[2] and self.timer.isInTimer(ev[0], ev[2], ev[3], service)
xpos, ewidth = self.calcEntryPosAndWidthHelper(ev[2], ev[3], start, end, width)
if self.curr_refcool.toString() == service:
backColorOrig = 0x516b96
if ev[2] <= now and (ev[2] + ev[3]) > now:
foreColor = self.nowForeColor
foreColorSelected = self.nowForeColorSelected
backColor = self.nowBackColor
# backColorSelected = self.backColorSelected # Event Selected
else:
backColor = backColorOrig
# backColorSelected = self.backColorSelected
foreColor = self.foreColor
foreColorSelected = self.foreColorSelected
if rec:
cooltyp = self.CoolRecRed(service, ev[2], ev[3], ev[0])
if cooltyp == "record":
backColor = 0xcf5353
backColorSelected = 0xf7664b
elif cooltyp == "justplay":
backColor = 0x669466
backColorSelected = 0x61a161
# elif cooltyp == "nichts" and cooltyp != "record":
# backColor = 0xB6FF00
# backColorSelected = 0xC0FF23
else:
backColor = backColorOrig
backColorSelected = self.backColorSelected
res.append(MultiContentEntryText(
pos = (left+xpos, top), size = (ewidth, height),
font = 1, flags = coolflags,
text = thepraefix + ev[1], color = foreColor, color_sel = foreColorSelected,
backcolor = backColor, backcolor_sel = backColorSelected, border_width = 1, border_color = borderColor)) # Color select Event
else:
left = r2.left()
top = r2.top()
width = r2.width()
height = r2.height()
res.append(MultiContentEntryText(
pos = (left, top), size = (width, height),
font = 1, flags = RT_HALIGN_LEFT | RT_VALIGN_CENTER,
text = " ", color = foreColor, color_sel = foreColorSelected,
border_width = 1, backcolor_sel = backColorSelected, border_color = borderColor))
return res
#######################################################################################################################
if CoolEvent == 2:
if coolpicon is None and self.coolheight >=40:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+1), size = (r1.width()-2, r1.height()-2),
png = self.CoolPiconsdef()))
if self.curr_refcool.toString() == service:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+1), size = (r1.width()-2, r1.height()-2),
png = self.CoolPiconsSelectdef()))
res.append(MultiContentEntryText(
pos = (r1.left()+1,r1.top()+1),
size = (r1.width()-2, r1.height()-2),
font = 0, flags = RT_HALIGN_CENTER | RT_VALIGN_CENTER,
text = service_name,
color = self.foreColorService,
border_width = 1, border_color = 0x000000))
elif self.coolheight >=40:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+CoolCenter1),
size = (r1.width()-2, r1.height()-2),
png = LoadPixmap(coolpicon),
backcolor = piconbkcolor,
backcolor_sel = 0))
if coolpico is None and self.coolheight <40:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+1), size = (r1.width()-2, r1.height()-2),
png = self.CoolPiconsSdef()))
if self.curr_refcool.toString() == service:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+1), size = (r1.width()-2, r1.height()-2),
png = self.CoolPiconsSelectSdef()))
res.append(MultiContentEntryText(
pos = (r1.left()+1,r1.top()+1),
size = (r1.width()-2, r1.height()-2),
font = 0, flags = RT_HALIGN_CENTER | RT_VALIGN_CENTER,
text = service_name,
color = self.foreColorService,
border_width = 1, border_color = 0x000000))
elif self.coolheight <40:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (r1.left()+1,r1.top()+CoolCenter2),
size = (r1.width()-2, r1.height()-2),
png = LoadPixmap(coolpico),
backcolor = piconbkcolor,
backcolor_sel = 0))
if events:
start = self.time_base+self.offs*self.time_epoch*60
end = start + self.time_epoch * 60
left = r2.left()
top = r2.top()
width = r2.width()
height = r2.height()
coolflags = RT_HALIGN_LEFT | RT_VALIGN_CENTER
thepraefix = " "
if self.coolheight > 30:
coolflags = RT_HALIGN_CENTER | RT_VALIGN_CENTER | RT_WRAP
thepraefix = ""
now = int(time())
for ev in events: #(event_id, event_title, begin_time, duration)
rec=ev[2] and self.timer.isInTimer(ev[0], ev[2], ev[3], service)
xpos, ewidth = self.calcEntryPosAndWidthHelper(ev[2], ev[3], start, end, width)
if self.coolheight <40:
if ev[2] <= now and (ev[2] + ev[3]) > now:
foreColor = self.nowForeColor
foreColorSelected = self.nowForeColorSelected
backColor = self.nowBackColor
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolNowSdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
else:
backColor = backColorOrig
backColorSelected = self.backColorSelected
foreColor = self.foreColor
foreColorSelected = self.foreColorSelected
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolBackSdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
if self.curr_refcool.toString() == service:
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolSelectSdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
if rec:
cooltyp = self.CoolRecRed(service, ev[2], ev[3], ev[0])
if cooltyp == "record":
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolRecSdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
backColorSelected = 0x9F0000
elif cooltyp == "justplay":
backColor = 0x669466
backColorSelected = 0x61a161
else:
backColor = backColorOrig
backColorSelected = self.backColorSelected
res.append(MultiContentEntryText(
pos = (left+xpos, top), size = (ewidth, height),
font = 1, flags = coolflags,
text = thepraefix + ev[1], color = foreColor, color_sel = foreColorSelected,
backcolor_sel = backColorSelected, border_width = 2, border_color = 0x000000)) # Color select Event
elif self.coolheight >=40:
if ev[2] <= now and (ev[2] + ev[3]) > now:
foreColor = self.nowForeColor
foreColorSelected = self.nowForeColorSelected
backColor = self.nowBackColor
# Gruen
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolNowdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
else:
backColor = backColorOrig
backColorSelected = self.backColorSelected
foreColor = self.foreColor
foreColorSelected = self.foreColorSelected
# Schwarz
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolBackdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
if self.curr_refcool.toString() == service:
# Blau
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolSelectdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
if rec:
cooltyp = self.CoolRecRed(service, ev[2], ev[3], ev[0])
if cooltyp == "record":
# Rot
res.append(MultiContentEntryPixmapAlphaTest(
pos = (left+xpos, top), size = (ewidth, height),
png = self.CoolRecdef(service, ev[2], ev[3], ev[0]),
backcolor = backColor,
backcolor_sel = backColorSelected))
backColorSelected = 0x9F0000
elif cooltyp == "justplay":
backColor = 0x669466
backColorSelected = 0x61a161
else:
backColor = backColorOrig
backColorSelected = self.backColorSelected
res.append(MultiContentEntryText(
pos = (left+xpos, top), size = (ewidth, height),
font = 1, flags = coolflags,
text = thepraefix + ev[1], color = foreColor, color_sel = foreColorSelected,
backcolor_sel = backColorSelected, border_width = 2, border_color = 0x000000)) # Color select Event
else:
left = r2.left()
top = r2.top()
width = r2.width()
height = r2.height()
res.append(MultiContentEntryText(
pos = (left, top), size = (width, height),
font = 1, flags = RT_HALIGN_LEFT | RT_VALIGN_CENTER,
text = " ", color = foreColor, color_sel = foreColorSelected,
border_width = 2, backcolor_sel = backColorSelected, border_color = 0x000000))
return res
#############################################################################################################################
def findCoolPicon(self, service = None, serviceName = None):
if config.misc.Cool_TV_Guide.CoolPiconON.value == "Yes":
if service is not None:
pos = service.rfind(':')
if pos != -1:
service = service[:pos].rstrip(':').replace(':','_')
pngname = "/tmp/cool3dpicon/" + service + ".png"
if fileExists(pngname):
return pngname
if serviceName is not None:
pngname = "/tmp/cool3dpicon/" + serviceName + ".png"
if fileExists(pngname):
return pngname
if service is not None:
for path in self.searchCoolPiconPaths:
pngname = path + service + ".png"
if fileExists(pngname):
return pngname
if serviceName is not None:
for path in self.searchCoolPiconPaths:
pngname = path + serviceName + ".png"
if fileExists(pngname):
return pngname
def findCoolPico(self, service = None, serviceName = None):
if config.misc.Cool_TV_Guide.CoolPicoON.value == "Yes":
if service is not None:
pos = service.rfind(':')
if pos != -1:
service = service[:pos].rstrip(':').replace(':','_')
pngname = "/tmp/cool3dpico/" + service + ".png"
if fileExists(pngname):
return pngname
if serviceName is not None:
pngname = "/tmp/cool3dpico/" + serviceName + ".png"
if fileExists(pngname):
return pngname
if service is not None:
for path in self.searchCoolPicoPaths:
pngname = path + service + ".png"
if fileExists(pngname):
return pngname
if serviceName is not None:
for path in self.searchCoolPicoPaths:
pngname = path + serviceName + ".png"
if fileExists(pngname):
return pngname
def selEntry(self, dir, visible=True):
cur_service = self.cur_service #(service, service_name, events)
self.recalcEntrySize()
valid_event = self.cur_event is not None
if cur_service:
update = True
entries = cur_service[2]
if dir == 0: #current
update = False
elif dir == +1: #next
if valid_event and self.cur_event+1 < len(entries):
self.cur_event+=1
else:
self.offs += 1
self.fillCoolTVGuide(None) # refill
return True
elif dir == -1: #prev
if valid_event and self.cur_event-1 >= 0:
self.cur_event-=1
elif self.offs > 0:
self.offs -= 1
self.fillCoolTVGuide(None) # refill
return True
elif dir == +2: #next page
self.offs += 1
self.fillCoolTVGuide(None) # refill
return True
elif dir == -2: #prev
if self.offs > 0:
self.offs -= 1
self.fillCoolTVGuide(None) # refill
return True
self.l.setSelectionClip(eRect(self.service_rect.left(), self.service_rect.top(), self.service_rect.width(), self.service_rect.height()), False) # left Picon select
if cur_service and valid_event:
entry = entries[self.cur_event] #(event_id, event_title, begin_time, duration)
time_base = self.time_base+self.offs*self.time_epoch*60
xpos, width = self.calcEntryPosAndWidth(self.event_rect, time_base, self.time_epoch, entry[2], entry[3])
self.l.setSelectionClip(eRect(xpos, 0, width, self.event_rect.height()), visible and update)
else:
self.l.setSelectionClip(eRect(self.event_rect.left(), self.event_rect.top(), self.event_rect.width(), self.event_rect.height()), False)
self.selectionChanged()
return False
def queryEPG(self, list, buildFunc=None):
if self.epgcache is not None:
if buildFunc is not None:
return self.epgcache.lookupEvent(list, buildFunc)
else:
return self.epgcache.lookupEvent(list)
return [ ]
def fillCoolTVGuide(self, services, stime=-1):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign" and self.SDCoolNow is None:
config.misc.Cool_TV_Guide.Cool3D.value = "Standard"
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign" and self.MDCoolNow is None:
config.misc.Cool_TV_Guide.Cool3D.value = "Standard"
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard" and self.CoolNow is None:
config.misc.Cool_TV_Guide.Cool3D.value = "No"
if services is None:
time_base = self.time_base+self.offs*self.time_epoch*60
test = [ (service[0], 0, time_base, self.time_epoch) for service in self.list ]
else:
self.cur_event = None
self.cur_service = None
self.time_base = int(stime)
test = [ (service.ref.toString(), 0, self.time_base, self.time_epoch) for service in services ]
test.insert(0, 'XRnITBD')
epg_data = self.queryEPG(test)
self.list = [ ]
tmp_list = None
service = ""
sname = ""
for x in epg_data:
if service != x[0]:
if tmp_list is not None:
self.list.append((service, sname, tmp_list[0][0] is not None and tmp_list or None))
service = x[0]
sname = x[1]
tmp_list = [ ]
tmp_list.append((x[2], x[3], x[4], x[5]))
if tmp_list and len(tmp_list):
self.list.append((service, sname, tmp_list[0][0] is not None and tmp_list or None))
self.l.setList(self.list)
self.findBestEvent()
def getEventRect(self):
rc = self.event_rect
return Rect( rc.left() + (self.instance and self.instance.position().x() or 0), rc.top(), rc.width(), rc.height() )
def getTimeEpoch(self):
return self.time_epoch
def getTimeBase(self):
return self.time_base + (self.offs * self.time_epoch * 60)
def resetOffset(self):
self.offs = 0
def CoolPiconsdef(self):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolPicons
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolPicons
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolPicons
def CoolPiconsSelectdef(self):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolPiconsSelect
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolPiconsSelect
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolPiconsSelect
def CoolPiconsSdef(self):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolPiconsS
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolPiconsS
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolPiconsS
def CoolPiconsSelectSdef(self):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolPiconsSelectS
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolPiconsSelectS
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolPiconsSelectS
def CoolNowdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolNow
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolNow
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolNow
def CoolBackdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolBack
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolBack
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolBack
def CoolSelectdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolSelect
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolSelect
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolSelect
def CoolRecdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolRec
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolRec
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolRec
def CoolNowSdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolNowS
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolNowS
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolNowS
def CoolBackSdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolBackS
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolBackS
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolBackS
def CoolSelectSdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolSelectS
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolSelectS
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolSelectS
def CoolRecSdef(self, refstr, beginTime, duration, eventId):
if config.misc.Cool_TV_Guide.Cool3D.value == "SkinDesign":
return self.SDCoolRecS
if config.misc.Cool_TV_Guide.Cool3D.value == "MyDesign":
return self.MDCoolRecS
if config.misc.Cool_TV_Guide.Cool3D.value == "Standard":
return self.CoolRecS
def CoolRecRed(self, refstr, beginTime, duration, eventId):
pre_clock = 1
post_clock = 2
clock_type = 0
endTime = beginTime + duration
for x in self.timer.timer_list:
if x.service_ref.ref.toString() == refstr:
if x.eit == eventId:
return "record"
beg = x.begin
end = x.end
if beginTime > beg and beginTime < end and endTime > end:
clock_type |= pre_clock
elif beginTime < beg and endTime > beg and endTime < end:
clock_type |= post_clock
if clock_type == 0:
return "record"
elif clock_type == pre_clock:
return "nichts"
elif clock_type == post_clock:
return "nichts"
else:
return "nichts"
class TimelineText(HTMLComponent, GUIComponent):
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", config.misc.Cool_TV_Guide.Cool_Timeline.value))
GUI_WIDGET = eListbox
def postWidgetCreate(self, instance):
instance.setContent(self.l)
def setEntries(self, entries):
res = [ None ]
for x in entries:
tm = x[0]
xpos = x[1]
str = strftime("%H:%M", localtime(tm))
res.append((eListboxPythonMultiContent.TYPE_TEXT, xpos-30, 0, 60, 25, 0, RT_HALIGN_CENTER|RT_VALIGN_CENTER, str))
self.l.setList([res])
class CoolTVGuide(Screen, ConfigListScreen):
EMPTY = 0
ADD_TIMER = 1
REMOVE_TIMER = 2
ZAP = 1
def __init__(self, session, services, zapFunc=None, bouquetChangeCB=None, bouquetname=""):
Screen.__init__(self, session)
CoolWide = getDesktop(0).size().width()
skinpath = str(resolveFilename)
if config.misc.Cool_TV_Guide.CoolMultiSwitch.value == "No":
self.skinName = "CoolTVGuide"
if CoolWide == 720:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolTVGuide_720.xml"
elif CoolWide == 1024:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolTVGuide_1024.xml"
else:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolTVGuide_1280.xml"
elif config.misc.Cool_TV_Guide.CoolMultiSwitch.value == "Yes":
self.skinName = "CoolMultiGuide"
if CoolWide == 720:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolMultiGuide_720.xml"
elif CoolWide == 1024:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolMultiGuide_1024.xml"
else:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolMultiGuide_1280.xml"
Cool = open(skin)
self.skin = Cool.read()
Cool.close()
self.bouquetChangeCB = bouquetChangeCB
now = time()
tmp = now % 900
self.ask_time = now - tmp
self.closeRecursive = False
self["key_red"] = Button("")
self["key_green"] = Button("")
self["key_yellow"] = Button("")
self["key_blue"] = Button("")
self.key_red_choice = self.EMPTY
self.key_green_choice = self.EMPTY
self.key_yellow_choice = self.EMPTY
self.key_blue_choice = self.EMPTY
self["timeline_text"] = TimelineText()
self["Event"] = Event()
self.time_lines = [ ]
for x in (0,1,2,3,4,5):
pm = Pixmap()
self.time_lines.append(pm)
self["timeline%d"%(x)] = pm
self["timeline_now"] = Pixmap()
self.services = services
self.zapFunc = zapFunc
if bouquetname != "":
Screen.setTitle(self, bouquetname)
global CoolList
self["list"] = CoolEPGList(selChangedCB = self.onSelectionChanged, timer = self.session.nav.RecordTimer,
time_epoch = config.misc.Cool_TV_Guide.prev_time_period.value,
overjump_empty = config.misc.Cool_TV_Guide.overjump.value)
CoolList = self["list"]
self["Coolman"] = HelpableActionMap(self, "CoolTVGuideActions",
{
"CoolMenu": (self.showSetup, _("show your Setup")),
"CoolTime": (self.enterDateTime, _("show Date Time")),
"CoolRed": self.CoolRed,
"CoolRedLong": self.CoolRedLong,
"CoolGreen": self.CoolGreen,
"CoolGreenLong": self.CoolGreenLong,
"CoolYellow": self.CoolYellow,
"CoolYellowLong": self.CoolYellowLong,
"CoolBlue": self.CoolBlue,
"CoolBlueLong": self.CoolBlueLong,
"CoolOK": self.CoolOK,
"CoolOKLong": self.CoolOKLong,
"CoolInfo": self.CoolInfo,
"CoolInfoLong": self.CoolInfoLong,
"CoolRecord": (self.CoolRecord, _("Record")),
})
self["actions"] = ActionMap(["EPGSelectActions", "OkCancelActions", "HelpActions"],
{
"cancel": self.CoolClose,
"displayHelp": self.myhelp,
"nextBouquet": self.nextBouquet,
"prevBouquet": self.prevBouquet,
"prevService": self.prevPressed,
"nextService": self.nextPressed,
})
self["actions"].csel = self
self["input_actions"] = ActionMap(["InputActions"],
{
"left": self.leftPressed,
"right": self.rightPressed,
"1": self.key1,
"2": self.key2,
"3": self.key3,
"4": self.key4,
"5": self.key5,
"6": self.key6,
"7": self.key7,
"8": self.key8,
"9": self.key9,
"0": self.key0,
},-1)
self["key_red"].setText(config.misc.Cool_TV_Guide.Cool_Red.value)
self["key_green"].setText(config.misc.Cool_TV_Guide.Cool_Green.value)
self["key_yellow"].setText(config.misc.Cool_TV_Guide.Cool_Yellow.value)
self["key_blue"].setText(config.misc.Cool_TV_Guide.Cool_Blue.value)
self.updateTimelineTimer = eTimer()
self.updateTimelineTimer.callback.append(self.moveTimeLines)
self.updateTimelineTimer.start(60*1000)
self.onLayoutFinish.append(self.onCreate)
self["date"] = Label()
def OpenCoolSingleGuide(self):
cur = self["list"].getCurrent()
event = cur[0]
serviceref = cur[1]
refstr = serviceref.ref.toString()
if event is not None:
self.session.open(CoolSingleGuide, refstr)
def OpenSingleEPG(self):
cur = self["list"].getCurrent()
event = cur[0]
serviceref = cur[1]
refstr = serviceref.ref.toString()
eventid = event.getEventId()
if event is not None:
self.session.open(EPGSelection, refstr, eventid)
def CoolAutoTimer(self):
cur = self["list"].getCurrent()
event = cur[0]
if not event: return
serviceref = cur[1]
try:
from Plugins.Extensions.AutoTimer.AutoTimerEditor import addAutotimerFromEvent
addAutotimerFromEvent(self.session, evt = event, service = serviceref)
except:
self.session.open(MessageBox, _("No AutoTimer seems to be installed. Please install it for this functionality."), MessageBox.TYPE_ERROR)
def CoolRecord(self):
cur = self["list"].getCurrent()
event = cur[0]
serviceref = cur[1]
if event is None:
return
eventid = event.getEventId()
refstr = serviceref.ref.toString()
for timer in self.session.nav.RecordTimer.timer_list:
if timer.eit == eventid and timer.service_ref.ref.toString() == refstr:
self.removeTimer(timer)
self["list"].fillCoolTVGuide(None)
break
else:
newEntry = RecordTimerEntry(serviceref, checkOldTimers = True, *parseEvent(event))
self.session.openWithCallback(self.finishedAdd, CoolTimerEntry, newEntry)
def CoolSearch(self):
try:
from Plugins.Extensions.EPGSearch.EPGSearch import EPGSearch
except ImportError:
EPGSearch = None
try:
from Bp.extra_epg import epgsearch
except ImportError:
epgsearch = None
try:
cur = self["list"].getCurrent()
event = cur[0]
name = event.getEventName()
except:
name = ''
if EPGSearch is not None:
self.session.open(EPGSearch, name , False)
if epgsearch is not None and EPGSearch is None:
self.session.open(epgsearch, cur)
def IMDbSearch(self):
try:
cur = self["list"].getCurrent()
event = cur[0]
name = event.getEventName()
except:
name = ''
if IMDB is not None:
self.session.open(IMDB, name, False)
def prevPressed(self):
coolhilf = config.misc.Cool_TV_Guide.prev_time_period.value
if coolhilf == 60:
cooltime = self["list"].getTimeBase() - 90000
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 120:
cooltime = self["list"].getTimeBase() - 93600
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 180:
cooltime = self["list"].getTimeBase() - 97200
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 240:
cooltime = self["list"].getTimeBase() - 100800
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 300:
cooltime = self["list"].getTimeBase() - 104400
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
def nextPressed(self):
coolhilf = config.misc.Cool_TV_Guide.prev_time_period.value
if coolhilf == 60:
cooltime = self["list"].getTimeBase() + 82800
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 120:
cooltime = self["list"].getTimeBase() + 79200
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 180:
cooltime = self["list"].getTimeBase() + 75600
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 240:
cooltime = self["list"].getTimeBase() + 72000
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
if coolhilf == 300:
cooltime = self["list"].getTimeBase() + 68400
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.updEvent(+2)
def leftPressed(self):
self.updEvent(-1)
def rightPressed(self):
self.updEvent(+1)
def updEvent(self, dir, visible=True):
ret = self["list"].selEntry(dir, visible)
if ret:
self.moveTimeLines(True)
def myhelp(self):
self.session.open(CoolTVGuideHelp, "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/help.jpg")
def key1(self):
hilf = config.misc.Cool_TV_Guide.prev_time_period.value
if hilf > 60:
hilf = hilf - 60
self["list"].setEpoch(hilf)
config.misc.Cool_TV_Guide.prev_time_period.value = hilf
self.moveTimeLines()
def key2(self):
self["list"].instance.moveSelection(self["list"].instance.pageUp)
def key3(self):
hilf = config.misc.Cool_TV_Guide.prev_time_period.value
if hilf < 300:
hilf = hilf + 60
self["list"].setEpoch(hilf)
config.misc.Cool_TV_Guide.prev_time_period.value = hilf
self.moveTimeLines()
def key4(self):
self.updEvent(-2)
def key5(self):
# self.updEvent()
# self["list"].instance.moveSelectionTo(0)
now = time()
tmp = now % 900
cooltime = now - tmp
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.moveTimeLines(True)
def key6(self):
self.updEvent(+2)
def key7(self):
Coolman = config.misc.Cool_TV_Guide.PiconItemHeight.value
if self["list"].coolheight >40:
Coolman = self["list"].coolheight
if self["list"].coolheight == Cool16:
self["list"].coolheight = Coolman
else:
self["list"].coolheight = Cool16
self["list"].l.setItemHeight(int(self["list"].coolheight))
self["list"].fillCoolTVGuide(None)
self.moveTimeLines()
def key8(self):
self["list"].instance.moveSelection(self["list"].instance.pageDown)
def key9(self):
cooltime = localtime(self["list"].getTimeBase())
hilf = (cooltime[0], cooltime[1], cooltime[2], config.misc.Cool_TV_Guide.CoolPrimetime1.value, config.misc.Cool_TV_Guide.CoolPrimetime2.value,0, cooltime[6], cooltime[7], cooltime[8])
cooltime = mktime(hilf)
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.moveTimeLines(True)
def key0(self):
self["list"].setEpoch2(180)
config.misc.Cool_TV_Guide.prev_time_period.value = 180
self["list"].instance.moveSelectionTo(0)
now = time()
tmp = now % 900
cooltime = now - tmp
self["list"].resetOffset()
self["list"].fillCoolTVGuide(self.services, cooltime)
self.moveTimeLines(True)
def CoolMultiGuide(self):
if config.misc.Cool_TV_Guide.CoolMultiSwitch.value == "No":
config.misc.Cool_TV_Guide.CoolMultiSwitch.value = "Yes"
elif config.misc.Cool_TV_Guide.CoolMultiSwitch.value == "Yes":
config.misc.Cool_TV_Guide.CoolMultiSwitch.value = "No"
self.CoolClose()
def CoolRed(self):
if config.misc.Cool_TV_Guide.Cool_Red.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_Red.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_Red.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_Red.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_Red.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_Red.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolRedLong(self):
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_RedLong.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolGreen(self):
if config.misc.Cool_TV_Guide.Cool_Green.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_Green.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_Green.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_Green.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_Green.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_Green.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolGreenLong(self):
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_GreenLong.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolYellow(self):
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolYellowLong(self):
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_YellowLong.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolBlue(self):
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolBlueLong(self):
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_BlueLong.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolOK(self):
if config.misc.Cool_TV_Guide.Cool_OK.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_OK.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_OK.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_OK.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_OK.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_OK.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolOKLong(self):
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Zap":
self.zapTo()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Zap + Exit":
self.zap()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Search":
self.CoolSearch()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "IMDb Search":
self.IMDbSearch()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "CoolSwitch":
self.key7()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Channel Info":
self.infoKeyPressed()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Timer":
self.timerAdd()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "QuickRec":
self.CoolRecord()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "AutoTimer":
self.CoolAutoTimer()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Primetime":
self.key9()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Bouquet +":
self.nextBouquet()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Bouquet -":
self.prevBouquet()
if config.misc.Cool_TV_Guide.Cool_OKLong.value == "Bouquetlist":
self.CoolBouquetlist()
def CoolInfo(self):
if config.misc.Cool_TV_Guide.Cool_Info.value == "Cool Single Guide":
self.OpenCoolSingleGuide()
if config.misc.Cool_TV_Guide.Cool_Info.value == "Cool TV<>Multi Guide":
self.CoolMultiGuide()
if config.misc.Cool_TV_Guide.Cool_Info.value == "View Single EPG":
self.OpenSingleEPG()
if config.misc.Cool_TV_Guide.Cool_Info.value == "Channel Info":
self.infoKeyPressed()
def CoolInfoLong(self):
if config.misc.Cool_TV_Guide.Cool_InfoLong.value == "Cool Single Guide":
self.OpenCoolSingleGuide()
if config.misc.Cool_TV_Guide.Cool_InfoLong.value == "Cool TV<>Multi Guide":
self.CoolMultiGuide()
if config.misc.Cool_TV_Guide.Cool_InfoLong.value == "View Single EPG":
self.OpenSingleEPG()
if config.misc.Cool_TV_Guide.Cool_InfoLong.value == "Channel Info":
self.infoKeyPressed()
def nextBouquet(self):
if self.bouquetChangeCB:
self.bouquetChangeCB(1, self)
def prevBouquet(self):
if self.bouquetChangeCB:
self.bouquetChangeCB(-1, self)
def CoolBouquetlist(self):
global bouquetSel
bouquetSel = Session.openWithCallback(closed, BouquetSelector, bouquets, openBouquetEPG, enableWrapAround=True)
dlg_stack.append(bouquetSel)
def enterDateTime(self):
self.session.openWithCallback(self.onDateTimeInputClosed, TimeDateInput, config.misc.Cool_TV_Guide.prev_time )
def onDateTimeInputClosed(self, ret):
if len(ret) > 1:
if ret[0]:
self.ask_time=ret[1]
l = self["list"]
l.resetOffset()
l.fillCoolTVGuide(self.services, ret[1])
self.moveTimeLines(True)
def showSetup(self):
self.session.openWithCallback(self.onSetupClose, CoolTVGuideSetup )
def onSetupClose(self):
l = self["list"]
l.setItemsPerPage()
l.setEventFontsize()
l.setEpoch(config.misc.Cool_TV_Guide.prev_time_period.value)
l.setOverjump_Empty(config.misc.Cool_TV_Guide.overjump.value)
self.moveTimeLines()
self["key_red"].setText(config.misc.Cool_TV_Guide.Cool_Red.value)
self["key_green"].setText(config.misc.Cool_TV_Guide.Cool_Green.value)
self["key_yellow"].setText(config.misc.Cool_TV_Guide.Cool_Yellow.value)
self["key_blue"].setText(config.misc.Cool_TV_Guide.Cool_Blue.value)
def CoolClose(self):
self.closeRecursive = True
ref = self["list"].getCurrent()[1]
if ref:
self.closeScreen()
def closeScreen(self):
config.misc.Cool_TV_Guide.save()
self.close(self.closeRecursive)
def infoKeyPressed(self):
cur = self["list"].getCurrent()
event = cur[0]
service = cur[1]
if event is not None:
self.session.open(CoolViewSimple, event, service, self.eventViewCallback, self.openSimilarList)
def openSimilarList(self, eventid, refstr):
self.session.open(EPGSelection, refstr, None, eventid)
def setServices(self, services):
self.services = services
self.onCreate()
def onCreate(self):
self["list"].curr_refcool = self.session.nav.getCurrentlyPlayingServiceReference()
self["list"].fillCoolTVGuide(self.services, self.ask_time)
self["list"].moveToService(self.session.nav.getCurrentlyPlayingServiceReference())
self.moveTimeLines()
if config.misc.Cool_TV_Guide.channel1.value == "Yes":
self["list"].instance.moveSelectionTo(0)
def eventViewCallback(self, setEvent, setService, val):
l = self["list"]
old = l.getCurrent()
self.updEvent(val, False)
cur = l.getCurrent()
if cur[0] is None and cur[1].ref != old[1].ref:
self.eventViewCallback(setEvent, setService, val)
else:
setService(cur[1])
setEvent(cur[0])
def zapTo(self):
if self.zapFunc:
self.closeRecursive = True
ref = self["list"].getCurrent()[1]
self["list"].curr_refcool = ref.ref
self["list"].fillCoolTVGuide(None)
if ref:
self.zapFunc(ref.ref)
def zap(self):
if self.zapFunc :
self.closeRecursive = True
ref = self["list"].getCurrent()[1]
if ref:
self.zapFunc(ref.ref)
self.closeScreen()
def eventSelected(self):
self.infoKeyPressed()
def removeTimer(self, timer):
timer.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(timer)
if config.misc.Cool_TV_Guide.Cool_Red.value == "Timer":
self["key_red"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Green.value == "Timer":
self["key_green"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Timer":
self["key_yellow"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Timer":
self["key_blue"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def timerAdd(self):
cur = self["list"].getCurrent()
event = cur[0]
serviceref = cur[1]
if event is None:
return
eventid = event.getEventId()
refstr = serviceref.ref.toString()
for timer in self.session.nav.RecordTimer.timer_list:
if timer.eit == eventid and timer.service_ref.ref.toString() == refstr:
cb_func = lambda ret : not ret or self.removeTimer(timer)
self.session.openWithCallback(cb_func, MessageBox, _("Do you really want to delete %s?") % event.getEventName())
break
else:
newEntry = RecordTimerEntry(serviceref, checkOldTimers = True, *parseEvent(event))
self.session.openWithCallback(self.finishedAdd, TimerEntry, newEntry)
def finishedAdd(self, answer):
print "finished add"
if answer[0]:
entry = answer[1]
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
if config.misc.Cool_TV_Guide.Cool_Red.value == "Timer":
self["key_red"].setText(_("Remove timer"))
if config.misc.Cool_TV_Guide.Cool_Green.value == "Timer":
self["key_green"].setText(_("Remove timer"))
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Timer":
self["key_yellow"].setText(_("Remove timer"))
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Timer":
self["key_blue"].setText(_("Remove timer"))
self.key_green_choice = self.REMOVE_TIMER
else:
if config.misc.Cool_TV_Guide.Cool_Red.value == "Timer":
self["key_red"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Green.value == "Timer":
self["key_green"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Timer":
self["key_yellow"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Timer":
self["key_blue"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
print "Timeredit aborted"
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def onSelectionChanged(self):
cur = self["list"].getCurrent()
if cur is None:
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
if self.key_red_choice != self.EMPTY:
self["key_red"].setText("")
self.key_red_choice = self.EMPTY
if self.key_yellow_choice != self.EMPTY:
self["key_yellow"].setText("")
self.key_yellow_choice = self.EMPTY
if self.key_blue_choice != self.EMPTY:
self["key_blue"].setText("")
self.key_blue_choice = self.EMPTY
return
event = cur[0]
self["Event"].newEvent(event)
count = self["list"].getCurrentChangeCount()
days = [ _("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun") ]
datestr = ""
if event is not None:
now = time()
beg = event.getBeginTime()
nowTime = localtime(now)
begTime = localtime(beg)
if nowTime[2] != begTime[2]:
datestr = '%s %d.%d.'%(days[begTime[6]], begTime[2], begTime[1])
else:
datestr = '%s %d.%d.'%(_("Today"), begTime[2], begTime[1])
self["date"].setText(datestr)
if cur[1] is None or cur[1].getServiceName() == "":
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
if self.key_red_choice != self.EMPTY:
self["key_red"].setText("")
self.key_red_choice = self.EMPTY
if self.key_yellow_choice != self.EMPTY:
self["key_yellow"].setText("")
self.key_yellow_choice = self.EMPTY
if self.key_blue_choice != self.EMPTY:
self["key_blue"].setText("")
self.key_blue_choice = self.EMPTY
return
if not event:
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
return
serviceref = cur[1]
eventid = event.getEventId()
refstr = serviceref.ref.toString()
isRecordEvent = False
for timer in self.session.nav.RecordTimer.timer_list:
if timer.eit == eventid and timer.service_ref.ref.toString() == refstr:
isRecordEvent = True
break
if isRecordEvent and self.key_green_choice != self.REMOVE_TIMER:
if config.misc.Cool_TV_Guide.Cool_Red.value == "Timer":
self["key_red"].setText(_("Remove timer"))
if config.misc.Cool_TV_Guide.Cool_Green.value == "Timer":
self["key_green"].setText(_("Remove timer"))
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Timer":
self["key_yellow"].setText(_("Remove timer"))
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Timer":
self["key_blue"].setText(_("Remove timer"))
self.key_green_choice = self.REMOVE_TIMER
elif not isRecordEvent and self.key_green_choice != self.ADD_TIMER:
if config.misc.Cool_TV_Guide.Cool_Red.value == "Timer":
self["key_red"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Green.value == "Timer":
self["key_green"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Yellow.value == "Timer":
self["key_yellow"].setText(_("Add timer"))
if config.misc.Cool_TV_Guide.Cool_Blue.value == "Timer":
self["key_blue"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def moveTimeLines(self, force=False):
self.updateTimelineTimer.start((60-(int(time())%60))*1000) #keep syncronised
l = self["list"]
event_rect = l.getEventRect()
time_epoch = l.getTimeEpoch()
time_base = l.getTimeBase()
if event_rect is None or time_epoch is None or time_base is None:
return
time_steps = time_epoch > 180 and 60 or 30
num_lines = time_epoch/time_steps
incWidth=event_rect.width()/num_lines
pos=event_rect.left()
timeline_entries = [ ]
x = 0
changecount = 0
for line in self.time_lines:
old_pos = line.position
new_pos = (x == num_lines and event_rect.left()+event_rect.width() or pos, old_pos[1])
if not x or x >= num_lines:
line.visible = False
else:
if old_pos != new_pos:
line.setPosition(new_pos[0], new_pos[1])
changecount += 1
line.visible = True
if not x or line.visible:
timeline_entries.append((time_base + x * time_steps * 60, new_pos[0]))
x += 1
pos += incWidth
if changecount or force:
self["timeline_text"].setEntries(timeline_entries)
now=time()
timeline_now = self["timeline_now"]
if now >= time_base and now < (time_base + time_epoch * 60):
xpos = int((((now - time_base) * event_rect.width()) / (time_epoch * 60))-(timeline_now.instance.size().width()/2))
old_pos = timeline_now.position
new_pos = (xpos+event_rect.left(), old_pos[1])
if old_pos != new_pos:
timeline_now.setPosition(new_pos[0], new_pos[1])
timeline_now.visible = True
else:
timeline_now.visible = False
l.l.invalidate()
class CoolTVGuideSetup(Screen, ConfigListScreen):
def __init__(self, session, args = None):
Screen.__init__(self, session)
self.setup_title = _("Cool TV Guide Settings")
skinpath = str(resolveFilename)
self.skinName = "CoolTVGuideSetup"
skin = "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/CoolSkin/CoolTVGuideSetup.xml"
Cool = open(skin)
self.skin = Cool.read()
Cool.close()
self["actions"] = ActionMap(["SetupActions", "HelpActions"],
{
"ok": self.keySave,
"save": self.keySave,
"cancel": self.keyCancel,
"red": self.keyCancel,
"green": self.keySave,
"displayHelp": self.myhelp,
}, -1)
self["oktext"] = Label(_("OK"))
self["canceltext"] = Label(_("Cancel"))
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("Save"))
self.onChangedEntry = [ ]
self.session = session
self.list = []
ConfigListScreen.__init__(self, self.list, session = self.session)
self.createSetup()
def myhelp(self):
self.session.open(CoolTVGuideHelp, "/usr/lib/enigma2/python/Plugins/Extensions/CoolTVGuide/help.jpg")
def createSetup(self):
print "Creating Cool TV Guide Setup"
self.list = [ ]
self.list.append(getConfigListEntry(_("Cool 3D"), config.misc.Cool_TV_Guide.Cool3D))
self.list.append(getConfigListEntry(_("Load Picon (Yes) (need restart)"), config.misc.Cool_TV_Guide.CoolPiconON))
self.list.append(getConfigListEntry(_("Load CoolPico (Yes) (need restart)"), config.misc.Cool_TV_Guide.CoolPicoON))
self.list.append(getConfigListEntry(_("Start View 60 , 30 (60)"), config.misc.Cool_TV_Guide.coolswitch))
self.list.append(getConfigListEntry(_("Picon Height (60), (54), (54)"), config.misc.Cool_TV_Guide.PiconHeight))
self.list.append(getConfigListEntry(_("Picon Item Height (60), (54), (54)"), config.misc.Cool_TV_Guide.PiconItemHeight))
self.list.append(getConfigListEntry(_("CoolPico Height (30), (27), (27)"), config.misc.Cool_TV_Guide.CoolPicoHeight))
self.list.append(getConfigListEntry(_("CoolPico Item Height (30), (27), (27)"), config.misc.Cool_TV_Guide.CoolPicoItemHeight))
self.list.append(getConfigListEntry(_("Left Width for 60 Height (110), (75), (75)"), config.misc.Cool_TV_Guide.cool_left8))
self.list.append(getConfigListEntry(_("Left Width for 30 Height (190), (110), (110)"), config.misc.Cool_TV_Guide.cool_left16))
self.list.append(getConfigListEntry(_("Channel 1 at Start (No)"), config.misc.Cool_TV_Guide.channel1))
self.list.append(getConfigListEntry(_("----------"), config.misc.Cool_TV_Guide.cool_BlankLine))
self.list.append(getConfigListEntry(_("Red Button (Zap)"), config.misc.Cool_TV_Guide.Cool_Red))
self.list.append(getConfigListEntry(_("LongRed Button (ZAP+Exit)"), config.misc.Cool_TV_Guide.Cool_RedLong))
self.list.append(getConfigListEntry(_("Green Button (Timer)"), config.misc.Cool_TV_Guide.Cool_Green))
self.list.append(getConfigListEntry(_("LongGreen Button (Autotimer)"), config.misc.Cool_TV_Guide.Cool_GreenLong))
self.list.append(getConfigListEntry(_("Yellow Button (CoolSwitch)"), config.misc.Cool_TV_Guide.Cool_Yellow))
self.list.append(getConfigListEntry(_("LongYellow Button (Bouquetlist)"), config.misc.Cool_TV_Guide.Cool_YellowLong))
self.list.append(getConfigListEntry(_("Blue Button (Search)"), config.misc.Cool_TV_Guide.Cool_Blue))
self.list.append(getConfigListEntry(_("LongBlue Button (IMDb Search)"), config.misc.Cool_TV_Guide.Cool_BlueLong))
self.list.append(getConfigListEntry(_("OK Button (Channel Info)"), config.misc.Cool_TV_Guide.Cool_OK))
self.list.append(getConfigListEntry(_("LongOK Button"), config.misc.Cool_TV_Guide.Cool_OKLong))
self.list.append(getConfigListEntry(_("Info Button (Cool Single Guide)"), config.misc.Cool_TV_Guide.Cool_Info))
self.list.append(getConfigListEntry(_("LongInfo Button (Cool TV<>Multi Guide)"), config.misc.Cool_TV_Guide.Cool_InfoLong))
self.list.append(getConfigListEntry(_("----------"), config.misc.Cool_TV_Guide.cool_BlankLine))
self.list.append(getConfigListEntry(_("Cool Primetime (20) hour"), config.misc.Cool_TV_Guide.CoolPrimetime1))
self.list.append(getConfigListEntry(_("Cool Primetime (00) minute"), config.misc.Cool_TV_Guide.CoolPrimetime2))
self.list.append(getConfigListEntry(_("----------"), config.misc.Cool_TV_Guide.cool_BlankLine))
self.list.append(getConfigListEntry(_("Event Fontsize (18), (15), (15)"), config.misc.Cool_TV_Guide.Cool_Fontsize))
self.list.append(getConfigListEntry(_("Left Fontsize (22), (18), (16) (need restart)"), config.misc.Cool_TV_Guide.Cool_Left_Fontsize))
self.list.append(getConfigListEntry(_("Timeline Fontsize (20), (18), (16) (need restart)"), config.misc.Cool_TV_Guide.Cool_Timeline))
self.list.append(getConfigListEntry(_("Time Scale (180)"), config.misc.Cool_TV_Guide.prev_time_period))
self.list.append(getConfigListEntry(_("----------"), config.misc.Cool_TV_Guide.cool_BlankLine))
self.list.append(getConfigListEntry(_("chance folder picon ==> coolpicon (needs fullrestart)"), config.misc.Cool_TV_Guide.CoolPiconPath))
self.list.append(getConfigListEntry(_("chance folder picon/coolpico ==> coolpicon/coolpico"), config.misc.Cool_TV_Guide.CoolPicoPath))
self.list.append(getConfigListEntry(_("Bouquet at Start (No)"), config.misc.Cool_TV_Guide.autostart_bouquet))
self.list.append(getConfigListEntry(_("Skip Empty Services (false) (need restart)"), config.misc.Cool_TV_Guide.overjump))
self["config"].list = self.list
self["config"].l.setList(self.list)
class CoolTVGuideHelp(Screen):
if (getDesktop(0).size().width()) == 720:
skin="""
"""
elif (getDesktop(0).size().width()) == 1024:
skin="""
"""
else:
skin="""
"""
def __init__(self, session, whatPic = None):
self.skin = CoolTVGuideHelp.skin
Screen.__init__(self, session)
self.whatPic = whatPic
self.EXscale = (AVSwitch().getFramebufferScale())
self.EXpicload = ePicLoad()
self["Picture"] = Pixmap()
self["actions"] = ActionMap(["WizardActions", "ColorActions"],
{
"ok": self.close,
"back": self.close,
"red": self.close,
"green": self.close
}, -1)
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("Save"))
self.EXpicload.PictureData.get().append(self.DecodeAction)
self.onLayoutFinish.append(self.Help_Picture)
def Help_Picture(self):
if self.whatPic is not None:
self.EXpicload.setPara([self["Picture"].instance.size().width(), self["Picture"].instance.size().height(), self.EXscale[0], self.EXscale[1], 0, 1, "#121214"])
self.EXpicload.startDecode(self.whatPic)
def DecodeAction(self, pictureInfo=" "):
if self.whatPic is not None:
ptr = self.EXpicload.getData()
self["Picture"].instance.setPixmap(ptr)
class CoolTimerEntry(TimerEntry):
def __init__(self, session, timer):
Screen.__init__(self, session)
self.timer = timer
self.entryDate = None
self.entryService = None
self.createConfig()
self.list = []
ConfigListScreen.__init__(self, self.list, session = session)
self.createSetup("config")
def createConfig(self):
justplay = self.timer.justplay
afterevent = {
AFTEREVENT.NONE: "nothing",
AFTEREVENT.DEEPSTANDBY: "deepstandby",
AFTEREVENT.STANDBY: "standby",
AFTEREVENT.AUTO: "auto"
}[self.timer.afterEvent]
weekday_table = ("mon", "tue", "wed", "thu", "fri", "sat", "sun")
day = []
weekday = 0
for x in (0, 1, 2, 3, 4, 5, 6):
day.append(0)
if self.timer.repeated: # repeated
type = "repeated"
if (self.timer.repeated == 31): # Mon-Fri
repeated = "weekdays"
elif (self.timer.repeated == 127): # daily
repeated = "daily"
else:
flags = self.timer.repeated
repeated = "user"
count = 0
for x in (0, 1, 2, 3, 4, 5, 6):
if flags == 1: # weekly
print "Set to weekday " + str(x)
weekday = x
if flags & 1 == 1: # set user defined flags
day[x] = 1
count += 1
else:
day[x] = 0
flags = flags >> 1
if count == 1:
repeated = "weekly"
else: # once
type = "once"
repeated = None
weekday = (int(strftime("%w", localtime(self.timer.begin))) - 1) % 7
day[weekday] = 1
self.timerentry_justplay = ConfigSelection(choices = [("zap", _("zap")), ("record", _("record"))], default = {0: "record", 1: "zap"}[justplay])
if SystemInfo["DeepstandbySupport"]:
shutdownString = _("go to deep standby")
else:
shutdownString = _("shut down")
self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")), ("standby", _("go to standby")), ("deepstandby", shutdownString), ("auto", _("auto"))], default = afterevent)
self.timerentry_type = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = type)
self.timerentry_name = ConfigText(default = self.timer.name, visible_width = 50, fixed_size = False)
self.timerentry_description = ConfigText(default = self.timer.description, visible_width = 50, fixed_size = False)
self.timerentry_tags = self.timer.tags[:]
self.timerentry_tagsset = ConfigSelection(choices = [not self.timerentry_tags and "None" or " ".join(self.timerentry_tags)])
self.timerentry_repeated = ConfigSelection(default = repeated, choices = [("daily", _("daily")), ("weekly", _("weekly")), ("weekdays", _("Mon-Fri")), ("user", _("user defined"))])
self.timerentry_date = ConfigDateTime(default = self.timer.begin, formatstring = _("%d.%B %Y"), increment = 86400)
self.timerentry_starttime = ConfigClock(default = self.timer.begin)
self.timerentry_endtime = ConfigClock(default = self.timer.end)
self.timerentry_showendtime = ConfigSelection(default = ((self.timer.end - self.timer.begin) > 4), choices = [(True, _("yes")), (False, _("no"))])
default = self.timer.dirname or defaultMoviePath()
tmp = config.movielist.videodirs.value
if default not in tmp:
tmp.append(default)
self.timerentry_dirname = ConfigSelection(default = default, choices = tmp)
self.timerentry_repeatedbegindate = ConfigDateTime(default = self.timer.repeatedbegindate, formatstring = _("%d.%B %Y"), increment = 86400)
self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))])
self.timerentry_day = ConfigSubList()
for x in (0, 1, 2, 3, 4, 5, 6):
self.timerentry_day.append(ConfigYesNo(default = day[x]))
servicename = "N/A"
try: # no current service available?
servicename = str(self.timer.service_ref.getServiceName())
except:
pass
self.timerentry_service_ref = self.timer.service_ref
self.timerentry_service = ConfigSelection([servicename])
def createSetup(self, widget):
self.list = []
self.list.append(getConfigListEntry(_("Name"), self.timerentry_name))
self.list.append(getConfigListEntry(_("Description"), self.timerentry_description))
self.timerJustplayEntry = getConfigListEntry(_("Timer Type"), self.timerentry_justplay)
self.list.append(self.timerJustplayEntry)
self.timerTypeEntry = getConfigListEntry(_("Repeat Type"), self.timerentry_type)
self.list.append(self.timerTypeEntry)
if self.timerentry_type.value == "once":
self.frequencyEntry = None
else: # repeated
self.frequencyEntry = getConfigListEntry(_("Repeats"), self.timerentry_repeated)
self.list.append(self.frequencyEntry)
self.repeatedbegindateEntry = getConfigListEntry(_("Starting on"), self.timerentry_repeatedbegindate)
self.list.append(self.repeatedbegindateEntry)
if self.timerentry_repeated.value == "daily":
pass
if self.timerentry_repeated.value == "weekdays":
pass
if self.timerentry_repeated.value == "weekly":
self.list.append(getConfigListEntry(_("Weekday"), self.timerentry_weekday))
if self.timerentry_repeated.value == "user":
self.list.append(getConfigListEntry(_("Monday"), self.timerentry_day[0]))
self.list.append(getConfigListEntry(_("Tuesday"), self.timerentry_day[1]))
self.list.append(getConfigListEntry(_("Wednesday"), self.timerentry_day[2]))
self.list.append(getConfigListEntry(_("Thursday"), self.timerentry_day[3]))
self.list.append(getConfigListEntry(_("Friday"), self.timerentry_day[4]))
self.list.append(getConfigListEntry(_("Saturday"), self.timerentry_day[5]))
self.list.append(getConfigListEntry(_("Sunday"), self.timerentry_day[6]))
self.entryDate = getConfigListEntry(_("Date"), self.timerentry_date)
if self.timerentry_type.value == "once":
self.list.append(self.entryDate)
self.entryStartTime = getConfigListEntry(_("StartTime"), self.timerentry_starttime)
self.list.append(self.entryStartTime)
self.entryShowEndTime = getConfigListEntry(_("Set End Time"), self.timerentry_showendtime)
if self.timerentry_justplay.value == "zap":
self.list.append(self.entryShowEndTime)
self.entryEndTime = getConfigListEntry(_("EndTime"), self.timerentry_endtime)
if self.timerentry_justplay.value != "zap" or self.timerentry_showendtime.value:
self.list.append(self.entryEndTime)
self.channelEntry = getConfigListEntry(_("Channel"), self.timerentry_service)
self.list.append(self.channelEntry)
self.dirname = getConfigListEntry(_("Location"), self.timerentry_dirname)
self.tagsSet = getConfigListEntry(_("Tags"), self.timerentry_tagsset)
if self.timerentry_justplay.value != "zap":
if config.usage.setup_level.index >= 2: # expert+
self.list.append(self.dirname)
if getPreferredTagEditor():
self.list.append(self.tagsSet)
self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent))
self.keyGo()
def finishedChannelSelection(self, *args):
if args:
self.timerentry_service_ref = ServiceReference(args[0])
self.timerentry_service.setCurrentText(self.timerentry_service_ref.getServiceName())
self["config"].invalidate(self.channelEntry)
def getTimestamp(self, date, mytime):
d = localtime(date)
dt = datetime(d.tm_year, d.tm_mon, d.tm_mday, mytime[0], mytime[1])
return int(mktime(dt.timetuple()))
def getBeginEnd(self):
date = self.timerentry_date.value
endtime = self.timerentry_endtime.value
starttime = self.timerentry_starttime.value
begin = self.getTimestamp(date, starttime)
end = self.getTimestamp(date, endtime)
if end < begin:
end += 86400
return begin, end
def selectChannelSelector(self, *args):
self.session.openWithCallback(
self.finishedChannelSelectionCorrection,
ChannelSelection.SimpleChannelSelection,
_("Select channel to record from")
)
def finishedChannelSelectionCorrection(self, *args):
if args:
self.finishedChannelSelection(*args)
self.keyGo()
def keyGo(self, result = None):
self.timer.name = self.timerentry_name.value
self.timer.description = self.timerentry_description.value
self.timer.justplay = self.timerentry_justplay.value == "zap"
if self.timerentry_justplay.value == "zap":
if not self.timerentry_showendtime.value:
self.timerentry_endtime.value = self.timerentry_starttime.value
self.timer.resetRepeated()
self.timer.afterEvent = {
"auto": AFTEREVENT.AUTO
}[self.timerentry_afterevent.value]
self.timer.service_ref = self.timerentry_service_ref
self.timer.tags = self.timerentry_tags
if self.timer.dirname or self.timerentry_dirname.value != defaultMoviePath():
self.timer.dirname = self.timerentry_dirname.value
config.movielist.last_timer_videodir.value = self.timer.dirname
config.movielist.last_timer_videodir.save()
if self.timerentry_type.value == "once":
self.timer.begin, self.timer.end = self.getBeginEnd()
if self.timer.eit is not None:
event = eEPGCache.getInstance().lookupEventId(self.timer.service_ref.ref, self.timer.eit)
if event:
n = event.getNumOfLinkageServices()
if n > 1:
tlist = []
ref = self.session.nav.getCurrentlyPlayingServiceReference()
parent = self.timer.service_ref.ref
selection = 0
for x in range(n):
i = event.getLinkageService(parent, x)
if i.toString() == ref.toString():
selection = x
tlist.append((i.getName(), i))
self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice to record..."), list = tlist, selection = selection)
return
elif n > 0:
parent = self.timer.service_ref.ref
self.timer.service_ref = ServiceReference(event.getLinkageService(parent, 0))
self.saveTimer()
self.close((True, self.timer))
def subserviceSelected(self, service):
if not service is None:
self.timer.service_ref = ServiceReference(service[1])
self.saveTimer()
self.close((True, self.timer))
def saveTimer(self):
self.session.nav.RecordTimer.saveTimer()
####################################################
def zapToService(service):
if not service is None:
if Servicelist.getRoot() != epg_bouquet: #already in correct bouquet?
Servicelist.clearPath()
if Servicelist.bouquet_root != epg_bouquet:
Servicelist.enterPath(Servicelist.bouquet_root)
Servicelist.enterPath(epg_bouquet)
Servicelist.setCurrentSelection(service) #select the service in Servicelist
Servicelist.zap()
def getBouquetServices(bouquet):
services = [ ]
Servicelist = eServiceCenter.getInstance().list(bouquet)
if not Servicelist is None:
while True:
service = Servicelist.getNext()
if not service.valid(): #check if end of list
break
if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
continue
services.append(ServiceReference(service))
return services
def cleanup():
global Session
Session = None
global Servicelist
Servicelist = None
def closed(ret=False):
closedScreen = dlg_stack.pop()
global bouquetSel
if bouquetSel and closedScreen == bouquetSel:
bouquetSel = None
dlgs=len(dlg_stack)
if ret and dlgs > 0: # recursive close wished
dlg_stack[dlgs-1].close(dlgs > 1)
if dlgs <= 0:
cleanup()
def openBouquetEPG(bouquet):
services = getBouquetServices(bouquet)
if len(services):
global epg_bouquet
epg_bouquet = bouquet
dlg_stack.append(Session.openWithCallback(closed, CoolTVGuide, services, zapToService, CoolBouquetchange))
return True
return False
def CoolBouquetchange(direction, epg):
global epg_bouquet
global man_bouquets
if bouquetSel:
if direction > 0:
bouquetSel.down()
else:
bouquetSel.up()
bouquet = bouquetSel.getCurrent()
services = getBouquetServices(bouquet)
if len(services):
# global epg_bouquet
epg_bouquet = bouquet
epg.setServices(services)
else:
for cool in range(len(cool_bouquets)):
if cool_bouquets[cool][1] == man_bouquets: break
cool = cool + 1
if direction > 0:
if cool == len(cool_bouquets): man = 0
else: man = cool
else:
if cool == 1:
man = len(cool_bouquets)
man = man - 1
else:
man = cool - 2
services = getBouquetServices(cool_bouquets[man][1])
if len(services):
# global man_bouquets
# global epg_bouquet
man_bouquets = cool_bouquets[man][1]
epg_bouquet = cool_bouquets[man][1]
epg.setServices(services)
def main(session, servicelist = None, **kwargs):
if servicelist == None:
if "servicelist" in kwargs:
servicelist = kwargs["servicelist"]
else:
session.open(MessageBox, _(" No function with your Image"), MessageBox.TYPE_ERROR)
return
global Session
Session = session
global cool_bouquets
global man_bouquets
global bouquetSel
global Servicelist
Servicelist = servicelist
man_bouquets = Servicelist and Servicelist.getRoot()
global bouquets
bouquets = Servicelist and Servicelist.getBouquetList()
del cool_bouquets[:]
for cool in range(len(bouquets)):
services = getBouquetServices(bouquets[cool][1])
if len(services):
cool_bouquets.append(bouquets[cool])
services = getBouquetServices(man_bouquets)
if bouquets is None:
cnt = 0
else:
cnt = len(bouquets)
if len(services):
cnt = 0
if cnt > 1: # show bouquet list
bouquetSel = Session.openWithCallback(closed, BouquetSelector, bouquets, openBouquetEPG, enableWrapAround=True)
dlg_stack.append(bouquetSel)
elif cnt == 1:
openBouquetEPG(bouquets[0][1])
if not openBouquetEPG(bouquets[0][1]):
cleanup()
elif config.misc.Cool_TV_Guide.autostart_bouquet.value == "Yes":
bouquetSel = Session.openWithCallback(closed, BouquetSelector, bouquets, openBouquetEPG, enableWrapAround=True)
dlg_stack.append(bouquetSel)
elif cnt == 0:
if not openBouquetEPG(man_bouquets):
cleanup()
def Plugins(**kwargs):
name = _("Cool TV Guide")
descr = _("Cool TV Guide 3D EPG with switchable 5-24 TV-Lines and changeable Buttons with Setup")
return [ PluginDescriptor(name=name, description=descr, where = PluginDescriptor.WHERE_EVENTINFO, fnc=main),
PluginDescriptor(name=name, description=descr, where = PluginDescriptor.WHERE_EXTENSIONSMENU, fnc=main) ]