Index: ipk/source/epg_crossepg_0_61/CONTROL/control =================================================================== --- ipk/source/epg_crossepg_0_61/CONTROL/control (revision 6396) +++ ipk/source/epg_crossepg_0_61/CONTROL/control (revision 6396) @@ -0,0 +1,10 @@ +Package: enigma2-plugin-epg-crossepg +Version: 0.61 +Architecture: sh4 +OE: CrossEPG by sandro cavazzoni for SKYit, SKYuk, AUsat +Section: epg +Priority: optional +Maintainer: sandro cavazzoni +Homepage: http://code.google.com/p/crossepg/ +Source: http://code.google.com/p/crossepg/ +Description: Plugin CrossEPG by sandro cavazzoni (modded by Civer) for SKYit, SKYuk and AUsat Index: ipk/source/epg_crossepg_0_61/CONTROL/postinst =================================================================== --- ipk/source/epg_crossepg_0_61/CONTROL/postinst (revision 6396) +++ ipk/source/epg_crossepg_0_61/CONTROL/postinst (revision 6396) @@ -0,0 +1,12 @@ +#!/bin/sh +TMP=/tmp/.epg + +echo "successfully installed" +echo "syncing disk" +sync +if [ `df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1 | wc -l` -eq 1 ]; then + SPACE=`df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1` + FREE=`expr $SPACE - 100` + echo new freespace size $FREE kb +fi +exit 0 Index: ipk/source/epg_crossepg_0_61/CONTROL/postrm =================================================================== --- ipk/source/epg_crossepg_0_61/CONTROL/postrm (revision 6396) +++ ipk/source/epg_crossepg_0_61/CONTROL/postrm (revision 6396) @@ -0,0 +1,14 @@ +#!/bin/sh +TMP=/tmp/.epg +PLUGINDIR=/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG +rm -r $PLUGINDIR > /dev/null 2>&1 + +echo "successfully removed" +echo "syncing disk" +sync +if [ `df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1 | wc -l` -eq 1 ]; then + SPACE=`df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1` + FREE=`expr $SPACE - 100` + echo new freespace size $FREE kb +fi +exit 0 Index: ipk/source/epg_crossepg_0_61/CONTROL/preinst =================================================================== --- ipk/source/epg_crossepg_0_61/CONTROL/preinst (revision 6396) +++ ipk/source/epg_crossepg_0_61/CONTROL/preinst (revision 6396) @@ -0,0 +1,44 @@ +#!/bin/sh +# +TMP=/tmp/.epg +echo "syncing disk" +sync + +model=`cat /etc/model` +echo"" +echo "Checking your Boxtype...." +echo "Some Plugins will not work correctly on your $model!" +echo "" +if [ "$model" = "" ]; then + echo "Sorry! This Plugin is not available for your $model because it will not work correctly!!!" + echo "Aborting installation..." + exit 1 +else + echo "Boxtype: $model OK" +fi + +if [ `df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1 | wc -l` -eq 1 ]; then + SPACE=`df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1` + FREE=`expr $SPACE - 100` + SIZE=307 + echo "checking freespace" + echo packege size $SIZE kb + echo freespace size $FREE kb + if [ "$FREE" -lt "$SIZE" ]; then + echo "sorry no freespace left on device" + exit 1 + else + echo ok + fi +fi +echo "installing CrossEPG 0.61 ..." +echo "checking OS" +if [ `cat /etc/motd | grep AAF | grep M | grep rev | wc -l` -eq 0 ]; then + echo --------------------------- + echo DONT USE this IPK Package!! + echo --- + echo Only for AAF Image!! + echo --------------------------- + exit 1 +fi +exit 0 Index: ipk/source/epg_crossepg_0_61/CONTROL/prerm =================================================================== --- ipk/source/epg_crossepg_0_61/CONTROL/prerm (revision 6396) +++ ipk/source/epg_crossepg_0_61/CONTROL/prerm (revision 6396) @@ -0,0 +1,11 @@ +#!/bin/sh +TMP=/tmp/.epg +echo "syncing disk" +sync +if [ `df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1 | wc -l` -eq 1 ]; then + SPACE=`df | grep /dev/mtdblock | grep var | sed 's/ \+/ /g' | cut -d ' ' -f4 | tail -n1` + FREE=`expr $SPACE - 100` + echo freespace size $FREE kb +fi +echo "removing CrossEPG v0.61" +exit 0 Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_about.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_about.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_about.py (revision 6396) @@ -0,0 +1,77 @@ +from enigma import getDesktop + +from Screens.Screen import Screen + +from Components.Label import Label +from Components.Button import Button +from Components.Pixmap import Pixmap +from Components.ActionMap import ActionMap + +from Tools.LoadPixmap import LoadPixmap + +from crossepglib import * +from crossepg_locale import _ + +import os +import sys + +class CrossEPG_About(Screen): + def __init__(self, session): + self.session = session + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/about_sd.xml" % (os.path.dirname(sys.modules[__name__].__file__)) + else: + skin = "%s/skins/about_hd.xml" % (os.path.dirname(sys.modules[__name__].__file__)) + f = open(skin, "r") + self.skin = f.read() + f.close() + + Screen.__init__(self, session) + + self.config = CrossEPG_Config() + self.config.load() + + self["about"] = Label("") + self["rytec_pix"] = Pixmap() + self["rytec_text"] = Label("") + self["krkadoni_pix"] = Pixmap() + self["krkadoni_text"] = Label("") + + self["actions"] = ActionMap(["SetupActions", "ColorActions"], + { + "red": self.quit, + "cancel": self.quit + }, -2) + + self["key_red"] = Button(_("Back")) + self["key_green"] = Button("") + self["key_yellow"] = Button("") + self["key_blue"] = Button("") + + try: + from version import version + except Exception, e: + version = "unknow version" + + credit = "SIFTeam CrossEPG %s (c) 2009-2010 Sandro Cavazzoni\n" % version + credit += "http://code.google.com/p/crossepg/\n\n" + credit += "Application credits:\n" + credit += "- Sandro Cavazzoni aka skaman (main developer)\n" + credit += "- Ambrosa (scripts developer)\n" + credit += "- Spaeleus (italian translations)\n" + credit += "- Bodyan (ukrainian translations)\n\n" + credit += "Sources credits:\n" + credit += "- Rytec http://www.rytec.be (xmltv providers for many countries)\n" + credit += "- Krkadoni http://www.krkadoni.com/ (xmltv provider for Ex Yugoslavia and various xepgdb sources maintainer)\n" + credit += "- Bodyan and dillinger http://linux-sat.tv/ (xmltv provider for ex USSR channels)" + self["about"].setText(credit) + + self.onFirstExecBegin.append(self.setImages) + + def setImages(self): + self["rytec_pix"].instance.setPixmapFromFile("%s/images/rytec.png" % (os.path.dirname(sys.modules[__name__].__file__))) + self["krkadoni_pix"].instance.setPixmapFromFile("%s/images/krkadoni.png" % (os.path.dirname(sys.modules[__name__].__file__))) + + def quit(self): + self.close() + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_auto.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_auto.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_auto.py (revision 6396) @@ -0,0 +1,298 @@ +from enigma import * #, quitMainloop +from Components.ServiceEventTracker import ServiceEventTracker +from Tools.Directories import fileExists +from crossepglib import * +from crossepg_downloader import CrossEPG_Downloader +from crossepg_converter import CrossEPG_Converter +from crossepg_loader import CrossEPG_Loader +from crossepg_importer import CrossEPG_Importer +from crossepg_locale import _ +from Screens.Screen import Screen + +from time import * + +import os + +class CrossEPG_Auto(Screen): + POLL_TIMER = 1800000 # poll every 30 minutes + #POLL_TIMER = 18000 + POLL_TIMER_FAST = 10000 # poll every 10 seconds + POLL_TIMER_BOOT = 60000 # poll every 1 minute + + def __init__(self): + self.session = None + + self.timer = eTimer() + self.standbyTimer = eTimer() + self.delayedInitTimer = eTimer() + + self.timer.callback.append(self.poll) + self.standbyTimer.callback.append(self.backToStandby) + self.delayedInitTimer.callback.append(self.init) + + self.config = CrossEPG_Config() + self.patchtype = getEPGPatchType() + + self.pdownloader = None + self.pimporter = None + self.pconverter = None + self.ploader = None + + self.osd = False + self.ontune = False + self.lock = False + + if fileExists("/tmp/crossepg.standby"): + os.system("rm -f /tmp/crossepg.standby") + print "[CrossEPG_Auto] coming back in standby in 30 seconds" + self.standbyTimer.start(30000, 1) + + self.config.load() + + if self.config.force_load_on_boot: + self.loader() + + def init(self, session = None): + if session != None: + self.session = session + + if time() < 1262325600: # if before 2010 probably the clock isn't yet updated + self.delayedInitTimer.start(60000, 1) #initialization delayed of 1 minute + return + + self.resetDailyDownloadDateCache() + self.timer.start(self.POLL_TIMER_BOOT, 1) + + def forcePoll(self): + self.timer.stop() + self.resetDailyDownloadDateCache() + self.timer.start(self.POLL_TIMER_FAST, 1) + + def resetDailyDownloadDateCache(self): + self.config.load() + now = time() + ttime = localtime(now) + ltime = (ttime[0], ttime[1], ttime[2], self.config.download_daily_hours, self.config.download_daily_minutes, 0, ttime[6], ttime[7], ttime[8]) + stime = mktime(ltime) + if stime < now: + ttime = localtime(stime+86400) # 24 hours in future + + # to avoid problems with internal clock (big changes on date/time) + # we step forward of 24 hours until the new time is greater than now + while ttime < now: + ttime = ttime+86400 # 24 hours in future + + self.cacheYear = ttime[0] + self.cacheMonth = ttime[1] + self.cacheDay = ttime[2] + + def poll(self): + from Screens.Standby import inStandby + self.config.load() + + if self.lock: + print "[CrossEPG_Auto] poll" + self.timer.start(self.POLL_TIMER_FAST, 1) + elif self.session.nav.RecordTimer.isRecording() or abs(self.session.nav.RecordTimer.getNextRecordingTime() - time()) <= 900 or abs(self.session.nav.RecordTimer.getNextZapTime() - time()) <= 900: + print "[CrossEPG_Auto] poll" + self.timer.start(self.POLL_TIMER, 1) + elif self.config.download_standby_enabled and inStandby: + self.providers = [] + now = time() + + if self.config.last_full_download_timestamp <= now - (24*60*60): + self.config.last_full_download_timestamp = now + self.config.last_partial_download_timestamp = now + self.config.save() + self.providers = self.config.providers + elif self.config.last_partial_download_timestamp <= now - (60*60): # skip xmltv... we download it only one time a day + self.config.last_partial_download_timestamp = now + self.config.save() + providers = self.config.getAllProviders() + i = 0 + for provider in providers[0]: + if self.config.providers.count(provider) > 0: + if providers[2][i] == "opentv": + self.providers.append(provider) + else: + print "[CrossEPG_Auto] is not OpenTV : skip provider %s (we download it only one time a day)" % provider + i += 1 + + if len(self.providers) == 0: + print "[CrossEPG_Auto] poll" + self.timer.start(self.POLL_TIMER, 1) + else: + print "[CrossEPG_Auto] automatic download in standby" + self.osd = False + self.ontune = False + self.config.deleteLog() + self.download(self.providers) + elif self.config.download_daily_enabled: + now = time() + ttime = localtime(now) + ltime = (self.cacheYear, self.cacheMonth, self.cacheDay, self.config.download_daily_hours, self.config.download_daily_minutes, 0, ttime[6], ttime[7], ttime[8]) + stime = mktime(ltime) + if stime < now and self.config.last_full_download_timestamp != stime: + from Screens.Standby import inStandby + self.osd = (inStandby == None) + self.ontune = False + self.config.last_full_download_timestamp = stime + self.config.last_partial_download_timestamp = stime + self.config.save() + ttime = localtime(stime+86400) # 24 hours in future + # to avoid problems with internal clock (big changes on date/time) + # we step forward of 24 hours until the new time is greater than now + while ttime < now: + ttime = ttime+86400 # 24 hours in future + self.cacheYear = ttime[0] + self.cacheMonth = ttime[1] + self.cacheDay = ttime[2] + self.config.deleteLog() + self.download(self.config.providers) + elif stime < now + (self.POLL_TIMER / 1000) and self.config.last_full_download_timestamp != stime: + print "[CrossEPG_Auto] poll" + delta = int(stime - now); + self.timer.start((delta + 5)*1000, 1) # 5 seconds offset + else: + print "[CrossEPG_Auto] poll" + self.timer.start(self.POLL_TIMER, 1) + elif self.config.download_tune_enabled: + now = time() + if self.config.last_partial_download_timestamp <= now - (60*60): + providerok = None + sservice = self.session.nav.getCurrentlyPlayingServiceReference() + if sservice: + service = sservice.toString() + + providers = self.config.getAllProviders() + i = 0 + for provider in providers[0]: + if providers[2][i] == "opentv": + if self.config.getChannelID(provider) == service: + providerok = provider + break; + i += 1 + + if providerok: + print "[CrossEPG_Auto] automatic download on tune" + self.osd = False + self.ontune = True + self.config.last_partial_download_timestamp = now + self.config.save() + self.config.deleteLog() + self.download([provider,]) + else: + print "[CrossEPG_Auto] poll" + self.timer.start(self.POLL_TIMER, 1) + else: + print "[CrossEPG_Auto] poll" + self.timer.start(self.POLL_TIMER, 1) + else: + print "[CrossEPG_Auto] poll" + self.timer.start(self.POLL_TIMER, 1) + + def download(self, providers): + print "[CrossEPG_Auto] providers selected for download:" + for provider in providers: + print "[CrossEPG_Auto] %s" % provider + if self.osd: + self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, providers) + else: + self.pdownloader = CrossEPG_Downloader(self.session, providers, self.downloadCallback, True) + + def downloadCallback(self, ret): + self.pdownloader = None + + from Screens.Standby import inStandby + if inStandby: # if in standby force service stop + self.session.nav.stopService() + + if ret: + if self.config.csv_import_enabled == 1 and not self.ontune: + self.importer() + else: + if self.patchtype != 3: + self.converter() + else: + self.loader() + else: + self.timer.start(self.POLL_TIMER, 1) + + def importer(self): + print "[CrossEPG_Auto] start csv import" + if self.osd: + self.session.openWithCallback(self.importerCallback, CrossEPG_Importer) + else: + self.pimporter = CrossEPG_Importer(self.session, self.importerCallback, True) + + def importerCallback(self, ret): + self.pimporter = None + + if ret: + if self.patchtype != 3: + self.converter() + else: + self.loader() + else: + self.timer.start(self.POLL_TIMER, 1) + + def converter(self): + print "[CrossEPG_Auto] start epg.dat conversion" + if self.osd: + self.session.openWithCallback(self.converterCallback, CrossEPG_Converter) + else: + self.pconverter = CrossEPG_Converter(self.session, self.converterCallback, True) + + def converterCallback(self, ret): + self.pconverter = None + + if ret: + if self.patchtype != -1: + self.loader() + else: + if self.config.download_daily_reboot: + from Screens.Standby import inStandby + if inStandby: + os.system("touch /tmp/crossepg.standby") + else: + os.system("rm /tmp/crossepg.standby") + print "[CrossEPG_Auto] rebooting" + from Screens.Standby import TryQuitMainloop + self.session.open(TryQuitMainloop, 3) + else: + self.timer.start(self.POLL_TIMER, 1) + else: + self.timer.start(self.POLL_TIMER, 1) + + def loader(self): + if self.osd: + self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader) + else: + self.ploader = CrossEPG_Loader(self.session, self.loaderCallback, True) + + def loaderCallback(self, ret): + self.ploader = None + self.timer.start(self.POLL_TIMER, 1) + + def stop(self): + if self.pdownloader: + self.pdownloader.quit() + self.pdownloader = None + if self.pimporter: + self.pimporter.quit() + self.pimporter = None + if self.pconverter: + self.pconverter.quit() + self.pconverter = None + if self.ploader: + self.ploader.quit() + self.ploader = None + + def backToStandby(self): + from Screens.Standby import inStandby + if inStandby == None: + print "[CrossEPG_Auto] coming back in standby" + from Screens.Standby import Standby + self.session.open(Standby) + +crossepg_auto = CrossEPG_Auto() Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_converter.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_converter.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_converter.py (revision 6396) @@ -0,0 +1,130 @@ +from enigma import getDesktop, eTimer + +from Components.Label import Label +from Components.Pixmap import Pixmap +from Components.ProgressBar import ProgressBar +from Components.ActionMap import NumberActionMap + +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox + +from crossepglib import * +from crossepg_locale import _ + +import os +import sys + +class CrossEPG_Converter(Screen): + def __init__(self, session, pcallback = None, noosd = False): + self.session = session + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/downloader_sd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 0 + else: + skin = "%s/skins/downloader_hd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 1 + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + self["background"] = Pixmap() + self["action"] = Label(_("Starting converter")) + self["status"] = Label("") + self["progress"] = ProgressBar() + self["progress"].hide() + self["actions"] = NumberActionMap(["WizardActions", "InputActions"], + { + "back": self.quit + }, -1) + + self.retValue = True + self.config = CrossEPG_Config() + self.config.load() + self.lamedb = self.config.lamedb + self.db_root = self.config.db_root + if not pathExists(self.db_root): + if not createDir(self.db_root): + self.db_root = "/hdd/crossepg" + + self.pcallback = pcallback + + self.wrapper = CrossEPG_Wrapper() + self.wrapper.addCallback(self.wrapperCallback) + + self.hideprogress = eTimer() + self.hideprogress.callback.append(self["progress"].hide) + + self.pcallbacktimer = eTimer() + self.pcallbacktimer.callback.append(self.doCallback) + + if noosd: + self.wrappertimer = eTimer() + self.wrappertimer.callback.append(self.startWrapper) + self.wrappertimer.start(100, 1) + else: + self.onFirstExecBegin.append(self.firstExec) + + def firstExec(self): + if self.isHD: + self["background"].instance.setPixmapFromFile("%s/images/background_hd.png" % (os.path.dirname(sys.modules[__name__].__file__))) + else: + self["background"].instance.setPixmapFromFile("%s/images/background.png" % (os.path.dirname(sys.modules[__name__].__file__))) + self.startWrapper() + + def startWrapper(self): + self.wrapper.init(CrossEPG_Wrapper.CMD_CONVERTER, self.db_root) + + def wrapperCallback(self, event, param): + if event == CrossEPG_Wrapper.EVENT_READY: + self.wrapper.epgdat("%s/ext.epg.dat" % (self.db_root)) + self.wrapper.lamedb("/etc/enigma2/%s" % (self.lamedb)) + self.wrapper.convert() + + elif event == CrossEPG_Wrapper.EVENT_END: + self.wrapper.delCallback(self.wrapperCallback) + self.wrapper.quit() + self.closeAndCallback(self.retValue) + + elif event == CrossEPG_Wrapper.EVENT_ACTION: + self["action"].text = param + + elif event == CrossEPG_Wrapper.EVENT_STATUS: + self["status"].text = param + + elif event == CrossEPG_Wrapper.EVENT_PROGRESS: + self["progress"].setValue(param) + + elif event == CrossEPG_Wrapper.EVENT_PROGRESSONOFF: + if param: + self.hideprogress.stop() + self["progress"].setValue(0) + self["progress"].show() + else: + self["progress"].setValue(100) + self.hideprogress.start(500, 1) + + elif event == CrossEPG_Wrapper.EVENT_QUIT: + self.closeAndCallback(self.retValue) + + elif event == CrossEPG_Wrapper.EVENT_ERROR: + self.session.open(MessageBox, _("CrossEPG error: %s") % (param), type = MessageBox.TYPE_INFO, timeout = 20) + self.retValue = False + self.quit() + + def quit(self): + if self.wrapper.running(): + self.retValue = False + self.wrapper.quit() + else: + self.closeAndCallback(False) + + def closeAndCallback(self, ret): + self.retValue = ret + self.close(ret) + self.pcallbacktimer.start(0, 1) + + def doCallback(self): + if self.pcallback: + self.pcallback(self.retValue) + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_downloader.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_downloader.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_downloader.py (revision 6396) @@ -0,0 +1,196 @@ +from enigma import getDesktop, iPlayableService, eTimer, eServiceReference + +from Components.Label import Label +from Components.Pixmap import Pixmap +from Components.ProgressBar import ProgressBar +from Components.ServiceEventTracker import ServiceEventTracker +from Components.ActionMap import NumberActionMap + +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox + +from crossepglib import * +from crossepg_locale import _ + +import os +import sys + +class CrossEPG_Downloader(Screen): + def __init__(self, session, providers, pcallback = None, noosd = False): + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/downloader_sd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 0 + else: + skin = "%s/skins/downloader_hd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 1 + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + self.session = session + + self["background"] = Pixmap() + self["action"] = Label(_("Starting downloader")) + self["status"] = Label("") + self["progress"] = ProgressBar() + self["progress"].hide() + self["actions"] = NumberActionMap(["WizardActions", "InputActions"], + { + "back": self.quit + }, -1) + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evTunedIn: self.tuned, + }) + + self.retValue = True + self.provider_index = 0 + self.status = 0 + self.open = False + self.saved = False + self.tune_enabled = False + self.oldService = self.session.nav.getCurrentlyPlayingServiceReference() + self.config = CrossEPG_Config() + self.config.load() + self.providers = providers + self.pcallback = pcallback + + self.wrapper = CrossEPG_Wrapper() + self.wrapper.addCallback(self.wrapperCallback) + + self.timeout = eTimer() + self.timeout.callback.append(self.quit) + + self.hideprogress = eTimer() + self.hideprogress.callback.append(self["progress"].hide) + + self.pcallbacktimer = eTimer() + self.pcallbacktimer.callback.append(self.doCallback) + + self.wrappertimer = eTimer() + self.wrappertimer.callback.append(self.initWrapper) + + if noosd: + self.wrappertimer.start(100, 1) + else: + self.onFirstExecBegin.append(self.firstExec) + + def firstExec(self): + if self.isHD: + self["background"].instance.setPixmapFromFile("%s/images/background_hd.png" % (os.path.dirname(sys.modules[__name__].__file__))) + else: + self["background"].instance.setPixmapFromFile("%s/images/background.png" % (os.path.dirname(sys.modules[__name__].__file__))) + self.wrappertimer.start(100, 1) + + def initWrapper(self): + if len(self.providers) == 0: + self.closeAndCallback(True) + else: + self.wrapper.init(CrossEPG_Wrapper.CMD_DOWNLOADER, self.config.db_root) + + def download(self): + if self.config.getChannelProtocol(self.providers[self.provider_index]) != "script": + if not self.open: + self.wrapper.open() + self.open = True + self.saved = False + else: + if self.open: + self.wrapper.save() + self.saved = True + self.provider_index -= 1 + return + + service = self.config.getChannelID(self.providers[self.provider_index]) + try: + cservice = self.session.nav.getCurrentlyPlayingServiceReference().toString() + except Exception, e: + cservice = None + + if service: + print "[CrossEPG_Downloader] %s service is %s" % (self.providers[self.provider_index], service) + if service == cservice: + self.wrapper.download(self.providers[self.provider_index]) + else: + self.tune_enabled = True + self.wrapper.wait() + self.timeout.start(60000, 1) + self.session.nav.playService(eServiceReference(service)) + else: + self.wrapper.download(self.providers[self.provider_index]) + + def wrapperCallback(self, event, param): + if event == CrossEPG_Wrapper.EVENT_READY: + self.download() + + elif event == CrossEPG_Wrapper.EVENT_END: + if self.saved and self.open: + self.wrapper.close() + self.open = False + + if self.status == 0: + self.provider_index += 1 + if self.provider_index < len(self.providers): + self.download() + else: + self.status = 1 + if self.oldService: + self.session.nav.playService(self.oldService) + if self.open: + self.wrapper.save() + else: + self.wrapper.quit() + else: + if self.open: + self.wrapper.close() + self.wrapper.quit() + + elif event == CrossEPG_Wrapper.EVENT_ACTION: + self["action"].text = param + self["status"].text = "" + + elif event == CrossEPG_Wrapper.EVENT_STATUS or event == CrossEPG_Wrapper.EVENT_URL: + self["status"].text = param + + elif event == CrossEPG_Wrapper.EVENT_PROGRESS: + self["progress"].setValue(param) + + elif event == CrossEPG_Wrapper.EVENT_PROGRESSONOFF: + if param: + self.hideprogress.stop() + self["progress"].setValue(0) + self["progress"].show() + else: + self["progress"].setValue(100) + self.hideprogress.start(500, 1) + elif event == CrossEPG_Wrapper.EVENT_QUIT: + self.closeAndCallback(self.retValue) + elif event == CrossEPG_Wrapper.EVENT_ERROR: + self.session.open(MessageBox, _("CrossEPG error: %s") % (param), type = MessageBox.TYPE_INFO, timeout = 20) + self.retValue = False + self.quit() + + def tuned(self): + if self.tune_enabled: + self.timeout.stop() + self.wrapper.download(self.providers[self.provider_index]) + self.tune_enabled = False + + def quit(self): + if self.wrapper.running(): + self.retValue = False + self.wrapper.quit() + else: + self.closeAndCallback(False) + + def closeAndCallback(self, ret): + self.retValue = ret + self.pcallbacktimer.start(0, 1) + self.close(ret) + + def doCallback(self): + if self.pcallback: + self.pcallback(self.retValue) + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_importer.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_importer.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_importer.py (revision 6396) @@ -0,0 +1,142 @@ +from enigma import getDesktop, eTimer + +from Components.Label import Label +from Components.Pixmap import Pixmap +from Components.ProgressBar import ProgressBar +from Components.ActionMap import NumberActionMap + +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox + +from crossepglib import * +from crossepg_locale import _ + +import os +import sys + +class CrossEPG_Importer(Screen): + def __init__(self, session, pcallback = None, noosd = False): + self.session = session + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/downloader_sd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 0 + else: + skin = "%s/skins/downloader_hd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 1 + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + self["background"] = Pixmap() + self["action"] = Label(_("Starting importer")) + self["status"] = Label("") + self["progress"] = ProgressBar() + self["progress"].hide() + self["actions"] = NumberActionMap(["WizardActions", "InputActions"], + { + "back": self.quit + }, -1) + + self.retValue = True + self.config = CrossEPG_Config() + self.config.load() + self.lamedb = self.config.lamedb + self.db_root = self.config.db_root + if not pathExists(self.db_root): + if not createDir(self.db_root): + self.db_root = "/hdd/crossepg" + + self.pcallback = pcallback + + self.wrapper = CrossEPG_Wrapper() + self.wrapper.addCallback(self.wrapperCallback) + + self.hideprogress = eTimer() + self.hideprogress.callback.append(self["progress"].hide) + + self.pcallbacktimer = eTimer() + self.pcallbacktimer.callback.append(self.doCallback) + + self.status = 0 + + if noosd: + self.wrappertimer = eTimer() + self.wrappertimer.callback.append(self.startWrapper) + self.wrappertimer.start(100, 1) + else: + self.onFirstExecBegin.append(self.firstExec) + + def firstExec(self): + if self.isHD: + self["background"].instance.setPixmapFromFile("%s/images/background_hd.png" % (os.path.dirname(sys.modules[__name__].__file__))) + else: + self["background"].instance.setPixmapFromFile("%s/images/background.png" % (os.path.dirname(sys.modules[__name__].__file__))) + self.startWrapper() + + def startWrapper(self): + self.wrapper.init(CrossEPG_Wrapper.CMD_IMPORTER, self.db_root) + + def wrapperCallback(self, event, param): + if event == CrossEPG_Wrapper.EVENT_READY: + self.wrapper.importx() + + elif event == CrossEPG_Wrapper.EVENT_END: + if self.status == 0: + self.status += 1 + self.wrapper.save() + else: + self.wrapper.delCallback(self.wrapperCallback) + self.wrapper.quit() + self.closeAndCallback(self.retValue) + + elif event == CrossEPG_Wrapper.EVENT_FILE: + self["action"].text = _("Parsing") + self["status"].text = param + + elif event == CrossEPG_Wrapper.EVENT_URL: + self["action"].text = _("Downloading") + self["status"].text = param + + elif event == CrossEPG_Wrapper.EVENT_ACTION: + self["action"].text = param + + elif event == CrossEPG_Wrapper.EVENT_STATUS: + self["status"].text = param + + elif event == CrossEPG_Wrapper.EVENT_PROGRESS: + self["progress"].setValue(param) + + elif event == CrossEPG_Wrapper.EVENT_PROGRESSONOFF: + if param: + self.hideprogress.stop() + self["progress"].setValue(0) + self["progress"].show() + else: + self["progress"].setValue(100) + self.hideprogress.start(500, 1) + + elif event == CrossEPG_Wrapper.EVENT_QUIT: + self.closeAndCallback(self.retValue) + + elif event == CrossEPG_Wrapper.EVENT_ERROR: + self.session.open(MessageBox, _("CrossEPG error: %s") % (param), type = MessageBox.TYPE_INFO, timeout = 20) + self.retValue = False + self.quit() + + def quit(self): + if self.wrapper.running(): + self.retValue = False + self.wrapper.quit() + else: + self.closeAndCallback(False) + + def closeAndCallback(self, ret): + self.retValue = ret + self.close(ret) + self.pcallbacktimer.start(0, 1) + + def doCallback(self): + if self.pcallback: + self.pcallback(self.retValue) + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_info.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_info.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_info.py (revision 6396) @@ -0,0 +1,84 @@ +from enigma import getDesktop + +from Screens.Screen import Screen + +from Components.Label import Label +from Components.Button import Button +from Components.ActionMap import ActionMap + +from crossepglib import * +from crossepg_locale import _ + +import os +import sys + +class CrossEPG_Info(Screen): + def __init__(self, session): + self.session = session + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/info_sd.xml" % (os.path.dirname(sys.modules[__name__].__file__)) + else: + skin = "%s/skins/info_hd.xml" % (os.path.dirname(sys.modules[__name__].__file__)) + f = open(skin, "r") + self.skin = f.read() + f.close() + + Screen.__init__(self, session) + + self.config = CrossEPG_Config() + self.config.load() + + self["version"] = Label("") + self["create"] = Label("") + self["last_update"] = Label("") + self["headersdb_size"] = Label("") + self["descriptorsdb_size"] = Label("") + self["indexesdb_size"] = Label("") + self["aliasesdb_size"] = Label("") + self["total_size"] = Label("") + self["channels_count"] = Label("") + self["events_count"] = Label("") + self["hashes_count"] = Label("") + self["actions"] = ActionMap(["SetupActions", "ColorActions"], + { + "red": self.quit, + "cancel": self.quit + }, -2) + + self["key_red"] = Button(_("Back")) + self["key_green"] = Button("") + self["key_yellow"] = Button("") + self["key_blue"] = Button("") + + self.wrapper = CrossEPG_Wrapper() + self.wrapper.addCallback(self.__wrapperCallback) + self.wrapper.init(CrossEPG_Wrapper.CMD_INFO, self.config.db_root) + + def quit(self): + if not self.wrapper.running(): + self.close() + + def __wrapperCallback(self, event, param): + if event == CrossEPG_Wrapper.INFO_HEADERSDB_SIZE: + self["headersdb_size"].text = _("Headers db size: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_DESCRIPTORSDB_SIZE: + self["descriptorsdb_size"].text = _("Descriptors db size: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_INDEXESDB_SIZE: + self["indexesdb_size"].text = _("Indexes db size: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_ALIASESDB_SIZE: + self["aliasesdb_size"].text = _("Aliases db size: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_TOTAL_SIZE: + self["total_size"].text = _("Total size: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_CHANNELS_COUNT: + self["channels_count"].text = _("Channels count: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_EVENTS_COUNT: + self["events_count"].text = _("Events count: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_HASHES_COUNT: + self["hashes_count"].text = _("Hashes count: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_CREATION_TIME: + self["create"].text = _("Creation time: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_UPDATE_TIME: + self["last_update"].text = _("Last update time: %s") % (param) + elif event == CrossEPG_Wrapper.INFO_VERSION: + self["version"].text = _("Version: %s") % (param) + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_loader.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_loader.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_loader.py (revision 6396) @@ -0,0 +1,226 @@ +from enigma import getDesktop, eTimer + +from Components.config import config +from Components.Label import Label +from Components.Pixmap import Pixmap +from Components.ProgressBar import ProgressBar +from Components.ActionMap import NumberActionMap + +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox + +from crossepglib import * +from crossepg_locale import _ + +import _enigma +import os +import sys + +class CrossEPG_Loader(Screen): + def __init__(self, session, pcallback = None, noosd = False): + self.session = session + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/downloader_sd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 0 + else: + skin = "%s/skins/downloader_hd.xml" % os.path.dirname(sys.modules[__name__].__file__) + self.isHD = 1 + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + self["background"] = Pixmap() + self["action"] = Label(_("Loading data")) + self["status"] = Label("") + self["progress"] = ProgressBar() + self["progress"].hide() + + self.retValue = True + self.config = CrossEPG_Config() + self.config.load() + self.db_root = self.config.db_root + if not pathExists(self.db_root): + if not createDir(self.db_root): + self.db_root = "/hdd/crossepg" + + self.pcallback = pcallback + self.wrapper = None + + self.pcallbacktimer = eTimer() + self.pcallbacktimer.callback.append(self.doCallback) + + if pathExists("/usr/crossepg"): + self.home_directory = "/usr/crossepg" + elif pathExists("/var/crossepg"): + self.home_directory = "/var/crossepg" + else: + print "[CrossEPG_Config] ERROR!! CrossEPG binaries non found" + + # check for common patches + try: + self.xepgpatch = new.instancemethod(_enigma.eEPGCache_crossepgImportEPGv21,None,eEPGCache) + print "[CrossEPG_Loader] patch crossepg v2.1 found" + except Exception, e: + self.xepgpatch = None + + try: + self.epgpatch = new.instancemethod(_enigma.eEPGCache_load,None,eEPGCache) + print "[CrossEPG_Loader] patch epgcache.load() found" + except Exception, e: + self.epgpatch = None + + try: + self.edgpatch = new.instancemethod(_enigma.eEPGCache_reloadEpg,None,eEPGCache) + print "[CrossEPG_Loader] patch EDG NEMESIS found" + except Exception, e: + self.edgpatch = None + + try: + self.oudeispatch = new.instancemethod(_enigma.eEPGCache_importEvent,None,eEPGCache) + print "[CrossEPG_Loader] patch Oudeis found" + except Exception, e: + self.oudeispatch = None + + if self.xepgpatch: + self.timer = eTimer() + self.timer.callback.append(self.loadEPG2) + self.timer.start(200, 1) + + elif self.epgpatch: + self.timer = eTimer() + self.timer.callback.append(self.loadEPG) + self.timer.start(200, 1) + + elif self.edgpatch: + self.timer = eTimer() + self.timer.callback.append(self.loadEDG) + self.timer.start(200, 1) + + elif self.oudeispatch: + self["actions"] = NumberActionMap(["WizardActions", "InputActions"], + { + "back": self.quit + }, -1) + + self.wrapper = CrossEPG_Wrapper() + self.wrapper.addCallback(self.wrapperCallback) + + self.timeout = eTimer() + self.timeout.callback.append(self.quit) + + self.hideprogress = eTimer() + self.hideprogress.callback.append(self["progress"].hide) + + self.epg_channel = None; + self.epg_tuple = () + self.epg_starttime = 0 + self.epg_length = 0 + self.epg_name = "" + + self.wrapper.init(CrossEPG_Wrapper.CMD_CONVERTER, self.db_root) + else: + print "No patch found... please reboot enigma2 manually" + self.closeAndCallback(True) + + if not noosd: + self.onFirstExecBegin.append(self.firstExec) + + def firstExec(self): + if self.isHD: + self["background"].instance.setPixmapFromFile("%s/images/background_hd.png" % (os.path.dirname(sys.modules[__name__].__file__))) + else: + self["background"].instance.setPixmapFromFile("%s/images/background.png" % (os.path.dirname(sys.modules[__name__].__file__))) + + def loadEPG2(self): + print "[CrossEPG_Loader] loading data with crossepg patch v2" + self.xepgpatch(eEPGCache.getInstance(), self.db_root) + self.closeAndCallback(True) + + def loadEPG(self): + cmd = "%s/crossepg_epgcopy %s/ext.epg.dat /hdd/epg.dat" % (self.home_directory, self.db_root) + print "[CrossEPG_Loader] %s" % (cmd) + os.system(cmd) + self.epgpatch(eEPGCache.getInstance()) + self.closeAndCallback(True) + + def loadEDG(self): + cmd = "%s/crossepg_epgcopy %s/ext.epg.dat %s/epg.dat" % (self.home_directory, self.db_root, config.nemepg.path.value) + print "[CrossEPG_Loader] %s" % (cmd) + os.system(cmd) + self.edgpatch(eEPGCache.getInstance()) + self.closeAndCallback(True) + + def wrapperCallback(self, event, param): + if event == CrossEPG_Wrapper.EVENT_READY: + self.wrapper.text() + + elif event == CrossEPG_Wrapper.EVENT_END: + self.wrapper.quit() + + elif event == CrossEPG_Wrapper.EVENT_ACTION: + self["action"].text = param + + elif event == CrossEPG_Wrapper.EVENT_STATUS: + self["status"].text = param + + elif event == CrossEPG_Wrapper.EVENT_PROGRESS: + self["progress"].setValue(param) + + elif event == CrossEPG_Wrapper.EVENT_CHANNEL: + if self.epg_channel: + if len(self.epg_tuple) > 0: + self.oudeispatch(eEPGCache.getInstance(), self.epg_channel, self.epg_tuple) + self.epg_tuple = () + self.epg_channel = param + + elif event == CrossEPG_Wrapper.EVENT_STARTTIME: + self.epg_starttime = param + + elif event == CrossEPG_Wrapper.EVENT_LENGTH: + self.epg_length = param + + elif event == CrossEPG_Wrapper.EVENT_NAME: + self.epg_name = param + + elif event == CrossEPG_Wrapper.EVENT_DESCRIPTION: + if self.epg_channel: + self.epg_tuple += ((self.epg_starttime, self.epg_length, self.epg_name, self.epg_name, param, 0),) + + elif event == CrossEPG_Wrapper.EVENT_PROGRESSONOFF: + if param: + self.hideprogress.stop() + self["progress"].setValue(0) + self["progress"].show() + else: + self["progress"].setValue(100) + self.hideprogress.start(500, 1) + elif event == CrossEPG_Wrapper.EVENT_QUIT: + if self.epg_channel: + if len(self.epg_tuple) > 0: + self.oudeispatch(eEPGCache.getInstance(), self.epg_channel, self.epg_tuple) + self.closeAndCallback(self.retValue) + + elif event == CrossEPG_Wrapper.EVENT_ERROR: + self.session.open(MessageBox, _("CrossEPG error: %s") % (param), type = MessageBox.TYPE_INFO, timeout = 20) + self.retValue = False + self.quit() + + def quit(self): + if self.wrapper: + if self.wrapper.running(): + self.retValue = False + self.wrapper.quit() + return + + self.closeAndCallback(False) + + def closeAndCallback(self, ret): + self.retValue = ret + self.close(ret) + self.pcallbacktimer.start(0, 1) + + def doCallback(self): + if self.pcallback: + self.pcallback(self.retValue) + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_locale.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_locale.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_locale.py (revision 6396) @@ -0,0 +1,25 @@ +from Components.Language import language +from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_LANGUAGE + +import os,gettext + +PluginLanguageDomain = "CrossEPG" +PluginLanguagePath = "SystemPlugins/CrossEPG/po" + +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! + print "[CrossEPG] set language to ", lang + gettext.bindtextdomain(PluginLanguageDomain, resolveFilename(SCOPE_PLUGINS, PluginLanguagePath)) + gettext.bindtextdomain('enigma2', resolveFilename(SCOPE_LANGUAGE, "")) + +def _(txt): + t = gettext.dgettext(PluginLanguageDomain, txt) + if t == txt: + #print "[CrossEPG] fallback to default translation for", txt + t = gettext.dgettext('enigma2', txt) + return t + + +localeInit() +language.addCallback(localeInit) Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_main.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_main.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_main.py (revision 6396) @@ -0,0 +1,86 @@ +from enigma import * +from Screens.MessageBox import MessageBox + +from crossepglib import * +from crossepg_downloader import CrossEPG_Downloader +from crossepg_importer import CrossEPG_Importer +from crossepg_converter import CrossEPG_Converter +from crossepg_loader import CrossEPG_Loader +from crossepg_setup import CrossEPG_Setup +from crossepg_menu import CrossEPG_Menu +from crossepg_auto import crossepg_auto + +class CrossEPG_Main: + def __init__(self): + self.config = CrossEPG_Config() + self.patchtype = getEPGPatchType() + + def downloader(self, session, **kwargs): + self.session = session + crossepg_auto.lock = True + crossepg_auto.stop() + self.config.load() + if self.config.configured == 0: + self.session.open(MessageBox, _("Please configure crossepg before start downloader"), type = MessageBox.TYPE_ERROR) + else: + self.config.deleteLog() + self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, self.config.providers) + + def downloadCallback(self, ret): + if ret: + if self.config.csv_import_enabled == 1: + self.importer() + else: + if self.patchtype != 3: + self.converter() + else: + self.loader() + else: + crossepg_auto.lock = False + + def importer(self): + self.session.openWithCallback(self.importerCallback, CrossEPG_Importer) + + def importerCallback(self, ret): + if ret: + if self.patchtype != 3: + self.converter() + else: + self.loader() + else: + crossepg_auto.lock = False + + def converter(self): + self.session.openWithCallback(self.converterCallback, CrossEPG_Converter) + + def converterCallback(self, ret): + if ret: + if self.patchtype != -1: + self.loader() + else: + if self.config.download_manual_reboot: + from Screens.Standby import TryQuitMainloop + self.session.open(TryQuitMainloop, 3) + else: + crossepg_auto.lock = False + else: + crossepg_auto.lock = False + + def loader(self): + self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader) + + def loaderCallback(self, ret): + crossepg_auto.lock = False + + def setup(self, session, **kwargs): + crossepg_auto.lock = True + crossepg_auto.stop() + session.openWithCallback(self.setupCallback, CrossEPG_Menu) + + def setupCallback(self): + crossepg_auto.lock = False + + def autostart(self, reason, session): + crossepg_auto.init(session) + +crossepg_main = CrossEPG_Main() Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_menu.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_menu.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_menu.py (revision 6396) @@ -0,0 +1,164 @@ +from enigma import * +from crossepglib import * +from crossepg_auto import crossepg_auto +from crossepg_info import CrossEPG_Info +from crossepg_about import CrossEPG_About +from crossepg_providers import CrossEPG_Providers +from crossepg_setup import CrossEPG_Setup +from crossepg_downloader import CrossEPG_Downloader +from crossepg_importer import CrossEPG_Importer +from crossepg_converter import CrossEPG_Converter +from crossepg_loader import CrossEPG_Loader +from crossepg_ordering import CrossEPG_Ordering +from crossepg_locale import _ + +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox + +from Components.Label import Label +from Components.Button import Button +from Components.MenuList import MenuList +from Components.Sources.List import List +from Components.MultiContent import MultiContentEntryText +from Components.Harddisk import harddiskmanager +from Components.PluginComponent import plugins +from Components.ActionMap import ActionMap +from Tools.LoadPixmap import LoadPixmap +from Tools.Directories import resolveFilename, SCOPE_PLUGINS +from Plugins.Plugin import PluginDescriptor + +from time import * + +try: + from version import version +except Exception, e: + pass + +import _enigma + +class CrossEPG_Menu(Screen): + def __init__(self, session): + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/menu_sd.xml" % os.path.dirname(sys.modules[__name__].__file__) + else: + skin = "%s/skins/menu_hd.xml" % os.path.dirname(sys.modules[__name__].__file__) + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + self.config = CrossEPG_Config() + self.config.load() + self.patchtype = getEPGPatchType() + + l = [] + l.append(self.buildListEntry(_("Configure"), "configure.png")) + l.append(self.buildListEntry(_("XMLTV providers"), "xmltv.png")) + l.append(self.buildListEntry(_("OpenTV providers"), "opentv.png")) + l.append(self.buildListEntry(_("XEPGDB providers"), "xepgdb.png")) + l.append(self.buildListEntry(_("Scripts providers"), "scripts.png")) + l.append(self.buildListEntry(_("Providers start order"), "reorder.png")) + l.append(self.buildListEntry(_("Download now"), "download.png")) + l.append(self.buildListEntry(_("Force csv import now"), "csv.png")) + l.append(self.buildListEntry(_("Force epg.dat conversion now"), "conversion.png")) + l.append(self.buildListEntry(_("Force epg reload"), "reload.png")) + l.append(self.buildListEntry(_("Info about database"), "dbinfo.png")) + l.append(self.buildListEntry(_("About"), "about.png")) + + self["list"] = List(l) + self["setupActions"] = ActionMap(["SetupActions"], + { + "cancel": self.quit, + "ok": self.openSelected, + }, -2) + + self.onFirstExecBegin.append(self.setTitleWithVerion) + + if self.config.configured == 0: + self.onFirstExecBegin.append(self.openSetup) + + def buildListEntry(self, description, image): + pixmap = LoadPixmap(cached=True, path="%s/images/%s" % (os.path.dirname(sys.modules[__name__].__file__), image)); + return((pixmap, description)) + + def openSetup(self): + self.session.open(CrossEPG_Setup) + + def setTitleWithVerion(self): + try: + global version + self.setTitle("CrossEPG - %s" % version) + except Exception, e: + self.setTitle("CrossEPG - unknow version") + + def openSelected(self): + index = self["list"].getIndex() + if index == 0: + self.session.open(CrossEPG_Setup) + elif index == 1: + self.session.open(CrossEPG_Providers, "xmltv") + elif index == 2: + self.session.open(CrossEPG_Providers, "opentv") + elif index == 3: + self.session.open(CrossEPG_Providers, "xepgdb") + elif index == 4: + self.session.open(CrossEPG_Providers, "script") + elif index == 5: + self.session.open(CrossEPG_Ordering) + elif index == 6: + self.config.load() + self.config.deleteLog() + self.downloader() + elif index == 7: + self.importer() + elif index == 8: + self.converter() + elif index == 9: + self.loader() + elif index == 10: + self.session.open(CrossEPG_Info) + elif index == 11: + self.session.open(CrossEPG_About) + + def quit(self): + self.close() + + def downloader(self): + self.config.load() + self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, self.config.providers) + + def downloadCallback(self, ret): + if ret: + if self.config.csv_import_enabled == 1: + self.importer() + else: + if self.patchtype != 3: + self.converter() + else: + self.loader() + + def importer(self): + self.session.openWithCallback(self.importerCallback, CrossEPG_Importer) + + def importerCallback(self, ret): + if ret: + if self.patchtype != 3: + self.converter() + else: + self.loader() + + def converter(self): + self.session.openWithCallback(self.converterCallback, CrossEPG_Converter) + + def converterCallback(self, ret): + if ret: + if self.patchtype != -1: + self.loader() + else: + if self.config.download_manual_reboot: + from Screens.Standby import TryQuitMainloop + session.open(TryQuitMainloop, 3) + + def loader(self): + self.session.open(CrossEPG_Loader) + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_ordering.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_ordering.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_ordering.py (revision 6396) @@ -0,0 +1,116 @@ +from enigma import getDesktop + +from Screens.Screen import Screen + +from Components.Label import Label +from Components.Button import Button +from Components.ActionMap import ActionMap +from Components.Sources.List import List + +from Tools.LoadPixmap import LoadPixmap + +from crossepg_locale import _ + +from crossepglib import * + +class CrossEPG_Ordering(Screen): + def __init__(self, session): + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/providers_sd.xml" % os.path.dirname(sys.modules[__name__].__file__) + else: + skin = "%s/skins/providers_hd.xml" % os.path.dirname(sys.modules[__name__].__file__) + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + self.config = CrossEPG_Config() + self.config.load() + self.providers = self.config.getAllProviders() + self.list = [] + + self["list"] = List(self.list) + self["list"].onSelectionChanged.append(self.selectionChanged) + self["key_red"] = Button(_("Back")) + self["key_green"] = Button("") + self["key_yellow"] = Button("") + self["key_blue"] = Button("") + self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], + { + "red": self.quit, + "cancel": self.quit, + "green": self.moveUp, + "yellow": self.moveDown, + }, -2) + + self.buildList() + self.onFirstExecBegin.append(self.setCustomTitle) + self.onFirstExecBegin.append(self.selectionChanged) + + def setCustomTitle(self): + self.setTitle(_("CrossEPG - Providers start order")) + + def getProviderDescription(self, provider): + i = 0 + for prv in self.providers[0]: + if prv == provider: + return self.providers[1][i] + i += 1 + + return provider + + def buildList(self): + self.list = [] + for provider in self.config.providers: + self.list.append(self.buildListEntry(provider, self.getProviderDescription(provider))) + + self["list"].setList(self.list) + + def buildListEntry(self, name, description): + return((description, None, name)) + + def selectionChanged(self): + if len(self.list) <= 1: + return + + index = self["list"].getIndex() + if index == 0: + self["key_green"].setText("") + self["key_yellow"].setText(_("Move down")) + elif index == len(self.list) - 1: + self["key_green"].setText(_("Move up")) + self["key_yellow"].setText("") + else: + self["key_green"].setText(_("Move up")) + self["key_yellow"].setText(_("Move down")) + + def moveUp(self): + if len(self.list) <= 1: + return + + index = self["list"].getIndex() + if index > 0: + tmp = self.config.providers[index - 1] + self.config.providers[index - 1] = self.config.providers[index] + self.config.providers[index] = tmp + + self.buildList() + self["list"].setIndex(index - 1) + + def moveDown(self): + if len(self.list) <= 1: + return + + index = self["list"].getIndex() + if index < len(self.list) - 1: + tmp = self.config.providers[index + 1] + self.config.providers[index + 1] = self.config.providers[index] + self.config.providers[index] = tmp + + self.buildList() + self["list"].setIndex(index + 1) + + def quit(self): + self.config.save() + self.close() + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_providers.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_providers.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_providers.py (revision 6396) @@ -0,0 +1,137 @@ +from enigma import getDesktop + +from Screens.Screen import Screen + +from Components.Label import Label +from Components.Button import Button +from Components.ActionMap import ActionMap +from Components.Sources.List import List + +from Tools.LoadPixmap import LoadPixmap + +from crossepg_downloader import CrossEPG_Downloader +from crossepg_converter import CrossEPG_Converter +from crossepg_loader import CrossEPG_Loader +from crossepg_locale import _ + +from crossepglib import * + +class CrossEPG_Providers(Screen): + def __init__(self, session, protocol): + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/providers_sd.xml" % os.path.dirname(sys.modules[__name__].__file__) + else: + skin = "%s/skins/providers_hd.xml" % os.path.dirname(sys.modules[__name__].__file__) + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + self.patchtype = getEPGPatchType() + self.config = CrossEPG_Config() + self.config.load() + self.providers = self.config.getAllProviders() + self.protocol = protocol + + self.old_service = None + self.list = [] + + self["list"] = List(self.list) + self["list"].onSelectionChanged.append(self.selectionChanged) + self["key_red"] = Button(_("Back")) + self["key_green"] = Button(_("Enable")) + self["key_yellow"] = Button(_("Download")) + self["key_blue"] = Button("") + self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], + { + "red": self.quit, + "cancel": self.quit, + "green": self.switchState, + "ok": self.switchState, + "yellow": self.download, + }, -2) + + self.buildList() + self.onFirstExecBegin.append(self.setTitleByProtocol) + self.onFirstExecBegin.append(self.selectionChanged) + + def setTitleByProtocol(self): + if self.protocol == "xmltv": + self.setTitle("CrossEPG - XMLTV providers") + elif self.protocol == "opentv": + self.setTitle("CrossEPG - OpenTV providers") + elif self.protocol == "xepgdb": + self.setTitle("CrossEPG - XEPGDB providers") + elif self.protocol == "scripts": + self.setTitle("CrossEPG - Scripts providers") + + def buildList(self): + self.list = [] + i = 0 + for provider in self.providers[0]: + if self.providers[2][i] == self.protocol: + self.list.append(self.buildListEntry(provider, self.providers[1][i], self.config.providers.count(provider) > 0)) + i += 1 + + self["list"].setList(self.list) + + def buildListEntry(self, name, description, enabled): + if enabled: + pixmap = LoadPixmap(cached=True, path="%s/images/enabled.png" % os.path.dirname(sys.modules[__name__].__file__)); + return((description, pixmap, name)) + else: + return((description, None, name)) + + def selectionChanged(self): + if len(self.list) == 0: + return + + index = self["list"].getIndex() + provider = self.list[index][2] + if self.config.providers.count(provider) > 0: + self["key_green"].setText(_("Disable")) + else: + self["key_green"].setText(_("Enable")) + + def switchState(self): + if len(self.list) == 0: + return + + index = self["list"].getIndex() + provider = self.list[index][2] + if self.config.providers.count(provider) > 0: + self.config.providers.remove(provider) + else: + self.config.providers.append(provider) + + self.buildList() + self["list"].setIndex(index) + + def download(self): + if len(self.list) == 0: + return + + index = self["list"].getIndex() + self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, [self.list[index][2],]) + + def downloadCallback(self, ret): + if ret: + if self.patchtype != 3: + self.converter() + else: + self.loader() + + def converter(self): + self.session.openWithCallback(self.converterCallback, CrossEPG_Converter) + + def converterCallback(self, ret): + if ret and self.patchtype != -1: + self.loader() + + def loader(self): + self.session.open(CrossEPG_Loader) + + def quit(self): + self.config.save() + self.close() + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_setup.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_setup.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepg_setup.py (revision 6396) @@ -0,0 +1,298 @@ +from enigma import getDesktop + +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox + +from Components.config import KEY_LEFT, KEY_RIGHT, KEY_HOME, KEY_END, KEY_0, ConfigYesNo, ConfigSelection, ConfigClock +from Components.ConfigList import ConfigList +from Components.Button import Button +from Components.Label import Label +from Components.Harddisk import harddiskmanager +from Components.PluginComponent import plugins +from Components.ActionMap import NumberActionMap + +from Tools.Directories import resolveFilename, SCOPE_PLUGINS + +from Plugins.Plugin import PluginDescriptor + +from crossepglib import * +from crossepg_locale import _ +from crossepg_auto import crossepg_auto + +from time import * + +class CrossEPG_Setup(Screen): + def __init__(self, session): + if (getDesktop(0).size().width() < 800): + skin = "%s/skins/setup_sd.xml" % (os.path.dirname(sys.modules[__name__].__file__)) + else: + skin = "%s/skins/setup_hd.xml" % (os.path.dirname(sys.modules[__name__].__file__)) + f = open(skin, "r") + self.skin = f.read() + f.close() + Screen.__init__(self, session) + + patchtype = getEPGPatchType() + if patchtype == 0 or patchtype == 1 or patchtype == 3: + self.fastpatch = True + else: + self.fastpatch = False + + self.session = session + + self.config = CrossEPG_Config() + self.config.load() + + self.lamedbs = self.config.getAllLamedbs() + + self.lamedbs_desc = [] + self.mountpoint = [] + self.mountdescription = [] + self.automatictype = [] + + self.show_extension = self.config.show_extension + self.show_plugin = self.config.show_plugin + + # make devices entries + if self.config.isQBOXHD(): + self.mountdescription.append(_("Internal flash")) + self.mountpoint.append("/var/crossepg/data") + + for partition in harddiskmanager.getMountedPartitions(): + if (partition.mountpoint != '/') and (partition.mountpoint != ''): # and self.isMountedInRW(partition.mountpoint): + self.mountpoint.append(partition.mountpoint + "/crossepg") + + if partition.description != '': + self.mountdescription.append(partition.description) + else: + self.mountdescription.append(partition.mountpoint) + + if not self.config.isQBOXHD(): # for other decoders we add internal flash as last entry (it's unsuggested) + self.mountdescription.append(_("Internal flash (unsuggested)")) + self.mountpoint.append(self.config.home_directory + "/data") + + # make lamedb entries + for lamedb in self.lamedbs: + if lamedb == "lamedb": + self.lamedbs_desc.append(_("main lamedb")) + else: + self.lamedbs_desc.append(lamedb.replace("lamedb.", "").replace(".", " ")) + + # make automatic type entries + self.automatictype.append(_("disabled")) + self.automatictype.append(_("once a day")) + self.automatictype.append(_("every hour (only in standby)")) + + self.list = [] + self["config"] = ConfigList(self.list, session = self.session) + self["config"].onSelectionChanged.append(self.setInfo) + self["information"] = Label("") + self["key_red"] = Button(_("Back")) + self["key_green"] = Button() + self["key_yellow"] = Button() + self["key_blue"] = Button("") + self["config_actions"] = NumberActionMap(["SetupActions", "InputAsciiActions", "KeyboardInputActions", "ColorActions"], + { + "red": self.quit, + "cancel": self.quit, + "left": self.keyLeft, + "right": self.keyRight, + "home": self.keyHome, + "end": self.keyEnd, + "1": self.keyNumberGlobal, + "2": self.keyNumberGlobal, + "3": self.keyNumberGlobal, + "4": self.keyNumberGlobal, + "5": self.keyNumberGlobal, + "6": self.keyNumberGlobal, + "7": self.keyNumberGlobal, + "8": self.keyNumberGlobal, + "9": self.keyNumberGlobal, + "0": self.keyNumberGlobal + }, -1) # to prevent left/right overriding the listbox + + self.makeList() + + def showWarning(self): + self.session.open(MessageBox, _("PLEASE READ!\nNo disk found. An hard drive or an usb pen is HARDLY SUGGESTED. If you still want use your internal flash pay attention to:\n(1) If you don't have enough free space your box may completely block and you need to flash it again\n(2) Many write operations on your internal flash may damage your flash memory"), type = MessageBox.TYPE_ERROR) + + def keyLeft(self): + self["config"].handleKey(KEY_LEFT) + self.update() + #self.setInfo() + + def keyRight(self): + self["config"].handleKey(KEY_RIGHT) + self.update() + #self.setInfo() + + def keyHome(self): + self["config"].handleKey(KEY_HOME) + self.update() + #self.setInfo() + + def keyEnd(self): + self["config"].handleKey(KEY_END) + self.update() + #self.setInfo() + + def keyNumberGlobal(self, number): + self["config"].handleKey(KEY_0 + number) + self.update() + #self.setInfo() + + def makeList(self): + self.list = [] + + device_default = None + i = 0 + for mountpoint in self.mountpoint: + if mountpoint == self.config.db_root: + device_default = self.mountdescription[i] + i += 1 + + # default device is really important... if miss a default we force it on first entry and update now the main config + if device_default == None: + self.config.db_root = self.mountpoint[0] + device_default = self.mountdescription[0] + + lamedb_default = _("main lamedb") + if self.config.lamedb != "lamedb": + lamedb_default = self.config.lamedb.replace("lamedb.", "").replace(".", " ") + + scheduled_default = None + if self.config.download_standby_enabled: + scheduled_default = _("every hour (only in standby)") + elif self.config.download_daily_enabled: + scheduled_default = _("once a day") + else: + scheduled_default = _("disabled") + + self.list.append((_("Storage device"), ConfigSelection(self.mountdescription, device_default))) + if len(self.lamedbs_desc) > 1: + self.list.append((_("Preferred lamedb"), ConfigSelection(self.lamedbs_desc, lamedb_default))) + + self.list.append((_("Enable csv import"), ConfigYesNo(self.config.csv_import_enabled > 0))) + self.list.append((_("Force epg reload on boot"), ConfigYesNo(self.config.force_load_on_boot > 0))) + self.list.append((_("Download on tune"), ConfigYesNo(self.config.download_tune_enabled > 0))) + self.list.append((_("Scheduled download"), ConfigSelection(self.automatictype, scheduled_default))) + + if self.config.download_daily_enabled: + ttime = localtime() + ltime = (ttime[0], ttime[1], ttime[2], self.config.download_daily_hours, self.config.download_daily_minutes, ttime[5], ttime[6], ttime[7], ttime[8]) + self.list.append((_("Scheduled download at"), ConfigClock(mktime(ltime)))) + + if not self.fastpatch: + self.list.append((_("Reboot after a scheduled download"), ConfigYesNo(self.config.download_daily_reboot > 0))) + self.list.append((_("Reboot after a manual download"), ConfigYesNo(self.config.download_manual_reboot > 0))) + self.list.append((_("Show as plugin"), ConfigYesNo(self.config.show_plugin > 0))) + self.list.append((_("Show as extension"), ConfigYesNo(self.config.show_extension > 0))) + + self["config"].setList(self.list) + self.setInfo() + + def update(self): + redraw = False + self.config.db_root = self.mountpoint[self.list[0][1].getIndex()] + + i = 1 + if len(self.lamedbs_desc) > 1: + self.config.lamedb = self.lamedbs[self.list[i][1].getIndex()] + i += 1 + + self.config.csv_import_enabled = int(self.list[i][1].getValue()) + self.config.force_load_on_boot = int(self.list[i+1][1].getValue()) + self.config.download_tune_enabled = int(self.list[i+2][1].getValue()) + + dailycache = self.config.download_daily_enabled + standbycache = self.config.download_standby_enabled + if self.list[i+3][1].getIndex() == 0: + self.config.download_daily_enabled = 0 + self.config.download_standby_enabled = 0 + elif self.list[i+3][1].getIndex() == 1: + self.config.download_daily_enabled = 1 + self.config.download_standby_enabled = 0 + else: + self.config.download_daily_enabled = 0 + self.config.download_standby_enabled = 1 + + if dailycache != self.config.download_daily_enabled or standbycache != self.config.download_standby_enabled: + redraw = True + + i += 4 + if dailycache: + self.config.download_daily_hours = self.list[i][1].getValue()[0] + self.config.download_daily_minutes = self.list[i][1].getValue()[1] + i += 1 + + if not self.fastpatch: + self.config.download_daily_reboot = int(self.list[i][1].getValue()) + self.config.download_manual_reboot = int(self.list[i+1][1].getValue()) + i += 2 + + self.config.show_plugin = int(self.list[i][1].getValue()) + self.config.show_extension = int(self.list[i+1][1].getValue()) + + if redraw: + self.makeList() + + def setInfo(self): + index = self["config"].getCurrentIndex() + if len(self.lamedbs_desc) <= 1 and index > 0: + index += 1 + if self.config.download_daily_enabled == 0 and index > 5: + index += 1 + if self.fastpatch and index > 6: + index += 2 + + if index == 0: + self["information"].setText(_("Drive where you save data.\nThe drive MUST be mounted in rw")) + elif index == 1: + self["information"].setText(_("Lamedb used for epg.dat conversion.\nThis option doesn't work with crossepg patch v2")) + elif index == 2: + self["information"].setText(_("Import *.csv and *.bin from %s/import or %s/import\n(*.bin are binaries with a csv as stdout)") % (self.config.db_root, self.config.home_directory)) + elif index == 3: + self["information"].setText(_("Reload epg at every boot.\nNormally it's not necessary but recover epg after an enigma2 crash")) + elif index == 4: + self["information"].setText(_("Only for opentv providers.\nIf you zap on channel used from a provider it download the epg in background")) + elif index == 5: + if self.config.download_standby_enabled: + self["information"].setText(_("When the decoder is in standby opentv providers will be automatically downloaded every hour.\nXMLTV providers will be always downloaded only once a day")) + elif self.config.download_daily_enabled: + self["information"].setText(_("Download epg once a day")) + else: + self["information"].setText(_("Scheduled download disabled")) + elif index == 6: + self["information"].setText(_("Time for scheduled daily download")) + elif index == 7: + self["information"].setText(_("Automatically reboot the decoder after a scheduled download")) + elif index == 8: + self["information"].setText(_("Automatically reboot the decoder after a manual download")) + elif index == 9: + self["information"].setText(_("Show crossepg in plugin menu")) + elif index == 10: + self["information"].setText(_("Show crossepg in extensions menu")) + + def quit(self): + self.config.last_full_download_timestamp = 0 + self.config.last_partial_download_timestamp = 0 + self.config.configured = 1 + self.config.save() + if self.show_extension != self.config.show_extension or self.show_plugin != self.config.show_plugin: + for plugin in plugins.getPlugins(PluginDescriptor.WHERE_PLUGINMENU): + if plugin.name == "CrossEPG Downloader": + plugins.removePlugin(plugin) + + for plugin in plugins.getPlugins(PluginDescriptor.WHERE_EXTENSIONSMENU): + if plugin.name == "CrossEPG Downloader": + plugins.removePlugin(plugin) + + plugins.readPluginList(resolveFilename(SCOPE_PLUGINS)) + + crossepg_auto.forcePoll() + + if self.config.db_root == self.config.home_directory + "/data" and not self.config.isQBOXHD(): + self.showWarning() + + self.close() + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepglib.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepglib.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/crossepglib.py (revision 6396) @@ -0,0 +1,643 @@ +from enigma import * +from crossepg_locale import _ +from Tools.Directories import crawlDirectory, pathExists, createDir +from types import * + +import sys, traceback +import os +import re +import time +import new +import _enigma + +# return value +# -1 none +# 0 simple epgcache.load() patch +# 1 edg nemesis patch +# 2 oudeis patch +# 3 crossepg v2.1 patch +def getEPGPatchType(): + try: + xepgpatch = new.instancemethod(_enigma.eEPGCache_crossepgImportEPGv21,None,eEPGCache) + return 3 + except Exception, e: + pass + + try: + epgpatch = new.instancemethod(_enigma.eEPGCache_load,None,eEPGCache) + return 0 + except Exception, e: + pass + + try: + edgpatch = new.instancemethod(_enigma.eEPGCache_reloadEpg,None,eEPGCache) + return 1 + except Exception, e: + pass + + try: + oudeispatch = new.instancemethod(_enigma.eEPGCache_importEvent,None,eEPGCache) + return 2 + except Exception, e: + pass + + return -1 + +class CrossEPG_Config: + providers = [ ] + db_root = "/hdd/crossepg" + lamedb = "lamedb" + home_directory = "" + + force_load_on_boot = 0 + download_daily_enabled = 0 + download_daily_hours = 4 + download_daily_minutes = 0 + download_daily_reboot = 1 + download_tune_enabled = 0 + download_standby_enabled = 0 + download_manual_reboot = 0 + csv_import_enabled = 0 + show_plugin = 1 + show_extension = 1 + last_partial_download_timestamp = 0 + last_full_download_timestamp = 0 + configured = 0 + + def __init__(self): + if pathExists("/usr/crossepg"): + self.home_directory = "/usr/crossepg" + elif pathExists("/var/crossepg"): + self.home_directory = "/var/crossepg" + else: + print "[CrossEPG_Config] ERROR!! CrossEPG binaries non found" + + def load(self): + try: + f = open("%s/crossepg.config" % (self.home_directory), "r") + except Exception, e: + #print "[CrossEPG_Config] %s" % (e) + return + + commentRe = re.compile(r"#(.*)") + entryRe = re.compile(r"(.*)=(.*)") + + for line in f.readlines(): + try: + comment = re.findall(commentRe, line) + if not comment: + entry = re.findall(entryRe, line) + if entry: + key = entry[0][0].strip() + value = entry[0][1].strip() + if key == "db_root": + self.db_root = value + if key == "lamedb": + self.lamedb = value + elif key == "providers": + self.providers = [] + tmp = value.split("|") + for p in tmp: + if len(p) > 0 and os.path.exists("%s/providers/%s.conf" % (self.home_directory, p)): + self.providers.append(p) + elif key == "force_load_on_boot": + self.force_load_on_boot = int(value); + elif key == "download_daily_enabled": + self.download_daily_enabled = int(value); + elif key == "download_daily_hours": + self.download_daily_hours = int(value); + elif key == "download_daily_minutes": + self.download_daily_minutes = int(value); + elif key == "download_tune_enabled": + self.download_tune_enabled = int(value); + elif key == "download_daily_reboot": + self.download_daily_reboot = int(value); + elif key == "download_manual_reboot": + self.download_manual_reboot = int(value); + elif key == "download_standby_enabled": + self.download_standby_enabled = int(value); + elif key == "last_partial_download_timestamp": + self.last_partial_download_timestamp = int(value); + elif key == "last_full_download_timestamp": + self.last_full_download_timestamp = int(value); + elif key == "csv_import_enabled": + self.csv_import_enabled = int(value); + elif key == "show_plugin": + self.show_plugin = int(value); + elif key == "show_extension": + self.show_extension = int(value); + elif key == "configured": + self.configured = int(value); + except Exception: + pass + + f.close() + + def save(self): + try: + f = open("%s/crossepg.config" % (self.home_directory), "w") + except Exception, e: + print "[CrossEPG_Config] %s" % (e) + return + + tmp = [] + for p in self.providers: + if len(p) > 0: + tmp.append(p) + self.providers = tmp + + f.write("db_root=%s\n" % (self.db_root)) + f.write("lamedb=%s\n" % (self.lamedb)) + f.write("providers=%s\n" % ("|".join(self.providers))) + f.write("force_load_on_boot=%d\n" % (self.force_load_on_boot)) + f.write("download_daily_enabled=%d\n" % (self.download_daily_enabled)) + f.write("download_daily_hours=%d\n" % (self.download_daily_hours)) + f.write("download_daily_minutes=%d\n" % (self.download_daily_minutes)) + f.write("download_daily_reboot=%d\n" % (self.download_daily_reboot)) + f.write("download_tune_enabled=%d\n" % (self.download_tune_enabled)) + f.write("download_manual_reboot=%d\n" % (self.download_manual_reboot)) + f.write("download_standby_enabled=%d\n" % (self.download_standby_enabled)) + f.write("last_full_download_timestamp=%d\n" % (self.last_full_download_timestamp)) + f.write("last_partial_download_timestamp=%d\n" % (self.last_partial_download_timestamp)) + f.write("csv_import_enabled=%d\n" % (self.csv_import_enabled)) + f.write("show_plugin=%d\n" % (self.show_plugin)) + f.write("show_extension=%d\n" % (self.show_extension)) + f.write("configured=%d\n" % (self.configured)) + + f.close() + + def getChannelProtocol(self, provider): + try: + f = open("%s/providers/%s.conf" % (self.home_directory, provider), "r") + except Exception, e: + print "[CrossEPG_Config] %s" % (e) + return + + proto = re.compile(r"protocol=(.*)") + for line in f.readlines(): + zproto = re.findall(proto, line) + if zproto: + f.close() + return zproto[0].strip() + + f.close() + return "" + + def getChannelID(self, provider): + try: + f = open("%s/providers/%s.conf" % (self.home_directory, provider), "r") + except Exception, e: + print "[CrossEPG_Config] %s" % (e) + return + + nid = -1; + tsid = -1; + sid = -1; + namespace = -1; + nidRe = re.compile(r"nid=(.*)") + tsidRe = re.compile(r"tsid=(.*)") + sidRe = re.compile(r"sid=(.*)") + namespaceRe = re.compile(r"namespace=(.*)") + + for line in f.readlines(): + znid = re.findall(nidRe, line) + if znid: + nid = int(znid[0]) + zsid = re.findall(sidRe, line) + if zsid: + sid = int(zsid[0]) + ztsid = re.findall(tsidRe, line) + if ztsid: + tsid = int(ztsid[0]) + znamespace = re.findall(namespaceRe, line) + if znamespace: + namespace = int(znamespace[0]); + + if nid == -1 or sid == -1 or tsid == -1: + return + + f.close() + return "1:0:1:%X:%X:%X:%X:0:0:0:" % (sid, tsid, nid, namespace) + + def getAllProviders(self): + providers = list() + providersdesc = list() + providersproto = list() + cfiles = crawlDirectory("%s/providers/" % (self.home_directory), ".*\.conf$") + for cfile in cfiles: + providers.append(cfile[1].replace(".conf", "")) + + providers.sort() + + for provider in providers: + try: + descadded = False + protoadded = False + f = open("%s/providers/%s.conf" % (self.home_directory, provider), "r") + desc = re.compile(r"description=(.*)") + proto = re.compile(r"protocol=(.*)") + for line in f.readlines(): + zdesc = re.findall(desc, line) + if zdesc: + providersdesc.append(zdesc[0].strip()) + descadded = True + + zproto = re.findall(proto, line) + if zproto: + providersproto.append(zproto[0].strip()) + protoadded = True + + if descadded and protoadded: + break + + f.close() + + if not descadded: + providersdesc.append(provider) + + if not protoadded: + providersproto.append(None) + + except Exception, e: + print "[CrossEPG_Config] %s" % (e) + providersdesc.append(provider) + providersproto.append(None) + + ret = [providers, providersdesc, providersproto] + return ret + + def getAllLamedbs(self): + lamedbs = list() + cfiles = crawlDirectory("/etc/enigma2/", "^lamedb.*") + for cfile in cfiles: + lamedbs.append(cfile[1]) + + return lamedbs + + def isQBOXHD(self): + try: + ret = False + f = open("/proc/stb/info/model", "r") + model = f.read().strip() + if model == "qboxhd" or model == "qboxhd-mini": + ret = True + f.close() + return ret + except Exception, e: + return False + + def deleteLog(self): + try: + os.unlink(self.db_root + "/crossepg.log") + except Exception, e: + print e + +class CrossEPG_Wrapper: + EVENT_READY = 0 + EVENT_OK = 1 + EVENT_START = 2 + EVENT_END = 3 + EVENT_QUIT = 4 + EVENT_ERROR = 5 + EVENT_ACTION = 6 + EVENT_STATUS = 7 + EVENT_PROGRESS = 8 + EVENT_PROGRESSONOFF = 9 + EVENT_CHANNEL = 10 + EVENT_STARTTIME = 11 + EVENT_LENGTH = 12 + EVENT_NAME = 13 + EVENT_DESCRIPTION = 14 + EVENT_FILE = 15 + EVENT_URL = 16 + + INFO_HEADERSDB_SIZE = 50 + INFO_DESCRIPTORSDB_SIZE = 51 + INFO_INDEXESDB_SIZE = 52 + INFO_ALIASESDB_SIZE = 53 + INFO_TOTAL_SIZE = 54 + INFO_CHANNELS_COUNT = 55 + INFO_EVENTS_COUNT = 56 + INFO_HASHES_COUNT = 57 + INFO_CREATION_TIME = 58 + INFO_UPDATE_TIME = 59 + INFO_VERSION = 60 + + CMD_DOWNLOADER = 0 + CMD_CONVERTER = 1 + CMD_INFO = 2 + CMD_IMPORTER = 3 + + home_directory = "" + + def __init__(self): + self.cmd = eConsoleAppContainer() + self.cache = None + self.callbackList = [] + self.type = 0 + self.maxSize = "0 byte" + + versionlist = getEnigmaVersionString().split("-"); + + self.oldapi = False + try: + if len(versionlist) >= 3: + self.version = int(versionlist[0]+versionlist[1]+versionlist[2]) + if self.version < 20100716: + self.oldapi = True + except Exception: + pass + + config = CrossEPG_Config() + if config.isQBOXHD(): + self.oldapi = True + + if pathExists("/usr/crossepg"): + self.home_directory = "/usr/crossepg" + elif pathExists("/var/crossepg"): + self.home_directory = "/var/crossepg" + else: + print "[CrossEPG_Config] ERROR!! CrossEPG binaries non found" + + def init(self, cmd, dbdir): + if not pathExists(dbdir): + if not createDir(dbdir): + dbdir = "/hdd/crossepg" + + if cmd == self.CMD_DOWNLOADER: + x = "%s/crossepg_downloader -r -d %s" % (self.home_directory, dbdir) + elif cmd == self.CMD_CONVERTER: + x = "%s/crossepg_dbconverter -r -d %s" % (self.home_directory, dbdir) + elif cmd == self.CMD_INFO: + x = "%s/crossepg_dbinfo -r -d %s" % (self.home_directory, dbdir) + elif cmd == self.CMD_IMPORTER: + importdir = "%s/import/" % (dbdir) + x = "%s/crossepg_importer -r -i %s -d %s" % (self.home_directory, importdir, dbdir) + else: + print "[CrossEPG_Wrapper] unknow command on init" + return + + print "[CrossEPG_Wrapper] executing %s" % (x) + self.cmd.appClosed.append(self.__cmdFinished) + self.cmd.dataAvail.append(self.__cmdData) + if self.cmd.execute(x): + self.cmdFinished(-1) + + def __cmdFinished(self, retval): + self.__callCallbacks(self.EVENT_QUIT) + self.cmd.appClosed.remove(self.__cmdFinished) + self.cmd.dataAvail.remove(self.__cmdData) + + def __cmdData(self, data): + if self.cache is None: + self.cache = data + else: + self.cache += data + + if '\n' in data: + splitcache = self.cache.split('\n') + if self.cache[-1] == '\n': + iteration = splitcache + self.cache = None + else: + iteration = splitcache[:-1] + self.cache = splitcache[-1] + for mydata in iteration: + if mydata != '': + self.__parseLine(mydata) + + def __parseLine(self, data): + if data.find("CHANNEL ") == 0: + self.__callCallbacks(self.EVENT_CHANNEL, data[7:]) + elif data.find("STARTTIME ") == 0: + self.__callCallbacks(self.EVENT_STARTTIME, int(data[10:])) + elif data.find("LENGTH ") == 0: + self.__callCallbacks(self.EVENT_LENGTH, int(data[7:])) + elif data.find("NAME ") == 0: + self.__callCallbacks(self.EVENT_NAME, data[5:]) + elif data.find("DESCRIPTION ") == 0: + self.__callCallbacks(self.EVENT_DESCRIPTION, data[12:].replace("\\n", "\n")) + elif data == "READY": + print "[CrossEPG_Wrapper] <- READY" + self.__callCallbacks(self.EVENT_READY, None) + elif data == "START": + print "[CrossEPG_Wrapper] <- START" + self.__callCallbacks(self.EVENT_START, None) + elif data == "END": + print "[CrossEPG_Wrapper] <- END" + self.__callCallbacks(self.EVENT_END, None) + elif data == "OK": + print "[CrossEPG_Wrapper] <- OK" + self.__callCallbacks(self.EVENT_OK, None) + elif data.find("ERROR ") == 0: + ttype = data[5:] + self.__callCallbacks(self.EVENT_ERROR, data[6:]) + elif data.find("TYPE ") == 0: + ttype = data[5:] + print "[CrossEPG_Wrapper] <- TYPE %s" % (ttype) + if ttype == "READ CHANNELS": + self.type = 0; + self.__callCallbacks(self.EVENT_ACTION, _("Reading channels")) + elif ttype == "READ TITLES": + self.type = 1; + self.__callCallbacks(self.EVENT_ACTION, _("Reading titles")) + elif ttype == "PARSE TITLES": + self.type = 2; + self.__callCallbacks(self.EVENT_ACTION, _("Parsing titles")) + elif ttype == "READ SUMMARIES": + self.type = 3; + self.__callCallbacks(self.EVENT_ACTION, _("Reading summaries")) + elif ttype == "PARSE SUMMARIES": + self.type = 4; + self.__callCallbacks(self.EVENT_ACTION, _("Parsing summaries")) + elif ttype == "DOWNLOADING CHANNELS LIST": + self.type = 5; + self.__callCallbacks(self.EVENT_ACTION, _("Downloading channels list")) + elif ttype == "DEFLATING CHANNELS LIST": + self.type = 6; + self.__callCallbacks(self.EVENT_ACTION, _("Deflating channels list")) + elif ttype == "PARSING CHANNELS LIST": + self.type = 7; + self.__callCallbacks(self.EVENT_ACTION, _("Parsing channels list")) + elif ttype == "DOWNLOADING EVENTS": + self.type = 8; + self.__callCallbacks(self.EVENT_ACTION, _("Downloading events")) + elif ttype == "DEFLATING EVENTS": + self.type = 9; + self.__callCallbacks(self.EVENT_ACTION, _("Deflating events")) + elif ttype == "PARSING EVENTS": + self.type = 10; + self.__callCallbacks(self.EVENT_ACTION, _("Parsing events")) + elif ttype == "DOWNLOADING XEPGDB": + self.type = 11; + self.__callCallbacks(self.EVENT_ACTION, _("Downloading XEPGDB")) + elif ttype == "PARSING XEPGDB": + self.type = 12; + self.__callCallbacks(self.EVENT_ACTION, _("Merging XEPGDB")) + elif ttype == "DEFLATING XEPGDB": + self.type = 13; + self.__callCallbacks(self.EVENT_ACTION, _("Deflating XEPGDB")) + elif ttype == "RUNNING SCRIPT": + self.type = 14; + self.__callCallbacks(self.EVENT_ACTION, _("Running script")) + elif ttype.find("RUNNING CSCRIPT ") == 0: + self.type = 14; + self.__callCallbacks(self.EVENT_ACTION, _("Running script") + " " + data[21:]) + + elif data.find("CHANNELS ") == 0: + self.__callCallbacks(self.EVENT_STATUS, _("%s channels") % (data[9:])) + elif data.find("SIZE ") == 0: + if self.type == 1 or self.type == 3: + self.maxSize = data[5:] + self.__callCallbacks(self.EVENT_STATUS, _("Read %s") % (data[5:])) + else: + self.__callCallbacks(self.EVENT_STATUS, _("%s of %s") % (data[5:], self.maxSize)) + elif data.find("PROGRESS ") == 0: + if data[9:] == "ON": + self.__callCallbacks(self.EVENT_PROGRESSONOFF, True) + elif data[9:] == "OFF": + self.__callCallbacks(self.EVENT_PROGRESSONOFF, False) + else: + self.__callCallbacks(self.EVENT_PROGRESS, int(data[9:])) + elif data.find("FILE ") == 0: + self.__callCallbacks(self.EVENT_FILE, data[5:]) + elif data.find("URL ") == 0: + self.__callCallbacks(self.EVENT_URL, data[4:]) + elif data.find("VERSION ") == 0: + self.__callCallbacks(self.INFO_VERSION, data[8:]) + elif data.find("HEADERSDB_SIZE ") == 0: + self.__callCallbacks(self.INFO_HEADERSDB_SIZE, data[15:]) + elif data.find("DESCRIPTORSDB_SIZE ") == 0: + self.__callCallbacks(self.INFO_DESCRIPTORSDB_SIZE, data[19:]) + elif data.find("INDEXESDB_SIZE ") == 0: + self.__callCallbacks(self.INFO_INDEXESDB_SIZE, data[15:]) + elif data.find("ALIASESDB_SIZE ") == 0: + self.__callCallbacks(self.INFO_ALIASESDB_SIZE, data[15:]) + elif data.find("TOTAL_SIZE ") == 0: + self.__callCallbacks(self.INFO_TOTAL_SIZE, data[11:]) + elif data.find("CHANNELS_COUNT ") == 0: + self.__callCallbacks(self.INFO_CHANNELS_COUNT, data[15:]) + elif data.find("EVENTS_COUNT ") == 0: + self.__callCallbacks(self.INFO_EVENTS_COUNT, data[13:]) + elif data.find("HASHES_COUNT ") == 0: + self.__callCallbacks(self.INFO_HASHES_COUNT, data[13:]) + elif data.find("CREATION_TIME ") == 0: + self.__callCallbacks(self.INFO_CREATION_TIME, data[14:]) + elif data.find("UPDATE_TIME ") == 0: + self.__callCallbacks(self.INFO_UPDATE_TIME, data[12:]) + elif data.find("LOGTEXT ") == 0: + self.__callCallbacks(self.EVENT_STATUS, data[8:]) + + def __callCallbacks(self, event, param = None): + for callback in self.callbackList: + callback(event, param) + + def addCallback(self, callback): + self.callbackList.append(callback) + + def delCallback(self, callback): + self.callbackList.remove(callback) + + def running(self): + return self.cmd.running() + + def lamedb(self, value): + print "[CrossEPG_Wrapper] -> LAMEDB %s" % (value) + cmd = "LAMEDB %s\n" % (value) + if self.oldapi: + self.cmd.write(cmd, len(cmd)) + else: + self.cmd.write(cmd) + + def epgdat(self, value): + print "[CrossEPG_Wrapper] -> EPGDAT %s" % (value) + cmd = "EPGDAT %s\n" % (value) + if self.oldapi: + self.cmd.write(cmd, len(cmd)) + else: + self.cmd.write(cmd) + + def demuxer(self, value): + print "[CrossEPG_Wrapper] -> DEMUXER %s" % (value) + cmd = "DEMUXER %s\n" % (value) + if self.oldapi: + self.cmd.write(cmd, len(cmd)) + else: + self.cmd.write(cmd) + + def download(self, provider): + print "[CrossEPG_Wrapper] -> DOWNLOAD %s" % (provider) + cmd = "DOWNLOAD %s\n" % (provider) + if self.oldapi: + self.cmd.write(cmd, len(cmd)) + else: + self.cmd.write(cmd) + + def convert(self): + print "[CrossEPG_Wrapper] -> CONVERT" + self.__callCallbacks(self.EVENT_ACTION, _("Converting data")) + self.__callCallbacks(self.EVENT_STATUS, "") + if self.oldapi: + self.cmd.write("CONVERT\n", 8) + else: + self.cmd.write("CONVERT\n") + + def importx(self): + print "[CrossEPG_Wrapper] -> IMPORT" + if self.oldapi: + self.cmd.write("IMPORT\n", 7) + else: + self.cmd.write("IMPORT\n") + + def text(self): + print "[CrossEPG_Wrapper] -> TEXT" + self.__callCallbacks(self.EVENT_ACTION, _("Loading data")) + self.__callCallbacks(self.EVENT_STATUS, "") + if self.oldapi: + self.cmd.write("TEXT\n", 5) + else: + self.cmd.write("TEXT\n") + + def stop(self): + print "[CrossEPG_Wrapper] -> STOP" + if self.oldapi: + self.cmd.write("STOP\n", 5) + else: + self.cmd.write("STOP\n") + + def save(self): + print "[CrossEPG_Wrapper] -> SAVE" + self.__callCallbacks(self.EVENT_ACTION, _("Saving data")) + self.__callCallbacks(self.EVENT_STATUS, "") + if self.oldapi: + self.cmd.write("SAVE\n", 5) + else: + self.cmd.write("SAVE\n") + + def wait(self): + print "[CrossEPG_Wrapper] -> WAIT" + if self.oldapi: + self.cmd.write("WAIT\n", 5) + else: + self.cmd.write("WAIT\n") + + def quit(self): + print "[CrossEPG_Wrapper] -> QUIT" + if self.oldapi: + self.cmd.write("QUIT\n", 5) + else: + self.cmd.write("QUIT\n") + + def open(self): + print "[CrossEPG_Wrapper] -> OPEN" + if self.oldapi: + self.cmd.write("OPEN\n", 5) + else: + self.cmd.write("OPEN\n") + + def close(self): + print "[CrossEPG_Wrapper] -> CLOSE" + if self.oldapi: + self.cmd.write("CLOSE\n", 6) + else: + self.cmd.write("CLOSE\n") Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/plugin.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/plugin.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/plugin.py (revision 6396) @@ -0,0 +1,47 @@ +from crossepglib import CrossEPG_Config +from crossepg_main import crossepg_main +from crossepg_locale import _ +from Plugins.Plugin import PluginDescriptor + +def setup(menuid, **kwargs): + if menuid == "setup": + return [("CrossEPG", crossepg_main.setup, "crossepg", None)] + else: + return [] + +def Plugins(**kwargs): + config = CrossEPG_Config() + config.load() + plugins = list() + if config.show_plugin == 1 and config.show_extension == 1: + plugins.append(PluginDescriptor(name="CrossEPG Downloader", + description=_("An EPG downloader"), + where = [ PluginDescriptor.WHERE_EXTENSIONSMENU, PluginDescriptor.WHERE_PLUGINMENU ], + fnc = crossepg_main.downloader)) + elif config.show_extension == 1: + plugins.append(PluginDescriptor(name="CrossEPG Downloader", + description=_("An EPG downloader"), + where = PluginDescriptor.WHERE_EXTENSIONSMENU, + fnc = crossepg_main.downloader)) + elif config.show_plugin == 1: + plugins.append(PluginDescriptor(name="CrossEPG Downloader", + description=_("An EPG downloader"), + where = PluginDescriptor.WHERE_PLUGINMENU, + fnc = crossepg_main.downloader)) + + if config.isQBOXHD(): + plugins.append(PluginDescriptor(name="CrossEPG", + description=_("CrossEPG setup panel"), + where = PluginDescriptor.WHERE_PLUGINMENU, + fnc = crossepg_main.setup)) + else: + plugins.append(PluginDescriptor(name="CrossEPG", + description=_("CrossEPG setup panel"), + where = PluginDescriptor.WHERE_MENU, + fnc = setup)) + + plugins.append(PluginDescriptor(name="CrossEPG Auto", + description = _("CrossEPG automatic actions"), + where = PluginDescriptor.WHERE_SESSIONSTART, + fnc = crossepg_main.autostart)) + return plugins; Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/about_hd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/about_hd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/about_hd.xml (revision 6396) @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/about_sd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/about_sd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/about_sd.xml (revision 6396) @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/downloader_hd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/downloader_hd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/downloader_hd.xml (revision 6396) @@ -0,0 +1,6 @@ + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/downloader_sd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/downloader_sd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/downloader_sd.xml (revision 6396) @@ -0,0 +1,6 @@ + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/info_hd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/info_hd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/info_hd.xml (revision 6396) @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/info_sd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/info_sd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/info_sd.xml (revision 6396) @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/menu_hd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/menu_hd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/menu_hd.xml (revision 6396) @@ -0,0 +1,13 @@ + + + + {"template": [ + MultiContentEntryPixmapAlphaTest(pos = (12, 4), size = (32, 32), png = 0), + MultiContentEntryText(pos = (58, 5), size = (440, 38), font=0, flags = RT_HALIGN_LEFT|RT_VALIGN_TOP, text = 1), + ], + "fonts": [gFont("Regular", 22)], + "itemHeight": 40 + } + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/menu_sd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/menu_sd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/menu_sd.xml (revision 6396) @@ -0,0 +1,13 @@ + + + + {"template": [ + MultiContentEntryPixmapAlphaTest(pos = (12, 4), size = (32, 32), png = 0), + MultiContentEntryText(pos = (58, 5), size = (440, 38), font=0, flags = RT_HALIGN_LEFT|RT_VALIGN_TOP, text = 1), + ], + "fonts": [gFont("Regular", 22)], + "itemHeight": 40 + } + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/providers_hd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/providers_hd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/providers_hd.xml (revision 6396) @@ -0,0 +1,23 @@ + + + + {"template": [ + MultiContentEntryText(pos = (12, 1), size = (440, 32), font=0, flags = RT_HALIGN_LEFT|RT_VALIGN_TOP, text = 0), + MultiContentEntryPixmapAlphaTest(pos = (480, 0), size = (40, 40), png = 1), + ], + "fonts": [gFont("Regular", 18)], + "itemHeight": 30 + } + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/providers_sd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/providers_sd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/providers_sd.xml (revision 6396) @@ -0,0 +1,23 @@ + + + + {"template": [ + MultiContentEntryText(pos = (12, 1), size = (440, 32), font=0, flags = RT_HALIGN_LEFT|RT_VALIGN_TOP, text = 0), + MultiContentEntryPixmapAlphaTest(pos = (480, 0), size = (40, 40), png = 1), + ], + "fonts": [gFont("Regular", 18)], + "itemHeight": 30 + } + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/setup_hd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/setup_hd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/setup_hd.xml (revision 6396) @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/setup_sd.xml =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/setup_sd.xml (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/skins/setup_sd.xml (revision 6396) @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + Index: ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/version.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/version.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/enigma2/python/Plugins/SystemPlugins/CrossEPG/version.py (revision 6396) @@ -0,0 +1,1 @@ +version = "0.6.1 (svn 241)" Index: ipk/source/epg_crossepg_0_61/usr/lib/python2.6/crossepg.py =================================================================== --- ipk/source/epg_crossepg_0_61/usr/lib/python2.6/crossepg.py (revision 6396) +++ ipk/source/epg_crossepg_0_61/usr/lib/python2.6/crossepg.py (revision 6396) @@ -0,0 +1,525 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 1.3.40 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. +# This file is compatible with both classic and new-style classes. + +from sys import version_info +if version_info >= (2,6,0): + def swig_import_helper(): + from os.path import dirname + import imp + fp = None + try: + fp, pathname, description = imp.find_module('_crossepg', [dirname(__file__)]) + except ImportError: + import _crossepg + return _crossepg + if fp is not None: + try: + _mod = imp.load_module('_crossepg', fp, pathname, description) + finally: + fp.close() + return _mod + _crossepg = swig_import_helper() + del swig_import_helper +else: + import _crossepg +del version_info +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'SwigPyObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError(name) + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +try: + _object = object + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 + + + +def log_enable(): + return _crossepg.log_enable() +log_enable = _crossepg.log_enable + +def log_disable(): + return _crossepg.log_disable() +log_disable = _crossepg.log_disable + +def log_open(*args): + return _crossepg.log_open(*args) +log_open = _crossepg.log_open + +def log_banner(*args): + return _crossepg.log_banner(*args) +log_banner = _crossepg.log_banner + +def log_close(): + return _crossepg.log_close() +log_close = _crossepg.log_close + +def log_add(*args): + return _crossepg.log_add(*args) +log_add = _crossepg.log_add + +def epgdb_aliases_clear(): + return _crossepg.epgdb_aliases_clear() +epgdb_aliases_clear = _crossepg.epgdb_aliases_clear + +def epgdb_aliases_add(*args): + return _crossepg.epgdb_aliases_add(*args) +epgdb_aliases_add = _crossepg.epgdb_aliases_add + +def epgdb_channels_count(): + return _crossepg.epgdb_channels_count() +epgdb_channels_count = _crossepg.epgdb_channels_count + +def epgdb_channels_get_first(): + return _crossepg.epgdb_channels_get_first() +epgdb_channels_get_first = _crossepg.epgdb_channels_get_first + +def epgdb_channels_set_first(*args): + return _crossepg.epgdb_channels_set_first(*args) +epgdb_channels_set_first = _crossepg.epgdb_channels_set_first + +def epgdb_channels_set_last(*args): + return _crossepg.epgdb_channels_set_last(*args) +epgdb_channels_set_last = _crossepg.epgdb_channels_set_last + +def epgdb_channels_get_by_freq(*args): + return _crossepg.epgdb_channels_get_by_freq(*args) +epgdb_channels_get_by_freq = _crossepg.epgdb_channels_get_by_freq + +def epgdb_channels_add(*args): + return _crossepg.epgdb_channels_add(*args) +epgdb_channels_add = _crossepg.epgdb_channels_add + +def epgdb_channels_reset(): + return _crossepg.epgdb_channels_reset() +epgdb_channels_reset = _crossepg.epgdb_channels_reset + +def epgdb_index_count(): + return _crossepg.epgdb_index_count() +epgdb_index_count = _crossepg.epgdb_index_count + +def epgdb_index_empties_count(): + return _crossepg.epgdb_index_empties_count() +epgdb_index_empties_count = _crossepg.epgdb_index_empties_count + +def epgdb_index_get_first(*args): + return _crossepg.epgdb_index_get_first(*args) +epgdb_index_get_first = _crossepg.epgdb_index_get_first + +def epgdb_index_empties_get_first(): + return _crossepg.epgdb_index_empties_get_first() +epgdb_index_empties_get_first = _crossepg.epgdb_index_empties_get_first + +def epgdb_index_empties_set_first(*args): + return _crossepg.epgdb_index_empties_set_first(*args) +epgdb_index_empties_set_first = _crossepg.epgdb_index_empties_set_first + +def epgdb_index_empties_set_last(*args): + return _crossepg.epgdb_index_empties_set_last(*args) +epgdb_index_empties_set_last = _crossepg.epgdb_index_empties_set_last + +def epgdb_index_empties_add(*args): + return _crossepg.epgdb_index_empties_add(*args) +epgdb_index_empties_add = _crossepg.epgdb_index_empties_add + +def epgdb_index_init(): + return _crossepg.epgdb_index_init() +epgdb_index_init = _crossepg.epgdb_index_init + +def epgdb_index_clean(): + return _crossepg.epgdb_index_clean() +epgdb_index_clean = _crossepg.epgdb_index_clean + +def epgdb_index_get_by_crc_length(*args): + return _crossepg.epgdb_index_get_by_crc_length(*args) +epgdb_index_get_by_crc_length = _crossepg.epgdb_index_get_by_crc_length + +def epgdb_index_add(*args): + return _crossepg.epgdb_index_add(*args) +epgdb_index_add = _crossepg.epgdb_index_add + +def epgdb_index_mark_all_as_unused(): + return _crossepg.epgdb_index_mark_all_as_unused() +epgdb_index_mark_all_as_unused = _crossepg.epgdb_index_mark_all_as_unused + +def epgdb_index_mark_as_used(*args): + return _crossepg.epgdb_index_mark_as_used(*args) +epgdb_index_mark_as_used = _crossepg.epgdb_index_mark_as_used + +def epgdb_index_empty_unused(): + return _crossepg.epgdb_index_empty_unused() +epgdb_index_empty_unused = _crossepg.epgdb_index_empty_unused +class epgdb_search_res_t(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, epgdb_search_res_t, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, epgdb_search_res_t, name) + __repr__ = _swig_repr + __swig_setmethods__["titles"] = _crossepg.epgdb_search_res_t_titles_set + __swig_getmethods__["titles"] = _crossepg.epgdb_search_res_t_titles_get + if _newclass:titles = _swig_property(_crossepg.epgdb_search_res_t_titles_get, _crossepg.epgdb_search_res_t_titles_set) + __swig_setmethods__["channels"] = _crossepg.epgdb_search_res_t_channels_set + __swig_getmethods__["channels"] = _crossepg.epgdb_search_res_t_channels_get + if _newclass:channels = _swig_property(_crossepg.epgdb_search_res_t_channels_get, _crossepg.epgdb_search_res_t_channels_set) + __swig_setmethods__["count"] = _crossepg.epgdb_search_res_t_count_set + __swig_getmethods__["count"] = _crossepg.epgdb_search_res_t_count_get + if _newclass:count = _swig_property(_crossepg.epgdb_search_res_t_count_get, _crossepg.epgdb_search_res_t_count_set) + def __init__(self): + this = _crossepg.new_epgdb_search_res_t() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _crossepg.delete_epgdb_search_res_t + __del__ = lambda self : None; +epgdb_search_res_t_swigregister = _crossepg.epgdb_search_res_t_swigregister +epgdb_search_res_t_swigregister(epgdb_search_res_t) + + +def epgdb_search_free(*args): + return _crossepg.epgdb_search_free(*args) +epgdb_search_free = _crossepg.epgdb_search_free + +def epgdb_search_by_name(*args): + return _crossepg.epgdb_search_by_name(*args) +epgdb_search_by_name = _crossepg.epgdb_search_by_name + +def epgdb_search_by_name_freq_time(*args): + return _crossepg.epgdb_search_by_name_freq_time(*args) +epgdb_search_by_name_freq_time = _crossepg.epgdb_search_by_name_freq_time + +def epgdb_title_alloc(): + return _crossepg.epgdb_title_alloc() +epgdb_title_alloc = _crossepg.epgdb_title_alloc + +def epgdb_title_free(*args): + return _crossepg.epgdb_title_free(*args) +epgdb_title_free = _crossepg.epgdb_title_free + +def epgdb_calculate_mjd(*args): + return _crossepg.epgdb_calculate_mjd(*args) +epgdb_calculate_mjd = _crossepg.epgdb_calculate_mjd + +def epgdb_titles_count(*args): + return _crossepg.epgdb_titles_count(*args) +epgdb_titles_count = _crossepg.epgdb_titles_count + +def epgdb_read_description(*args): + return _crossepg.epgdb_read_description(*args) +epgdb_read_description = _crossepg.epgdb_read_description + +def epgdb_read_long_description(*args): + return _crossepg.epgdb_read_long_description(*args) +epgdb_read_long_description = _crossepg.epgdb_read_long_description + +def epgdb_titles_set_long_description(*args): + return _crossepg.epgdb_titles_set_long_description(*args) +epgdb_titles_set_long_description = _crossepg.epgdb_titles_set_long_description + +def epgdb_titles_set_description(*args): + return _crossepg.epgdb_titles_set_description(*args) +epgdb_titles_set_description = _crossepg.epgdb_titles_set_description + +def epgdb_titles_set_long_description_utf8(*args): + return _crossepg.epgdb_titles_set_long_description_utf8(*args) +epgdb_titles_set_long_description_utf8 = _crossepg.epgdb_titles_set_long_description_utf8 + +def epgdb_titles_set_description_utf8(*args): + return _crossepg.epgdb_titles_set_description_utf8(*args) +epgdb_titles_set_description_utf8 = _crossepg.epgdb_titles_set_description_utf8 + +def epgdb_titles_get_by_id_and_mjd(*args): + return _crossepg.epgdb_titles_get_by_id_and_mjd(*args) +epgdb_titles_get_by_id_and_mjd = _crossepg.epgdb_titles_get_by_id_and_mjd + +def epgdb_titles_get_by_time(*args): + return _crossepg.epgdb_titles_get_by_time(*args) +epgdb_titles_get_by_time = _crossepg.epgdb_titles_get_by_time + +def epgdb_titles_delete_in_range(*args): + return _crossepg.epgdb_titles_delete_in_range(*args) +epgdb_titles_delete_in_range = _crossepg.epgdb_titles_delete_in_range + +def epgdb_titles_add(*args): + return _crossepg.epgdb_titles_add(*args) +epgdb_titles_add = _crossepg.epgdb_titles_add +DB_REVISION = _crossepg.DB_REVISION +FLAG_UTF8 = _crossepg.FLAG_UTF8 +class epgdb_title_t(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, epgdb_title_t, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, epgdb_title_t, name) + __repr__ = _swig_repr + __swig_setmethods__["event_id"] = _crossepg.epgdb_title_t_event_id_set + __swig_getmethods__["event_id"] = _crossepg.epgdb_title_t_event_id_get + if _newclass:event_id = _swig_property(_crossepg.epgdb_title_t_event_id_get, _crossepg.epgdb_title_t_event_id_set) + __swig_setmethods__["mjd"] = _crossepg.epgdb_title_t_mjd_set + __swig_getmethods__["mjd"] = _crossepg.epgdb_title_t_mjd_get + if _newclass:mjd = _swig_property(_crossepg.epgdb_title_t_mjd_get, _crossepg.epgdb_title_t_mjd_set) + __swig_setmethods__["start_time"] = _crossepg.epgdb_title_t_start_time_set + __swig_getmethods__["start_time"] = _crossepg.epgdb_title_t_start_time_get + if _newclass:start_time = _swig_property(_crossepg.epgdb_title_t_start_time_get, _crossepg.epgdb_title_t_start_time_set) + __swig_setmethods__["length"] = _crossepg.epgdb_title_t_length_set + __swig_getmethods__["length"] = _crossepg.epgdb_title_t_length_get + if _newclass:length = _swig_property(_crossepg.epgdb_title_t_length_get, _crossepg.epgdb_title_t_length_set) + __swig_setmethods__["genre_id"] = _crossepg.epgdb_title_t_genre_id_set + __swig_getmethods__["genre_id"] = _crossepg.epgdb_title_t_genre_id_get + if _newclass:genre_id = _swig_property(_crossepg.epgdb_title_t_genre_id_get, _crossepg.epgdb_title_t_genre_id_set) + __swig_setmethods__["flags"] = _crossepg.epgdb_title_t_flags_set + __swig_getmethods__["flags"] = _crossepg.epgdb_title_t_flags_get + if _newclass:flags = _swig_property(_crossepg.epgdb_title_t_flags_get, _crossepg.epgdb_title_t_flags_set) + __swig_setmethods__["description_crc"] = _crossepg.epgdb_title_t_description_crc_set + __swig_getmethods__["description_crc"] = _crossepg.epgdb_title_t_description_crc_get + if _newclass:description_crc = _swig_property(_crossepg.epgdb_title_t_description_crc_get, _crossepg.epgdb_title_t_description_crc_set) + __swig_setmethods__["description_seek"] = _crossepg.epgdb_title_t_description_seek_set + __swig_getmethods__["description_seek"] = _crossepg.epgdb_title_t_description_seek_get + if _newclass:description_seek = _swig_property(_crossepg.epgdb_title_t_description_seek_get, _crossepg.epgdb_title_t_description_seek_set) + __swig_setmethods__["long_description_crc"] = _crossepg.epgdb_title_t_long_description_crc_set + __swig_getmethods__["long_description_crc"] = _crossepg.epgdb_title_t_long_description_crc_get + if _newclass:long_description_crc = _swig_property(_crossepg.epgdb_title_t_long_description_crc_get, _crossepg.epgdb_title_t_long_description_crc_set) + __swig_setmethods__["long_description_seek"] = _crossepg.epgdb_title_t_long_description_seek_set + __swig_getmethods__["long_description_seek"] = _crossepg.epgdb_title_t_long_description_seek_get + if _newclass:long_description_seek = _swig_property(_crossepg.epgdb_title_t_long_description_seek_get, _crossepg.epgdb_title_t_long_description_seek_set) + __swig_setmethods__["description_length"] = _crossepg.epgdb_title_t_description_length_set + __swig_getmethods__["description_length"] = _crossepg.epgdb_title_t_description_length_get + if _newclass:description_length = _swig_property(_crossepg.epgdb_title_t_description_length_get, _crossepg.epgdb_title_t_description_length_set) + __swig_setmethods__["long_description_length"] = _crossepg.epgdb_title_t_long_description_length_set + __swig_getmethods__["long_description_length"] = _crossepg.epgdb_title_t_long_description_length_get + if _newclass:long_description_length = _swig_property(_crossepg.epgdb_title_t_long_description_length_get, _crossepg.epgdb_title_t_long_description_length_set) + __swig_setmethods__["iso_639_1"] = _crossepg.epgdb_title_t_iso_639_1_set + __swig_getmethods__["iso_639_1"] = _crossepg.epgdb_title_t_iso_639_1_get + if _newclass:iso_639_1 = _swig_property(_crossepg.epgdb_title_t_iso_639_1_get, _crossepg.epgdb_title_t_iso_639_1_set) + __swig_setmethods__["iso_639_2"] = _crossepg.epgdb_title_t_iso_639_2_set + __swig_getmethods__["iso_639_2"] = _crossepg.epgdb_title_t_iso_639_2_get + if _newclass:iso_639_2 = _swig_property(_crossepg.epgdb_title_t_iso_639_2_get, _crossepg.epgdb_title_t_iso_639_2_set) + __swig_setmethods__["iso_639_3"] = _crossepg.epgdb_title_t_iso_639_3_set + __swig_getmethods__["iso_639_3"] = _crossepg.epgdb_title_t_iso_639_3_get + if _newclass:iso_639_3 = _swig_property(_crossepg.epgdb_title_t_iso_639_3_get, _crossepg.epgdb_title_t_iso_639_3_set) + __swig_setmethods__["revision"] = _crossepg.epgdb_title_t_revision_set + __swig_getmethods__["revision"] = _crossepg.epgdb_title_t_revision_get + if _newclass:revision = _swig_property(_crossepg.epgdb_title_t_revision_get, _crossepg.epgdb_title_t_revision_set) + __swig_setmethods__["changed"] = _crossepg.epgdb_title_t_changed_set + __swig_getmethods__["changed"] = _crossepg.epgdb_title_t_changed_get + if _newclass:changed = _swig_property(_crossepg.epgdb_title_t_changed_get, _crossepg.epgdb_title_t_changed_set) + __swig_setmethods__["prev"] = _crossepg.epgdb_title_t_prev_set + __swig_getmethods__["prev"] = _crossepg.epgdb_title_t_prev_get + if _newclass:prev = _swig_property(_crossepg.epgdb_title_t_prev_get, _crossepg.epgdb_title_t_prev_set) + __swig_setmethods__["next"] = _crossepg.epgdb_title_t_next_set + __swig_getmethods__["next"] = _crossepg.epgdb_title_t_next_get + if _newclass:next = _swig_property(_crossepg.epgdb_title_t_next_get, _crossepg.epgdb_title_t_next_set) + def __init__(self): + this = _crossepg.new_epgdb_title_t() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _crossepg.delete_epgdb_title_t + __del__ = lambda self : None; +epgdb_title_t_swigregister = _crossepg.epgdb_title_t_swigregister +epgdb_title_t_swigregister(epgdb_title_t) + +class epgdb_index_t(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, epgdb_index_t, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, epgdb_index_t, name) + __repr__ = _swig_repr + __swig_setmethods__["crc"] = _crossepg.epgdb_index_t_crc_set + __swig_getmethods__["crc"] = _crossepg.epgdb_index_t_crc_get + if _newclass:crc = _swig_property(_crossepg.epgdb_index_t_crc_get, _crossepg.epgdb_index_t_crc_set) + __swig_setmethods__["seek"] = _crossepg.epgdb_index_t_seek_set + __swig_getmethods__["seek"] = _crossepg.epgdb_index_t_seek_get + if _newclass:seek = _swig_property(_crossepg.epgdb_index_t_seek_get, _crossepg.epgdb_index_t_seek_set) + __swig_setmethods__["length"] = _crossepg.epgdb_index_t_length_set + __swig_getmethods__["length"] = _crossepg.epgdb_index_t_length_get + if _newclass:length = _swig_property(_crossepg.epgdb_index_t_length_get, _crossepg.epgdb_index_t_length_set) + __swig_setmethods__["used"] = _crossepg.epgdb_index_t_used_set + __swig_getmethods__["used"] = _crossepg.epgdb_index_t_used_get + if _newclass:used = _swig_property(_crossepg.epgdb_index_t_used_get, _crossepg.epgdb_index_t_used_set) + __swig_setmethods__["prev"] = _crossepg.epgdb_index_t_prev_set + __swig_getmethods__["prev"] = _crossepg.epgdb_index_t_prev_get + if _newclass:prev = _swig_property(_crossepg.epgdb_index_t_prev_get, _crossepg.epgdb_index_t_prev_set) + __swig_setmethods__["next"] = _crossepg.epgdb_index_t_next_set + __swig_getmethods__["next"] = _crossepg.epgdb_index_t_next_get + if _newclass:next = _swig_property(_crossepg.epgdb_index_t_next_get, _crossepg.epgdb_index_t_next_set) + def __init__(self): + this = _crossepg.new_epgdb_index_t() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _crossepg.delete_epgdb_index_t + __del__ = lambda self : None; +epgdb_index_t_swigregister = _crossepg.epgdb_index_t_swigregister +epgdb_index_t_swigregister(epgdb_index_t) + +class epgdb_alias_t(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, epgdb_alias_t, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, epgdb_alias_t, name) + __repr__ = _swig_repr + __swig_setmethods__["nid"] = _crossepg.epgdb_alias_t_nid_set + __swig_getmethods__["nid"] = _crossepg.epgdb_alias_t_nid_get + if _newclass:nid = _swig_property(_crossepg.epgdb_alias_t_nid_get, _crossepg.epgdb_alias_t_nid_set) + __swig_setmethods__["tsid"] = _crossepg.epgdb_alias_t_tsid_set + __swig_getmethods__["tsid"] = _crossepg.epgdb_alias_t_tsid_get + if _newclass:tsid = _swig_property(_crossepg.epgdb_alias_t_tsid_get, _crossepg.epgdb_alias_t_tsid_set) + __swig_setmethods__["sid"] = _crossepg.epgdb_alias_t_sid_set + __swig_getmethods__["sid"] = _crossepg.epgdb_alias_t_sid_get + if _newclass:sid = _swig_property(_crossepg.epgdb_alias_t_sid_get, _crossepg.epgdb_alias_t_sid_set) + def __init__(self): + this = _crossepg.new_epgdb_alias_t() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _crossepg.delete_epgdb_alias_t + __del__ = lambda self : None; +epgdb_alias_t_swigregister = _crossepg.epgdb_alias_t_swigregister +epgdb_alias_t_swigregister(epgdb_alias_t) + +class epgdb_channel_t(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, epgdb_channel_t, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, epgdb_channel_t, name) + __repr__ = _swig_repr + __swig_setmethods__["nid"] = _crossepg.epgdb_channel_t_nid_set + __swig_getmethods__["nid"] = _crossepg.epgdb_channel_t_nid_get + if _newclass:nid = _swig_property(_crossepg.epgdb_channel_t_nid_get, _crossepg.epgdb_channel_t_nid_set) + __swig_setmethods__["tsid"] = _crossepg.epgdb_channel_t_tsid_set + __swig_getmethods__["tsid"] = _crossepg.epgdb_channel_t_tsid_get + if _newclass:tsid = _swig_property(_crossepg.epgdb_channel_t_tsid_get, _crossepg.epgdb_channel_t_tsid_set) + __swig_setmethods__["sid"] = _crossepg.epgdb_channel_t_sid_set + __swig_getmethods__["sid"] = _crossepg.epgdb_channel_t_sid_get + if _newclass:sid = _swig_property(_crossepg.epgdb_channel_t_sid_get, _crossepg.epgdb_channel_t_sid_set) + __swig_setmethods__["prev"] = _crossepg.epgdb_channel_t_prev_set + __swig_getmethods__["prev"] = _crossepg.epgdb_channel_t_prev_get + if _newclass:prev = _swig_property(_crossepg.epgdb_channel_t_prev_get, _crossepg.epgdb_channel_t_prev_set) + __swig_setmethods__["next"] = _crossepg.epgdb_channel_t_next_set + __swig_getmethods__["next"] = _crossepg.epgdb_channel_t_next_get + if _newclass:next = _swig_property(_crossepg.epgdb_channel_t_next_get, _crossepg.epgdb_channel_t_next_set) + __swig_setmethods__["title_first"] = _crossepg.epgdb_channel_t_title_first_set + __swig_getmethods__["title_first"] = _crossepg.epgdb_channel_t_title_first_get + if _newclass:title_first = _swig_property(_crossepg.epgdb_channel_t_title_first_get, _crossepg.epgdb_channel_t_title_first_set) + __swig_setmethods__["title_last"] = _crossepg.epgdb_channel_t_title_last_set + __swig_getmethods__["title_last"] = _crossepg.epgdb_channel_t_title_last_get + if _newclass:title_last = _swig_property(_crossepg.epgdb_channel_t_title_last_get, _crossepg.epgdb_channel_t_title_last_set) + __swig_setmethods__["aliases"] = _crossepg.epgdb_channel_t_aliases_set + __swig_getmethods__["aliases"] = _crossepg.epgdb_channel_t_aliases_get + if _newclass:aliases = _swig_property(_crossepg.epgdb_channel_t_aliases_get, _crossepg.epgdb_channel_t_aliases_set) + __swig_setmethods__["aliases_count"] = _crossepg.epgdb_channel_t_aliases_count_set + __swig_getmethods__["aliases_count"] = _crossepg.epgdb_channel_t_aliases_count_get + if _newclass:aliases_count = _swig_property(_crossepg.epgdb_channel_t_aliases_count_get, _crossepg.epgdb_channel_t_aliases_count_set) + def __init__(self): + this = _crossepg.new_epgdb_channel_t() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _crossepg.delete_epgdb_channel_t + __del__ = lambda self : None; +epgdb_channel_t_swigregister = _crossepg.epgdb_channel_t_swigregister +epgdb_channel_t_swigregister(epgdb_channel_t) + + +def epgdb_open(*args): + return _crossepg.epgdb_open(*args) +epgdb_open = _crossepg.epgdb_open + +def epgdb_close(): + return _crossepg.epgdb_close() +epgdb_close = _crossepg.epgdb_close + +def epgdb_load(): + return _crossepg.epgdb_load() +epgdb_load = _crossepg.epgdb_load + +def epgdb_save(*args): + return _crossepg.epgdb_save(*args) +epgdb_save = _crossepg.epgdb_save + +def epgdb_clean(): + return _crossepg.epgdb_clean() +epgdb_clean = _crossepg.epgdb_clean + +def epgdb_get_fdd(): + return _crossepg.epgdb_get_fdd() +epgdb_get_fdd = _crossepg.epgdb_get_fdd + +def epgdb_get_creation_time(): + return _crossepg.epgdb_get_creation_time() +epgdb_get_creation_time = _crossepg.epgdb_get_creation_time + +def epgdb_get_update_time(): + return _crossepg.epgdb_get_update_time() +epgdb_get_update_time = _crossepg.epgdb_get_update_time +import os +import re + +def epgdb_get_installroot(): + if os.path.exists("/usr/crossepg"): + return("/usr/crossepg") + elif os.path.exists("/var/crossepg"): + return("/var/crossepg") + else: + return False + +def epgdb_get_dbroot(): + + homedir = epgdb_get_installroot() + + if homedir == False: + return False + + try: + f = open("%s/crossepg.config" % (homedir), "r") + except Exception, e: + return False + + entryRe = re.compile(r"db_root=(.*)") + + for line in f.readlines(): + entry = re.findall(entryRe, line) + if entry: + dbroot = entry[0].strip() + + f.close() + return dbroot + +def IS_UTF8(flags): + return flags & 0x01 + +def SET_UTF8(flags): + return flags | 0x01 + +def UNSET_UTF8(flags): + return flags & (~0x01) + + +