Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/control =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/control (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/control (revision 8782) @@ -0,0 +1,10 @@ +Package: enigma2-plugin-swapplayers-partnerbox +Version: 1.0 +Architecture: sh4 +OE: Partnerbox +Section: players +Priority: optional +Maintainer: acid-burn@opendreambox.org +Homepage: http://www.aaf-digital.info +Source: http://www.aaf-digital.info +Description: Partnerbox plugin to stream live-TV from an other Box! SWAPSTICK IS NEEDED! Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/postinst =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/postinst (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/postinst (revision 8782) @@ -0,0 +1,7 @@ +#!/bin/sh +TMP=/tmp/.swappartnerbox +echo "successfully installed" +echo "syncing disk" +echo "please reboot your box so that the extension will be mounted..." +sync +exit 0 Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/postrm =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/postrm (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/postrm (revision 8782) @@ -0,0 +1,9 @@ +#!/bin/sh +TMP=/tmp/.swappartnerbox + +rm -rf /var/swap/extensions/Partnerbox + +echo "successfully removed" +echo "syncing disk" +sync +exit 0 Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/preinst =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/preinst (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/preinst (revision 8782) @@ -0,0 +1,39 @@ +#!/bin/sh +# +TMP=/tmp/.swappartnerbox +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 + +echo "checking swapstick" +if [ ! -d /var/swap/extensions/ ]; then + echo "--------------------------" + echo "no swapstick found...." + echo "--------------------------" + exit 1 +fi +echo "swapstick found...." +echo "installing Swap PartnerBox plugin to swapstick..." +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.sh4/swapplayers_partnerbox_1_0/CONTROL/prerm =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/prerm (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/CONTROL/prerm (revision 8782) @@ -0,0 +1,6 @@ +#!/bin/sh +TMP=/tmp/.swappartnerbox +echo "syncing disk" +sync +echo "removing Swap PartnerBox plugin from swapstick" +exit 0 Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/Makefile.am =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/Makefile.am (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/Makefile.am (revision 8782) @@ -0,0 +1,7 @@ +SUBDIRS = servicewebts icons + +installdir = /usr/lib/enigma2/python/Plugins/Extensions/Partnerbox + +install_PYTHON = *.py servicewebts/servicewebts.so + +install_DATA = *.png maintainer.info Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxEPGList.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxEPGList.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxEPGList.py (revision 8782) @@ -0,0 +1,238 @@ +# +# Partnerbox E2 +# +# $Id: PartnerboxEPGList.py,v 1.5 2009-10-08 20:38:18 ritzmo Exp $ +# +# Coded by Dr.Best (c) 2009 +# Support: www.dreambox-tools.info +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# + +from Components.EpgList import EPGList +from enigma import eListboxPythonMultiContent, \ + RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_VALIGN_CENTER, RT_HALIGN_CENTER + +from time import localtime + +from Tools.LoadPixmap import LoadPixmap +import PartnerboxFunctions as partnerboxfunctions + +baseEPGList__init__ = None +basebuildSingleEntry = None +basebuildSimilarEntry = None +basebuildMultiEntry = None + +def Partnerbox_EPGListInit(): + global baseEPGList__init__, basebuildSingleEntry, basebuildSimilarEntry, basebuildMultiEntry + if baseEPGList__init__ is None: + baseEPGList__init__ = EPGList.__init__ + if basebuildSingleEntry is None: + basebuildSingleEntry = EPGList.buildSingleEntry + if basebuildSimilarEntry is None: + basebuildSimilarEntry = EPGList.buildSimilarEntry + if basebuildMultiEntry is None: + basebuildMultiEntry = EPGList.buildMultiEntry + if partnerboxfunctions.remote_timer_list is None: + partnerboxfunctions.remote_timer_list = [] + EPGList.__init__ = Partnerbox_EPGList__init__ + EPGList.buildSingleEntry = Partnerbox_SingleEntry + EPGList.buildSimilarEntry = Partnerbox_SimilarEntry + EPGList.buildMultiEntry = Partnerbox_MultiEntry + +def Partnerbox_EPGList__init__(self, type=0, selChangedCB=None, timer = None): + baseEPGList__init__(self, type, selChangedCB, timer) + # Partnerbox Clock Icons + self.remote_clock_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock.png') + self.remote_clock_add_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_add.png') + self.remote_clock_pre_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_pre.png') + self.remote_clock_post_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_post.png') + self.remote_clock_prepost_pixmap = LoadPixmap('/usr/lib/enigma2/python/Plugins/Extensions/Partnerbox/icons/remote_epgclock_prepost.png') + +def Partnerbox_SingleEntry(self, service, eventId, beginTime, duration, EventName): + rec1=beginTime and (self.timer.isInTimer(eventId, beginTime, duration, service)) + rec2=beginTime and (isInRemoteTimer(self,beginTime, duration, service)) + r1=self.weekday_rect + r2=self.datetime_rect + r3=self.descr_rect + t = localtime(beginTime) + res = [ + None, # no private data needed + (eListboxPythonMultiContent.TYPE_TEXT, r1.left(), r1.top(), r1.width(), r1.height(), 0, RT_HALIGN_RIGHT, self.days[t[6]]), + (eListboxPythonMultiContent.TYPE_TEXT, r2.left(), r2.top(), r2.width(), r1.height(), 0, RT_HALIGN_RIGHT, "%02d.%02d, %02d:%02d"%(t[2],t[1],t[3],t[4])) + ] + if rec1 or rec2: + if rec1: + clock_pic = self.getClockPixmap(service, beginTime, duration, eventId) + #eventuell auch in der Partnerbox + if rec2: + clock_pic_partnerbox = getRemoteClockPixmap(self,service, beginTime, duration, eventId) + else: + clock_pic = getRemoteClockPixmap(self,service, beginTime, duration, eventId) + if rec1 and rec2: + # wenn sowohl lokal als auch auf Partnerbox + res.extend(( + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r3.left(), r3.top(), 21, 21, clock_pic), + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r3.left() + 25, r3.top(), 21, 21, clock_pic_partnerbox), + (eListboxPythonMultiContent.TYPE_TEXT, r3.left() + 50, r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, EventName))) + else: + res.extend(( + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r3.left(), r3.top(), 21, 21, clock_pic), + (eListboxPythonMultiContent.TYPE_TEXT, r3.left() + 25, r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, EventName))) + else: + res.append((eListboxPythonMultiContent.TYPE_TEXT, r3.left(), r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, EventName)) + return res + + +def Partnerbox_SimilarEntry(self, service, eventId, beginTime, service_name, duration): + rec1=beginTime and (self.timer.isInTimer(eventId, beginTime, duration, service)) + rec2=beginTime and (isInRemoteTimer(self,beginTime, duration, service)) + r1=self.weekday_rect + r2=self.datetime_rect + r3=self.service_rect + t = localtime(beginTime) + res = [ + None, # no private data needed + (eListboxPythonMultiContent.TYPE_TEXT, r1.left(), r1.top(), r1.width(), r1.height(), 0, RT_HALIGN_RIGHT, self.days[t[6]]), + (eListboxPythonMultiContent.TYPE_TEXT, r2.left(), r2.top(), r2.width(), r1.height(), 0, RT_HALIGN_RIGHT, "%02d.%02d, %02d:%02d"%(t[2],t[1],t[3],t[4])) + ] + if rec1 or rec2: + if rec1: + clock_pic = self.getClockPixmap(service, beginTime, duration, eventId) + #eventuell auch in der Partnerbox + if rec2: + clock_pic_partnerbox = getRemoteClockPixmap(self,service, beginTime, duration, eventId) + else: + clock_pic = getRemoteClockPixmap(self,service, beginTime, duration, eventId) + if rec1 and rec2: + # wenn sowohl lokal als auch auf Partnerbox + res.extend(( + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r3.left(), r3.top(), 21, 21, clock_pic), + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r3.left() + 25, r3.top(), 21, 21, clock_pic_partnerbox), + (eListboxPythonMultiContent.TYPE_TEXT, r3.left() + 50, r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, service_name) + )) + else: + res.extend(( + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r3.left(), r3.top(), 21, 21, clock_pic), + (eListboxPythonMultiContent.TYPE_TEXT, r3.left() + 25, r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, service_name) + )) + else: + res.append((eListboxPythonMultiContent.TYPE_TEXT, r3.left(), r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, service_name)) + return res + +def Partnerbox_MultiEntry(self, changecount, service, eventId, begTime, duration, EventName, nowTime, service_name): + # so wie es aussieht wird der MultiEPG ueber ein Plugin angefahren...lasse den Code dennoch mal drinnen... + rec1=begTime and (self.timer.isInTimer(eventId, begTime, duration, service)) + rec2=begTime and (isInRemoteTimer(self,begTime, duration, service)) + r1=self.service_rect + r2=self.progress_rect + r3=self.descr_rect + r4=self.start_end_rect + res = [ None ] # no private data needed + if rec1 or rec2: + if rec1: + clock_pic = self.getClockPixmap(service, begTime, duration, eventId) + #eventuell auch in der Partnerbox + if rec2: + clock_pic_partnerbox = getRemoteClockPixmap(self,service, begTime, duration, eventId) + else: + clock_pic = getRemoteClockPixmap(self,service, begTime, duration, eventId) + if rec1 and rec2: + # wenn sowohl lokal als auch auf Partnerbox + res.extend(( + (eListboxPythonMultiContent.TYPE_TEXT, r1.left(), r1.top(), r1.width()-41, r1.height(), 0, RT_HALIGN_LEFT, service_name), + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r1.left()+r1.width()-32, r1.top(), 21, 21, clock_pic), + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r1.left()+r1.width()-16, r1.top(), 21, 21, clock_pic_partnerbox) + )) + else: + res.extend(( + (eListboxPythonMultiContent.TYPE_TEXT, r1.left(), r1.top(), r1.width()-21, r1.height(), 0, RT_HALIGN_LEFT, service_name), + (eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r1.left()+r1.width()-16, r1.top(), 21, 21, clock_pic) + )) + else: + res.append((eListboxPythonMultiContent.TYPE_TEXT, r1.left(), r1.top(), r1.width(), r1.height(), 0, RT_HALIGN_LEFT, service_name)) + if begTime is not None: + if nowTime < begTime: + begin = localtime(begTime) + end = localtime(begTime+duration) + res.extend(( + (eListboxPythonMultiContent.TYPE_TEXT, r4.left(), r4.top(), r4.width(), r4.height(), 1, RT_HALIGN_CENTER|RT_VALIGN_CENTER, "%02d.%02d - %02d.%02d"%(begin[3],begin[4],end[3],end[4])), + (eListboxPythonMultiContent.TYPE_TEXT, r3.left(), r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, EventName) + )) + else: + percent = (nowTime - begTime) * 100 / duration + res.extend(( + (eListboxPythonMultiContent.TYPE_PROGRESS, r2.left(), r2.top(), r2.width(), r2.height(), percent), + (eListboxPythonMultiContent.TYPE_TEXT, r3.left(), r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, EventName) + )) + return res + + + +def isInRemoteTimer(self, begin, duration, service): + time_match = 0 + chktime = None + chktimecmp = None + chktimecmp_end = None + end = begin + duration + for x in partnerboxfunctions.remote_timer_list: + if x.servicereference.upper() == service.upper(): + if x.repeated != 0: + if chktime is None: + chktime = localtime(begin) + chktimecmp = chktime.tm_wday * 1440 + chktime.tm_hour * 60 + chktime.tm_min + chktimecmp_end = chktimecmp + (duration / 60) + time = localtime(x.timebegin) + for y in range(7): + if x.repeated & (2 ** y): + timecmp = y * 1440 + time.tm_hour * 60 + time.tm_min + if timecmp <= chktimecmp < (timecmp + ((x.timeend - x.timebegin) / 60)): + time_match = ((timecmp + ((x.timeend - x.timebegin) / 60)) - chktimecmp) * 60 + elif chktimecmp <= timecmp < chktimecmp_end: + time_match = (chktimecmp_end - timecmp) * 60 + else: + if begin <= x.timebegin <= end: + diff = end - x.timebegin + if time_match < diff: + time_match = diff + elif x.timebegin <= begin <= x.timeend: + diff = x.timeend - begin + if time_match < diff: + time_match = diff + if time_match: + break + return time_match + + +def getRemoteClockPixmap(self, refstr, beginTime, duration, eventId): + pre_clock = 1 + post_clock = 2 + clock_type = 0 + endTime = beginTime + duration + for x in partnerboxfunctions.remote_timer_list: + if x.servicereference.upper() == refstr.upper(): + if x.eventId == eventId: + return self.remote_clock_pixmap + beg = x.timebegin + end = x.timeend + if beginTime > beg and beginTime < end and endTime > end: + clock_type |= pre_clock + elif beginTime < beg and endTime > beg and endTime < end: + clock_type |= post_clock + if clock_type == 0: + return self.remote_clock_add_pixmap + elif clock_type == pre_clock: + return self.remote_clock_pre_pixmap + elif clock_type == post_clock: + return self.remote_clock_post_pixmap + else: + return self.remote_clock_prepost_pixmap + Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxEPGSelection.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxEPGSelection.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxEPGSelection.py (revision 8782) @@ -0,0 +1,199 @@ + +# Partnerbox E2 +# +# $Id: PartnerboxEPGSelection.py,v 1.5 2009-06-22 18:07:13 dr_best Exp $ +# +# Coded by Dr.Best (c) 2009 +# Support: www.dreambox-tools.info +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# + +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox +from Components.config import config +from PartnerboxSetup import PartnerboxEntriesListConfigScreen +from Screens.EpgSelection import EPGSelection +from Components.EpgList import EPG_TYPE_SINGLE, EPG_TYPE_SIMILAR, EPG_TYPE_MULTI +from Tools.BoundFunction import boundFunction +from PartnerboxFunctions import SetPartnerboxTimerlist, isInTimerList, sendPartnerBoxWebCommand, FillE1TimerList, FillE2TimerList +import PartnerboxFunctions as partnerboxfunctions + +# for localized messages +from . import _ + +baseEPGSelection__init__ = None +baseEPGSelection_zapTo = None +baseonSelectionChanged = None +basetimerAdd = None +basefinishedAdd = None +baseonCreate = None + +def Partnerbox_EPGSelectionInit(): + global baseEPGSelection__init__, baseEPGSelection_zapTo, baseonSelectionChanged, basetimerAdd, basefinishedAdd, baseonCreate + if baseEPGSelection__init__ is None: + baseEPGSelection__init__ = EPGSelection.__init__ + if baseEPGSelection_zapTo is None: + baseEPGSelection_zapTo = EPGSelection.zapTo + if baseonSelectionChanged is None: + baseonSelectionChanged = EPGSelection.onSelectionChanged + if basetimerAdd is None: + basetimerAdd = EPGSelection.timerAdd + if basefinishedAdd is None: + basefinishedAdd = EPGSelection.finishedAdd + if baseonCreate is None: + baseonCreate = EPGSelection.onCreate + + EPGSelection.__init__ = Partnerbox_EPGSelection__init__ + EPGSelection.zapTo = Partnerbox_EPGSelection_zapTo + EPGSelection.onSelectionChanged = Partnerbox_onSelectionChanged + EPGSelection.timerAdd = Partnerbox_timerAdd + EPGSelection.finishedAdd = Partnerbox_finishedAdd + EPGSelection.onCreate = Partnerbox_onCreate + # new methods + EPGSelection.NewPartnerBoxSelected = NewPartnerBoxSelected + EPGSelection.GetPartnerboxTimerlistCallback = GetPartnerboxTimerlistCallback + EPGSelection.GetPartnerboxTimerlistCallbackError = GetPartnerboxTimerlistCallbackError + EPGSelection.CheckRemoteTimer = CheckRemoteTimer + EPGSelection.DeleteTimerConfirmed = DeleteTimerConfirmed + EPGSelection.DeleteTimerCallback = DeleteTimerCallback + EPGSelection.GetPartnerboxTimerlist = GetPartnerboxTimerlist + EPGSelection.PartnerboxInit = PartnerboxInit + +def Partnerbox_EPGSelection__init__(self, session, service, zapFunc=None, eventid=None, bouquetChangeCB=None, serviceChangeCB=None): + baseEPGSelection__init__(self, session, service, zapFunc, eventid, bouquetChangeCB, serviceChangeCB) + self.PartnerboxInit(True) + +def PartnerboxInit(self, filterRef): + self.filterRef = filterRef + self.partnerboxentry = None + partnerboxfunctions.remote_timer_list = [] + if int(config.plugins.Partnerbox.entriescount.value) >= 1: + try: + self.partnerboxentry = config.plugins.Partnerbox.Entries[0] + partnerboxfunctions.CurrentIP = self.partnerboxentry.ip.value + except: self.partnerboxentry = None + try:self["key_red"].setText(config.plugins.Partnerbox.Entries[0].name.value) + except: pass + + +def Partnerbox_EPGSelection_zapTo(self): # just used in multiepg + if not (self.zapFunc and self.key_red_choice == self.ZAP): + self.session.openWithCallback(self.NewPartnerBoxSelected, PartnerboxEntriesListConfigScreen, 0) + else: + baseEPGSelection_zapTo(self) + +def NewPartnerBoxSelected(self, session, what, partnerboxentry = None): + if partnerboxentry is not None: + self.partnerboxentry = partnerboxentry + curService = None + if self.type == EPG_TYPE_SINGLE and self.filterRef: + curService = self.currentService.ref.toString() + SetPartnerboxTimerlist(partnerboxentry, curService) + Partnerbox_onSelectionChanged(self) + self["key_red"].setText(partnerboxentry.name.value) + self["list"].l.invalidate() # immer zeichnen, da neue Box ausgewaehlt wurde + +def Partnerbox_onSelectionChanged(self): + baseonSelectionChanged(self) + self.CheckRemoteTimer() + +def Partnerbox_timerAdd(self): + proceed = True + if self.key_green_choice == self.REMOVE_TIMER: + cur = self["list"].getCurrent() + event = cur[0] + serviceref = cur[1] + if event is not None: + timerentry = isInTimerList(event.getBeginTime(), event.getDuration(),serviceref.ref.toString(), event.getEventId(), partnerboxfunctions.remote_timer_list) + if timerentry is not None: + proceed = False + if int(self.partnerboxentry.enigma.value) == 0: + name = timerentry.name + else: + name = timerentry.description + self.session.openWithCallback(boundFunction(self.DeleteTimerConfirmed,timerentry), MessageBox, _("Do you really want to delete the timer \n%s ?") % name) + if proceed:basetimerAdd(self) + +def Partnerbox_finishedAdd(self, answer): + basefinishedAdd(self,answer) + self.CheckRemoteTimer() + +def Partnerbox_onCreate(self): + baseonCreate(self) + self.GetPartnerboxTimerlist() + +def GetPartnerboxTimerlist(self): + if self.partnerboxentry is not None: + ip = "%d.%d.%d.%d" % tuple(self.partnerboxentry.ip.value) + port = self.partnerboxentry.port.value + http = "http://%s:%d" % (ip,port) + if int(self.partnerboxentry.enigma.value) == 0: + sCommand = http + "/web/timerlist" + else: + sCommand = http + "/xml/timers" + print "[Partnerbox] %s"%sCommand + sendPartnerBoxWebCommand(sCommand, None,3, "root", self.partnerboxentry.password.value).addCallback(self.GetPartnerboxTimerlistCallback).addErrback(GetPartnerboxTimerlistCallbackError) + + +def GetPartnerboxTimerlistCallback(self, sxml = None): + if sxml is not None: + curService = None + if self.type == EPG_TYPE_SINGLE and self.filterRef: + curService = self.currentService.ref.toString() + if int(self.partnerboxentry.enigma.value) == 0: + partnerboxfunctions.remote_timer_list = FillE2TimerList(sxml, curService) + else: + partnerboxfunctions.remote_timer_list = FillE1TimerList(sxml, curService) + if len(partnerboxfunctions.remote_timer_list) != 0: + Partnerbox_onSelectionChanged(self) + self["list"].l.invalidate() + +def GetPartnerboxTimerlistCallbackError(self, error = None): + if error is not None: + print str(error.getErrorMessage()) + +def CheckRemoteTimer(self): + if self.key_green_choice != self.REMOVE_TIMER: + cur = self["list"].getCurrent() + if cur is None: + return + event = cur[0] + serviceref = cur[1] + if event is not None: + timerentry = isInTimerList(event.getBeginTime(), event.getDuration(),serviceref.ref.toString(),event.getEventId(), partnerboxfunctions.remote_timer_list) + if timerentry is not None: + self["key_green"].setText(_("Remove timer")) + self.key_green_choice = self.REMOVE_TIMER + +def DeleteTimerConfirmed (self, timerentry, answer): + if answer: + ip = "%d.%d.%d.%d" % tuple(self.partnerboxentry.ip.value) + port = self.partnerboxentry.port.value + http = "http://%s:%d" % (ip,port) + if int(self.partnerboxentry.enigma.value) == 0: + sCommand = http + "/web/timerdelete?sRef=" + timerentry.servicereference + "&begin=" + ("%s"%(timerentry.timebegin)) + "&end=" +("%s"%(timerentry.timeend)) + else: + sCommand = http + "/deleteTimerEvent?ref=" + timerentry.servicereference + "&start=" + ("%s"%(timerentry.timebegin)) + "&type=" +("%s"%(timerentry.type)) + "&force=yes" + sendPartnerBoxWebCommand(sCommand, None,3, "root", self.partnerboxentry.password.value).addCallback(self.DeleteTimerCallback).addErrback(DeleteTimerCallbackError) + +def DeleteTimerCallback(self, callback = None): + curService = None + if self.type == EPG_TYPE_SINGLE and self.filterRef: + curService = self.currentService.ref.toString() + SetPartnerboxTimerlist(self.partnerboxentry, curService) + Partnerbox_onSelectionChanged(self) + self["list"].l.invalidate() # immer zeichnen, da ja was geloescht wurde + +def DeleteTimerCallbackError(self, error = None): + if error is not None: + self.session.open(MessageBox, str(error.getErrorMessage()),MessageBox.TYPE_INFO) + Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxFunctions.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxFunctions.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxFunctions.py (revision 8782) @@ -0,0 +1,290 @@ +# +# Partnerbox E2 +# +# $Id: PartnerboxFunctions.py,v 1.9 2010-11-08 09:18:06 dr_best Exp $ +# +# Coded by Dr.Best (c) 2009 +# Support: www.dreambox-tools.info +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# + +import urllib +from time import localtime +from timer import TimerEntry +from twisted.internet import reactor +from twisted.web import client +from twisted.web.client import HTTPClientFactory +from base64 import encodestring +import xml.etree.cElementTree + +CurrentIP = None +remote_timer_list = None +oldIP = None + +def getTimerType(refstr, beginTime, duration, eventId, timer_list): + pre = 1 + post = 2 + type = 0 + endTime = beginTime + duration + for x in timer_list: + if x.servicereference.upper() == refstr.upper(): + if x.eventId == eventId: + return True + beg = x.timebegin + end = x.timeend + if beginTime > beg and beginTime < end and endTime > end: + type |= pre + elif beginTime < beg and endTime > beg and endTime < end: + type |= post + if type == 0: + return True + elif type == pre: + return False + elif type == post: + return False + else: + return True + +def isInTimerList(begin, duration, service, eventid, timer_list): + time_match = 0 + chktime = None + chktimecmp = None + chktimecmp_end = None + end = begin + duration + timerentry = None + for x in timer_list: + if x.servicereference.upper() == service.upper(): + if x.repeated != 0: + if chktime is None: + chktime = localtime(begin) + chktimecmp = chktime.tm_wday * 1440 + chktime.tm_hour * 60 + chktime.tm_min + chktimecmp_end = chktimecmp + (duration / 60) + time = localtime(x.timebegin) + for y in range(7): + if x.repeated & (2 ** y): + timecmp = y * 1440 + time.tm_hour * 60 + time.tm_min + if timecmp <= chktimecmp < (timecmp + ((x.timeend - x.timebegin) / 60)): + time_match = ((timecmp + ((x.timeend - x.timebegin) / 60)) - chktimecmp) * 60 + elif chktimecmp <= timecmp < chktimecmp_end: + time_match = (chktimecmp_end - timecmp) * 60 + else: + if begin <= x.timebegin <= end: + diff = end - x.timebegin + if time_match < diff: + time_match = diff + elif x.timebegin <= begin <= x.timeend: + diff = x.timeend - begin + if time_match < diff: + time_match = diff + if time_match: + if getTimerType(service, begin, duration, eventid, timer_list): + timerentry = x + break + return timerentry + + +class E2Timer: + def __init__(self, servicereference = "", servicename = "", name = "", disabled = 0, timebegin = 0, timeend = 0, duration = 0, startprepare = 0, state = 0, repeated = 0, justplay = 0, eventId = 0, afterevent = 0, dirname = "", description = "", type = 0): + self.servicereference = servicereference + self.servicename = servicename + self.name = name + self.disabled = disabled + self.timebegin = timebegin + self.timeend = timeend + self.duration = duration + self.startprepare = startprepare + self.state = state + self.repeated = repeated + self.justplay = justplay + self.eventId = eventId + self.afterevent = afterevent + self.dirname = dirname + self.description = description + self.type = type + if type != 0: # E1 Timerlist + self.timeend = timebegin + duration + self.name = description + if type & PlaylistEntry.isRepeating: + self.repeated = 1 + self.dirname = "/hdd/movie/" + +def FillE2TimerList(xmlstring, sreference = None): + E2TimerList = [] + try: root = xml.etree.cElementTree.fromstring(xmlstring) + except: return E2TimerList + for timer in root.findall("e2timer"): + go = False + state = 0 + try: state = int(timer.findtext("e2state", 0)) + except: state = 0 + disabled = 0 + try: disabled = int(timer.findtext("e2disabled", 0)) + except: disabled = 0 + servicereference = str(timer.findtext("e2servicereference", '').encode("utf-8", 'ignore')) + if sreference is None: + go = True + else: + if sreference.upper() == servicereference.upper() and state != TimerEntry.StateEnded and not disabled: + go = True + if go: + timebegin = 0 + timeend = 0 + duration = 0 + startprepare = 0 + repeated = 0 + justplay = 0 + afterevent = 0 + eventId = -1 + try: timebegin = int(timer.findtext("e2timebegin", 0)) + except: timebegin = 0 + try: timeend = int(timer.findtext("e2timeend", 0)) + except: timeend = 0 + try: duration = int(timer.findtext("e2duration", 0)) + except: duration = 0 + try: startprepare = int(timer.findtext("e2startprepare", 0)) + except: startprepare = 0 + try: repeated = int(timer.findtext("e2repeated", 0)) + except: repeated = 0 + try: justplay = int(timer.findtext("e2justplay", 0)) + except: justplay = 0 + try: afterevent = int(timer.findtext("e2afterevent", 0)) + except: afterevent = 0 + try: eventId = int(timer.findtext("e2eit", -1)) + except: eventId = -1 + E2TimerList.append(E2Timer( + servicereference = servicereference, + servicename = str(timer.findtext("e2servicename", 'n/a').encode("utf-8", 'ignore')), + name = str(timer.findtext("e2name", '').encode("utf-8", 'ignore')), + disabled = disabled, + timebegin = timebegin, + timeend = timeend, + duration = duration, + startprepare = startprepare, + state = state, + repeated = repeated, + justplay = justplay, + eventId = eventId, + afterevent = afterevent, + dirname = str(timer.findtext("e2location", '').encode("utf-8", 'ignore')), + description = str(timer.findtext("e2description", '').encode("utf-8", 'ignore')), + type = 0)) + return E2TimerList + + +def FillE1TimerList(xmlstring, sreference = None): + E1TimerList = [] + try: root = xml.etree.cElementTree.fromstring(xmlstring) + except: return E1TimerList + for timer in root.findall("timer"): + try: typedata = int(timer.findtext("typedata", 0)) + except: typedata = 0 + for service in timer.findall("service"): + servicereference = str(service.findtext("reference", '').encode("utf-8", 'ignore')) + servicename = str(service.findtext("name", 'n/a').encode("utf-8", 'ignore')) + for event in timer.findall("event"): + try: timebegin = int(event.findtext("start", 0)) + except: timebegin = 0 + try: duration = int(event.findtext("duration", 0)) + except: duration = 0 + description = str(event.findtext("description", '').encode("utf-8", 'ignore')) + go = False + if sreference is None: + go = True + else: + if sreference.upper() == servicereference.upper() and ( (typedata & PlaylistEntry.stateWaiting) or (typedata & PlaylistEntry.stateRunning)): + go = True + if go: + E1TimerList.append(E2Timer(servicereference = servicereference, servicename = servicename, name = "", disabled = 0, timebegin = timebegin, timeend = 0, duration = duration, startprepare = 0, state = 0 , repeated = 0, justplay= 0, eventId = -1, afterevent = 0, dirname = "", description = description, type = typedata)) + return E1TimerList + +class myHTTPClientFactory(HTTPClientFactory): + def __init__(self, url, method='GET', postdata=None, headers=None, + agent="Twisted Remotetimer", timeout=0, cookies=None, + followRedirect=1, lastModified=None, etag=None): + HTTPClientFactory.__init__(self, url, method=method, postdata=postdata, + headers=headers, agent=agent, timeout=timeout, cookies=cookies,followRedirect=followRedirect) + + +def sendPartnerBoxWebCommand(url, contextFactory=None, timeout=60, username = "root", password = "", *args, **kwargs): + scheme, host, port, path = client._parse(url) + basicAuth = encodestring(("%s:%s")%(username,password)) + authHeader = "Basic " + basicAuth.strip() + AuthHeaders = {"Authorization": authHeader} + if kwargs.has_key("headers"): + kwargs["headers"].update(AuthHeaders) + else: + kwargs["headers"] = AuthHeaders + factory = myHTTPClientFactory(url, *args, **kwargs) + reactor.connectTCP(host, port, factory, timeout=timeout) + return factory.deferred + +class PlaylistEntry: + + PlaylistEntry=1 # normal PlaylistEntry (no Timerlist entry) + SwitchTimerEntry=2 #simple service switch timer + RecTimerEntry=4 #timer do recording + + recDVR=8 #timer do DVR recording + recVCR=16 #timer do VCR recording (LIRC) not used yet + recNgrab=131072 #timer do record via Ngrab Server + + stateWaiting=32 #timer is waiting + stateRunning=64 #timer is running + statePaused=128 #timer is paused + stateFinished=256 #timer is finished + stateError=512 #timer has error state(s) + + errorNoSpaceLeft=1024 #HDD no space Left ( recDVR ) + errorUserAborted=2048 #User Action aborts this event + errorZapFailed=4096 #Zap to service failed + errorOutdated=8192 #Outdated event + + boundFile=16384 #Playlistentry have an bounded file + isSmartTimer=32768 #this is a smart timer (EIT related) not uses Yet + isRepeating=262144 #this timer is repeating + doFinishOnly=65536 #Finish an running event/action + + doShutdown=67108864 #timer shutdown the box + doGoSleep=134217728 #timer set box to standby + + Su=524288 + Mo=1048576 + Tue=2097152 + Wed=4194304 + Thu=8388608 + Fr=16777216 + Sa=33554432 + + +def SetPartnerboxTimerlist(partnerboxentry = None, sreference = None): + global remote_timer_list + global CurrentIP + if partnerboxentry is None: + return + try: + password = partnerboxentry.password.value + username = "root" + CurrentIP = partnerboxentry.ip.value + ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + port = partnerboxentry.port.value + if int(partnerboxentry.enigma.value) == 0: + sCommand = "http://%s:%s@%s:%d/web/timerlist" % (username, password, ip,port) + else: + sCommand = "http://%s:%s@%s:%d/xml/timers" % (username, password, ip,port) + print "[RemoteEPGList] Getting timerlist data from %s..."%ip + f = urllib.urlopen(sCommand) + sxml = f.read() + if int(partnerboxentry.enigma.value) == 0: + remote_timer_list = FillE2TimerList(sxml, sreference) + else: + remote_timer_list = FillE1TimerList(sxml, sreference) + except: pass Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxSetup.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxSetup.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/PartnerboxSetup.py (revision 8782) @@ -0,0 +1,291 @@ +# +# Partnerbox E2 +# +# $Id: PartnerboxSetup.py,v 1.5 2009-10-16 17:27:01 dr_best Exp $ +# +# Coded by Dr.Best (c) 2009 +# Support: www.dreambox-tools.info +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# + +from enigma import eListboxPythonMultiContent, eListbox, gFont, \ + RT_HALIGN_LEFT, RT_VALIGN_CENTER +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox +from Components.MenuList import MenuList +from Components.Button import Button +from Components.config import config +from Components.ActionMap import ActionMap, NumberActionMap +from Components.ConfigList import ConfigList, ConfigListScreen +from Components.config import ConfigSubsection, ConfigSubList, ConfigIP, ConfigInteger, ConfigSelection, ConfigText, ConfigYesNo, getConfigListEntry, configfile + +# for localized messages +from . import _ + +def initPartnerboxEntryConfig(): + config.plugins.Partnerbox.Entries.append(ConfigSubsection()) + i = len(config.plugins.Partnerbox.Entries) -1 + config.plugins.Partnerbox.Entries[i].name = ConfigText(default = "dreambox", visible_width = 50, fixed_size = False) + config.plugins.Partnerbox.Entries[i].ip = ConfigIP(default = [192,168,0,98]) + config.plugins.Partnerbox.Entries[i].port = ConfigInteger(default=80, limits=(1, 65555)) + config.plugins.Partnerbox.Entries[i].enigma = ConfigSelection(default="0", choices = [("0", _("Enigma 2")),("1", _("Enigma 1"))]) + config.plugins.Partnerbox.Entries[i].password = ConfigText(default = "dreambox", visible_width = 50, fixed_size = False) + config.plugins.Partnerbox.Entries[i].useinternal = ConfigSelection(default="1", choices = [("0", _("use external")),("1", _("use internal"))]) + config.plugins.Partnerbox.Entries[i].zaptoservicewhenstreaming = ConfigYesNo(default = True) + return config.plugins.Partnerbox.Entries[i] + +def initConfig(): + count = config.plugins.Partnerbox.entriescount.value + if count != 0: + i = 0 + while i < count: + initPartnerboxEntryConfig() + i += 1 + +def showPartnerboxIconsinEPGList(): + # for epgsearch + return config.plugins.Partnerbox.enablepartnerboxepglist.value + +class PartnerboxSetup(ConfigListScreen, Screen): + skin = """ + + + + + + + + + """ + + def __init__(self, session, args = None): + Screen.__init__(self, session) + + self["key_red"] = Button(_("Cancel")) + self["key_green"] = Button(_("OK")) + self["key_yellow"] = Button(_("Partnerbox Entries")) + + + self.list = [ ] + self.list.append(getConfigListEntry(_("Show 'RemoteTimer' in E-Menu"), config.plugins.Partnerbox.showremotetimerinextensionsmenu)) + self.list.append(getConfigListEntry(_("Show 'RemoteTV Player' in E-Menu"), config.plugins.Partnerbox.showremotetvinextensionsmenu)) + self.list.append(getConfigListEntry(_("Show 'Stream current Service' in E-Menu"), config.plugins.Partnerbox.showcurrentstreaminextensionsmenu)) + self.list.append(getConfigListEntry(_("Enable Partnerbox-Function in TimerEvent"), config.plugins.Partnerbox.enablepartnerboxintimerevent)) + self.list.append(getConfigListEntry(_("Enable Partnerbox-Function in EPGList"), config.plugins.Partnerbox.enablepartnerboxepglist)) + ConfigListScreen.__init__(self, self.list, session) + self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], + { + "green": self.keySave, + "cancel": self.keyClose, + "ok": self.keySave, + "yellow": self.PartnerboxEntries, + }, -2) + + def keySave(self): + for x in self["config"].list: + x[1].save() + configfile.save() + self.close(self.session, True) + + def keyClose(self): + for x in self["config"].list: + x[1].cancel() + self.close(self.session, False) + + def PartnerboxEntries(self): + self.session.open(PartnerboxEntriesListConfigScreen) + + +class PartnerboxEntriesListConfigScreen(Screen): + skin = """ + + + + + + + + + + + + + + """ % _("Partnerbox: List of Entries") + + def __init__(self, session, what = None): + Screen.__init__(self, session) + self.session = session + self["name"] = Button(_("Name")) + self["ip"] = Button(_("IP")) + self["port"] = Button(_("Port")) + self["type"] = Button(_("Enigma Type")) + self["key_red"] = Button(_("Add")) + self["key_yellow"] = Button(_("Edit")) + self["key_blue"] = Button(_("Delete")) + self["entrylist"] = PartnerboxEntryList([]) + self["actions"] = ActionMap(["WizardActions","MenuActions","ShortcutActions"], + { + "ok" : self.keyOK, + "back" : self.keyClose, + "red" : self.keyRed, + "yellow": self.keyYellow, + "blue": self.keyDelete, + }, -1) + self.what = what + self.updateList() + + def updateList(self): + self["entrylist"].buildList() + + def keyClose(self): + self.close(self.session, self.what, None) + + def keyRed(self): + self.session.openWithCallback(self.updateList,PartnerboxEntryConfigScreen,None) + + def keyOK(self): + try:sel = self["entrylist"].l.getCurrentSelection()[0] + except: sel = None + self.close(self.session, self.what, sel) + + def keyYellow(self): + try:sel = self["entrylist"].l.getCurrentSelection()[0] + except: sel = None + if sel is None: + return + self.session.openWithCallback(self.updateList,PartnerboxEntryConfigScreen,sel) + + def keyDelete(self): + try:sel = self["entrylist"].l.getCurrentSelection()[0] + except: sel = None + if sel is None: + return + self.session.openWithCallback(self.deleteConfirm, MessageBox, _("Really delete this Partnerbox Entry?")) + + def deleteConfirm(self, result): + if not result: + return + sel = self["entrylist"].l.getCurrentSelection()[0] + config.plugins.Partnerbox.entriescount.value = config.plugins.Partnerbox.entriescount.value - 1 + config.plugins.Partnerbox.entriescount.save() + config.plugins.Partnerbox.Entries.remove(sel) + config.plugins.Partnerbox.Entries.save() + config.plugins.Partnerbox.save() + configfile.save() + self.updateList() + +class PartnerboxEntryList(MenuList): + def __init__(self, list, enableWrapAround = True): + MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent) + self.l.setFont(0, gFont("Regular", 20)) + self.l.setFont(1, gFont("Regular", 18)) + def postWidgetCreate(self, instance): + MenuList.postWidgetCreate(self, instance) + instance.setItemHeight(20) + + def buildList(self): + self.list=[] + for c in config.plugins.Partnerbox.Entries: + res = [c] + res.append((eListboxPythonMultiContent.TYPE_TEXT, 5, 0, 150, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, str(c.name.value))) + ip = "%d.%d.%d.%d" % tuple(c.ip.value) + res.append((eListboxPythonMultiContent.TYPE_TEXT, 120, 0, 150, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, str(ip))) + port = "%d"%(c.port.value) + res.append((eListboxPythonMultiContent.TYPE_TEXT, 270, 0, 100, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, str(port))) + if int(c.enigma.value) == 0: + e_type = "Enigma2" + else: + e_type = "Enigma1" + res.append((eListboxPythonMultiContent.TYPE_TEXT, 410, 0, 100, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, str(e_type))) + self.list.append(res) + self.l.setList(self.list) + self.moveToIndex(0) + +class PartnerboxEntryConfigScreen(ConfigListScreen, Screen): + skin = """ + + + + + + + + + + """ % _("Partnerbox: Edit Entry") + + def __init__(self, session, entry): + self.session = session + Screen.__init__(self, session) + + self["actions"] = ActionMap(["SetupActions", "ColorActions"], + { + "green": self.keySave, + "red": self.keyCancel, + "blue": self.keyDelete, + "cancel": self.keyCancel + }, -2) + + self["key_red"] = Button(_("Cancel")) + self["key_green"] = Button(_("OK")) + self["key_blue"] = Button(_("Delete")) + + if entry is None: + self.newmode = 1 + self.current = initPartnerboxEntryConfig() + else: + self.newmode = 0 + self.current = entry + + cfglist = [ + getConfigListEntry(_("Name"), self.current.name), + getConfigListEntry(_("IP"), self.current.ip), + getConfigListEntry(_("Port"), self.current.port), + getConfigListEntry(_("Enigma Type"), self.current.enigma), + getConfigListEntry(_("Password"), self.current.password), + getConfigListEntry(_("Servicelists/EPG"), self.current.useinternal), + getConfigListEntry(_("Zap to service when streaming"), self.current.zaptoservicewhenstreaming) + ] + + ConfigListScreen.__init__(self, cfglist, session) + + def keySave(self): + if self.newmode == 1: + config.plugins.Partnerbox.entriescount.value = config.plugins.Partnerbox.entriescount.value + 1 + config.plugins.Partnerbox.entriescount.save() + ConfigListScreen.keySave(self) + config.plugins.Partnerbox.save() + configfile.save() + self.close() + + def keyCancel(self): + if self.newmode == 1: + config.plugins.Partnerbox.Entries.remove(self.current) + ConfigListScreen.cancelConfirm(self, True) + + def keyDelete(self): + if self.newmode == 1: + self.keyCancel() + else: + self.session.openWithCallback(self.deleteConfirm, MessageBox, _("Really delete this Partnerbox Entry?")) + + def deleteConfirm(self, result): + if not result: + return + config.plugins.Partnerbox.entriescount.value = config.plugins.Partnerbox.entriescount.value - 1 + config.plugins.Partnerbox.entriescount.save() + config.plugins.Partnerbox.Entries.remove(self.current) + config.plugins.Partnerbox.Entries.save() + config.plugins.Partnerbox.save() + configfile.save() + self.close() Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/RemoteTimerEntry.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/RemoteTimerEntry.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/RemoteTimerEntry.py (revision 8782) @@ -0,0 +1,545 @@ +# +# Partnerbox E2 +# +# $Id: RemoteTimerEntry.py,v 1.9 2010-06-08 20:39:36 dr_best Exp $ +# +# Coded by Dr.Best (c) 2009 +# Support: www.dreambox-tools.info +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# + +from Screens.Screen import Screen +import Screens.ChannelSelection +from ServiceReference import ServiceReference +from Components.config import config, ConfigSelection, ConfigText, ConfigSubList, ConfigDateTime, ConfigClock, ConfigYesNo, getConfigListEntry +from Components.ActionMap import NumberActionMap +from Components.ConfigList import ConfigListScreen +from Components.MenuList import MenuList +from Components.Button import Button +from Components.Label import Label +from Components.Pixmap import Pixmap +from Screens.MovieSelection import getPreferredTagEditor +from Screens.LocationBox import MovieLocationBox +from Screens.ChoiceBox import ChoiceBox +from RecordTimer import AFTEREVENT +from Tools.Directories import resolveFilename, SCOPE_HDD +from enigma import eEPGCache +from time import localtime, mktime, time, strftime +from datetime import datetime +from Screens.TimerEntry import TimerEntry +from Screens.MessageBox import MessageBox +from Tools.BoundFunction import boundFunction +import urllib + +import xml.etree.cElementTree +from Components.ActionMap import ActionMap + +from PartnerboxFunctions import PlaylistEntry, SetPartnerboxTimerlist, sendPartnerBoxWebCommand +import PartnerboxFunctions as partnerboxfunctions + +# for localized messages +from . import _ + + +class RemoteTimerEntry(Screen, ConfigListScreen): + skin = """ + + + + + + + + + """ + + def __init__(self, session, timer, Locations): + self.session = session + Screen.__init__(self, session) + self.timer = timer + self.Locations = Locations + self.entryDate = None + self.entryService = None + self["oktext"] = Label(_("OK")) + self["canceltext"] = Label(_("Cancel")) + self["ok"] = Pixmap() + self["cancel"] = Pixmap() + self.createConfig() + self["actions"] = NumberActionMap(["SetupActions", "GlobalActions", "PiPSetupActions"], + { + "save": self.keyGo, + "cancel": self.keyCancel, + "volumeUp": self.incrementStart, + "volumeDown": self.decrementStart, + "size+": self.incrementEnd, + "size-": self.decrementEnd + }, -2) + self.list = [] + ConfigListScreen.__init__(self, self.list, session = session) + self.createSetup("config") + + def createConfig(self): + + if self.timer.type == 0: + justplay = self.timer.justplay + afterevent = { + 0: "nothing", + 2: "deepstandby", + 1: "standby", + 3: "auto" + }[self.timer.afterevent] + else: + if self.timer.type & PlaylistEntry.doShutdown: + afterevent = PlaylistEntry.doShutdown + elif self.timer.type & PlaylistEntry.doGoSleep: + afterevent = PlaylistEntry.doGoSleep + else: + afterevent = 0 + + if self.timer.type & PlaylistEntry.RecTimerEntry: + if self.timer.type & PlaylistEntry.recDVR: + justplay = PlaylistEntry.recDVR + elif self.timer.type & PlaylistEntry.recNgrab: + justplay = PlaylistEntry.recNgrab + elif self.timer.type & PlaylistEntry.SwitchTimerEntry: + justplay = PlaylistEntry.SwitchTimerEntry + + weekday_table = ("mon", "tue", "wed", "thu", "fri", "sat", "sun") + day = [] + weekday = 0 + for x in (0, 1, 2, 3, 4, 5, 6): + day.append(0) + begin = self.timer.timebegin + end = self.timer.timeend + weekday = (int(strftime("%w", localtime(begin))) - 1) % 7 + day[weekday] = 1 + name = self.timer.name + description = self.timer.description + if self.timer.type == 0: + self.timerentry_justplay = ConfigSelection(choices = [("1", _("zap")), ("0", _("record"))], default = str(justplay)) + self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")), ("standby", _("go to standby")), ("deepstandby", _("go to deep standby")), ("auto", _("auto"))], default = afterevent) + self.timerentry_name = ConfigText(default = name, visible_width = 50, fixed_size = False) + else: + self.timerentry_justplay = ConfigSelection(choices = [(str(PlaylistEntry.SwitchTimerEntry), _("zap")), (str(PlaylistEntry.recNgrab), _("NGRAB")),(str(PlaylistEntry.recDVR), _("DVR"))], default = str(justplay)) + self.timerentry_afterevent = ConfigSelection(choices = [("0", _("do nothing")), (str(PlaylistEntry.doGoSleep), _("go to standby")), (str(PlaylistEntry.doShutdown), _("go to deep standby"))], default = str(afterevent)) + self.timerentry_description = ConfigText(default = description, visible_width = 50, fixed_size = False) + self.timerentry_date = ConfigDateTime(default = begin, formatstring = _("%d.%B %Y"), increment = 86400) + self.timerentry_starttime = ConfigClock(default = begin) + self.timerentry_endtime = ConfigClock(default = end) + if self.timer.type == 0: + default = self.timer.dirname + if default == "None": default = "/hdd/movie/" + if default not in self.Locations: + self.Locations.append(default) + self.timerentry_dirname = ConfigSelection(default = default, choices = self.Locations) + self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))]) + self.timerentry_day = ConfigSubList() + for x in (0, 1, 2, 3, 4, 5, 6): + self.timerentry_day.append(ConfigYesNo(default = day[x])) + servicename = self.timer.servicename + self.timerentry_service = ConfigSelection([servicename]) + + def createSetup(self, widget): + self.list = [] + if self.timer.type == 0: + self.list.append(getConfigListEntry(_("Name"), self.timerentry_name)) + self.list.append(getConfigListEntry(_("Description"), self.timerentry_description)) + self.timerJustplayEntry = getConfigListEntry(_("Timer Type"), self.timerentry_justplay) + self.list.append(self.timerJustplayEntry) + self.entryDate = getConfigListEntry(_("Date"), self.timerentry_date) + self.list.append(self.entryDate) + self.entryStartTime = getConfigListEntry(_("StartTime"), self.timerentry_starttime) + self.list.append(self.entryStartTime) + if self.timer.type == 0: + if int(self.timerentry_justplay.value) != 1: + self.entryEndTime = getConfigListEntry(_("EndTime"), self.timerentry_endtime) + self.list.append(self.entryEndTime) + else: + self.entryEndTime = None + else: + self.entryEndTime = getConfigListEntry(_("EndTime"), self.timerentry_endtime) + self.list.append(self.entryEndTime) + self.channelEntry = getConfigListEntry(_("Channel"), self.timerentry_service) + self.list.append(self.channelEntry) + if self.timer.type == 0: + self.dirname = getConfigListEntry(_("Location"), self.timerentry_dirname) + if int(self.timerentry_justplay.value) != 1: + self.list.append(self.dirname) + self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent)) + else: + self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent)) + self[widget].list = self.list + self[widget].l.setList(self.list) + + def newConfig(self): + if self["config"].getCurrent() == self.timerJustplayEntry: + self.createSetup("config") + + def keyLeft(self): + ConfigListScreen.keyLeft(self) + self.newConfig() + + def keyRight(self): + ConfigListScreen.keyRight(self) + self.newConfig() + + def getTimestamp(self, date, mytime): + d = localtime(date) + dt = datetime(d.tm_year, d.tm_mon, d.tm_mday, mytime[0], mytime[1]) + return int(mktime(dt.timetuple())) + + def getBeginEnd(self): + date = self.timerentry_date.value + endtime = self.timerentry_endtime.value + starttime = self.timerentry_starttime.value + begin = self.getTimestamp(date, starttime) + end = self.getTimestamp(date, endtime) + if end < begin: + end += 86400 + return begin, end + + def keyCancel(self): + self.close((False,)) + + def keyGo(self): + if self.timer.type == 0: + self.timer.name = self.timerentry_name.value + self.timer.dirname = self.timerentry_dirname.value + self.timer.afterevent = { + "nothing": 0, + "deepstandby": 2, + "standby": 1, + "auto": 3 + }[self.timerentry_afterevent.value] + else: + self.timer.afterevent = int(self.timerentry_afterevent.value) + self.timer.description = self.timerentry_description.value + self.timer.justplay = int(self.timerentry_justplay.value) + + self.timer.timebegin, self.timer.timeend = self.getBeginEnd() + self.close((True, self.timer)) + + def incrementStart(self): + self.timerentry_starttime.increment() + self["config"].invalidate(self.entryStartTime) + + def decrementStart(self): + self.timerentry_starttime.decrement() + self["config"].invalidate(self.entryStartTime) + + def incrementEnd(self): + if self.entryEndTime is not None: + self.timerentry_endtime.increment() + self["config"].invalidate(self.entryEndTime) + + def decrementEnd(self): + if self.entryEndTime is not None: + self.timerentry_endtime.decrement() + self["config"].invalidate(self.entryEndTime) + + + +# ########################################## +# TimerEntry +# ########################################## +baseTimerEntrySetup = None +baseTimerEntryGo = None +baseTimerEntrynewConfig = None +baseTimerkeyLeft = None +baseTimerkeyRight = None +baseTimerkeySelect = None +baseTimercreateConfig = None + +def RemoteTimerInit(): + global baseTimerEntrySetup, baseTimerEntryGo, baseTimerEntrynewConfig, baseTimerkeyLeft, baseTimerkeyRight, baseTimerkeySelect, baseTimercreateConfig + if baseTimerEntrySetup is None: + baseTimerEntrySetup = TimerEntry.createSetup + if baseTimerEntryGo is None: + baseTimerEntryGo = TimerEntry.keyGo + if baseTimerEntrynewConfig is None: + baseTimerEntrynewConfig = TimerEntry.newConfig + if baseTimerkeyLeft is None: + baseTimerkeyLeft = TimerEntry.keyLeft + if baseTimerkeyRight is None: + baseTimerkeyRight = TimerEntry.keyRight + if baseTimerkeySelect is None: + baseTimerkeySelect = TimerEntry.keySelect + if baseTimercreateConfig is None: + baseTimercreateConfig = TimerEntry.createConfig + + TimerEntry.createConfig = RemoteTimerConfig + TimerEntry.keyLeft = RemoteTimerkeyLeft + TimerEntry.keyRight = RemoteTimerkeyRight + TimerEntry.keySelect = RemoteTimerkeySelect + TimerEntry.createSetup = createRemoteTimerSetup + TimerEntry.keyGo = RemoteTimerGo + TimerEntry.newConfig = RemoteTimernewConfig + +def RemoteTimerConfig(self): + self.Locations = [] + self.entryguilist = [] + self.entryguilist.append(("0",_("No"),None)) + index = 1 + for c in config.plugins.Partnerbox.Entries: + self.entryguilist.append((str(index),str(c.name.value),c)) + index = index + 1 + self.timerentry_remote = ConfigSelection(default = "0", choices = self.entryguilist) + baseTimercreateConfig(self) + +#def getLocationsError(self, error): +# RemoteTimercreateConfig(self) +# RemoteTimerCreateSetup(self,"config") + +def getLocationsCallback(self, xmlstring): + self.Locations = [] + try: root = xml.etree.cElementTree.fromstring(xmlstring) + except: return + for location in root.findall("e2location"): + self.Locations.append(location.text.encode("utf-8", 'ignore')) + for location in root.findall("e2simplexmlitem"): # vorerst Kompatibilitaet zum alten Webinterface-Api aufrecht erhalten (e2simplexmlitem) + self.Locations.append(location.text.encode("utf-8", 'ignore')) + +def createRemoteTimerSetup(self, widget): + baseTimerEntrySetup(self, widget) + self.display = _("Remote Timer") + self.timerRemoteEntry = getConfigListEntry(self.display, self.timerentry_remote) + self.list.insert(0, self.timerRemoteEntry) + self[widget].list = self.list + +def RemoteTimerkeyLeft(self): + if int(self.timerentry_remote.value) != 0: + ConfigListScreen.keyLeft(self) + RemoteTimernewConfig(self) + else: + baseTimerkeyLeft(self) + +def RemoteTimerkeyRight(self): + if int(self.timerentry_remote.value) != 0: + ConfigListScreen.keyRight(self) + RemoteTimernewConfig(self) + else: + baseTimerkeyRight(self) + +def RemoteTimerkeySelect(self): + if int(self.timerentry_remote.value) != 0: + RemoteTimerGo(self) + else: + baseTimerkeySelect(self) + + +def RemoteTimernewConfig(self): + if self["config"].getCurrent() == self.timerRemoteEntry: + if int(self.timerentry_remote.value) != 0: + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 1: # E1 + self.timertype = PlaylistEntry.RecTimerEntry|PlaylistEntry.recDVR + else: # E2 + self.timertype = 0 + ip = "%d.%d.%d.%d" % tuple(self.entryguilist[int(self.timerentry_remote.value)][2].ip.value) + port = self.entryguilist[int(self.timerentry_remote.value)][2].port.value + http_ = "%s:%d" % (ip,port) + sCommand = "http://root:" + self.entryguilist[int(self.timerentry_remote.value)][2].password.value + "@" + http_ + "/web/getlocations" + #sCommand = self.http + "/web/getlocations" + #sendPartnerBoxWebCommand(sCommand, None,3, self.username, self.password).addCallback(boundFunction(getLocationsCallback,self)).addErrback(boundFunction(getLocationsError,self)) + # ich mach das besser synchron, falls die Partnerbox aus ist ( dann koennte man hier schon abbrechen und eine Meldung bringen...) + try: + f = urllib.urlopen(sCommand) + sxml = f.read() + getLocationsCallback(self,sxml) + except: pass + RemoteTimercreateConfig(self) + RemoteTimerCreateSetup(self,"config") + else: + baseTimercreateConfig(self) + createRemoteTimerSetup(self, "config") + elif self["config"].getCurrent() == self.timerJustplayEntry: + if int(self.timerentry_remote.value) != 0: + RemoteTimerCreateSetup(self,"config") + else: + baseTimerEntrynewConfig(self) + else: + if int(self.timerentry_remote.value) == 0: + baseTimerEntrynewConfig(self) + +def RemoteTimercreateConfig(self): + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 0: + justplay = self.timer.justplay + afterevent = { + AFTEREVENT.NONE: "nothing", + AFTEREVENT.DEEPSTANDBY: "deepstandby", + AFTEREVENT.STANDBY: "standby", + AFTEREVENT.AUTO: "auto" + }[self.timer.afterEvent] + else: + if self.timertype & PlaylistEntry.doShutdown: + afterevent = PlaylistEntry.doShutdown + elif self.timertype & PlaylistEntry.doGoSleep: + afterevent = PlaylistEntry.doGoSleep + else: + afterevent = 0 + if self.timertype & PlaylistEntry.RecTimerEntry: + if self.timertype & PlaylistEntry.recDVR: + justplay = PlaylistEntry.recDVR + elif self.timertype & PlaylistEntry.recNgrab: + justplay = PlaylistEntry.recNgrab + elif self.timertype & PlaylistEntry.SwitchTimerEntry: + justplay = PlaylistEntry.SwitchTimerEntry + weekday_table = ("mon", "tue", "wed", "thu", "fri", "sat", "sun") + day = [] + weekday = 0 + for x in (0, 1, 2, 3, 4, 5, 6): + day.append(0) + begin = self.timer.begin + end = self.timer.end + weekday = (int(strftime("%w", localtime(begin))) - 1) % 7 + day[weekday] = 1 + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 0: + name = self.timer.name + description = self.timer.description + self.timerentry_justplay = ConfigSelection(choices = [("zap", _("zap")), ("record", _("record"))], default = {0: "record", 1: "zap"}[justplay]) + self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")), ("standby", _("go to standby")), ("deepstandby", _("go to deep standby")), ("auto", _("auto"))], default = afterevent) + self.timerentry_name = ConfigText(default = name, visible_width = 50, fixed_size = False) + else: + description = self.timer.name + self.timerentry_justplay = ConfigSelection(choices = [(str(PlaylistEntry.SwitchTimerEntry), _("zap")), (str(PlaylistEntry.recNgrab), _("NGRAB")),(str(PlaylistEntry.recDVR), _("DVR"))], default = str(justplay)) + self.timerentry_afterevent = ConfigSelection(choices = [("0", _("do nothing")), (str(PlaylistEntry.doGoSleep), _("go to standby")), (str(PlaylistEntry.doShutdown), _("go to deep standby"))], default = str(afterevent)) + self.timerentry_description = ConfigText(default = description, visible_width = 50, fixed_size = False) + self.timerentry_date = ConfigDateTime(default = begin, formatstring = _("%d.%B %Y"), increment = 86400) + self.timerentry_starttime = ConfigClock(default = begin) + self.timerentry_endtime = ConfigClock(default = end) + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 0: + default = "/hdd/movie/" + if default not in self.Locations: + self.Locations.append(default) + self.timerentry_dirname = ConfigSelection(default = default, choices = self.Locations) + self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))]) + self.timerentry_day = ConfigSubList() + for x in (0, 1, 2, 3, 4, 5, 6): + self.timerentry_day.append(ConfigYesNo(default = day[x])) + # FIXME some service-chooser needed here + servicename = "N/A" + try: # no current service available? + servicename = str(self.timer.service_ref.getServiceName()) + except: + pass + self.timerentry_service_ref = self.timer.service_ref + self.timerentry_service = ConfigSelection([servicename]) + +def RemoteTimerCreateSetup(self, widget): + self.list = [] + self.timerRemoteEntry = getConfigListEntry(self.display, self.timerentry_remote) + self.list.append(self.timerRemoteEntry) + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 0: + self.list.append(getConfigListEntry(_("Name"), self.timerentry_name)) + self.list.append(getConfigListEntry(_("Description"), self.timerentry_description)) + self.timerJustplayEntry = getConfigListEntry(_("Timer Type"), self.timerentry_justplay) + self.list.append(self.timerJustplayEntry) + self.entryDate = getConfigListEntry(_("Date"), self.timerentry_date) + self.list.append(self.entryDate) + self.entryStartTime = getConfigListEntry(_("StartTime"), self.timerentry_starttime) + self.list.append(self.entryStartTime) + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 0: + if self.timerentry_justplay.value != "zap": + self.entryEndTime = getConfigListEntry(_("EndTime"), self.timerentry_endtime) + self.list.append(self.entryEndTime) + else: + self.entryEndTime = None + else: + self.entryEndTime = getConfigListEntry(_("EndTime"), self.timerentry_endtime) + self.list.append(self.entryEndTime) + self.channelEntry = getConfigListEntry(_("Channel"), self.timerentry_service) + self.list.append(self.channelEntry) + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 0: + self.dirname = getConfigListEntry(_("Location"), self.timerentry_dirname) + if self.timerentry_justplay.value != "zap": + self.list.append(self.dirname) + self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent)) + else: + self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent)) + self[widget].list = self.list + self[widget].l.setList(self.list) + +def RemoteTimerGo(self): + if int(self.timerentry_remote.value) == 0: + baseTimerEntryGo(self) + else: + service_ref = self.timerentry_service_ref + descr = urllib.quote(self.timerentry_description.value) + begin, end = self.getBeginEnd() + ip = "%d.%d.%d.%d" % tuple(self.entryguilist[int(self.timerentry_remote.value)][2].ip.value) + port = self.entryguilist[int(self.timerentry_remote.value)][2].port.value + http = "http://%s:%d" % (ip,port) + if int(self.entryguilist[int(self.timerentry_remote.value)][2].enigma.value) == 1: + # E1 + afterevent = self.timerentry_afterevent.value + justplay = int(self.timerentry_justplay.value) + if justplay & PlaylistEntry.SwitchTimerEntry: + action = "zap" + elif justplay & PlaylistEntry.recNgrab: + action = "ngrab" + else: + action = "" + # FIXME some service-chooser needed here + servicename = "N/A" + try: # no current service available? + servicename = str(service_ref .getServiceName()) + except: + pass + channel = urllib.quote(servicename) + sCommand = "%s/addTimerEvent?ref=%s&start=%d&duration=%d&descr=%s&channel=%s&after_event=%s&action=%s" % (http, service_ref , begin, end - begin, descr, channel, afterevent, action) + sendPartnerBoxWebCommand(sCommand, None,3, "root", str(self.entryguilist[int(self.timerentry_remote.value)][2].password.value)).addCallback(boundFunction(AddTimerE1Callback,self, self.session)).addErrback(boundFunction(AddTimerError,self, self.session)) + else: + # E2 + name = urllib.quote(self.timerentry_name.value) + self.timer.tags = self.timerentry_tags + if self.timerentry_justplay.value == "zap": + justplay = 1 + dirname = "" + else: + justplay = 0 + dirname = urllib.quote(self.timerentry_dirname.value) + afterevent = { + "deepstandby": AFTEREVENT.DEEPSTANDBY, + "standby": AFTEREVENT.STANDBY, + }.get(self.timerentry_afterevent.value, AFTEREVENT.NONE) + sCommand = "%s/web/timeradd?sRef=%s&begin=%d&end=%d&name=%s&description=%s&dirname=%s&eit=0&justplay=%d&afterevent=%s" % (http, service_ref,begin,end,name,descr,dirname,justplay,afterevent) + sendPartnerBoxWebCommand(sCommand, None,3, "root", str(self.entryguilist[int(self.timerentry_remote.value)][2].password.value)).addCallback(boundFunction(AddTimerE2Callback,self, self.session)).addErrback(boundFunction(AddTimerError,self,self.session)) + +def AddTimerE2Callback(self, session, answer): + text = "" + try: root = xml.etree.cElementTree.fromstring(answer) + except: pass + statetext = root.findtext("e2statetext") + state = root.findtext("e2state") + if statetext: + text = statetext.encode("utf-8", 'ignore') + ok = state == "True" + session.open(MessageBox,_("Partnerbox Answer: \n%s") % (text),MessageBox.TYPE_INFO, timeout = 3) + if ok: + if (config.plugins.Partnerbox.enablepartnerboxepglist.value): + # Timerlist der Partnerbox neu laden --> Anzeige fuer EPGList, aber nur, wenn die gleiche IP in EPGList auch angezeigt wird + if partnerboxfunctions.CurrentIP == self.entryguilist[int(self.timerentry_remote.value)][2].ip.value: + SetPartnerboxTimerlist(self.entryguilist[int(self.timerentry_remote.value)][2]) + self.keyCancel() + +def AddTimerE1Callback(self, session, answer): + ok = answer == "Timer event was created successfully." + session.open(MessageBox,_("Partnerbox Answer: \n%s") % (answer),MessageBox.TYPE_INFO, timeout = 3) + if ok: + if (config.plugins.Partnerbox.enablepartnerboxepglist.value): + # Timerlist der Partnerbox neu laden --> Anzeige fuer EPGList, aber nur, wenn die gleiche IP in EPGList auch angezeigt wird + if partnerboxfunctions.CurrentIP == self.entryguilist[int(self.timerentry_remote.value)][2].ip.value: + SetPartnerboxTimerlist(self.entryguilist[int(self.timerentry_remote.value)][2]) + self.keyCancel() + +def AddTimerError(self, session, error): + session.open(MessageBox,str(error.getErrorMessage()),MessageBox.TYPE_INFO) + Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/Services.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/Services.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/Services.py (revision 8782) @@ -0,0 +1,118 @@ +# +# Partnerbox E2 +# +# $Id: Services.py,v 1.2 2009-05-05 10:41:15 dr_best Exp $ +# +# Coded by Dr.Best (c) 2009 +# Support: www.dreambox-tools.info +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# + +from Components.Sources.Source import Source +from Components.Sources.ServiceList import ServiceList +from Screens.ChannelSelection import service_types_tv +from enigma import eServiceReference, eEPGCache + + +class E2EPGListAllData: + def __init__(self, servicereference = "", servicename = "", eventid = 0, eventstart = 0, eventduration = 0, eventtitle = "", eventdescription = "", eventdescriptionextended = ""): + self.servicereference = servicereference + self.servicename = servicename + self.eventid = eventid + self.eventstart = eventstart + self.eventduration = eventduration + self.eventtitle = eventtitle + self.eventdescription = eventdescription + self.eventdescriptionextended = eventdescriptionextended + +class E2ServiceList: + def __init__(self, servicereference = "", servicename = ""): + self.servicereference = servicereference + self.servicename = servicename + +class Services( Source ): + def __init__(self, session): + Source.__init__(self) + self.session = session + self.servicelist = {} + self.epgcache = eEPGCache.getInstance() + + def buildList(self, ref, epg): + self.servicelist = ServiceList(ref, command_func = self.getServiceList, validate_commands=False) + list = self.servicelist.getServicesAsList() + E2List = [] + for index in range(len(list)): + item = list[index] + servicereference = item[0] + servicename = item[1] + eventstart = 0 + eventduration = 0 + eventtitle = "" + eventid = 0 + eventdescription = "" + eventdescriptionextended = "" + if epg: + epgref = item[0] + events = self.epgcache.lookupEvent(['IBDTSERNX', (epgref, 0, -1)]) + if events: + if events[0][0] is not None: + eventid = events[0][0] + if events[0][1] is not None: + eventstart = events[0][1] + if events[0][2] is not None: + eventduration = events[0][2] + if events[0][3] is not None: + eventtitle = events[0][3] + if events[0][4] is not None: + eventdescription= events[0][4] + if events[0][5] is not None: + eventdescriptionextended= events[0][5] + E2List.append(E2EPGListAllData(servicereference = servicereference, servicename = servicename, eventstart = eventstart, eventduration = eventduration, eventtitle = eventtitle, eventid = eventid, eventdescription= eventdescription, eventdescriptionextended = eventdescriptionextended)) + else: + E2List.append(E2ServiceList(servicereference = item[0], servicename = item[1])) + return E2List + + def buildEPGList(self, ref): + E2List = [] + events = self.epgcache.lookupEvent(['IBDTSERN',(ref,0,-1,-1)]); + if events: + for item in events: + servicereference = "" + servicename = "" + eventstart = 0 + eventduration = 0 + eventtitle = "" + eventid = 0 + eventdescription = "" + eventdescriptionextended = "" + if item[6] is not None: + servicereference = item[6] + if item[7] is not None: + servicename = item[7] + if item[1] is not None: + eventstart = item[1] + if item[2] is not None: + eventduration = item[2] + if item[3] is not None: + eventtitle = item[3] + if item[0] is not None: + eventid = item[0] + if item[4] is not None: + eventdescription = item[4] + if item[5] is not None: + eventdescriptionextended = item[5] + if eventstart != 0: + E2List.append(E2EPGListAllData(servicereference = servicereference, servicename = servicename, eventstart = eventstart, eventduration = eventduration, eventtitle = eventtitle, eventid = eventid, eventdescription= eventdescription, eventdescriptionextended = eventdescriptionextended)) + return E2List + + def getServiceList(self, ref): + self.servicelist.root = ref Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/__init__.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/__init__.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/__init__.py (revision 8782) @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +from Components.Language import language +from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_LANGUAGE +from os import environ as os_environ +import gettext + +def localeInit(): + lang = language.getLanguage()[:2] # getLanguage returns e.g. "fi_FI" for "language_country" + os_environ["LANGUAGE"] = lang # Enigma doesn't set this (or LC_ALL, LC_MESSAGES, LANG). gettext needs it! + gettext.bindtextdomain("Partnerbox", resolveFilename(SCOPE_PLUGINS, "Extensions/Partnerbox/locale")) + +def _(txt): + t = gettext.dgettext("Partnerbox", txt) + if t == txt: + print "[Partnerbox] fallback to default translation for", txt + t = gettext.gettext(txt) + return t + +localeInit() +language.addCallback(localeInit) + Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/maintainer.info =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/maintainer.info (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/maintainer.info (revision 8782) @@ -0,0 +1,2 @@ +dr.best@dreambox-tools.info +Partnerbox Index: /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/plugin.py =================================================================== --- /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/plugin.py (revision 8782) +++ /ipk/source.sh4/swapplayers_partnerbox_1_0/var/swap/extensions/Partnerbox/plugin.py (revision 8782) @@ -0,0 +1,1640 @@ +# +# Partnerbox E2 +# +# $Id: plugin.py,v 1.9 2009-12-09 18:44:51 dr_best Exp $ +# +# Coded by Dr.Best (c) 2009 +# Support: www.dreambox-tools.info +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# + +from Plugins.Plugin import PluginDescriptor +from Screens.Screen import Screen +from Screens.MessageBox import MessageBox +from Screens.ChoiceBox import ChoiceBox +from Components.config import config +from Components.ScrollLabel import ScrollLabel +from Components.ActionMap import ActionMap, NumberActionMap +from Components.MenuList import MenuList +from Components.Label import Label +from Components.Button import Button +from Components.EpgList import Rect +from Components.MultiContent import MultiContentEntryText +from enigma import eServiceReference +from enigma import eListboxPythonMultiContent, eListbox, gFont, \ + RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_VALIGN_CENTER +from Tools.LoadPixmap import LoadPixmap +from Tools.Directories import resolveFilename, SCOPE_SKIN_IMAGE +from Tools.FuzzyDate import FuzzyTime +from timer import TimerEntry +from enigma import eTimer +from time import localtime +import time +import xml.etree.cElementTree +import urllib +#import SocketServer +#import servicewebts +ENIGMA_WEBSERVICE_ID = 0x1001 +from Screens.InfoBarGenerics import InfoBarAudioSelection +from RemoteTimerEntry import RemoteTimerEntry, RemoteTimerInit +from PartnerboxEPGSelection import Partnerbox_EPGSelectionInit + +from PartnerboxFunctions import PlaylistEntry, FillE1TimerList, E2Timer, FillE2TimerList, SetPartnerboxTimerlist, sendPartnerBoxWebCommand, isInTimerList + +from PartnerboxEPGList import Partnerbox_EPGListInit +from PartnerboxSetup import PartnerboxSetup, PartnerboxEntriesListConfigScreen, PartnerboxEntryList, PartnerboxEntryConfigScreen, initPartnerboxEntryConfig, initConfig +import time + +from Services import Services, E2EPGListAllData, E2ServiceList +from Screens.ChannelSelection import service_types_tv + +from Components.ConfigList import ConfigList, ConfigListScreen +from Components.config import ConfigSubsection, ConfigSubList, ConfigIP, ConfigInteger, ConfigSelection, ConfigText, ConfigYesNo, getConfigListEntry, configfile + +from Components.GUIComponent import GUIComponent + +# for localized messages +from . import _ + + +config.plugins.Partnerbox = ConfigSubsection() +config.plugins.Partnerbox.showremotetvinextensionsmenu= ConfigYesNo(default = True) +config.plugins.Partnerbox.showcurrentstreaminextensionsmenu= ConfigYesNo(default = True) +config.plugins.Partnerbox.showremotetimerinextensionsmenu= ConfigYesNo(default = True) +config.plugins.Partnerbox.enablepartnerboxintimerevent = ConfigYesNo(default = False) +config.plugins.Partnerbox.enablepartnerboxepglist = ConfigYesNo(default = False) +config.plugins.Partnerbox.entriescount = ConfigInteger(0) +config.plugins.Partnerbox.Entries = ConfigSubList() +initConfig() + + +def partnerboxpluginStart(session, what): + count = config.plugins.Partnerbox.entriescount.value + if count == 1: + partnerboxplugin(session, what, config.plugins.Partnerbox.Entries[0]) + else: + session.openWithCallback(partnerboxplugin, PartnerboxEntriesListConfigScreen, what) + +def partnerboxplugin(session, what, partnerboxentry = None): + if partnerboxentry is None: + return + if what == 0: # Current RemoteTV + session.open(CurrentRemoteTV, partnerboxentry) + elif what == 1: # RemoteTV + session.open(RemoteTimerBouquetList, [], partnerboxentry, 1) + elif what == 2: # RemoteTimer + session.open(RemoteTimer, partnerboxentry) + +def autostart_RemoteTimerInit(reason, **kwargs): + if "session" in kwargs: + session = kwargs["session"] + try: RemoteTimerInit() + except: pass + +def autostart_Partnerbox_EPGList(reason, **kwargs): + if "session" in kwargs: + session = kwargs["session"] + try: + Partnerbox_EPGListInit() + Partnerbox_EPGSelectionInit() + except: pass + +def PartnerboxSetupFinished(session, result): + if result: + session.open(MessageBox,_("You have to restart Enigma2 to activate your new preferences!"), MessageBox.TYPE_INFO) + +def setup(session,**kwargs): + session.openWithCallback(PartnerboxSetupFinished, PartnerboxSetup) + + +def currentremotetv(session,**kwargs): + partnerboxpluginStart(session, 0) + +def remotetvplayer(session,**kwargs): + partnerboxpluginStart(session, 1) + +def main(session,**kwargs): + partnerboxpluginStart(session, 2) + +def Plugins(**kwargs): + list = [PluginDescriptor(name="Partnerbox: RemoteTimer", description=_("Manage timer for other dreamboxes in network"), + where = [PluginDescriptor.WHERE_EVENTINFO ], fnc=main)] + if config.plugins.Partnerbox.enablepartnerboxintimerevent.value: + list.append(PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, fnc = autostart_RemoteTimerInit)) + if config.plugins.Partnerbox.enablepartnerboxepglist.value: + list.append(PluginDescriptor(where = PluginDescriptor.WHERE_SESSIONSTART, fnc = autostart_Partnerbox_EPGList)) + list.append(PluginDescriptor(name="Setup Partnerbox", description=_("setup for partnerbox"), where = [PluginDescriptor.WHERE_PLUGINMENU], fnc=setup)) + if config.plugins.Partnerbox.showremotetimerinextensionsmenu.value: + list.append(PluginDescriptor(name="Partnerbox: RemoteTimer", description=_("Manage timer for other dreamboxes in network"), + where = [PluginDescriptor.WHERE_EXTENSIONSMENU], fnc=main)) + if config.plugins.Partnerbox.showremotetvinextensionsmenu.value: + list.append(PluginDescriptor(name="Partnerbox: RemoteTV Player", description=_("Stream TV from your Partnerbox"), where = [PluginDescriptor.WHERE_EXTENSIONSMENU], fnc=remotetvplayer)) + if config.plugins.Partnerbox.showcurrentstreaminextensionsmenu.value: + list.append(PluginDescriptor(name="Stream current Service from Partnerbox", description=_("Stream current service from partnerbox"), where = [PluginDescriptor.WHERE_EXTENSIONSMENU], fnc=currentremotetv)) + + return list + +def FillLocationList(xmlstring): + Locations = [] + try: root = xml.etree.cElementTree.fromstring(xmlstring) + except: Locations + for location in root.findall("e2location"): + Locations.append(location.text.encode("utf-8", 'ignore')) + for location in root.findall("e2simplexmlitem"): # vorerst Kompatibilitaet zum alten Webinterface-Api aufrecht erhalten (e2simplexmlitem) + Locations.append(location.text.encode("utf-8", 'ignore')) + return Locations + + +class CurrentRemoteTV(Screen): + skin = """ + + + """ + def __init__(self, session, partnerboxentry): + self.session = session + Screen.__init__(self, session) + self.CurrentService = self.session.nav.getCurrentlyPlayingServiceReference() + self.PartnerboxEntry = partnerboxentry + self.password = partnerboxentry.password.value + self.username = "root" + self.ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + port = partnerboxentry.port.value + self.http = "http://%s:%d" % (self.ip,port) + self.enigma_type = int(partnerboxentry.enigma.value) + self.useinternal = int(partnerboxentry.useinternal.value) + if self.enigma_type == 1: + self.url = self.http + "/video.m3u" + else: + self.url = self.http + "/web/getcurrent" + + tt = "Starting Remote Player (IP = %s)" % (self.ip) + self["text"] = Label(tt) + self.onLayoutFinish.append(self.startRun) + + def startRun(self): + sendPartnerBoxWebCommand(self.url, None,10, self.username, self.password).addCallback(self.Callback).addErrback(self.Error) + + def Callback(self, xmlstring): + url = "" + servicereference = "" + if self.enigma_type == 0: + root = xml.etree.cElementTree.fromstring(xmlstring) + for service in root.findall("e2service"): + servicereference = str(service.findtext("e2servicereference", '').encode("utf-8", 'ignore')) + if len(servicereference) > 0: + url = "http://" + self.ip + ":8001/" + servicereference + else: + self.close() + else: + url = xmlstring + if len(url) > 0: + self.session.nav.stopService() + sref = eServiceReference(ENIGMA_WEBSERVICE_ID, 0, url) + self.session.nav.playService(sref) + self.session.openWithCallback(self.RemotePlayerFinished, RemotePlayer,"" ,"", 0, 0, self.PartnerboxEntry, servicereference) + else: + self.close() + + def RemotePlayerFinished(self): + self.session.nav.playService(self.CurrentService) + self.close() + + def Error(self, error = None): + self.close() + +class RemoteTimer(Screen): + global CurrentParnerBoxName + skin = """ + + + + + + + + + + + + """ + + timerlist = [] + def __init__(self, session, partnerboxentry): + self.session = session + Screen.__init__(self, session) + self["key_red"] = Label(_("Delete")) + self["key_green"] = Label() # Dummy, kommt eventuell noch was + self["key_yellow"] = Label(_("EPG Selection")) + self["key_blue"] = Label(_("Clean up")) + self["text"] = Label(_("Getting Partnerbox Information...")) + self.onLayoutFinish.append(self.startRun) + self.E2TimerList = [] + self["actions"] = ActionMap(["WizardActions", "DirectionActions", "ColorActions", "EPGSelectActions"], + { + "ok": self.getLocations, + "back": self.close, + "yellow": self.EPGList, + "blue": self.cleanupTimer, + "red": self.deleteTimer, + }, -1) + + self.PartnerboxEntry = partnerboxentry + self.password = partnerboxentry.password.value + self.username = "root" + self.ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + self.port = partnerboxentry.port.value + self.http = "http://%s:%d" % (self.ip,self.port) + self.enigma_type = int(partnerboxentry.enigma.value) + self.useinternal = int(partnerboxentry.useinternal.value) + self.oldstart = 0 + self.oldend = 0 + self.oldtype = 0 + self.Locations = [] + self["timerlist"] = E2TimerMenu(self.enigma_type) + + def getLocations(self): + if self.enigma_type == 0: + sCommand = self.http + "/web/getlocations" + sendPartnerBoxWebCommand(sCommand, None,3, self.username, self.password).addCallback(self.getLocationsCallback).addErrback(self.deleteTimerError) + else: + self.addTimer() + + def getLocationsCallback(self, xmlstring): + self.Locations = [] + self.Locations = FillLocationList(xmlstring) + self.addTimer() + + def addTimer(self): + try: + sel = self["timerlist"].l.getCurrentSelection()[0] + except: return + if sel is None: + return + if sel.repeated == 0: + self.oldstart = sel.timebegin + self.oldend = sel.timeend + self.oldtype = sel.type + self.session.openWithCallback(self.RemoteTimerEntryFinished, RemoteTimerEntry,sel, self.Locations) + else: + text = "Repeated Timer are not supported!" + self.session.open(MessageBox,text, MessageBox.TYPE_INFO) + + def RemoteTimerEntryFinished(self, answer): + if answer[0]: + entry = answer[1] + self["timerlist"].instance.hide() + if self.enigma_type == 0: + ref_old = "&channelOld=" + urllib.quote(entry.servicereference.decode('utf8').encode('latin-1','ignore')) + "&beginOld=" + ("%s"%(self.oldstart)) + "&endOld=" + ("%s"%(self.oldend)) + "&deleteOldOnSave=1" + ref = urllib.quote(entry.servicereference.decode('utf8').encode('latin-1','ignore')) + "&begin=" + ("%s"%(entry.timebegin)) + "&end=" + ("%s"%(entry.timeend)) + "&name=" + urllib.quote(entry.name) + "&description=" + urllib.quote(entry.description) + "&dirname=" + urllib.quote(entry.dirname) + "&eit=0&justplay=" + ("%s"%(entry.justplay)) + "&afterevent=" + ("%s"%(entry.afterevent)) + sCommand = self.http + "/web/timerchange?sRef=" + ref + ref_old + sendPartnerBoxWebCommand(sCommand, None,10, self.username, self.password).addCallback(self.deleteTimerCallback).addErrback(self.downloadError) + else: + if entry.justplay & PlaylistEntry.SwitchTimerEntry: + action = "zap" + elif entry.justplay & PlaylistEntry.recNgrab: + action = "ngrab" + else: + action = "" + tstart = time.localtime(entry.timebegin) + tend = time.localtime(entry.timeend) + ref_time_start = "&sday=" + ("%s"%(tstart.tm_mday)) + "&smonth=" + ("%s"%(tstart.tm_mon)) + "&syear=" + ("%s"%(tstart.tm_year)) + "&shour=" + ("%s"%(tstart.tm_hour)) + "&smin=" + ("%s"%(tstart.tm_min)) + ref_time_end = "&eday=" + ("%s"%(tend.tm_mday)) + "&emonth=" + ("%s"%(tend.tm_mon)) + "&eyear=" + ("%s"%(tend.tm_year)) + "&ehour=" + ("%s"%(tend.tm_hour)) + "&emin=" + ("%s"%(tend.tm_min)) + ref_old = "&old_type=" + ("%s"%(self.oldtype)) + "&old_stime=" + ("%s"%(self.oldstart)) + "&force=yes" + ref = urllib.quote(entry.servicereference.decode('utf8').encode('latin-1','ignore')) + "&descr=" + urllib.quote(entry.description) + "&channel=" + urllib.quote(entry.servicename) + "&after_event=" + ("%s"%(entry.afterevent)) + "&action=" + ("%s"%(action)) + sCommand = self.http + "/changeTimerEvent?ref=" + ref + ref_old + ref_time_start + ref_time_end + sendPartnerBoxWebCommand(sCommand, None,10, self.username, self.password).addCallback(self.deleteTimerCallback).addErrback(self.downloadError) + + def startRun(self): + self["timerlist"].instance.hide() + self.action() + + def cleanupTimer(self): + self["timerlist"].instance.hide() + self["text"].setText(_("Cleaning up finished timer entries...")) + if self.enigma_type == 0: + sCommand = self.http + "/web/timercleanup?cleanup=1" + else: + sCommand = self.http + "/cleanupTimerList" + sendPartnerBoxWebCommand(sCommand, None,3, self.username, self.password).addCallback(self.cleanupTimerlistCallback).addErrback(self.cleanupTimerlistCallback) + + def cleanupTimerlistCallback(self, answer): + self.action() + + def deleteTimer(self): + try: + sel = self["timerlist"].l.getCurrentSelection()[0] + if sel is None: + return + if self.enigma_type == 0: + name = sel.name + else: + name = sel.description + self.session.openWithCallback(self.deleteTimerConfirmed, MessageBox, _("Do you really want to delete the timer \n%s ?") % name) + except: return + + def deleteTimerConfirmed(self, val): + if val: + sel = self["timerlist"].l.getCurrentSelection()[0] + if sel is None: + return + if self.enigma_type == 0: + sCommand = self.http + "/web/timerdelete?sRef=" + sel.servicereference + "&begin=" + ("%s"%(sel.timebegin)) + "&end=" +("%s"%(sel.timeend)) + else: + sCommand = self.http + "/deleteTimerEvent?ref=" + sel.servicereference + "&start=" + ("%s"%(sel.timebegin)) + "&type=" +("%s"%(sel.type)) + "&force=yes" + sendPartnerBoxWebCommand(sCommand, None,3, self.username, self.password).addCallback(self.deleteTimerCallback).addErrback(self.deleteTimerError) + + def deleteTimerCallback(self, callback = None): + self.action() + + def deleteTimerError(self, error = None): + if error is not None: + self["timerlist"].instance.hide() + self["text"].setText(str(error.getErrorMessage())) + + def downloadCallback(self, callback = None): + self.readXML(callback) + self["timerlist"].instance.show() + + def downloadError(self, error = None): + if error is not None: + self["text"].setText(str(error.getErrorMessage())) + + def action(self): + if self.enigma_type == 0: + url = self.http + "/web/timerlist" + else: + url = self.http + "/xml/timers" + sendPartnerBoxWebCommand(url, None,10, self.username, self.password).addCallback(self.downloadCallback).addErrback(self.downloadError) + + def readXML(self, xmlstring): + self.E2TimerList = [] + if self.enigma_type == 0: + self.E2TimerList = FillE2TimerList(xmlstring) + else: + self.E2TimerList = FillE1TimerList(xmlstring) + self["timerlist"].setList([ (x,) for x in self.E2TimerList]) + + def EPGList(self): + self.session.openWithCallback(self.CallbackEPGList, RemoteTimerBouquetList, self.E2TimerList, self.PartnerboxEntry, 0) + + def CallbackEPGList(self): + self.startRun() + +class RemoteTimerBouquetList(Screen): + skin = """ + + + + """ + + def __init__(self, session, E2Timerlist, partnerboxentry, playeronly): + self.session = session + Screen.__init__(self, session) + self["bouquetlist"] = E2BouquetList([]) + self["text"] = Label(_("Getting Partnerbox Bouquet Information...")) + self.onLayoutFinish.append(self.startRun) + self.E2TimerList = E2Timerlist + self["actions"] = ActionMap(["WizardActions", "DirectionActions"], + { + "ok": self.action, + "back": self.close, + }, -1) + self.PartnerboxEntry = partnerboxentry + self.password = partnerboxentry.password.value + self.username = "root" + ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + port = partnerboxentry.port.value + self.http = "http://%s:%d" % (ip,port) + self.enigma_type = int(partnerboxentry.enigma.value) + self.useinternal = int(partnerboxentry.useinternal.value) + self.playeronly = playeronly + if self.enigma_type == 0: + self.url = self.http + "/web/getservices" + else: + self.url = self.http + "/xml/services?mode=0&submode=4" + self.E1XMLString = "" + + + def action(self): + try: + sel = self["bouquetlist"].l.getCurrentSelection()[0] + if sel is None: + return + self.session.openWithCallback(self.CallbackEPGList, RemoteTimerChannelList, self.E2TimerList, sel.servicereference, sel.servicename, self.PartnerboxEntry, self.E1XMLString, self.playeronly) + except: return + + def CallbackEPGList(self): + pass + + def startRun(self): + if self.useinternal == 1 : + BouquetList = [] + a = Services(self.session) + ref = eServiceReference( service_types_tv + ' FROM BOUQUET "bouquets.tv" ORDER BY bouquet') + BouquetList = a.buildList(ref, False) + self["bouquetlist"].buildList(BouquetList) + else: + self["bouquetlist"].instance.hide() + self.getBouquetList() + + def getBouquetList(self): + sendPartnerBoxWebCommand(self.url, None,10, self.username, self.password).addCallback(self.downloadCallback).addErrback(self.downloadError) + + def downloadCallback(self, callback = None): + if self.enigma_type == 0: + self.readXML(callback) + else: + self.readXMLE1(callback) + self["bouquetlist"].instance.show() + + def downloadError(self, error = None): + if error is not None: + self["text"].setText(str(error.getErrorMessage())) + + def readXMLE1(self,xmlstring): + self.E1XMLString = xmlstring + BouquetList = [] + root = xml.etree.cElementTree.fromstring(xmlstring) + for bouquets in root.findall("bouquet"): + BouquetList.append(E2ServiceList( + servicereference = str(bouquets.findtext("reference", '').encode("utf-8", 'ignore')), + servicename = str(bouquets.findtext("name", 'n/a').encode("utf-8", 'ignore')))) + self["bouquetlist"].buildList(BouquetList) + + def readXML(self, xmlstring): + BouquetList = [] + root = xml.etree.cElementTree.fromstring(xmlstring) + for servives in root.findall("e2service"): + BouquetList.append(E2ServiceList( + servicereference = str(servives.findtext("e2servicereference", '').encode("utf-8", 'ignore')), + servicename = str(servives.findtext("e2servicename", 'n/a').encode("utf-8", 'ignore')))) + self["bouquetlist"].buildList(BouquetList) + +class RemoteTimerChannelList(Screen): + EMPTY = 0 + ADD_TIMER = 1 + REMOVE_TIMER = 2 + REMOTE_TIMER_MODE = 0 + REMOTE_TV_MODE = 1 + skin = """ + + + + + + + + + + + + """ + + def __init__(self, session, E2Timerlist, ServiceReference, ServiceName, partnerboxentry, E1XMLString, playeronly): + self.session = session + Screen.__init__(self, session) + self["channellist"] = E2ChannelList([], selChangedCB = self.onSelectionChanged) + self.playeronly = playeronly + self["key_red"] = Label(_("Zap")) + self["key_green"] = Label() + if self.playeronly == 0: + self["key_yellow"] = Label(_("EPG Selection")) + else: + self["key_yellow"] = Label() + self["key_blue"] = Label(_("Info")) + + self["text"] = Label(_("Getting Channel Information...")) + self.onLayoutFinish.append(self.startRun) + self.E2TimerList = E2Timerlist + self.E2ChannelList = [] + self.servicereference = ServiceReference + self.E1XMLString = E1XMLString + self["actions"] = ActionMap(["WizardActions", "DirectionActions", "ColorActions"], + { + "ok": self.PlayRemoteStream, + "back": self.close, + "yellow": self.EPGSelection, + "blue": self.EPGEvent, + "red": self.Zap, + }, -1) + + + self.PartnerboxEntry = partnerboxentry + self.password = partnerboxentry.password.value + self.username = "root" + self.ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + self.port = partnerboxentry.port.value + self.http = "http://%s:%d" % (self.ip,self.port) + self.enigma_type = int(partnerboxentry.enigma.value) + self.useinternal = int(partnerboxentry.useinternal.value) + self.zaptoservicewhenstreaming = partnerboxentry.zaptoservicewhenstreaming.value + self.key_green_choice = self.ADD_TIMER + self.zapTimer = eTimer() + self.zapTimer.timeout.get().append(self.zapTimerTimeout) + self.onClose.append(self.__onClose) + self.ChannelListCurrentIndex = 0 + self.mode = self.REMOTE_TIMER_MODE + self.CurrentService = self.session.nav.getCurrentlyPlayingServiceReference() + + def __onClose(self): + if self.zapTimer.isActive(): + self.zapTimer.stop() + + def startRun(self): + if self.useinternal == 1 : + ChannelList = [] + a = Services(self.session) + Channelref = eServiceReference(self.servicereference) + ChannelList = a.buildList(Channelref, True) + self["channellist"].buildList(ChannelList) + self["channellist"].instance.show() + if self.ChannelListCurrentIndex !=0: + sel = self["channellist"].moveSelectionTo(self.ChannelListCurrentIndex) + self.ChannelListCurrentIndex = 0 + else: + self["channellist"].instance.hide() + self.getChannelList() + + def PlayRemoteStream(self): + if self.playeronly == 1: + if self.mode == self.REMOTE_TIMER_MODE: + self.mode = self.REMOTE_TV_MODE + if self.zaptoservicewhenstreaming == False and self.enigma_type == 0: + self.GetStreamInfosCallback() + else: + self.Zap() + else: + self.session.nav.playService(self.CurrentService) + self.mode = self.REMOTE_TIMER_MODE + self["channellist"].instance.show() + else: + self.EPGSelection() + + def Zap(self): + sel = None + try: + sel = self["channellist"].l.getCurrentSelection()[0] + except:return + if sel is None: + return + self["channellist"].instance.hide() + self.ChannelListCurrentIndex = self["channellist"].getCurrentIndex() + self["text"].setText("Zapping to " + sel.servicename) + + if self.useinternal == 1 and self.mode == self.REMOTE_TIMER_MODE: + self.session.nav.playService(eServiceReference(sel.servicereference)) + self.ZapCallback(None) + else: + if self.enigma_type == 0: + url = self.http + "/web/zap?sRef=" + urllib.quote(sel.servicereference.decode('utf8').encode('latin-1','ignore')) + else: + url = self.http + "/cgi-bin/zapTo?path=" + urllib.quote(sel.servicereference.decode('utf8').encode('latin-1','ignore')) + sendPartnerBoxWebCommand(url, None,10, self.username, self.password).addCallback(self.ZapCallback).addErrback(self.DoNotCareError) + + def DoNotCareError(self, dnce = None): + # Jesses, E1 sendet 204 nach umschalten, kommt hier also immer rein... + self.ZapCallback(dnce) + + def ZapCallback(self, callback = None): + if self.mode == self.REMOTE_TIMER_MODE: + self["text"].setText("Give Enigma time to fill epg cache...") + self.zapTimer.start(10000) # 10 Sekunden + else: + self.zapTimer.start(3000) # 3 Sekunden REMOTE_TV + + def zapTimerTimeout(self): + if self.zapTimer.isActive(): + self.zapTimer.stop() + if self.mode == self.REMOTE_TIMER_MODE: + self.startRun() + else: + self.GetStreamInfosCallback() + + def GetStreamInfosCallback(self): + if self.enigma_type == 0: + url = "http://" + self.ip + ":8001/" + self["channellist"].l.getCurrentSelection()[0].servicereference + self.StreamTV(url) + else: + url = self.http + "/video.m3u" + sendPartnerBoxWebCommand(url, None,10, self.username, self.password).addCallback(self.StreamTV).addErrback(self.ChannelListDownloadError) + + def MoveItem(self, next): + self.mode = self.REMOTE_TIMER_MODE + self.session.nav.stopService() + if next: + self["channellist"].moveSelection(eListbox.moveDown) + else: + self["channellist"].moveSelection(eListbox.moveUp) + + def StreamTV(self, connectstring): + self.session.nav.stopService() + sref = eServiceReference(ENIGMA_WEBSERVICE_ID, 0, connectstring) + self.session.nav.playService(sref) + self.session.openWithCallback(self.PlayRemoteStream, RemotePlayer, self["channellist"].l.getCurrentSelection()[0].servicename,self["channellist"].l.getCurrentSelection()[0].eventtitle, self["channellist"].l.getCurrentSelection()[0].eventstart, self["channellist"].l.getCurrentSelection()[0].eventduration, self.PartnerboxEntry, self["channellist"].l.getCurrentSelection()[0].servicereference, self.session.current_dialog) + + def EPGEvent(self): + sel = self["channellist"].l.getCurrentSelection()[0] + if sel is None: + return + self.session.openWithCallback(self.CallbackEPGEvent, RemoteTimerEventView, self.E2TimerList, sel, self.PartnerboxEntry) + + def CallbackEPGEvent(self): + pass + + def onSelectionChanged(self): + cur = self["channellist"].getCurrent() + if cur is None: + self["key_green"].setText("") + self.key_green_choice = self.EMPTY + self["key_yellow"].setText("") + self["key_blue"].setText("") + return + eventid = cur[0].eventid + if eventid ==0: + self["key_green"].setText("") + self.key_green_choice = self.EMPTY + self["key_yellow"].setText("") + self["key_blue"].setText("") + return + if self.playeronly == 0: + self["key_yellow"].setText(_("EPG Selection")) + self["key_blue"].setText(_("Info")) + serviceref = cur[0].servicereference + +# isRecordEvent = False +# for timer in self.E2TimerList: +# if timer.eventId == eventid and timer.servicereference == serviceref: +# isRecordEvent = True +# break +# if isRecordEvent and self.key_green_choice != self.REMOVE_TIMER: +# self["key_green"].setText(_("Remove timer")) +# self.key_green_choice = self.REMOVE_TIMER +# elif not isRecordEvent and self.key_green_choice != self.ADD_TIMER: +# self["key_green"].setText(_("Add timer")) +# self.key_green_choice = self.ADD_TIMER + + def ChannelListDownloadCallback(self, callback = None): + self.readXMLServiceList(callback) + if self.ChannelListCurrentIndex !=0: + sel = self["channellist"].moveSelectionTo(self.ChannelListCurrentIndex) + self.ChannelListCurrentIndex = 0 + self["channellist"].instance.show() + + def ChannelListDownloadError(self, error = None): + if error is not None: + self["text"].setText(str(error.getErrorMessage())) + self.mode = REMOTE_TIMER_MODE + + def getChannelList(self): + if self.enigma_type == 0: + ref = urllib.quote(self.servicereference.decode('utf8').encode('latin-1','ignore')) + url = self.http + "/web/epgnow?bRef=" + ref + sendPartnerBoxWebCommand(url, None,10, self.username, self.password).addCallback(self.ChannelListDownloadCallback).addErrback(self.ChannelListDownloadError) + else: + self.readXMLServiceListE1() + if self.ChannelListCurrentIndex !=0: + sel = self["channellist"].moveSelectionTo(self.ChannelListCurrentIndex) + self.ChannelListCurrentIndex = 0 + self["channellist"].instance.show() + + def readXMLServiceListE1(self): + self.E2ChannelList = [] + root = xml.etree.cElementTree.fromstring(self.E1XMLString) + for bouquets in root.findall("bouquet"): + tempref = str(bouquets.findtext("reference", '').encode("utf-8", 'ignore')) + if tempref == self.servicereference: + for services in bouquets.findall("service"): + servicereference = str(services.findtext("reference", '').encode("utf-8", 'ignore')) + servicename = str(services.findtext("name", 'n/a').encode("utf-8", 'ignore')) + http_ = "%s:%d" % (self.ip,self.port) + url = "http://" + self.username + ":" + self.password + "@" + http_ + "/xml/serviceepg?ref=" + servicereference + "&entries=1" + f = urllib.urlopen(url) + sxml = f.read() + eventstart, eventduration, eventtitle, eventdescriptionextended, eventdescription, eventid = self.XMLReadEPGDataE1(sxml) + self.E2ChannelList.append(E2EPGListAllData(servicereference = servicereference, servicename = servicename, eventstart = eventstart, eventduration = eventduration, eventtitle = eventtitle, eventid = eventid , eventdescription= eventdescription, eventdescriptionextended = eventdescriptionextended)) + self["channellist"].buildList(self.E2ChannelList) + + def XMLReadEPGDataE1(self,xmlstring): + eventstart = 0 + eventduration = 0 + eventtitle = "" + eventdescriptionextended = "" + eventdescription = "" + eventid = 0 + xmlstring = xmlstring.replace("""""","") + root = xml.etree.cElementTree.fromstring(xmlstring) + for events in root.findall("event"): + try:eventtitle = str(events.findtext("description", '').encode("utf-8", 'ignore')) + except:eventtitle = "" + try:eventdescriptionextended = str(events.findtext("details", '').encode("utf-8", 'ignore')) + except:eventdescriptionextended = "" + try:eventdescription = str(events.findtext("genre", '').encode("utf-8", 'ignore')) + except:eventdescription = "" + try:eventstart = int(events.findtext("start", 0)) + except:eventstart = 0 + try:eventduration = int(events.findtext("duration", 0)) + except:eventduration = 0 + if eventstart != 0: + eventid = 1 + + return eventstart, eventduration, eventtitle, eventdescriptionextended, eventdescription,eventid + + def readXMLServiceList(self, xmlstring): + self.E2ChannelList = [] + root = xml.etree.cElementTree.fromstring(xmlstring) + for events in root.findall("e2event"): + servicereference = str(events.findtext("e2eventservicereference", '').encode("utf-8", 'ignore')) + servicename = str(events.findtext("e2eventservicename", 'n/a').encode("utf-8", 'ignore')) + try:eventstart = int(events.findtext("e2eventstart", 0)) + except:eventstart = 0 + try:eventduration = int(events.findtext("e2eventduration", 0)) + except:eventduration = 0 + try:eventtitle = str(events.findtext("e2eventtitle", '').encode("utf-8", 'ignore')) + except:eventtitle = "" + try:eventid = int(events.findtext("e2eventid", 0)) + except:eventid = 0 + try:eventdescription = str(events.findtext("e2eventdescription", '').encode("utf-8", 'ignore')) + except:eventdescription = "" + try:eventdescriptionextended = str(events.findtext("e2eventdescriptionextended", '').encode("utf-8", 'ignore')) + except:eventdescriptionextended = "" + self.E2ChannelList.append(E2EPGListAllData( + servicereference = servicereference, servicename = servicename, eventstart = eventstart, + eventduration = eventduration, eventtitle = eventtitle, eventid = eventid, eventdescription= eventdescription, + eventdescriptionextended = eventdescriptionextended)) + self["channellist"].buildList(self.E2ChannelList) + + def EPGSelection(self): + if self.playeronly == 0: + try: + sel = self["channellist"].l.getCurrentSelection()[0] + if sel is None: + return + if sel.eventid != 0: + self.session.openWithCallback(self.CallbackEPGSelection, RemoteTimerEPGList, self.E2TimerList, sel.servicereference, sel.servicename, self.PartnerboxEntry) + except: return + + def CallbackEPGSelection(self): + pass + +class RemotePlayer(Screen, InfoBarAudioSelection): + + + HDSkn = False + try: + sz_w = getDesktop(0).size().width() + if sz_w == 1280: + HDSkn = True + else: + HDSkn = False + except: + HDSkn = False + if HDSkn: + skin=""" + + + + + + """ + else: + skin=""" + + + + + + """ + + def __init__(self, session, ServiceName, EventTitle, eventstart, eventduration, partnerboxentry, servicereference, parent = None): + self.session = session + Screen.__init__(self, session) + InfoBarAudioSelection.__init__(self) + self.enigma_type = int(partnerboxentry.enigma.value) + self.useinternal = int(partnerboxentry.useinternal.value) + endtime = int(eventstart + eventduration) + tt = ((" %s ... %s (+%d " + _("mins") + ")") % (FuzzyTime(eventstart)[1], FuzzyTime(endtime)[1], (endtime - time.time()) / 60)) + self["ServiceName"] = Label(EventTitle) + self.ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + port = partnerboxentry.port.value + self.http = self.http = "http://%s:%d" % (self.ip,port) + self["IP"] = Label(self.ip) + if eventstart != 0: + self["DateTime"] = Label(ServiceName + ": " + tt) + else: + self["DateTime"] = Label() + self.isVisible = True + self["actions"] = ActionMap(["WizardActions", "DirectionActions", "ColorActions"], + { + "ok": self.Infobar, + "back": self.close, + "right": self.nextChannel, + "left": self.previousChannel, + }, -1) + self.password = partnerboxentry.password.value + self.username = "root" + self.servicereference = servicereference + self.onLayoutFinish.append(self.startRun) + self.onClose.append(self.__onClose) + + self.parent = parent + + self.Timer = eTimer() + self.Timer.timeout.get().append(self.TimerTimeout) + + def nextChannel(self): + if self.parent is not None: + self.parent.MoveItem(True) + self.close() + + def previousChannel(self): + if self.parent is not None: + self.parent.MoveItem(False) + self.close() + + def TimerTimeout(self): + if self.Timer.isActive(): + self.Timer.stop() + self.Infobar() + + def startRun(self): + idx = config.usage.infobar_timeout.index + if idx: + self.Timer.start(idx * 1000) + else: + self.Timer.start(6 * 1000) + if self.enigma_type == 0: + url = self.http + "/web/epgservicenow?sRef=" + self.servicereference + else: + url = self.http + "/xml/serviceepg?ref=" + self.servicereference + "&entries=1" + sendPartnerBoxWebCommand(url, None,10, self.username, self.password).addCallback(self.CurrentEPGCallback).addErrback(self.CurrentEPGCallbackError) + + def CurrentEPGCallback(self, xmlstring): + xmlstring = xmlstring.replace("""""","") + root = xml.etree.cElementTree.fromstring(xmlstring) + e2eventtitle = "" + e2eventservicename = "" + e2eventstart = 0 + e2eventduration = 0 + if self.enigma_type == 0: + for events in root.findall("e2event"): + try:e2eventservicename = str(events.findtext("e2eventservicename", 'n/a').encode("utf-8", 'ignore')) + except:e2eventservicename = "n/a" + try:e2eventstart = int(events.findtext("e2eventstart", 0)) + except:e2eventstart = 0 + try:e2eventduration = int(events.findtext("e2eventduration", 0)) + except:e2eventduration = 0 + try:e2eventtitle = str(events.findtext("e2eventtitle", '').encode("utf-8", 'ignore')) + except:e2eventtitle = "" + else: + for services in root.findall("service"): + try:e2eventservicename = str(services.findtext("name", 'n/a').encode("utf-8", 'ignore')) + except:e2eventservicename = "n/a" + for events in root.findall("event"): + try:e2eventstart = int(events.findtext("start", 0)) + except:e2eventstart = 0 + try:e2eventduration = int(events.findtext("duration", 0)) + except:e2eventduration = 0 + try:e2eventtitle = str(events.findtext("description", '').encode("utf-8", 'ignore')) + except:e2eventtitle = "" + endtime = int(e2eventstart + e2eventduration) + if endtime != 0: + tt = ((": %s ... %s (+%d " + _("mins") + ")") % (FuzzyTime(e2eventstart)[1], FuzzyTime(endtime)[1], (endtime - time.time()) / 60)) + else: + tt = "" + self["ServiceName"].setText(e2eventtitle) + self["DateTime"].setText(e2eventservicename + tt) + + def CurrentEPGCallbackError(self, error = None): + print "[RemotePlayer] Error: ",error.getErrorMessage() + +# def readXMSubChanelList(self, xmlstring): +# BouquetList = [] +# counter = 0 +# dom = xml.dom.minidom.parseString(xmlstring) +# for node in dom.firstChild.childNodes: +# servicereference = "" +# servicename = "" +# if node.nodeName == "e2service": +# for node2 in node.childNodes: +# if node2.nodeName == "e2servicereference": servicereference = str(node2.firstChild.data.strip().encode("utf-8")) +# if node2.nodeName == "e2servicename": +# try:servicename = str(node2.firstChild.data.strip().encode("utf-8")) +# except:servicename = "n/a" +# if counter != 0: # erster Eintrag ist der aktuelle Sedner, nicht aufnehmen +# BouquetList.append(E2ServiceList(servicereference = servicereference, servicename = servicename)) +# counter += 1 + + def Infobar(self): + if self.isVisible: + if self.Timer.isActive(): + self.Timer.stop() + self.hide() + self.isVisible = False + else: + self.startRun() + self.show() + self.isVisible = True + + def __onClose(self): + if self.Timer.isActive(): + self.Timer.stop() + +class RemoteTimerEPGList(Screen): + EMPTY = 0 + ADD_TIMER = 1 + REMOVE_TIMER = 2 + skin = """ + + + + + + + + + + + + """ + + def __init__(self, session, E2Timerlist, ServiceReference, ServiceName, partnerboxentry): + self.session = session + Screen.__init__(self, session) + self.E2TimerList = E2Timerlist + self["epglist"] = E2EPGList([],selChangedCB = self.onSelectionChanged) + self["key_red"] = Label()# Dummy, kommt eventuell noch was + self["key_green"] = Label(_("Add timer")) + self.key_green_choice = self.ADD_TIMER + self["key_yellow"] = Label() # Dummy, kommt eventuell noch was + self["key_blue"] = Label(_("Info")) + self["text"] = Label(_("Getting EPG Information...")) + self.onLayoutFinish.append(self.startRun) + self.servicereference = ServiceReference + self["actions"] = ActionMap(["WizardActions", "DirectionActions", "ColorActions"], + { + "back": self.close, + "green": self.GreenPressed, + "blue": self.EPGEvent, + }, -1) + + self.PartnerboxEntry = partnerboxentry + self.password = partnerboxentry.password.value + self.username = "root" + self.ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + port = partnerboxentry.port.value + self.http = "http://%s:%d" % (self.ip,port) + self.enigma_type = int(partnerboxentry.enigma.value) + self.useinternal = int(partnerboxentry.useinternal.value) + + if self.enigma_type == 0: + self.url = self.http + "/web/epgservice?sRef=" + urllib.quote(self.servicereference.decode('utf8').encode('latin-1','ignore')) + else: + self.url = self.http + "/xml/serviceepg?ref=" + urllib.quote(self.servicereference.decode('utf8').encode('latin-1','ignore')) + self.ListCurrentIndex = 0 + self.Locations = [] + + def EPGEvent(self): + + sel = self["epglist"].l.getCurrentSelection()[0] + if sel is None: + return + self.session.openWithCallback(self.CallbackEPGEvent, RemoteTimerEventView, self.E2TimerList, sel, self.PartnerboxEntry) + + def CallbackEPGEvent(self): + pass + + def onSelectionChanged(self): + cur = self["epglist"].getCurrent() + if cur is None: + self["key_green"].setText("") + self.key_green_choice = self.EMPTY + self["key_blue"].setText("") + return + serviceref = cur[0].servicereference + eventid = cur[0].eventid + if eventid ==0: + self["key_green"].setText("") + self.key_green_choice = self.EMPTY + self["key_blue"].setText("") + return + self["key_blue"].setText(_("Info")) + + timerentry = isInTimerList(cur[0].eventstart,cur[0].eventduration, cur[0].servicereference, cur[0].eventid, self.E2TimerList) + if timerentry is None: + if self.key_green_choice != self.ADD_TIMER: + self["key_green"].setText(_("Add timer")) + self.key_green_choice = self.ADD_TIMER + else: + if self.key_green_choice != self.REMOVE_TIMER: + self["key_green"].setText(_("Remove timer")) + self.key_green_choice = self.REMOVE_TIMER + + def startRun(self): + if self.useinternal == 1: + EPGList = [] + a = Services(self.session) + EPGList = a.buildEPGList(self.servicereference) + self["epglist"].buildList(EPGList, self.E2TimerList) + if self.ListCurrentIndex != 0: + sel = self["epglist"].moveSelectionTo(self.ListCurrentIndex) + self.ListCurrentIndex = 0 + else: + self["epglist"].instance.hide() + self.getEPGList() + + def getEPGList(self): + sendPartnerBoxWebCommand(self.url, None,10, self.username, self.password).addCallback(self.EPGListDownloadCallback).addErrback(self.EPGListDownloadError) + + def EPGListDownloadCallback(self, callback = None): + if self.enigma_type == 0: + self.readXMLEPGList(callback) + else: + self.readXMLEPGListE1(callback) + self["epglist"].instance.show() + + def EPGListDownloadError(self, error = None): + if error is not None: + self["text"].setText(str(error.getErrorMessage())) + + def readXMLEPGListE1(self, xmlstring): + E1ListEPG = [] + xmlstring = xmlstring.replace("""""","") + root = xml.etree.cElementTree.fromstring(xmlstring) + for services in root.findall("service"): + servicereference = str(services.findtext("reference", 'n/a').encode("utf-8", 'ignore')) + try:servicename = str(services.findtext("name", 'n/a').encode("utf-8", 'ignore')) + except:servicename = "n/a" + for events in root.findall("event"): + try:eventstart = int(events.findtext("start", 0)) + except:eventstart = 0 + try:eventduration = int(events.findtext("duration", 0)) + except:eventduration = 0 + try:eventtitle = str(events.findtext("description", '').encode("utf-8", 'ignore')) + except:eventtitle = "" + try:eventdescription = str(events.findtext("genre", '').encode("utf-8", 'ignore')) + except:eventdescription = "" + try:eventdescriptionextended = str(events.findtext("details", '').encode("utf-8", 'ignore')) + except:eventdescriptionextended = "" + E1ListEPG.append(E2EPGListAllData(servicereference = servicereference, servicename = servicename, eventid = 1, eventstart = eventstart, eventduration = eventduration, eventtitle = eventtitle, eventdescription = eventdescription, eventdescriptionextended = eventdescriptionextended )) + self["epglist"].buildList(E1ListEPG, self.E2TimerList) + if self.ListCurrentIndex != 0: + sel = self["epglist"].moveSelectionTo(self.ListCurrentIndex) + self.ListCurrentIndex = 0 + + def readXMLEPGList(self, xmlstring): + E2ListEPG = [] + root = xml.etree.cElementTree.fromstring(xmlstring) + for events in root.findall("e2event"): + servicereference = str(events.findtext("e2eventservicereference", '').encode("utf-8", 'ignore')) + servicename = str(events.findtext("e2eventservicename", 'n/a').encode("utf-8", 'ignore')) + try:eventstart = int(events.findtext("e2eventstart", 0)) + except:eventstart = 0 + try:eventduration = int(events.findtext("e2eventduration", 0)) + except:eventduration = 0 + try:eventtitle = str(events.findtext("e2eventtitle", '').encode("utf-8", 'ignore')) + except:eventtitle = "" + try:eventid = int(events.findtext("e2eventid", 0)) + except:eventid = 0 + try:eventdescription = str(events.findtext("e2eventdescription", '').encode("utf-8", 'ignore')) + except:eventdescription = "" + try:eventdescriptionextended = str(events.findtext("e2eventdescriptionextended", '').encode("utf-8", 'ignore')) + except:eventdescriptionextended = "" + E2ListEPG.append(E2EPGListAllData(servicereference = servicereference, servicename = servicename, eventid = eventid, eventstart = eventstart, eventduration = eventduration, eventtitle = eventtitle, eventdescription = eventdescription, eventdescriptionextended = eventdescriptionextended )) + self["epglist"].buildList(E2ListEPG, self.E2TimerList) + if self.ListCurrentIndex != 0: + sel = self["epglist"].moveSelectionTo(self.ListCurrentIndex) + self.ListCurrentIndex = 0 + + def GreenPressed(self): + if self.key_green_choice == self.ADD_TIMER: + if self.enigma_type == 0: + self.getLocations() + else: + self.addTimerEvent() + elif self.key_green_choice == self.REMOVE_TIMER: + self.deleteTimer() + + def LocationsError(self, error = None): + if error is not None: + self["epglist"].instance.hide() + self["text"].setText(str(error.getErrorMessage())) + + def getLocations(self): + sCommand = self.http + "/web/getlocations" + sendPartnerBoxWebCommand(sCommand, None,3, self.username, self.password).addCallback(self.getLocationsCallback).addErrback(self.LocationsError) + + def getLocationsCallback(self, xmlstring): + self.Locations = [] + self.Locations = FillLocationList(xmlstring) + self.addTimerEvent() + + def addTimerEvent(self): + cur = self["epglist"].getCurrent() + if cur is None: + return + if self.enigma_type == 0: + description = cur[0].eventdescription + type = 0 + dirname = "/hdd/movie/" + else: + dirname = "" + type = PlaylistEntry.RecTimerEntry|PlaylistEntry.recDVR + description = cur[0].eventtitle + timerentry = E2Timer(servicereference = cur[0].servicereference, servicename = cur[0].servicename, name = cur[0].eventtitle, disabled = 0, timebegin = cur[0].eventstart, timeend = cur[0].eventstart + cur[0].eventduration, duration = cur[0].eventduration, startprepare = 0, state = 0 , repeated = 0, justplay= 0, eventId = 0, afterevent = 0, dirname = dirname, description = description, type = type ) + self.session.openWithCallback(self.RemoteTimerEntryFinished, RemoteTimerEntry,timerentry, self.Locations) + + def RemoteTimerEntryFinished(self, answer): + if answer[0]: + self.ListCurrentIndex = self["epglist"].getCurrentIndex() + entry = answer[1] + self["epglist"].instance.hide() + if self.enigma_type == 0: + ref = urllib.quote(entry.servicereference.decode('utf8').encode('latin-1','ignore')) + "&begin=" + ("%s"%(entry.timebegin)) + "&end=" + ("%s"%(entry.timeend)) + "&name=" + urllib.quote(entry.name) + "&description=" + urllib.quote(entry.description) + "&dirname=" + urllib.quote(entry.dirname) + "&eit=0&justplay=" + ("%s"%(entry.justplay)) + "&afterevent=" + ("%s"%(entry.afterevent)) + sCommand = self.http + "/web/timeradd?sRef=" + ref + sendPartnerBoxWebCommand(sCommand, None,10, self.username, self.password).addCallback(self.deleteTimerCallback).addErrback(self.EPGListDownloadError) + else: + if entry.justplay & PlaylistEntry.SwitchTimerEntry: + action = "zap" + elif entry.justplay & PlaylistEntry.recNgrab: + action = "ngrab" + else: + action = "" + ref = urllib.quote(entry.servicereference.decode('utf8').encode('latin-1','ignore')) + "&start=" + ("%s"%(entry.timebegin)) + "&duration=" + ("%s"%(entry.timeend - entry.timebegin)) + "&descr=" + urllib.quote(entry.description) + "&channel=" + urllib.quote(entry.servicename) + "&after_event=" + ("%s"%(entry.afterevent)) + "&action=" + ("%s"%(action)) + sCommand = self.http + "/addTimerEvent?ref=" + ref + sendPartnerBoxWebCommand(sCommand, None,10, self.username, self.password).addCallback(self.deleteTimerCallback).addErrback(self.EPGListDownloadError) + + def deleteTimer(self): + cur = self["epglist"].getCurrent() + if cur is None: + return + timerentry = isInTimerList(cur[0].eventstart,cur[0].eventduration, cur[0].servicereference, cur[0].eventid, self.E2TimerList) + if timerentry is None: + return + else: + self.session.openWithCallback(self.deleteTimerConfirmed, MessageBox, _("Do you really want to delete the timer \n%s ?") % timerentry.name) + + def deleteTimerConfirmed(self, val): + if val: + cur = self["epglist"].getCurrent() + if cur is None: + return + self.ListCurrentIndex = self["epglist"].getCurrentIndex() + timerentry = isInTimerList(cur[0].eventstart,cur[0].eventduration, cur[0].servicereference, cur[0].eventid, self.E2TimerList) + if timerentry is None: + return + else: + self["epglist"].instance.hide() + if self.enigma_type == 0: + sCommand = self.http + "/web/timerdelete?sRef=" + timerentry.servicereference + "&begin=" + ("%s"%(timerentry.timebegin)) + "&end=" +("%s"%(timerentry.timeend)) + else: + sCommand = self.http + "/deleteTimerEvent?ref=" + timerentry.servicereference + "&start=" + ("%s"%(timerentry.timebegin)) + "&type=" +("%s"%(timerentry.type)) + "&force=yes" + sendPartnerBoxWebCommand(sCommand, None,3, self.username, self.password).addCallback(self.deleteTimerCallback).addErrback(self.EPGListDownloadError) + + def deleteTimerCallback(self, callback = None): + if self.enigma_type == 0: + url = self.http + "/web/timerlist" + else: + if callback.find("Timer event deleted successfully.") != -1: + msg = "Timer event deleted successfully." + else: + msg = callback + self.session.open(MessageBox,msg, MessageBox.TYPE_INFO, timeout = 3) + url = self.http + "/xml/timers" + sendPartnerBoxWebCommand(url, None,10, self.username, self.password).addCallback(self.readXML).addErrback(self.EPGListDownloadError) + + def readXML(self, xmlstring = None): + if xmlstring is not None: + self["text"].setText("Getting timerlist data...") + self.E2TimerList = [] + if self.enigma_type == 0: + self.E2TimerList = FillE2TimerList(xmlstring) + else: + self.E2TimerList = FillE1TimerList(xmlstring) + self["text"].setText("Getting EPG data...") + if self.useinternal == 1: + EPGList = [] + a = Services(self.session) + EPGList = a.buildEPGList(self.servicereference) + self["epglist"].buildList(EPGList, self.E2TimerList) + self["epglist"].instance.show() + if self.ListCurrentIndex != 0: + sel = self["epglist"].moveSelectionTo(self.ListCurrentIndex) + self.ListCurrentIndex = 0 + else: + self.getEPGList() + +class E2TimerMenu(GUIComponent, object): + + def __init__(self,enigma_type): + GUIComponent.__init__(self) + self.l = eListboxPythonMultiContent() + if enigma_type == 0: + self.l.setBuildFunc(self.buildEntry) + else: + self.l.setBuildFunc(self.buildEntryE1) + self.l.setFont(0, gFont("Regular", 20)) + self.l.setFont(1, gFont("Regular", 18)) + self.l.setItemHeight(70) + + def buildEntry(self, timer): + width = self.l.getItemSize().width() + res = [ timer ] + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, width, 30, 0, RT_HALIGN_LEFT|RT_VALIGN_CENTER, timer.servicename)) + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 30, width, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, timer.name)) + repeatedtext = "" + days = [ _("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun") ] + if timer.repeated: + flags = timer.repeated + count = 0 + for x in range(0, 7): + if (flags & 1 == 1): + if (count != 0): + repeatedtext += ", " + repeatedtext += days[x] + count += 1 + flags = flags >> 1 + if timer.justplay: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-150, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + ((" %s "+ _("(ZAP)")) % (FuzzyTime(timer.timebegin)[1])))) + else: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-150, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + ((" %s ... %s (%d " + _("mins") + ")") % (FuzzyTime(timer.timebegin)[1], FuzzyTime(timer.timeend)[1], (timer.timeend - timer.timebegin) / 60)))) + else: + if timer.justplay: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-150, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + (("%s, %s " + _("(ZAP)")) % (FuzzyTime(timer.timebegin))))) + else: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-150, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + (("%s, %s ... %s (%d " + _("mins") + ")") % (FuzzyTime(timer.timebegin) + FuzzyTime(timer.timeend)[1:] + ((timer.timeend - timer.timebegin) / 60,))))) + + if timer.state == TimerEntry.StateWaiting: + state = _("waiting") + elif timer.state == TimerEntry.StatePrepared: + state = _("about to start") + elif timer.state == TimerEntry.StateRunning: + if timer.justplay: + state = _("zapped") + else: + state = _("recording...") + elif timer.state == TimerEntry.StateEnded: + state = _("done!") + else: + state = _("") + + if timer.disabled: + state = _("disabled") + + res.append((eListboxPythonMultiContent.TYPE_TEXT, width-150, 50, 150, 20, 1, RT_HALIGN_RIGHT|RT_VALIGN_CENTER, state)) + + if timer.disabled: + png = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/icons/redx.png")) + res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, 490, 5, 40, 40, png)) + + return res + + def buildEntryE1(self,timer): + width = self.l.getItemSize().width() + res = [ timer ] + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, width, 30, 0, RT_HALIGN_LEFT|RT_VALIGN_CENTER, timer.servicename)) + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 30, width, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, timer.description)) + + repeatedtext = "" + days = [ _("Sun"), _("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat") ] + if timer.type & PlaylistEntry.isRepeating : + mask = PlaylistEntry.Su + count = 0 + for x in range(0, 7): + if timer.type & mask: + if (count != 0): + repeatedtext += ", " + repeatedtext += days[x] + count += 1 + mask *= 2 + if timer.type & PlaylistEntry.SwitchTimerEntry: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-170, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + ((" %s "+ _("(ZAP)")) % (FuzzyTime(timer.timebegin)[1])))) + elif timer.type & PlaylistEntry.RecTimerEntry: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-170, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + ((" %s ... %s (%d " + _("mins") + ")") % (FuzzyTime(timer.timebegin)[1], FuzzyTime(timer.timeend)[1], (timer.timeend - timer.timebegin) / 60)))) + else: + if timer.type & PlaylistEntry.SwitchTimerEntry: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-170, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + (("%s, %s ... %s (%d " + _("mins") + ") ") % (FuzzyTime(timer.timebegin) + FuzzyTime(timer.timeend)[1:] + ((timer.timeend - timer.timebegin) / 60,))) + _("(ZAP)"))) + elif timer.type & PlaylistEntry.RecTimerEntry: + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-170, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, repeatedtext + (("%s, %s ... %s (%d " + _("mins") + ")") % (FuzzyTime(timer.timebegin) + FuzzyTime(timer.timeend)[1:] + ((timer.timeend - timer.timebegin) / 60,))))) + + if timer.type & PlaylistEntry.stateWaiting: + state = _("waiting") + elif timer.type & PlaylistEntry.stateRunning: + if timer.type & PlaylistEntry.SwitchTimerEntry: + state = _("zapped") + elif timer.type & PlaylistEntry.RecTimerEntry: + state = _("recording...") + elif timer.type & PlaylistEntry.stateFinished: + state = _("done!") + elif timer.type & PlaylistEntry.stateError: + if timer.type & PlaylistEntry.errorNoSpaceLeft: + state = _("Error: No space left") + elif timer.type & PlaylistEntry.errorUserAborted: + state = _("Error: User aborted") + elif timer.type & PlaylistEntry.errorZapFailed: + state = _("Error: Zap failed") + elif timer.type & PlaylistEntry.errorOutdated: + state = _("Error: Outdated") + else: + state = "Error: " + _("") + else: + state = _("") + res.append((eListboxPythonMultiContent.TYPE_TEXT, width-170, 50, 170, 20, 1, RT_HALIGN_RIGHT|RT_VALIGN_CENTER, state)) + return res + def getCurrent(self): + cur = self.l.getCurrentSelection() + return cur and cur[0] + + GUI_WIDGET = eListbox + + def postWidgetCreate(self, instance): + instance.setContent(self.l) + + def preWidgetRemove(self, instance): + instance.setContent(None) + + def moveToIndex(self, index): + self.instance.moveSelectionTo(index) + + def getCurrentIndex(self): + return self.instance.getCurrentIndex() + + currentIndex = property(getCurrentIndex, moveToIndex) + currentSelection = property(getCurrent) + + def setList(self, list): + self.l.setList(list) + +class E2BouquetList(MenuList): + def __init__(self, list, enableWrapAround = True): + MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent) + self.l.setFont(0, gFont("Regular", 20)) + self.l.setFont(1, gFont("Regular", 18)) + def postWidgetCreate(self, instance): + MenuList.postWidgetCreate(self, instance) + instance.setItemHeight(30) + + def buildList(self,listnew): + self.list=[] + width = self.l.getItemSize().width() + for bouquets in listnew: + res = [ bouquets ] + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, width, 30, 0, RT_HALIGN_LEFT|RT_VALIGN_CENTER, bouquets.servicename)) + self.list.append(res) + self.l.setList(self.list) + self.moveToIndex(0) + +class E2ChannelList(MenuList): + def __init__(self, list, selChangedCB=None, enableWrapAround = True): + MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent) + self.onSelChanged = [ ] + if selChangedCB is not None: + self.onSelChanged.append(selChangedCB) + self.l.setFont(0, gFont("Regular", 20)) + self.l.setFont(1, gFont("Regular", 18)) + def postWidgetCreate(self, instance): + MenuList.postWidgetCreate(self, instance) + instance.setItemHeight(70) + instance.selectionChanged.get().append(self.selectionChanged) + + def preWidgetRemove(self, instance): + instance.selectionChanged.get().remove(self.selectionChanged) + + def selectionChanged(self): + for x in self.onSelChanged: + if x is not None: + x() + + def getCurrentIndex(self): + return self.instance.getCurrentIndex() + + def moveSelectionTo(self,index): + self.moveToIndex(index) + + def moveSelection(self, how): + self.instance.moveSelection(how) + + def buildList(self,listnew): + self.list=[] + width = self.l.getItemSize().width() + for epgdata in listnew: + res = [ epgdata ] + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 0, width, 30, 0, RT_HALIGN_LEFT|RT_VALIGN_CENTER, epgdata.servicename)) + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 30, width, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, epgdata.eventtitle)) + if epgdata.eventstart != 0: + endtime = int(epgdata.eventstart + epgdata.eventduration) + res.append((eListboxPythonMultiContent.TYPE_TEXT, 0, 50, width-150, 20, 1, RT_HALIGN_LEFT|RT_VALIGN_CENTER, (("%s ... %s (%d " + _("mins") + ")") % (FuzzyTime(epgdata.eventstart)[1], FuzzyTime(endtime)[1], (endtime - epgdata.eventstart) / 60)))) + self.list.append(res) + self.l.setList(self.list) + self.moveToIndex(0) + +class E2EPGList(MenuList): + def __init__(self, list, selChangedCB=None, enableWrapAround = True): + MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent) + self.onSelChanged = [ ] + if selChangedCB is not None: + self.onSelChanged.append(selChangedCB) + self.l.setFont(0, gFont("Regular", 22)) + self.l.setFont(1, gFont("Regular", 16)) + self.days = [ _("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun") ] + self.timer_list = [] + self.clock_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, 'skin_default/icons/epgclock.png')) + self.clock_add_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, 'skin_default/icons/epgclock_add.png')) + self.clock_pre_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, 'skin_default/icons/epgclock_pre.png')) + self.clock_post_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, 'skin_default/icons/epgclock_post.png')) + self.clock_prepost_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, 'skin_default/icons/epgclock_prepost.png')) + + def postWidgetCreate(self, instance): + MenuList.postWidgetCreate(self, instance) + instance.setItemHeight(30) + instance.selectionChanged.get().append(self.selectionChanged) + + def preWidgetRemove(self, instance): + instance.selectionChanged.get().remove(self.selectionChanged) + + def getCurrentIndex(self): + return self.instance.getCurrentIndex() + + def moveSelectionTo(self,index): + self.moveToIndex(index) + + def selectionChanged(self): + for x in self.onSelChanged: + if x is not None: + x() + + def buildList(self,listnew, timerlist): + self.list=[] + self.timer_list = timerlist + for epgdata in listnew: + res = [ epgdata ] + rec=epgdata.eventstart and (self.isInTimer(epgdata.eventstart, epgdata.eventduration, epgdata.servicereference)) + esize = self.l.getItemSize() + width = esize.width() + height = esize.height() + r1 = Rect(0, 0, width/20*2-10, height) + r2 = Rect(width/20*2, 0, width/20*5-15, height) + r3 = Rect(width/20*7, 0, width/20*13, height) + t = localtime(epgdata.eventstart) + res.append((eListboxPythonMultiContent.TYPE_TEXT, r1.left(), r1.top(), r1.width(), r1.height(), 0, RT_HALIGN_RIGHT, self.days[t[6]])) + res.append((eListboxPythonMultiContent.TYPE_TEXT, r2.left(), r2.top(), r2.width(), r1.height(), 0, RT_HALIGN_RIGHT, "%02d.%02d, %02d:%02d"%(t[2],t[1],t[3],t[4]))) + if rec: + clock_pic = self.getClockPixmap(epgdata.servicereference, epgdata.eventstart, epgdata.eventduration, epgdata.eventid) + res.append((eListboxPythonMultiContent.TYPE_PIXMAP_ALPHATEST, r3.left(), r3.top(), 21, 21, clock_pic)) + res.append((eListboxPythonMultiContent.TYPE_TEXT, r3.left() + 25, r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, epgdata.eventtitle)) + else: + res.append((eListboxPythonMultiContent.TYPE_TEXT, r3.left(), r3.top(), r3.width(), r3.height(), 0, RT_HALIGN_LEFT, epgdata.eventtitle)) + + self.list.append(res) + self.l.setList(self.list) + self.moveToIndex(0) + + def isInTimer(self, begin, duration, service): + time_match = 0 + chktime = None + chktimecmp = None + chktimecmp_end = None + end = begin + duration + for x in self.timer_list: + if x.servicereference.upper() == service.upper(): + if x.repeated != 0: + if chktime is None: + chktime = localtime(begin) + chktimecmp = chktime.tm_wday * 1440 + chktime.tm_hour * 60 + chktime.tm_min + chktimecmp_end = chktimecmp + (duration / 60) + time = localtime(x.timebegin) + for y in range(7): + if x.repeated & (2 ** y): + timecmp = y * 1440 + time.tm_hour * 60 + time.tm_min + if timecmp <= chktimecmp < (timecmp + ((x.timeend - x.timebegin) / 60)): + time_match = ((timecmp + ((x.timeend - x.timebegin) / 60)) - chktimecmp) * 60 + elif chktimecmp <= timecmp < chktimecmp_end: + time_match = (chktimecmp_end - timecmp) * 60 + else: + if begin <= x.timebegin <= end: + diff = end - x.timebegin + if time_match < diff: + time_match = diff + elif x.timebegin <= begin <= x.timeend: + diff = x.timeend - begin + if time_match < diff: + time_match = diff + if time_match: + break + return time_match + + def getClockPixmap(self, refstr, beginTime, duration, eventId): + + pre_clock = 1 + post_clock = 2 + clock_type = 0 + endTime = beginTime + duration + for x in self.timer_list: + if x.servicereference.upper() == refstr.upper(): + if x.eventId == eventId: + return self.clock_pixmap + beg = x.timebegin + end = x.timeend + if beginTime > beg and beginTime < end and endTime > end: + clock_type |= pre_clock + elif beginTime < beg and endTime > beg and endTime < end: + clock_type |= post_clock + if clock_type == 0: + return self.clock_add_pixmap + elif clock_type == pre_clock: + return self.clock_pre_pixmap + elif clock_type == post_clock: + return self.clock_post_pixmap + else: + return self.clock_prepost_pixmap + +class RemoteTimerEventView(Screen): + EMPTY = 0 + ADD_TIMER = 1 + REMOVE_TIMER = 2 + skin = """ + + + + + + + + + + + + + + """ + + def __init__(self, session, E2Timerlist, epgdata , partnerboxentry): + self.session = session + Screen.__init__(self, session) + self["epg_description"] = ScrollLabel() + self["datetime"] = Label() + self["channel"] = Label() + self["duration"] = Label() + self["key_red"] = Label() # Dummy, kommt eventuell noch was + self["key_green"] = Label() # Dummy, kommt eventuell noch was + self["key_yellow"] = Label() # Dummy, kommt eventuell noch was + self["key_blue"] = Label() # Dummy, kommt eventuell noch was + self.key_green_choice = self.ADD_TIMER + self.onLayoutFinish.append(self.startRun) + self.E2TimerList = E2Timerlist + self.epgdata = epgdata + + self["actions"] = ActionMap(["WizardActions", "DirectionActions", "ColorActions", "EventViewActions"], + { + "back": self.close, + "pageUp": self.pageUp, + "pageDown": self.pageDown, + }, -1) + + self.PartnerboxEntry = partnerboxentry + self.password = partnerboxentry.password.value + self.username = "root" + self.ip = "%d.%d.%d.%d" % tuple(partnerboxentry.ip.value) + port = partnerboxentry.port.value + self.http = "http://%s:%d" % (self.ip,port) + self.enigma_type = int(partnerboxentry.enigma.value) + self.useinternal = int(partnerboxentry.useinternal.value) + + def startRun(self): + name = self.epgdata.servicename + if name != "n/a": + self["channel"].setText(name) + else: + self["channel"].setText(_("unknown service")) + text = self.epgdata.eventtitle + short = self.epgdata.eventdescription + ext = self.epgdata.eventdescriptionextended + if len(short) > 0 and short != text: + text = text + '\n\n' + short + if len(ext) > 0: + if len(text) > 0: + text = text + '\n\n' + text = text + ext + self.setTitle(self.epgdata.eventtitle) + self["epg_description"].setText(text) + endtime = int(self.epgdata.eventstart + self.epgdata.eventduration) + t = localtime(self.epgdata.eventstart) + datetime = ("%02d.%02d, %02d:%02d"%(t[2],t[1],t[3],t[4])) + duration = (" (%d " + _("mins")+")") % ((self.epgdata.eventduration ) / 60) + self["datetime"].setText(datetime) + self["duration"].setText(duration) + self["key_red"].setText("") + + def pageUp(self): + self["epg_description"].pageUp() + + def pageDown(self): + self["epg_description"].pageDown()