コード例 #1
0
ファイル: common.py プロジェクト: easyspider/archivczsk
 def __init__(self, text, cutLeft=True, replaceChar='.', replaceCharNum=4):
     self.maxChars = 9999
     self.cutLeft = cutLeft
     self.replaceChar = replaceChar
     self.replaceCharNum = replaceCharNum
     self.testInstance = None
     Label.__init__(self, text)
コード例 #2
0
ファイル: Ipkg.py プロジェクト: TitanNit/tdt
	def __init__(self, session, cmdList = []):
		Screen.__init__(self, session)
		
		self.cmdList = cmdList

		self.sliderPackages = {}
		
		self.slider = Slider(0, len(cmdList))
		self["slider"] = self.slider
		self.activityslider = Slider(0, 100)
		self["activityslider"] = self.activityslider
		self.status = Label(_("Preparing... Please wait"))
		self["status"] = self.status
		self.package = Label()
		self["package"] = self.package
		
		self.packages = 0
		self.error = 0
		
		self.activity = 0
		self.activityTimer = eTimer()
		self.activityTimer.callback.append(self.doActivityTimer)
		#self.activityTimer.start(100, False)
				
		self.ipkg = IpkgComponent()
		self.ipkg.addCallback(self.ipkgCallback)
		
		self.runningCmd = None
		self.runNextCmd()
		
		self["actions"] = ActionMap(["WizardActions"], 
		{
			"ok": self.exit, 
			"back": self.exit
		}, -1)
コード例 #3
0
ファイル: Ipkg.py プロジェクト: kingvuplus/boom
 def __init__(self, session, cmdList = None):
     if not cmdList:
         cmdList = []
     Screen.__init__(self, session)
     self.cmdList = cmdList
     self.sliderPackages = {}
     self.slider = Slider(0, len(cmdList))
     self['slider'] = self.slider
     self.activityslider = Slider(0, 100)
     self['activityslider'] = self.activityslider
     self.status = Label(_('Preparing... Please wait'))
     self['status'] = self.status
     self.package = Label()
     self['package'] = self.package
     self.packages = 0
     self.error = 0
     self.processed_packages = []
     self.activity = 0
     self.activityTimer = eTimer()
     self.activityTimer.callback.append(self.doActivityTimer)
     self.ipkg = IpkgComponent()
     self.ipkg.addCallback(self.ipkgCallback)
     self.runningCmd = None
     self.runNextCmd()
     self['actions'] = ActionMap(['WizardActions'], {'ok': self.exit,
      'back': self.exit}, -1)
     return
コード例 #4
0
ファイル: common.py プロジェクト: easyspider/archivczsk
    def applySkin(self, desktop, parent):
        # testInstance = self.GUI_WIDGET(parent)
        testInstance = self.testInstance
        testInstance.hide()
        testSkinAttributes = []
        if self.skinAttributes:
            for (attrib, value) in self.skinAttributes:
                if attrib == 'size':
                    x, y = value.split(',')
                    x = '2000'
                    new_value = x + ',' + y
                    testSkinAttributes.append((attrib, new_value))
                else:
                    testSkinAttributes.append((attrib, value))
            skin.applyAllAttributes(testInstance, desktop, testSkinAttributes, parent.scale)
        Label.applySkin(self, desktop, parent)
        maxWidth = self.instance.size().width()

        # some random text
        text = 'DSADJASNKDNSJANDJKSANDJKSANDNASJKNDSJKANDJKSANDJKAS'
        text += 'FDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFSDFDSFDS'
        text += 'FDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFSDFDSFDS'
        text += 'FDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFDSFSDFDSFDS'

        testInstance.setText(text)
        actWidth = testInstance.calculateSize().width()
        pixsPerChar = float(actWidth) / float(len(text))
        print actWidth, '/', len(text), '=', pixsPerChar
        print maxWidth
        if pixsPerChar > 0:
            self.maxChars = int(maxWidth / pixsPerChar)
        print self.maxChars
コード例 #5
0
	def __init__(self,session):
		Label.__init__(self,text=Channel)
		self.timer=eTimer()
		self.timer_conn = self.timer.timeout.connect(self.updateChanName)
		self.timer.start(500)
		self.oldname=self.text
		self.pipe=MessagePipe()
コード例 #6
0
	def __init__(self, text=""):
		self.offset = 0
		self.displayLength = 100

		Label.__init__(self, text)

		self.moveTimer = eTimer()
		self.moveTimer_conn = self.moveTimer.timeout.connect(self.doMove)
コード例 #7
0
	def __init__(self, text=""):
		self.offset = 0
		self.displayLength = 100

		Label.__init__(self, text)

		self.moveTimer = eTimer()
		self.moveTimer.callback.append(self.doMove)
コード例 #8
0
ファイル: common.py プロジェクト: easyspider/archivczsk
 def setText(self, text):
     print len(text), self.maxChars
     if len(text) > self.maxChars:
         cutChars = len(text) - self.maxChars
         if self.cutLeft:
             text = text[cutChars:]
             text = "%s %s" % (self.replaceChar * self.replaceCharNum, text[self.replaceCharNum + 1:])
         else:
             text = text[:self.cutChars]
             text = "%s %s" % (text[:-self.replaceCharNum + 1], self.replaceChar * self.replaceCharNum)
     Label.setText(self, text)
コード例 #9
0
	def doMove(self):
		offset = self.offset + 1
		text = self.longText[offset:self.displayLength+offset]
		self.offset = offset

		if not text:
			# it appears we're done displaying the full text, so stop now or waste cpu time forever :D
			self.stopMoving()

		try:
			Label.setText(self, text.encode('utf-8', 'ignore'))
		except Exception:
			self.stopMoving()
コード例 #10
0
	def __init__(self, session, updateurl, version):
		from Components.Slider import Slider

		self.session = session
		Screen.__init__(self, session)
		self.target = updateurl
		self.version = version
		self.file_name = "/tmp/%s" % self.target.split('/')[-1]
		self.fileSize = 5 * 1024
		self.downloadDone = False
		self.container = eConsoleAppContainer()
		self.appClosed_conn = None
		self.stdoutAvail_conn = None

		self['srlog'] = Label()

		self.status = Label(_("Preparing... Please wait"))
		self['status'] = self.status
		self.activityslider = Slider(0, 100)
		self['activityslider'] = self.activityslider
		self.activity = 0
		self.activityTimer = eTimer()
		if isDreamboxOS:
			self.activityTimerConnection = self.activityTimer.timeout.connect(self.doActivityTimer)
		else:
			self.activityTimer.callback.append(self.doActivityTimer)

		self.onLayoutFinish.append(self.__onLayoutFinished)
コード例 #11
0
ファイル: about.py プロジェクト: serge61/eePlugins
 def __init__(self, session, args = 0):
     self.session = session
     Screen.__init__(self, session)
     self["setupActions"] = ActionMap(["SetupActions", "ColorActions"],
         {
             "cancel": self.cancel,
             "ok": self.keyOk,
         }, -2)
     self.setTitle(_("UserSkin %s") % UserSkinInfo)
     self['skininfo'] = Label("")
     if path.exists(SkinPath + 'skin.config'):
         with open(SkinPath + 'skin.config', "r") as f:
             for line in f:
                 if line.startswith('description='):
                     self['skininfo'].text = line.split('=')[1].replace('"','').replace("'","").strip()
                     break
             f.close()
コード例 #12
0
ファイル: Backup.py プロジェクト: trunca/novale-viejo
    def __init__(self, session, picPath = None):
        Screen.__init__(self, session)
        print '[sfteambckScreen] __init__\n'
        self.picPath = picPath
        self.Scale = AVSwitch().getFramebufferScale()
        self.PicLoad = ePicLoad()
        self['sftPic'] = Pixmap()
        self['information'] = Label('')
        self['information'].text = _('\n\n\n\nInstructions\n------------------------------\n\n1) Mount HDD in your receiver\n2) En caso necesario monte como HDD pulsando boton azul\n3) Click OK to start the process')
        self['actions'] = ActionMap(['OkCancelActions', 'ColorActions'], {'cancel': self.cancel,
	 'blue': self.mount,
         'green': self.preHaceBackup,
         'red': self.cancel}, -1)
        self['key_red'] = Label(_('Cancel'))
        self['key_green'] = Label(_('OK'))
	self['key_blue'] = Label(_('Mount'))
        self.PicLoad.PictureData.get().append(self.DecodePicture)
        self.onLayoutFinish.append(self.ShowPicture)
コード例 #13
0
ファイル: StreamServerConfig.py プロジェクト: OpenDMM/enigma2
	def __init__(self, session):
		Screen.__init__(self, session)
		ConfigListScreen.__init__(self, [], session=session)
		self._streamServerControl = streamServerControl
		self._upstreamBitrate = 0
		self._clientCount = streamServerControl.rtspClientCount

		self._key_blue = StaticText("")
		self["key_blue"] = self._key_blue
		self["key_yellow"] = StaticText(_("Presets"))
		self._info = Label("")
		self["info"] = self._info

		self["details_label"] = Label(_("Status Detail"))
		self._details = Label(_("No details available..."))
		self["details"] = self._details
		self._detailsHint = Label("Press PVR in channel selection to change the service in background mode")
		self["details_hint"] = self._detailsHint

		if not self._setInfoText in self["config"].onSelectionChanged:
			self["config"].onSelectionChanged.append(self._setInfoText)

		self._closeAfterApply = False
		self._presetChoiceBox = None

		self["setupActions"] = ActionMap(["OkCancelActions", "ColorActions"],
		{
			"blue": self.apply,
			"yellow": self._showPresets,
			"cancel": self._applyAndClose,
			"ok" : self._applyAndClose,
		}, -2)

		self.setTitle(_("Streaming Server"))

		streamServerControl.onRtspClientCountChanged.append(self._onRtspClientCountChanged)

		self._streamServerControl.config.streamserver.rtsp.enabled.addNotifier(self._onEnabled, initial_call=False)
		self._streamServerControl.config.streamserver.hls.enabled.addNotifier(self._onEnabled, initial_call=False)
		self._streamServerControl.config.streamserver.gopLength.addNotifier(self._onGopLengthChanged, initial_call=False)
		self._streamServerControl.config.streamserver.bFrames.addNotifier(self._onBframesChanged, initial_call=False)
		self._createSetup()
コード例 #14
0
ファイル: plugin.py プロジェクト: aassww/xta
    def __init__(self, session):
        self.session = session
        path = '/usr/lib/enigma2/python/Plugins/Extensions/iSkin/Skin/Main.xml'
        with open(path, 'r') as f:
            self.skin = f.read()
            f.close()
        mdom = xml.etree.cElementTree.parse(path)
        for x in mdom.getroot():
            if x.tag == 'widget' and x.get('name') == 'cover':
                Size = x.get('size').split(',')
                self.SizeY = int(Size[0])
                self.SizeX = int(Size[1])

        Screen.__init__(self, session)
        self['Key_Red'] = Label(_('Exit'))
        self['Key_Green'] = Label('')
        self['Key_Yellow'] = Label('')
        self['ButtonYellow'] = Pixmap()
        self['ButtonYellow'].hide()
        if os.path.exists('/usr/lib/enigma2/python/Components/Converter/TestConnection.pyo'):
            self['Key_Yellow'].setText(_('Config Connection'))
            self['ButtonYellow'].show()
        self.Region = Label('')
        self['Key_Region'] = self.Region
        self.Key_Blu = Label('')
        self['Key_Blu'] = self.Key_Blu
        self['SkinSelect'] = iMenuList([])
        self.isMoving = False
        self['cover'] = Pixmap()
        self.Loop = eTimer()
        self.Loop.stop()
        self.Loop.callback.append(self.Cover)
        self['setupActions'] = ActionMap(['SkinActionSetup'], {'blue': self.keyBlue,
         'green': self.keyGreen,
         'yellow': self.keyYellow,
         'ok': self.keyOK,
         'up': self.up,
         'down': self.down,
         'red': self.close,
         'cancel': self.close}, -1)
        self.onLayoutFinish.append(self.layoutFinished)
        self.onShown.append(self.SetButtonWeather)
コード例 #15
0
	def applySkin(self, desktop, screen):
		if self.skinAttributes is not None:
			attribs = []
			append = attribs.append
			for attrib, value in self.skinAttributes:
				if attrib == "displayLength":
					self.displayLength = int(value)
				else:
					append((attrib, value))
			self.skinAttributes = attribs
		return Label.applySkin(self, desktop, screen)
コード例 #16
0
    def __init__(self, groupTimer=None):
        Label.__init__(self)

        self.moving = False

        # TODO: get real values
        self.x = 0.0
        self.y = 0.0

        self.xDest = 0.0
        self.yDest = 0.0

        self.clearPath()

        self.isGroupTimer = groupTimer is not None
        if self.isGroupTimer:
            self.moveTimer = groupTimer
        else:
            self.moveTimer = eTimer()
        self.moveTimer.callback.append(self.doMove)
コード例 #17
0
ファイル: plugin.py プロジェクト: R7UST/oe-alliance-plugins
	def __init__(self, session): 
		Screen.__init__(self, session)
                self.session = session
		self.list = []
		ConfigListScreen.__init__(self, self.list)
		
		#refresh devices
		iInputDevices.getInputDevices()
		self.browser_root = "/usr/bin"
		
		self.browser_name = "arora"
		self.conf_file = "/usr/lib/enigma2/python/Plugins/Extensions/WebBrowser/settings.conf"
		self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
                {	"red": self.keyCancel,
			"green": self.keyGo,
			"cancel": self.keyExit,
                }, -2)
		self.info = Label(_("If you want to quit the Browser,\nPress RED -> EXIT."))
		self["info"] = self.info
		self["key_red"] = StaticText(_("Exit"))
		self["key_green"] = StaticText(_("Start"))

		self.conf_alpha = ""
		self.conf_mouse = ""
		self.conf_keyboard = ""
		self.conf_keymap = ""

		self.usb_mouse = None
		self.usb_keyboard = None
		self.rc_mouse = None
		self.rc_keyboard = None

		self.current_lang_idx = language.getActiveLanguageIndex()

		self.makeConfig()
		#time.sleep(2)
		excute_cmd("echo 1 > /proc/stb/fp/mouse")

		self.lock = False
		self.service = PlayerService(self.session)
		self.service.start(timeout=5)

		self.exit_wait_cond = False
		self.timer_exit_cond = eTimer()
		self.timer_exit_cond.callback.append(self.resetExitCond)

		self.test_cond = True
コード例 #18
0
ファイル: plugin.py プロジェクト: popazerty/bh1
	def __init__(self, session): 
		Screen.__init__(self, session)
		

                self.session = session
		self.list = []
		ConfigListScreen.__init__(self, self.list)

		self.browser_root = "/usr/bin"
		self.browser_name = "arora"

		from Tools.Directories import resolveFilename, SCOPE_PLUGINS
		self.conf_file = resolveFilename(SCOPE_PLUGINS, "Extensions/WebBrowser/settings.conf")
		self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
                {	"red": self.keyCancel,
			"green": self.keyGo,
			"cancel": self.keyExit,
                }, -2)
		self.info = Label(_("If you want to quit the Browser,\nPress RED -> EXIT."))
		self["info"] = self.info
		self["key_red"] = StaticText(_("Exit"))
		self["key_green"] = StaticText(_("Start"))

		self.conf_alpha = ""
		self.conf_mouse = ""
		self.conf_keyboard = ""
		self.conf_keymap = ""

		self.usb_mouse = None
		self.usb_keyboard = None
		self.rc_mouse = None
		self.rc_keyboard = None

		self.makeConfig()
		#time.sleep(2)

		self.lock = False
		self.vu_service = VuPlayerService(self.session)
		self.vu_service.start(timeout=5)

		self.exit_wait_cond = False
		self.timer_exit_cond = eTimer()
		self.timer_exit_cond.callback.append(self.resetExitCond)

		self.test_cond = True
		self.current_lang_idx = language.getActiveLanguageIndex()
コード例 #19
0
ファイル: BaseScreens.py プロジェクト: Haehnchen/e2-fb
  def SetMessage(self, msg):
    if not self.has_key("Statusbar"):
      self["Statusbar"] = Label("")    

    self["Statusbar"].text = str(msg)
コード例 #20
0
ファイル: Browser.py プロジェクト: popazerty/12
class Browser(Screen, HelpableScreen):

	def __init__(self, session, fullscreen = False, url = None, isHbbtv = False, isTransparent = False, hbbtvMenu = None):
		size = getDesktop(0).size()
		width = int(size.width() * 0.9)
		fwidth = int(size.width())
		height = int(size.height() * 0.85)
		fheight = int(size.height())

		Browser.skin = """
			<screen name="Browser" position="center,center" size="%(w)d,%(h)d" title="Web Browser" backgroundColor="#FF000000">
				<widget name="cursor" position="0,0" size="19,30" zPosition="1" alphatest="on"/>
				<widget name="url" position="0,0" zPosition="2" size="%(w)d,25" font="Regular;20" halign="left" valign="bottom" backgroundColor="background"/>
				<widget name="loading" position="%(loadingX)d,0" zPosition="3" size="150,25" font="Regular;20" halign="right" valign="bottom" backgroundColor="background"/>
				<widget name="urlList" position="0,30" zPosition="2" size="%(w)d,150" backgroundColor="background"/>
				<widget name="text" position="%(textX)d,100" size="350,40" font="Regular;20"  zPosition="2" halign="center" valign="center" backgroundColor="background"/>
				<widget source="webnavigation" render="WebView" position="0,25" zPosition="0" size="%(w)d,%(mainH)d" transparent="1"/>
				<widget source="canvas" render="Canvas" position="0,25" zPosition="1" size="%(w)d,%(mainH)d" backgroundColor="#FF000000" transparent="1" alphatest="on"/>

				<group name="_buttonBar">
					<widget name="buttonBar" position="0,%(btnBarY)d" size="%(w)d,30" zPosition="0" backgroundColor="background" transparent="0" />
					<ePixmap pixmap="skin_default/buttons/button_red_off.png" position="5,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_red" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_red.png" position="5,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="red" position="25,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1" />

					<ePixmap pixmap="skin_default/buttons/button_green_off.png" position="195,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_green" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_green.png" position="195,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="green" position="215,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<ePixmap pixmap="skin_default/buttons/button_yellow_off.png" position="385,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_yellow" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_yellow.png" position="385,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="yellow" position="405,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<ePixmap pixmap="skin_default/buttons/button_blue_off.png" position="585,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_blue" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_blue.png" position="585,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="blue" position="605,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>
				</group>
				<widget name="statuslabel" position="%(notifX)d,%(btnTxtY)d" size="350,20" font="Regular;18"  zPosition="3" halign="right" valign="center" backgroundColor="background" />
			</screen>
			""" %{	"w" : width,
					"h" : height,
					"loadingX" : width-150,
					"textX" : (width - 375) / 2,
					"mainH" : height-55,
					"btnY" : height-22,
					"btnTxtY" : height-24,
					"btnBarY" : height - 30,
					"notifX" : width-350
				}

		Browser.skinFullscreen = """
			<screen name="BrowserFullscreen" flags="wfNoBorder" position="center,center" size="%(w)d,%(h)d" title="Web Browser" backgroundColor="#FF000000">
				<widget name="cursor" position="0,0" size="19,30" zPosition="1" alphatest="on"/>
				<widget name="url" position="75,75" zPosition="2" size="%(urlW)d,25" font="Regular;20" halign="left" valign="bottom" backgroundColor="background"/>
				<widget name="loading" position="%(loadingX)d,%(loadingY)d" zPosition="2" size="200,50" font="Regular;20" halign="center" valign="center" backgroundColor="background"/>
				<widget name="urlList" position="75,100" zPosition="2" size="%(urlW)d,150" backgroundColor="background" transparent="0" />
				<widget name="text" position="%(textX)d,100" size="350,40" font="Regular;20"  zPosition="2" halign="center" valign="center" backgroundColor="background" transparent="0" />
				<widget source="webnavigation" render="WebView" position="0,0" zPosition="0" size="%(w)d,%(h)d" transparent="1"/>
				<widget source="canvas" render="Canvas" position="0,0" zPosition="1" size="%(w)d,%(h)d" backgroundColor="#FF000000" transparent="1" alphatest="on"/>

				<group name="_buttonBar">
					<widget name="buttonBar" position="%(btnBarX)d,%(btnBarY)d" size="200,110" zPosition="0" backgroundColor="background" transparent="0" />
					<widget source="button_red_off" render="Pixmap" pixmap="skin_default/buttons/button_red_off.png" position="%(btnX)d,%(btnRedY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_red" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_red.png" position="%(btnX)d,%(btnRedY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="red" position="%(btnTxtX)d,%(btnRedY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<widget source="button_green_off" render="Pixmap" pixmap="skin_default/buttons/button_green_off.png" position="%(btnX)d,%(btnGreenY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_green" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_green.png" position="%(btnX)d,%(btnGreenY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="green" position="%(btnTxtX)d,%(btnGreenY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<widget source="button_yellow_off" render="Pixmap" pixmap="skin_default/buttons/button_yellow_off.png" position="%(btnX)d,%(btnYellowY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_yellow" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_yellow.png" position="%(btnX)d,%(btnYellowY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="yellow" position="%(btnTxtX)d,%(btnYellowY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<widget source="button_blue_off" render="Pixmap" pixmap="skin_default/buttons/button_blue_off.png" position="%(btnX)d,%(btnBlueY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_blue" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_blue.png" position="%(btnX)d,%(btnBlueY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="blue" position="%(btnTxtX)d,%(btnBlueY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>
				</group>

				<widget name="statuslabel" position="%(notifX)d,%(loadingY)d" size="350,50" zPosition="1" font="Regular;18" halign="center" valign="center" backgroundColor="background" transparent="0" />
			</screen>
			""" %{	"w" : fwidth,
					"h" : fheight,
					"urlW": fwidth - 150,
					"loadingY" : fheight - 125,
					"loadingX" : ( fwidth / 2 ) - 75,
					"textX" : (fwidth - 375) / 2,
					"mainH" : fheight-55,
					"btnBarX": fwidth - 75 - 200,
					"btnBarY": fheight - 75 - 108,
					"btnX" : fwidth - 75 - 190,
					"btnTxtX" : fwidth - 75 - 165,
					"btnRedY" : fheight - 75 - 100,
					"btnGreenY" : fheight - 75 - 75,
					"btnYellowY" : fheight - 75 - 50,
					"btnBlueY" : fheight - 75 - 25,
					"notifX" : ( fwidth / 2 ) - 175,
				}

		self.__isHbbtv = isHbbtv
		if self.__isHbbtv:
			isTransparent = fullscreen = True

		self.__hbbtvMenu = hbbtvMenu

		self.__isTransparent = isTransparent
		self.__fullscreen = fullscreen
		if self.__fullscreen:
			Browser.skin = Browser.skinFullscreen

		Screen.__init__(self, session)
		HelpableScreen.__init__(self)

		if self.__fullscreen:
			self.skinName = "BrowserFullscreen"

		self.__startUrl = url

		self["loading"] = Label("")

		self.urlInput = EnhancedInput()
		self["url"] = self.urlInput

		self.textInput = Input()
		self["text"] = self.textInput
		self.textInput.hide()

		self.statuslabel = Label("")
		self["statuslabel"] = self.statuslabel
		self.statuslabel.hide();

		self.urlInputEnabled = False

		self.webnavigation = WebNavigation()
		self.webnavigation.zoomFactor = 1.0
		self.__onStoragePathChanged()
		self["webnavigation"] = self.webnavigation

		self.__urlList = MenuList([], enableWrapAround = True, content = eListboxPythonStringContent)
		self["urlList"] = self.__urlList

		self.canvas =  CanvasSource()
		self["canvas"] = self.canvas

		self["buttonBar"] = Label("")
		self["button_red_off"] = Boolean(True)
		self["button_green_off"] = Boolean(True)
		self["button_yellow_off"] = Boolean(True)
		self["button_blue_off"] = Boolean(True)
		self["button_red"] = Boolean(True)
		self["button_green"] = Boolean(False)
		self["button_yellow"] = Boolean(True)
		self["button_blue"] = Boolean(True)
		self["red"] = Label(_("Mouse Off"))
		self["green"] = Label("")
		self["yellow"] = Label(_("Navigation"))
		self["blue"] = Label(_("Pagescroll"))

		self["cursor"] = Pixmap()
		self.__cursorPos = ePoint(50,50)
		self.__mouseMode = False

		self.__db = BrowserDB.getInstance()
		self.pageTitle = ""

		self.__urlSuggestionTimer = eTimer()
		self.__urlSuggestionTimer_conn = self.__urlSuggestionTimer.timeout.connect(self.__onSuggestionTimeout)
		self.__inputTimer = eTimer()
		self.__inputTimer_conn = self.__inputTimer.timeout.connect(self.onInputTimer)
		self.__statusTimer = eTimer()
		self.__statusTimer_conn = self.__statusTimer.timeout.connect(self.__hideStatus)

		self.__scrollMode = False
		self.__zoomMode = False
		self.__isInput = False
		self.__hasSslErrors = False
		self.__handledUnsupportedContent = False
		self.__currentPEM = None
		self.__currentUser = None
		self.__currentPass = None
		self.__currentRealm = None
		self.__keyboardMode = eRCInput.getInstance().getKeyboardMode()

		self.onFirstExecBegin.append(self.__onFirstExecBegin)
		self.onExecEnd = []
		self.onPageLoadFinished = []
		self.onActionTv = []
		self.onActionRecord = []
		self.onUrlChanged = []

		self["helpableactions"] = HelpableActionMap(self, "BrowserActions",
		{
			"exit": (self.__actionExit, _("Close the browser")),
			"url": (self.__actionEnterUrl, _("Enter web address or search term")),
			"back": self.__actionBack,
			"forward": self.__actionForward,
			"left": self.__actionLeft,
			"right": self.__actionRight,
			"up": self.__actionUp,
			"down": self.__actionDown,
			"pageUp": (self.__actionPageUp, _("Page Up / Zoom in")),
			"pageDown": (self.__actionPageDown, _("Page Down / Zoom out")),
			"seekBack": boundFunction(self.__actionNavigate, eWebView.navMediaRewind),
			"seekFwd": boundFunction(self.__actionNavigate, eWebView.navMediaFastForward),
			"tab": (boundFunction(self.__actionNavigate, eWebView.navTab), _("Tab")),
			"backspace": (self.__actionBackspace, _("Backspace / Navigate back")),
			"backtab": boundFunction(self.__actionNavigate, eWebView.navBacktab),
			"delete": (self.__actionDelete, _("Delete / Navigate forward")),
			"ascii": self.__actionAscii,
			"text" : (self.__actionVirtualAscii, _("Open Virtual Keyboard")),
			"ok" : self.__actionOk,
			"enter" : self.__actionEnter,
			"menu" : (self.__actionMenu, _("Menu")),
			"fullscreen" : self.__actionFullscreen,
			"play" : self.__actionPlay,
			"pause" : self.__actionPause,
			"playpause" : self.__actionPlayPause,
			"stop" : self.actionStop,
			"tv" : self.__actionTv,
			"record" : self.__actionRecord,
		}, -2)

		self["coloractions"] = ActionMap(["ColorActions"],
		{
			"red" : self.__actionRed,
			"green" : self.__actionGreen,
			"yellow" : self.__actionYellow,
			"blue" : self.__actionBlue,
		})

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

	def execEnd(self):
		Screen.execEnd(self)
		for fnc in self.onExecEnd:
			fnc()

	def setBackgroundTransparent(self, enabled):
		self.webnavigation.setBackgroundTransparent(enabled)

	def __setKeyBoardModeAscii(self):
		eRCInput.getInstance().setKeyboardMode(eRCInput.kmAscii)

	def __unsetKeyBoardModeAscii(self):
		eRCInput.getInstance().setKeyboardMode(self.__keyboardMode)

	def __setStatus(self, text):
		print "[Browser].__setStatus"
		self.statuslabel.setText(text)
		self.statuslabel.show()
		self.__statusTimer.startLongTimer(3)

	def __hideStatus(self):
		self["statuslabel"].hide()
		self.__statusTimer.stop()

	def __setMouseMode(self, enabled):
		self.__mouseMode = enabled
		if enabled:
			self.__setCursor()
			self["cursor"].show()
			self["red"].setText("Mouse On")
			self.__clearCanvas()
		else:
			self["cursor"].hide()
			self["red"].setText("Mouse Off")

	def __actionExit(self):
		if self.__isHbbtv:
			self.__actionExitCB(True)
			return
		self.session.openWithCallback(self.__actionExitCB, MessageBox, _("Do you really want to exit the browser?"), type = MessageBox.TYPE_YESNO)

	def __actionExitCB(self, confirmed):
		if confirmed:
			self.__urlSuggestionTimer.stop()
			self.__inputTimer.stop()
			if not self.__isHbbtv:
				config.plugins.WebBrowser.lastvisited.value = self.webnavigation.url
				config.plugins.WebBrowser.lastvisited.save()
			self.__persistCookies()
			self.close()

	def __onFirstExecBegin(self):
		self["cursor"].instance.setPixmapFromFile(resolveFilename(SCOPE_PLUGINS, "Extensions/Browser/cursor.png"))
		self.__setCursor()
		self.__setMouseMode(self.__mouseMode)

		#enable/disable transparent background
		self.setBackgroundTransparent(self.__isTransparent)
		#set Accept-Language header to current language
		lang = '-'.join(language.getLanguage().split('_'))
		self.webnavigation.setAcceptLanguage(lang)
		self.__registerCallbacks()
		self.__urlList.hide()
		self.__restoreCookies()
		if self.__fullscreen:
			self.__showHideBars(False)
			self.__showHideButtonBar(False)
		if self.__startUrl is None:
			if config.plugins.WebBrowser.startPage.value == "home":
				self.__actionHome()
			else:
				self.setUrl(config.plugins.WebBrowser.lastvisited.value)
		else:
			self.setUrl(self.__startUrl)

	def __clearCanvas(self):
		size = getDesktop(0).size()
		self.canvas.fill(0, 0, size.width(), size.height(), 0xFF000000)
		self.canvas.flush()

	def __onStoragePathChanged(self):
		if config.plugins.WebBrowser.storage.enabled.value:
			self.webnavigation.enablePersistentStorage(config.plugins.WebBrowser.storage.path.value)

	def __onMicroFocusChanged(self, x, y, w, h, isInput):
		if not self.__isHbbtv and not self.__mouseMode:
			self.__cursorPos.setX(x)
			self.__cursorPos.setY(y)

			if self.__isInput and not isInput:
				self.__unsetKeyBoardModeAscii()

			self.__isInput = isInput
			if self.__isInput:
				self.setKeyboardModeAscii()

			self.__clearCanvas()
			lw = 4 #line width
			y = y
			x = x - lw
			w = w + lw
			blo = y + h #bottom line offset
			color =0xFF9900 #line color

			self.canvas.fill(x, y, lw, h, color)#left line
			self.canvas.fill(x, blo, w, lw, color)#bottom line
			self.canvas.flush()#Done -> Flush

	def __onSuggestionTimeout(self):
		needle = self.urlInput.getText()
		if needle != "":
			list = self.__db.suggsetUrls(self.urlInput.getText())
			list.insert(0, needle)
			list.insert(1, _("Search for '%s'") %needle)
			self.__urlList.setList(list)
			self.__urlList.moveToIndex(0)
			self.__urlList.show()
		else:
			self.__urlList.hide()

	def __onAuthRequired(self, token, user, password, realm):
		if self.__currentUser != None and self.__currentPassword != None and realm == self.__currentRealm:
			d = eDict()
			d.setString("user", self.__currentUser)
			d.setString("password", self.__currentPassword)
			self.webnavigation.setDict(token, d)
			self.__currentUser = None
			self.__currentPassword = None
			self.__currentRealm = None
		else:
			msgbox = self.session.openWithCallback(self.__onAuthRequiredCB, HttpAuthenticationDialog, user, password, realm)
			msgbox.setTitle(_("Authentication required"))

	def __onAuthRequiredCB(self, dict):
		if dict != None:
			self.__currentUser = dict["user"]
			self.__currentPassword = dict["password"]
			self.__currentRealm = dict["realm"]
			self.setUrl(self.webnavigation.url)

	def __onProxyAuthRequired(self, token, user, password, realm):
		self.onAuthRequired(token, user, password, realm)

	def __onDownloadRequested(self, url):
		print "[Browser].__onDownloadRequested '%s'" %(url)
		filename = url_unquote(url).split("/")[-1]
		localfile = "%s/%s" %(config.plugins.WebBrowser.downloadpath.value, filename)
		downloadManager.AddJob(DownloadJob(url, localfile, filename))
		self.session.open(MessageBox, _("Download started..."), type = MessageBox.TYPE_INFO, timeout = 3)

	def __onUnsupportedContent(self, url, contentType):
		print "[Browser].__onUnsupportedContent 'url=%s; contentType='%s'" %(url, contentType)
		self.__handledUnsupportedContent = True
		if contentType.startswith("video") or contentType.startswith("audio"):
			list = [( _("Download"), ("download", url) ),
					( _("Play"), ("play", url) )]
			self.session.openWithCallback(self.__onUnsupportedContentCB, ChoiceBox, title=_("You've selected a media file what do you want to do?"), list = list)
		else:
			self.__onDownloadRequested(url)

	def __onUnsupportedContentCB(self, answer):
		if answer != None:
			answer = answer and answer[1]
			if answer[0] == "download":
				self.__onDownloadRequested(answer[1])
			else:
				service = eServiceReference(4097,0,answer[1])
				self.session.open(MoviePlayer, service)

	def __actionMenu(self):
		if self.__isHbbtv:
			if self.__hbbtvMenu is not None:
				self.__hbbtvMenu()
			return

		self.__urlSuggestionTimer.stop()
		self.__inputTimer.stop()
		self.__urlList.hide()
		self.__persistCookies()
		self.session.openWithCallback(self.__menuCB, BrowserMenu, self.pageTitle, self.webnavigation.url)

	def __menuCB(self, actions = None):
		if actions != None:
			for action in actions:
				if action[0] == BrowserMenu.ACTION_BOOKMARK:
					self.setUrl(action[1])
				elif action[0] == BrowserMenu.ACTION_COOKIES:
					self.__restoreCookies()
				elif action[0] == BrowserMenu.ACTION_STORAGE_PATH:
					self.__onStoragePathChanged()

		if self.skinName == "BrowserFullscreen" and not config.plugins.WebBrowser.fullscreen.value:
			self.__requireRestart()
		if self.skinName != "BrowserFullscreen" and config.plugins.WebBrowser.fullscreen.value:
			self.__requireRestart()

	def __requireRestart(self):
		text = _("Some of the configuration changes require a restart of the Browser.\nDo you want to restart the Browser now?")
		msgbox = self.session.openWithCallback(self.__requireRestartCB, MessageBox, text, type = MessageBox.TYPE_YESNO)
		msgbox.setTitle(_("Restart required"))

	def __requireRestartCB(self, confirmed):
		if confirmed:
			self.close(self.session, True, self.webnavigation.url)

	def __enableUrlInput(self):
		self.urlInputEnabled = True
		self.urlInput.markAll()
		self.__setKeyBoardModeAscii()
		if self.__fullscreen:
			self.__showHideBars()

	def __disableUrlInput(self, hide = True):
		self.urlInputEnabled = False
		self.__urlSuggestionTimer.stop()
		self.__urlList.hide()
		self.urlInput.markNone()
		if not self.__isInput:
			self.__unsetKeyBoardModeAscii()
		if self.__fullscreen and hide:
			self.__showHideBars(False)

	def __showHideButtonBar(self, visible = True):
		if visible:
			self["_buttonBar"].show()
		else:
			self["_buttonBar"].hide()
			
		used_buttons = ("button_red_off", "button_green_off", "button_yellow_off",
			"button_blue_off", "button_red", "button_yellow", "button_blue")
		for button in used_buttons:
			self[button].setBoolean(visible)
		#disable green
		self["button_green"].setBoolean(False)

	def __showHideBars(self, visible = True):
		if self.__fullscreen:
			if visible:
				self.urlInput.show()
			else:
				self.urlInput.hide()

			if not self.__isHbbtv:
				self.__showHideButtonBar(visible)

	def __registerCallbacks(self):
		print "[Browser].__registerCallbacks"
		self.webnavigation.onUrlChanged.append(self.__onUrlChanged)
		self.webnavigation.onTitleChanged.append(self.__onTitleChanged)
		self.webnavigation.onLoadProgress.append(self.__onLoadProgress)
		self.webnavigation.onLoadFinished.append(self.__onLoadFinished)
		self.webnavigation.onDownloadRequested.append(self.__onDownloadRequested)
		self.webnavigation.onUnsupportedContent.append(self.__onUnsupportedContent)
		self.webnavigation.onMicroFocusChanged.append(self.__onMicroFocusChanged)
		self.webnavigation.onWindowRequested.append(self.__onWindowRequested)
		self.webnavigation.onSslErrors.append(self.__onSslErrors)
		self.webnavigation.onAuthRequired.append(self.__onAuthRequired)
		self.webnavigation.onProxyAuthRequired.append(self.__onProxyAuthRequired)

	def __actionOk(self):
		if self.textInput.visible:
			self.onInputTimer()
		elif self.urlInputEnabled:
			if self.__urlList.visible and self.__urlList.getSelectedIndex() > 0:
				if self.__urlList.getSelectedIndex() == 1:
					self.__searchUsingCurrentUrlValue()
					self.__disableUrlInput(False)
				else:
					self.urlInput.setText(self.__urlList.getCurrent())
					self.urlInput.end()
					self.__urlList.hide()
			else:
				self.setUrl(self.urlInput.getText())
				self.__isInput = False
				self.__disableUrlInput(False)

		else:
			if self.__mouseMode:
				self.webnavigation.leftClick(self.__cursorPos)
			else:
				self.__actionNavigate(eWebView.navOpenLink)

	def __actionEnter(self):
		if self.textInput.visible or self.urlInputEnabled:
			self.__actionOk()
		else:
			if self.__mouseMode:
				self.webnavigation.leftClick(self.__cursorPos)
			else:
				self.__actionNavigate(eWebView.navOpenLink)

	def __actionPlay(self):
		self.__actionNavigate(eWebView.navMediaPlay)

	def __actionPause(self):
		self.__actionNavigate(eWebView.navMediaPause)

	def __actionPlayPause(self):
		self.__actionNavigate(eWebView.navMediaPlay) #playpause doesn't work anywhere, but play does (HBBTV)

	def actionStop(self):
		self.__actionNavigate(eWebView.navMediaStop)

	def __actionBack(self):
		if self.__isHbbtv:
			self.__actionNavigate(eWebView.navBack)
		else:
			self.__actionNavigate(eWebView.navBackExplicit)

	def __actionForward(self):
		if self.__isHbbtv:
			self.__actionNavigate(eWebView.navForward)
		else:
			self.__actionNavigate(eWebView.navForwardExplicit)

	def __actionBackspace(self):
		if self.textInput.visible:
			self.restartTimer()
			self.textInput.deleteBackward()
		elif self.urlInputEnabled:
			self.urlInput.deleteBackward()
			self.__onUrlInputChanged()
		else:
			if self.__isInput:
				self.__actionNavigate(eWebView.navBackspace)
			else:
				self.__actionBack()

	def __actionDelete(self):
		if self.textInput.visible:
			self.restartTimer()
			self.textInput.delete()
		elif self.urlInputEnabled:
			self.urlInput.delete()
			self.__onUrlInputChanged()
		else:
			if self.__isInput:
				self.__actionNavigate(eWebView.navDelete)
			else:
				self.__actionForward()

	def __moveCursor(self, x=0, y=0):
		if x != 0 or y != 0:
			wSize = self.webnavigation.size
			#horizontal
			if x != 0:
				x = self.__cursorPos.x() + x
				w = wSize.width()
				if x <= 2:
					x = 2
					self.__scroll(0-int(config.plugins.WebBrowser.scrollOffset.value), 0)
				elif x >= w-2:
					x = w-2
					self.__scroll(int(config.plugins.WebBrowser.scrollOffset.value), 0)
				self.__cursorPos.setX(x)
			#vertical
			if y != 0:
				y = self.__cursorPos.y() + y
				h = wSize.height()
				if y < 2:
					y = 2
					self.__scroll(0, 0-int(config.plugins.WebBrowser.scrollOffset.value))
				elif y > h-2:
					y = h-2
					self.__scroll(0, int(config.plugins.WebBrowser.scrollOffset.value))
				self.__cursorPos.setY(y)
		self.__setCursor()

	def __setCursor(self):
		wPos = self.webnavigation.position
		relPos = None
		if wPos.x() > 0 or wPos.y() > 0:
			relPos = ePoint(self.__cursorPos.x() + wPos.x(), self.__cursorPos.y() + wPos.y())
		else:
			relPos = self.__cursorPos
		self["cursor"].move(relPos)

	def __actionLeft(self):
		if self.urlInputEnabled:
			self.urlInput.left()
		elif self.__scrollMode:
			self.__scroll(0-int(config.plugins.WebBrowser.scrollOffset.value), 0)
		elif self.textInput.visible:
			self.restartTimer()
			self.textInput.left()
		else:
			if self.__mouseMode:
				self.__moveCursor(x=-10)
			else:
				self.__actionNavigate(eWebView.navLeft)

	def __actionRight(self):
		if self.urlInputEnabled:
			self.urlInput.right()
		elif self.__scrollMode:
			self.__scroll(int(config.plugins.WebBrowser.scrollOffset.value), 0)
		elif self.textInput.visible:
			self.restartTimer()
			self.textInput.right()
		else:
			if self.__mouseMode:
				self.__moveCursor(x=10)
			else:
				self.__actionNavigate(eWebView.navRight)

	def __actionUp(self):
		if self.urlInputEnabled:
			if self.__urlList.visible:
				self.__urlList.up()
		elif self.__scrollMode:
			self.__scroll(0, 0-int(config.plugins.WebBrowser.scrollOffset.value))
		elif self.textInput.visible:
			self.restartTimer()
			self.textInput.up()
		else:
			if self.__mouseMode:
				self.__moveCursor(y=-10)
			else:
				self.__actionNavigate(eWebView.navUp)

	def __actionDown(self):
		if self.urlInputEnabled:
			if self.__urlList.visible:
				self.__urlList.down()
			#else:
			#	self.urlInput.down()
		elif self.__scrollMode:
			self.__scroll(0, int(config.plugins.WebBrowser.scrollOffset.value))
		elif self.textInput.visible:
			self.restartTimer()
			self.textInput.down()
		else:
			if self.__mouseMode:
				self.__moveCursor(y=10)
			else:
				self.__actionNavigate(eWebView.navDown)

	def __actionTv(self):
		for fnc in self.onActionTv:
			if fnc() is True: #Function told us to stop handling
				return

	def __actionRecord(self):
		for fnc in self.onActionRecord:
			if fnc() is True: #Function told us to stop handling
				return

	def __scroll(self, dx, dy):
		self.webnavigation.scroll(dx, dy)

	def __actionRed(self):
		if self.__isHbbtv:
			self.__actionNavigate(eWebView.navRed)
		else:
			self.__setMouseMode(not self.__mouseMode)

	def __actionGreen(self):
		self.__actionNavigate(eWebView.navGreen)

	def __actionYellow(self):
		if self.__isHbbtv:
			self.__actionNavigate(eWebView.navYellow)
		else:
			self.__scrollMode = not self.__scrollMode
			enDis = _("disabled")
			mode = _("Navigation")
			if self.__scrollMode:
				enDis = _("enabled")
				mode = _("Scrolling")
			text = _("Scroll mode is now %s") %enDis
			self["yellow"].setText(mode)
			self.__setStatus(text)

	def __actionBlue(self):
		if self.__isHbbtv:
			self.__actionNavigate(eWebView.navBlue)
		else:
			self.__zoomMode = not self.__zoomMode
			enDis = _("disabled")
			mode = _("Pagescroll")
			if self.__zoomMode:
				enDis = _("enabled")
				mode = _("Zoom")
			text = _("Zoom mode is now %s") %enDis
			self["blue"].setText(mode)
			self.__setStatus(text)

	def restartTimer(self):
		self.__inputTimer.stop()
		self.__inputTimer.startLongTimer(5)

	def __onUrlChanged(self, url):
		if url != None:
			self.__clearCanvas()
			self.urlInput.setText(url)
			self.urlInput.markNone()
			if self.__fullscreen and not self.__isHbbtv:
				self.__showHideBars()

			for fnc in self.onUrlChanged:
				fnc(url)

	def __onTitleChanged(self, title):
		if title != None:
			self.pageTitle = title
			self.setTitle("Web Browser - %s" %self.pageTitle)

	def __onLoadProgress(self, progress):
		print "[Browser].__onLoadProgress %s" %progress
		if(progress < 100):
			self["loading"].show()
			self["loading"].setText(_("Loading... %s%%" %progress))
		else:
			self["loading"].hide()
			self["loading"].setText("")

	def __onLoadFinished(self, val):
		print "[Browser].__onLoadFinished %s" %val
		if val == 1:
			if not self.__isHbbtv:
				self.__db.addToHistory(HistoryItem(title = self.pageTitle, url = self.webnavigation.url));
			if self.__fullscreen:
				self.__showHideBars(False)
		else:
			if not self.__hasSslErrors and not self.__handledUnsupportedContent:
				self.__handledUnsupportedContent = False
		for fnc in self.onPageLoadFinished:
			fnc()

	def __searchUsingCurrentUrlValue(self):
		needle = self.urlInput.getText()
		if needle != "":
			needle = needle.replace("http://", "").replace("https://", "").replace("ftp://", "")
			self.__onSearchRequested(needle)

	def __onSearchRequested(self, needle):
		if needle != "" and needle != None:
			needle = url_quote_plus(needle)
			url = "%s%s" %(config.plugins.WebBrowser.searchProvider.value, needle)
			self.setUrl(url)

	def __onWindowRequested(self, url):
		print "[Browser].__onWindowRequested :: '%s'" %url
		self.setUrl(url)

	def __onSslErrors(self, token, errors, pems):
		print "[Browser].__onSslErrors :: 'token='%s', errors='%s'" %(token, errors)
		self.__hasSslErrors = True
		cnt = 0
		perrors = {}
		pems = list(pems)
		pems.sort()
		for bytes in pems:
			pem = "".join(map(chr, bytes))
			if pem.strip() != "":
				messages = perrors.get(pem, [])
				messages.append(errors[cnt])
				perrors[pem] = messages
				cnt += 1

		for pem, messages in perrors.iteritems():
			cert = Certificate(-1, self.__getCurrentNetloc(), pem)
			checkVal = self.__db.checkCert( cert ) == BrowserDB.CERT_UNKOWN
			if checkVal == BrowserDB.CERT_OK:
				print "[Browser].__onSslErrors :: netloc/pem combination known and trusted!"
				dict = eDict()
				dict.setFlag("ignore")
				self.webnavigation.setDict(token, dict)
			else:
				print "[Browser].__onSslErrors :: netloc/pem combination NOT known and/or trusted!"
				self.__currentPEM = pem

				errorstr = ""
				for m in messages:
					errorstr = "%s\n%s" %(m, errorstr)

				text = ""
				if checkVal == BrowserDB.CERT_UNKOWN:
					text = _("A certificate for the desired secure connection has the following errors:\n%s\nDo you want to add an exception for this certificate and accept connections to this host anyways?") %errorstr
				elif checkVal == BrowserDB.CERT_CHANGED:
					text = _("ATTENTION!\nPotential security breach detected!\nA certificate for the desired secure connection has CHANGED!\nIn addition it has the following errors:\n%s\nDo you want to add an exception for this certificate and accept connections to this host anyways?") %errorstr
				msgbox = self.session.openWithCallback( self.__onSslErrorCB, MessageBox, text, type = MessageBox.TYPE_YESNO)
				msgbox.setTitle(_("Certificate errors!"))

	def __onSslErrorCB(self, confirmed):
		self.__hasSslErrors = False
		if confirmed:
			print "[Browser].__onSslErrorCB :: loc='%s', PEM='%s'" %(self.__getCurrentNetloc(), self.__currentPEM)
			self.__db.addCert( Certificate(-1, self.__getCurrentNetloc(), self.__currentPEM) )
			self.setUrl(self.webnavigation.url)

	def __getCurrentNetloc(self):
		return self.__getNetloc(self.webnavigation.url)

	def __getNetloc(self, url):
		return urlparse(url).netloc

	def __actionHome(self):
		self.setUrl(config.plugins.WebBrowser.home.value)

	def __actionEnterUrl(self):
		if self.urlInputEnabled:
			self.__disableUrlInput()
		else:
			self.__enableUrlInput()

	def setUrl(self, url):
		if url != None:
			if url.find("://") == -1:
				url = "http://%s" %url
			if url:
				self.webnavigation.url = url

	def getUserAgent(self):
		return self.webnavigation.useragent

	def setUserAgent(self, useragent):
		self.webnavigation.useragent = useragent

	def __actionAscii(self):
		if self.urlInputEnabled:
			self.urlInput.handleAscii(getPrevAsciiCode())
			self.__onUrlInputChanged()
		elif self.__isInput:
			self.webnavigation.changed(WebNavigation.COMMAND_ASCII_INPUT, getPrevAsciiCode())
		else:
			self.__actionNavigateNumber(chr(getPrevAsciiCode()))

	def __actionNavigateNumber(self, char):
		print "[Browser].__actionNavigateNumber %s" %char
		nav = { '0' : eWebView.nav0,
				'1' : eWebView.nav1,
				'2' : eWebView.nav2,
				'3' : eWebView.nav3,
				'4' : eWebView.nav4,
				'5' : eWebView.nav5,
				'6' : eWebView.nav6,
				'7' : eWebView.nav7,
				'8' : eWebView.nav8,
				'9' : eWebView.nav9,
				}

		action = nav.get(str(char), None)
		if action != None:
			if self.__mouseMode:
				self.__actionMouseJump(char)
			else:
				self.__actionNavigate(action)

	def __actionMouseJump(self, char):
		size = self.webnavigation.size
		off = 100 #offset

		hcenter = size.width() / 2
		vcenter = size.height() / 2

		roff = size.width() - off #right offset
		boff = size.height() - off # bottom offset

		offsets = {
			'1' : [off,off],
			'2' : [hcenter, off],
			'3' : [roff, off],
			'4' : [off, vcenter],
			'5' : [hcenter, vcenter],
			'6' : [roff, vcenter],
			'7' : [off, boff],
			'8' : [hcenter, boff],
			'9' : [roff, boff],
			}
		offset = offsets.get(str(char), None)
		if offset:
			self.__cursorPos.setX(offset[0])
			self.__cursorPos.setY(offset[1])
			self.__setCursor()

	def __actionVirtualAscii(self):
		self.session.openWithCallback(self.sendTextAsAscii, VirtualKeyBoard, title="Browser Input")

	def __actionPageUp(self):
		if self.__zoomMode:
			self.webnavigation.zoomFactor += 0.1
		else:
			self.__actionNavigate(eWebView.navPageUp)

	def __actionPageDown(self):
		if self.__zoomMode:
			self.webnavigation.zoomFactor -= 0.1
		else:
			self.__actionNavigate(eWebView.navPageDown)

	def sendTextAsAscii(self, text):
		if text != None:
			for c in text:
				self.webnavigation.changed(WebNavigation.COMMAND_ASCII_INPUT, ord(c))

	def __actionNavigate(self, param):
		if not self.urlInputEnabled and not self.textInput.visible:
			self.webnavigation.changed(WebNavigation.COMMAND_NAVIGATE, param)

	def keyNumberGlobal(self, number):
		if self.urlInputEnabled:
			self.urlInput.number(number)
			self.__onUrlInputChanged()
		elif self.__isInput:
			self.textInput.show()
			self.restartTimer()
			self.textInput.number(number)
		else:
			self.__actionNavigateNumber(number)

	def __onUrlInputChanged(self):
		if not self.__urlSuggestionTimer.isActive():
			self.__urlSuggestionTimer.startLongTimer(1)

	def onInputTimer(self):
		self.__inputTimer.stop()
		self.textInput.hide()
		text = self.textInput.getText()
		self.textInput.setText("")
		if text != "" and text != None:
			self.sendTextAsAscii(text)

	def __actionFullscreen(self):
		self.webnavigation.size = (self.width, self.height)
		self.webnavigation.position = (0, 0)

	def __restoreCookies(self):
		cookies = self.__db.getCookies()
		print "[Browser].__restoreCookies ::: restoring %s cookies" %len(cookies)
		rawCookies = []
		for cookie in cookies:
			rawCookies.append( b64encode(cookie.raw) )
		self.webnavigation.cookies = ','.join(rawCookies)

	def __persistCookies(self):
		rawCookies = self.webnavigation.cookies
		if rawCookies.strip() != "":
			rawCookies = rawCookies.split(",")
			cookies = []
			cookie = None
			for rawCookie in rawCookies:
				cookie = Cookie.fromRawString(b64decode(rawCookie))
				if cookie != None:
					cookies.append( cookie )
			print "[Browser].__persistCookies ::: persisting %s cookies" %len(cookies)
			self.__db.persistCookies(cookies)
		else:
			print "[Browser].__persistCookies ::: NO cookies to be persisted"
コード例 #21
0
ファイル: Ipkg.py プロジェクト: popazerty/12
class Ipkg(Screen):
	def __init__(self, session, cmdList = []):
		Screen.__init__(self, session)
		
		self.cmdList = cmdList

		self.sliderPackages = {}
		
		self.slider = Slider(0, len(cmdList))
		self["slider"] = self.slider
		self.activityslider = Slider(0, 100)
		self["activityslider"] = self.activityslider
		self.status = Label(_("Preparing... Please wait"))
		self["status"] = self.status
		self.package = Label()
		self["package"] = self.package
		
		self.packages = 0
		self.error = 0
		self.processed_packages = []
		
		self.activity = 0
		self.activityTimer = eTimer()
		self.activityTimer_conn = self.activityTimer.timeout.connect(self.doActivityTimer)
		#self.activityTimer.start(100, False)
				
		self.ipkg = IpkgComponent()
		self.ipkg.addCallback(self.ipkgCallback)
		
		self.runningCmd = None
		self.runNextCmd()
		
		self["actions"] = ActionMap(["WizardActions"], 
		{
			"ok": self.exit, 
			"back": self.exit
		}, -1)
		
	def runNextCmd(self):
		if self.runningCmd is None:
			self.runningCmd = 0
		else:
			self.runningCmd += 1
		print len(self.cmdList), self.runningCmd
		if len(self.cmdList) - 1 < self.runningCmd:
			self.activityslider.setValue(0)
			self.slider.setValue(len(self.cmdList))
				
			self.package.setText("")
			self.status.setText(_("Done - Installed, upgraded or removed %d packages with %d errors") % (self.packages, self.error))
			return False
		else:
			cmd = self.cmdList[self.runningCmd]
			self.slider.setValue(self.runningCmd)
			self.ipkg.startCmd(cmd[0], args = cmd[1])
			self.startActivityTimer()
			
	def doActivityTimer(self):
		if not self.ipkg.isRunning():
			self.stopActivityTimer()
		else:
			self.activity += 1
			if self.activity == 100:
				self.activity = 0
			self.activityslider.setValue(self.activity)
		
	def startActivityTimer(self):
		self.activityTimer.start(100, False)
		
	def stopActivityTimer(self):
		self.activityTimer.stop()
		
	def ipkgCallback(self, event, param):
		if event == IpkgComponent.EVENT_DOWNLOAD:
			self.status.setText(_("Downloading"))
		elif event == IpkgComponent.EVENT_UPGRADE:
			if self.sliderPackages.has_key(param):
				self.slider.setValue(self.sliderPackages[param])
			self.package.setText(param)
			self.status.setText(_("Upgrading"))
			if not param in self.processed_packages:
				self.processed_packages.append(param)
				self.packages += 1
		elif event == IpkgComponent.EVENT_INSTALL:
			self.package.setText(param)
			self.status.setText(_("Installing"))
			if not param in self.processed_packages:
				self.processed_packages.append(param)
				self.packages += 1
		elif event == IpkgComponent.EVENT_REMOVE:
			self.package.setText(param)
			self.status.setText(_("Removing"))
			if not param in self.processed_packages:
				self.processed_packages.append(param)
				self.packages += 1
		elif event == IpkgComponent.EVENT_CONFIGURING:
			self.package.setText(param)
			self.status.setText(_("Configuring"))
		elif event == IpkgComponent.EVENT_ERROR:
			self.error += 1
		elif event == IpkgComponent.EVENT_DONE:
			self.runNextCmd()

	def exit(self):
		if not self.ipkg.isRunning():
			self.close()
コード例 #22
0
ファイル: StreamServerConfig.py プロジェクト: OpenDMM/enigma2
class StreamServerConfig(Screen, ConfigListScreen):
	skin = """
		<screen name="StreamServerConfig" position="center,120" size="920,520" title="Stream Server configuration">
			<ePixmap pixmap="skin_default/buttons/yellow.png" position="10,5" size="200,40" />
			<ePixmap pixmap="skin_default/buttons/blue.png" position="210,5" size="200,40" />
			<widget source="key_yellow" render="Label" position="10,5" size="200,40" zPosition="1" font="Regular;20" halign="center" valign="center" backgroundColor="#a08500" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-2,-2" />
			<widget source="key_blue" render="Label" position="210,5" size="200,40" zPosition="1" font="Regular;20" halign="center" valign="center" backgroundColor="#18188b" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-2,-2" />
			<eLabel position="10,50" size="560,1" backgroundColor="grey" />
			<widget name="config" position="10,55" size="560,450" scrollbarMode="showOnDemand" zPosition="1"/>
			<ePixmap position="580,5" size="330,500" pixmap="skin_default/menu.png" zPosition="-1" scale="stretch"/>
			<!-- details -->
			<widget name="details_label" position="590,20" zPosition="2" size="300,25" font="Regular;20" backgroundColor="background" halign="center" transparent="1" />
			<widget name="details" position="590,50" zPosition="2" size="300,320" font="Regular;18" backgroundColor="background" halign="center" transparent="1" />
			<widget name="details_hint" position="580,390" zPosition="2" size="330,45" font="Regular;17" backgroundColor="background" halign="center" transparent="1" />
			<!-- info -->
			<widget name="info" position="590,450" zPosition="2" size="310,45" font="Regular;17" halign="center" valign="bottom" backgroundColor="background" transparent="1" />
		</screen>"""

	PRESETS = [
		EncoderPreset(_("Very Low"), 800, 64, StreamServerControl.RES_KEY_PAL),
		EncoderPreset(_("Low"), 1200, 96, StreamServerControl.RES_KEY_PAL),
		EncoderPreset(_("Medium"), 2000, 128, StreamServerControl.RES_KEY_720P),
		EncoderPreset(_("High"), 4000, 192, StreamServerControl.RES_KEY_720P),
		EncoderPreset(_("Higher"), 6000, 256, StreamServerControl.RES_KEY_1080P),
		EncoderPreset(_("Best"), 8000, 256, StreamServerControl.RES_KEY_1080P),
		EncoderPreset(_("Maximum"), 10000, 448, StreamServerControl.RES_KEY_1080P),
	]

	def __init__(self, session):
		Screen.__init__(self, session)
		ConfigListScreen.__init__(self, [], session=session)
		self._streamServerControl = streamServerControl
		self._upstreamBitrate = 0
		self._clientCount = streamServerControl.rtspClientCount

		self._key_blue = StaticText("")
		self["key_blue"] = self._key_blue
		self["key_yellow"] = StaticText(_("Presets"))
		self._info = Label("")
		self["info"] = self._info

		self["details_label"] = Label(_("Status Detail"))
		self._details = Label(_("No details available..."))
		self["details"] = self._details
		self._detailsHint = Label("Press PVR in channel selection to change the service in background mode")
		self["details_hint"] = self._detailsHint

		if not self._setInfoText in self["config"].onSelectionChanged:
			self["config"].onSelectionChanged.append(self._setInfoText)

		self._closeAfterApply = False
		self._presetChoiceBox = None

		self["setupActions"] = ActionMap(["OkCancelActions", "ColorActions"],
		{
			"blue": self.apply,
			"yellow": self._showPresets,
			"cancel": self._applyAndClose,
			"ok" : self._applyAndClose,
		}, -2)

		self.setTitle(_("Streaming Server"))

		streamServerControl.onRtspClientCountChanged.append(self._onRtspClientCountChanged)

		self._streamServerControl.config.streamserver.rtsp.enabled.addNotifier(self._onEnabled, initial_call=False)
		self._streamServerControl.config.streamserver.hls.enabled.addNotifier(self._onEnabled, initial_call=False)
		self._streamServerControl.config.streamserver.gopLength.addNotifier(self._onGopLengthChanged, initial_call=False)
		self._streamServerControl.config.streamserver.bFrames.addNotifier(self._onBframesChanged, initial_call=False)
		self._createSetup()

	def _onBframesChanged(self, element):
		self._createSetup()

	def _onRtspClientCountChanged(self, count, client):
		self._clientCount = count
		self._setInfoText()

	def _onLoginCreated(self, *args):
		self._createSetup()

	def _onClientStreamUrlChanged(self, *args):
		self._setInfoText()

	def apply(self):
		applyConfig(self._streamServerControl)
		if self._closeAfterApply:
			self.close()

	def _applyAndClose(self):
		self._closeAfterApply = True
		self.apply()

	def close(self):
		streamServerControl.onRtspClientCountChanged.remove(self._onRtspClientCountChanged)

		self._streamServerControl.config.streamserver.rtsp.enabled.removeNotifier(self._onEnabled)
		self._streamServerControl.config.streamserver.hls.enabled.removeNotifier(self._onEnabled)
		self._streamServerControl.config.streamserver.gopLength.removeNotifier(self._onGopLengthChanged)
		self._streamServerControl.config.streamserver.bFrames.removeNotifier(self._onBframesChanged)
		self._streamServerControl.config.streamserver.save()

		Screen.close(self)

	def _onEnabled(self, element):
		self.apply()
		self._streamServerControl.config.streamserver.save()
		self._createSetup()

	def _onGopLengthChanged(self, element):
		self._createSetup()

	def _onMediatorEnabled(self, element):
		self._createSetup()

	def _createSetup(self):
		self._setInfoText()

		entries = [ getConfigListEntry(_("RTSP")),
					getConfigListEntry(_("RTSP Server"), self._streamServerControl.config.streamserver.rtsp.enabled),]

		if self._streamServerControl.config.streamserver.rtsp.enabled.value:
			entries.extend([
				getConfigListEntry(_("User"), self._streamServerControl.config.streamserver.rtsp.user),
				getConfigListEntry(_("Password"), self._streamServerControl.config.streamserver.rtsp.password),
			])
			if config.usage.setup_level.index > 0:
				entries.extend([
					#getConfigListEntry(_("RTSP Port"), self._streamServerControl.config.streamserver.rtsp.port),
					getConfigListEntry(_("RTSP Path"), self._streamServerControl.config.streamserver.rtsp.path),
				])

		entries.extend([
			getConfigListEntry(_("HLS")),
			getConfigListEntry(_("HLS Server"), self._streamServerControl.config.streamserver.hls.enabled)
		])
		if self._streamServerControl.config.streamserver.hls.enabled.value:
			entries.extend([
				getConfigListEntry(_("User"), self._streamServerControl.config.streamserver.hls.user),
				getConfigListEntry(_("Password"), self._streamServerControl.config.streamserver.hls.password)
			])
			if config.usage.setup_level.index > 0:
				entries.append(getConfigListEntry(_("Path"), self._streamServerControl.config.streamserver.hls.path))

		if self._streamServerControl.isAnyEnabled():
			entries.extend([
					getConfigListEntry(_("Bitrates")),
					getConfigListEntry(_("Audio Bitrate"),self. _streamServerControl.config.streamserver.audioBitrate),
					getConfigListEntry(_("Video Bitrate"), self._streamServerControl.config.streamserver.videoBitrate),
					getConfigListEntry(_("Basic Encoder Settings")),
					getConfigListEntry(_("Data Source"), self._streamServerControl.config.streamserver.source),
					getConfigListEntry(_("Resolution"), self._streamServerControl.config.streamserver.resolution),
					getConfigListEntry(_("Framerate"), self._streamServerControl.config.streamserver.framerate),
					getConfigListEntry(_("Expert Encoder Settings")),
					getConfigListEntry(_("GOP Length (ms, P-Frames auto calculated)"), self._streamServerControl.config.streamserver.gopLength)
				])

			if self._streamServerControl.config.streamserver.gopLength.value == eStreamServer.GOP_LENGTH_AUTO:
				entries.append( getConfigListEntry(_("Number of P-Frames"), self._streamServerControl.config.streamserver.pFrames) )

			entries.append( getConfigListEntry(_("Number of B-Frames"), self._streamServerControl.config.streamserver.bFrames) )

			if self._streamServerControl.config.streamserver.bFrames.value:
				entries.append( getConfigListEntry(_("Open GOP"), self._streamServerControl.config.streamserver.openGop) )

			if StreamServerControl.FEATURE_SCENE_DETECTION and not self._streamServerControl.config.streamserver.bFrames.value and not self._streamServerControl.config.streamserver.gopLength.value:
				entries.append( getConfigListEntry(_("New GOP On Scene Change"), self._streamServerControl.config.streamserver.gopOnSceneChange) )

			if StreamServerControl.FEATURE_SLICES:
				entries.append( getConfigListEntry(_("Number of slices"), self._streamServerControl.config.streamserver.slices) )

			entries.extend([
					getConfigListEntry(_("Level"), self._streamServerControl.config.streamserver.level),
					getConfigListEntry(_("Profile"), self._streamServerControl.config.streamserver.profile),
				])

		self["config"].list = entries

	def _setInfoText(self):
		detailtext =_("Local client(s):\n    %s") %(self._clientCount)
		self._details.setText(detailtext)

		localstreams = []
		if self._streamServerControl.config.streamserver.rtsp.enabled.value or self._streamServerControl.config.streamserver.hls.enabled.value:
			ifaces = iNetworkInfo.getConfiguredInterfaces()
			for iface in ifaces.itervalues():
				ip = iface.getIpv4()
				if not ip:
					ip = iface.getIpv6()
				if ip:
					if self._streamServerControl.config.streamserver.rtsp.enabled.value:
						localstreams.append("rtsp://%s:%s/%s" %(ip.getAddress(), self._streamServerControl.config.streamserver.rtsp.port.value, self._streamServerControl.config.streamserver.rtsp.path.value))
					if self._streamServerControl.config.streamserver.hls.enabled.value:
						localstreams.append("http://%s:%s/%s.m3u8" %(ip.getAddress(), self._streamServerControl.config.streamserver.hls.port.value, self._streamServerControl.config.streamserver.hls.path.value))
					break

		infotext = ""
		if not localstreams:
			infotext = _("no active streams...")
		else:
			infotext = "\n".join(localstreams)
		self._info.setText(infotext)

	def _showPresets(self):
		presets = []
		for preset in self.PRESETS:
			presets.append((preset.name, preset))
		current = self.PRESETS[0]
		title = _("Video Bitrate:\t%s\nAudio Bitrate:\t%s\nResolution:\t%s") %(current.videoBitrate, current.audioBitrate, current.resolution)
		self._presetChoiceBox = self.session.openWithCallback(self._onPresetSelected, ChoiceBox, title=title, titlebartext=_("Encoder Presets"), list=presets)
		self._presetChoiceBox["list"].onSelectionChanged.append(self._onSelectedPresetChanged)
		self._presetChoiceBox.onLayoutFinish.append(self._onSelectedPresetChanged)

	def _onSelectedPresetChanged(self, *args):
		if not self._presetChoiceBox:
			return
		current = self._presetChoiceBox["list"].getCurrent()
		if not current:
			return
		current = current[0][1]
		text = _("Video Bitrate:\t%s\nAudio Bitrate:\t%s\nResolution:\t%s") %(current.videoBitrate, current.audioBitrate, current.resolution)
		self._presetChoiceBox["text"].setText(text)

	def _onPresetSelected(self, choice):
		self._presetChoiceBox = None
		if choice:
			preset = choice[1]
			self._streamServerControl.config.streamserver.videoBitrate.value = preset.videoBitrate
			self._streamServerControl.config.streamserver.audioBitrate.value = preset.audioBitrate
			if preset.resolution != self._streamServerControl.config.streamserver.resolution.value:
				self._streamServerControl.config.streamserver.resolution.value = preset.resolution
			self._createSetup()
コード例 #23
0
ファイル: BrowserMenu.py プロジェクト: aitchala/enigma2
class BrowserMenu(Screen):
	ACTION_BOOKMARK = 0
	ACTION_COOKIES = 1
	ACTION_STORAGE_PATH = 2

	MENU_BOOKMARKS = 0
	MENU_SETTINGS = 1
	MENU_HISTORY = 2
	MENU_DOWNLOADS = 3
	MENU_CERTS = 4
	MENU_COOKIES = 5

	size = getDesktop(0).size()
	width = int(size.width() * 0.9)
	height = int(size.height() * 0.85)
	bof = height - 35 #Button-Offset

	skin = """
		<screen name="BrowserMenu" position="center,center" size="%(w)d,%(h)d" title="Web Browser - Menu" >
			<widget name="menu" position="0,0" zPosition="1" size="200,%(h)d" backgroundColor="#000000" transparent="1" />
			<widget source="line" render="Canvas" position="203,0" zPosition="2" size="4,%(h)d" backgroundColor="#000000" transparent="1" alphatest="on"/>
			<widget source="list" render="Listbox" position="210,0" zPosition="1" size="%(listW)d,%(listH)d" backgroundColor="#000000" transparent="1">
				<convert type="TemplatedMultiContent">
					{"templates":
						{"default": (55, [
							MultiContentEntryText(pos = (10, 1), size = (920, 25), font = 0, flags = RT_VALIGN_CENTER, text = 1),
							MultiContentEntryText(pos = (10, 30), size = (920, 25), font = 1, flags = RT_VALIGN_CENTER, text = 2),
						]),
						"history": (55, [
							MultiContentEntryText(pos = (10, 1), size = (150, 25), font = 1, flags = RT_VALIGN_CENTER, text = 1),
							MultiContentEntryText(pos = (10, 28), size = (150, 25), font = 1, flags = RT_VALIGN_CENTER, text = 2),
							MultiContentEntryText(pos = (190, 1), size = (690, 25), font = 0, flags = RT_VALIGN_CENTER, text = 3),
							MultiContentEntryText(pos = (190, 28), size = (690, 25), font = 1, flags = RT_VALIGN_CENTER, text = 4),
						]),
						"downloads": (25, [
							MultiContentEntryText(pos = (0, 1), size = (600, 24), font=1, flags = RT_HALIGN_LEFT, text = 1),
							MultiContentEntryText(pos = (610, 1), size = (150, 24), font=1, flags = RT_HALIGN_RIGHT, text = 2),
							MultiContentEntryProgress(pos = (760, 1), size = (100, 24), percent = 3),
							MultiContentEntryText(pos = (870, 1), size = (70, 24), font=1, flags = RT_HALIGN_RIGHT, text = 4),
						]),
						"certificates": (85, [
							MultiContentEntryText(pos = (10, 1), size = (150, 25), font = 1, flags = RT_VALIGN_CENTER, text = 1),
							MultiContentEntryText(pos = (10, 28), size = (150, 25), font = 1, flags = RT_VALIGN_CENTER, text = 2),
							MultiContentEntryText(pos = (190, 1), size = (690, 25), font = 0, flags = RT_VALIGN_CENTER, text = 3),
							MultiContentEntryText(pos = (190, 28), size = (690, 25), font = 1, flags = RT_VALIGN_CENTER, text = 4),
							MultiContentEntryText(pos = (10, 60), size = (900, 25), font = 0, flags = RT_VALIGN_CENTER, text = 5),
						]),
						"cookies": (75, [
							MultiContentEntryText(pos = (10, 1), size = (150, 25), font = 1, flags = RT_VALIGN_CENTER, text = 1),
							MultiContentEntryText(pos = (10, 28), size = (150, 25), font = 1, flags = RT_VALIGN_CENTER, text = 2),
							MultiContentEntryText(pos = (180, 1), size = (720, 25), font = 0, flags = RT_VALIGN_CENTER, text = 3),
							MultiContentEntryText(pos = (180, 28), size = (625, 25), font = 1, flags = RT_VALIGN_CENTER, text = 4),
							MultiContentEntryText(pos = (10, 60), size = (900, 15), font = 2, flags = RT_VALIGN_CENTER, text = 5),
						])
						},
					"fonts": [gFont("Regular", 22), gFont("Regular", 16), gFont("Regular", 13)]
					}
				</convert>
			</widget>
			<widget name="statuslabel" position="210,%(inputY)d" size="%(listW)d,25" font="Regular;20"  zPosition="2" halign="center" valign="center" backgroundColor="#000000" transparent="0" />
			<widget name="input" position="210,%(inputY)d" zPosition="1" size="%(listW)d,25" font="Regular;20" halign="left" valign="bottom" backgroundColor="#000000" transparent="1"/>
			<widget name="config" position="210,0" zPosition="2" size="%(listW)d,%(configH)d" backgroundColor="background" transparent="0" />

			<ePixmap pixmap="skin_default/buttons/button_red_off.png" position="210,%(btnY)d" size="15,16" alphatest="on" />
			<widget source="button_red" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_red.png" position="210,%(btnY)d" size="15,16" alphatest="on">
				<convert type="ConditionalShowHide" />
			</widget>
			<widget name="red" position="230,%(btnTxtY)d" size="100,20" foregroundColor="white" backgroundColor="background" font="Regular;18" transparent="1" halign="left" valign="top"/>

			<ePixmap pixmap="skin_default/buttons/button_green_off.png" position="340,%(btnY)d" size="15,16" zPosition="1" alphatest="on" />
			<widget source="button_green" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_green.png" position="340,%(btnY)d" size="15,16" alphatest="on">
				<convert type="ConditionalShowHide" />
			</widget>
			<widget name="green" position="360,%(btnTxtY)d" size="100,20" foregroundColor="white" backgroundColor="background" font="Regular;18" transparent="1" halign="left" valign="top"/>

			<ePixmap pixmap="skin_default/buttons/button_yellow_off.png" position="470,%(btnY)d" size="15,16" alphatest="on" />
			<widget source="button_yellow" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_yellow.png" position="470,%(btnY)d" size="15,16" alphatest="on">
				<convert type="ConditionalShowHide" />
			</widget>
			<widget name="yellow" position="490,%(btnTxtY)d" size="100,20" foregroundColor="white" backgroundColor="background" font="Regular;18" transparent="1" halign="left" valign="top"/>

			<ePixmap pixmap="skin_default/buttons/button_blue_off.png" position="600,%(btnY)d" size="15,16" alphatest="on" />
			<widget source="button_blue" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_blue.png" position="600,%(btnY)d" size="15,16" alphatest="on">
				<convert type="ConditionalShowHide" />
			</widget>
			<widget name="blue" position="620,%(btnTxtY)d" size="200,20" foregroundColor="white" backgroundColor="background" font="Regular;18" transparent="1" halign="left" valign="top"/>
		</screen>
		""" %{ 	"w" : width,
				"h" : height,
				"listW" : width - 210, "listH" : height - 90,
				"inputY" : height - 80,
				"configH" : height - 90,
				"btnY" : bof + 2,
				"btnTxtY" : bof
			}

	def __init__(self, session, currentTitle, currentUrl, menulist = None):
		Screen.__init__(self, session)

		self.currentUrl = currentUrl
		self.currentTitle = currentTitle

		#Menu
		if menulist is None:
			self.menu = MenuList([
						(_("Bookmarks"), self.MENU_BOOKMARKS),
						(_("History"), self.MENU_HISTORY),
						(_("Downloads"), self.MENU_DOWNLOADS),
						(_("Certificates"), self.MENU_CERTS),
						(_("Cookies"), self.MENU_COOKIES),
						(_("Settings"), self.MENU_SETTINGS),
				], enableWrapAround = True)
		else:
			self.menu = MenuList(menulist, enableWrapAround=True)
		self["menu"] = self.menu

		self["statuslabel"] = Label("")
		self["statuslabel"].hide()

		#Color Buttons
		self["button_red"] = Boolean(False)
		self["button_green"] = Boolean(False)
		self["button_yellow"] = Boolean(False)
		self["button_blue"] = Boolean(False)
		self.red = Label("")
		self.green = Label("")
		self.yellow = Label("")
		self.blue = Label("")
		self["red"] = self.red
		self["green"] = self.green
		self["yellow"] = self.yellow
		self["blue"] = self.blue

		#Lists
		self.detailList = List([], enableWrapAround = True)
		self.detailConfigList = ConfigList([])
		self.detailConfigList.l.setSeperation( (BrowserMenu.width - 210) / 2 )
		config.plugins.WebBrowser.storage.enabled.addNotifier(self.__cfgExpandableElementChanged, initial_call = False)
		config.plugins.WebBrowser.storage.enabled.addNotifier(self.__cfgStoragePathChanged, initial_call = False)
		config.plugins.WebBrowser.storage.path.addNotifier(self.__cfgStoragePathChanged, initial_call = False)

		self.detailInput = EnhancedInput()

		self["list"] = self.detailList
		self["config"] = self.detailConfigList
		self["input"] = self.detailInput
		self["line"] = CanvasSource()

		self.__cfgCreateSetup()

		self.__db = BrowserDB.getInstance()
		self.__curMenu = self.MENU_BOOKMARKS
		self.__bmList = None
		self.__hisList = None
		self.__crtList = None
		self.__ckList = None
		self.__bmNeedle = ""
		self.__bmFilterTimer = eTimer()
		self.__bmFilterTimer_conn = self.__bmFilterTimer.timeout.connect(self.__bmFilterCB)
		self.__hisNeedle = ""
		self.__hisFilterTimer = eTimer()
		self.__hisFilterTimer_conn = self.__hisFilterTimer.timeout.connect(self.__hisFilterCB)
		self.__dlRefreshTimer = eTimer()
		self.__dlRefreshTimer_conn = self.__dlRefreshTimer.timeout.connect(self.__dlBuildList)
		self.__statusTimer = eTimer()
		self.__statusTimer_conn = self.__statusTimer.timeout.connect(self.__hideStatus)
		self.__actions = []

		self.onFirstExecBegin.append(self.__drawSeparator)
		self.onFirstExecBegin.append(self.__onMenuChanged)
		self.onExecBegin.append(self.__reloadData)
		self.onShow.append(self.setKeyboardModeAscii)

		self["actions"] = ActionMap(["BrowserActions", "ColorActions"],
		{
			"ok" : self.__actionOk,
			"enter" : self.__actionOk,
			"exit" : self.__actionExit,
			"pageUp" : self.__actionMenuUp,
			"pageDown" : self.__actionMenuDown,
			"up" : boundFunction(self.__action, "up"),
			"down" : boundFunction(self.__action, "down"),
			"left" : boundFunction(self.__action, "left"),
			"right" : boundFunction(self.__action, "right"),
			"red" : boundFunction(self.__action, "red"),
			"green" : boundFunction(self.__action, "green"),
			"yellow" : boundFunction(self.__action, "yellow"),
			"blue" : boundFunction(self.__action, "blue"),
			"backspace" : boundFunction(self.__action, "backspace"),
			"delete" : boundFunction(self.__action, "delete"),
			"ascii": boundFunction(self.__action, "ascii"),
			# TODO "text" : self.__text
		}, -2)

		self["numberactions"] = NumberActionMap(["NumberActions"],
		{
			"1": self.__keyNumberGlobal,
			"2": self.__keyNumberGlobal,
			"3": self.__keyNumberGlobal,
			"4": self.__keyNumberGlobal,
			"5": self.__keyNumberGlobal,
			"6": self.__keyNumberGlobal,
			"7": self.__keyNumberGlobal,
			"8": self.__keyNumberGlobal,
			"9": self.__keyNumberGlobal,
			"0": self.__keyNumberGlobal
		}, -2)

		self.__actionFuncs = {
			self.MENU_BOOKMARKS : {
				"up" : self.detailList.selectPrevious,
				"down" : self.detailList.selectNext,
				"left" : self.detailList.selectPrevious,
				"right" : self.detailList.pageDown,
				"ok" : self.__bmOk,
				"enter" : self.__bmOk,
				"red" : self.__bmDelete,
				"green" : self.__bmAdd,
				"yellow" : self.__bmEdit,
				"blue" : self.__bmSetCurrentAsHome,
				"backspace" : self.__bmKeyBackspace,
				"delete" : self.__bmKeyDelete,
				"ascii": self.__bmKeyAscii,
				},
			self.MENU_HISTORY : {
				"up" : self.detailList.selectPrevious,
				"down" : self.detailList.selectNext,
				"left" : self.detailList.pageUp,
				"right" : self.detailList.pageDown,
				"ok" : self.__hisOk,
				"enter" : self.__hisOk,
				"red" : self.__hisClear,
				"blue" : self.__hisSetCurrentAsHome,
				"backspace" : self.__hisKeyBackspace,
				"delete" : self.__hisKeyDelete,
				"ascii": self.__hisKeyAscii,
				},
			self.MENU_SETTINGS : {
				"up" : self.__cfgKeyUp,
				"down" : self.__cfgKeyDown,
				"left" : self.__cfgKeyLeft,
				"right" : self.__cfgKeyRight,
				"ok" : self.__cfgKeyOK,
				"enter" : self.__cfgKeyOK,
				"red" : self.__cfgCancel,
				"green" : self.__cfgSave,
				"backspace" : self.__cfgKeyBackspace,
				"delete" : self.__cfgKeyDelete,
				"ascii": self.__cfgKeyAscii,
				},
			self.MENU_DOWNLOADS : {
				"up" : self.detailList.selectPrevious,
				"down" : self.detailList.selectNext,
				"left" : self.detailList.pageUp,
				"right" : self.detailList.pageDown,
				"red" : self.__dlAbort,
				},
			self.MENU_CERTS : {
				"up" : self.detailList.selectPrevious,
				"down" : self.detailList.selectNext,
				"left" : self.detailList.pageUp,
				"right" : self.detailList.pageDown,
				"red" : self.__crtDelete,
				"green" : self.__crtDetails,
				},
			self.MENU_COOKIES : {
				"up" : self.detailList.selectPrevious,
				"down" : self.detailList.selectNext,
				"left" : self.detailList.pageUp,
				"right" : self.detailList.pageDown,
				"red" : self.__ckDelete,
				"blue" : self.__ckDeleteAll,
				}
		}

	def _close(self):
		config.plugins.WebBrowser.storage.enabled.removeNotifier(self.__cfgExpandableElementChanged)
		config.plugins.WebBrowser.storage.enabled.removeNotifier(self.__cfgStoragePathChanged)
		config.plugins.WebBrowser.storage.path.removeNotifier(self.__cfgStoragePathChanged)
		self.close(self.__actions)

	def __actionOk(self):
		if self["statuslabel"].visible:
			self["statuslabel"].hide()
		else:
			self.__action("ok")

	def __actionExit(self):
		if self["statuslabel"].visible:
			self["statuslabel"].hide()
		else:
			if self.detailConfigList.isChanged():
				self.__cfgSave()
			self._close()

	def __actionMenuUp(self):
		self.menu.up()
		self.__onMenuChanged()

	def __actionMenuDown(self):
		self.menu.down()
		self.__onMenuChanged()

	def __reloadData(self):
		self.__bmList = self.__db.getBookmarks()
		self.__hisList = self.__db.getHistory()
		self.__crtList = self.__db.getCerts()
		self.__ckList = self.__db.getCookies()

	def __action(self, action):
		print "[BrowserMenu].__action :: action='%s'" %action
		fnc = self.__actionFuncs[self.__curMenu].get(action, None)
		if fnc != None:
			fnc()

	def __text(self):
		if self.__curMenu == self.MENU_SETTINGS:
			self.__cfgKeyText()
		elif self.__curMenu == self.MENU_BOOKMARKS:
			pass

	def __keyNumberGlobal(self, number):
		if self.__curMenu == self.MENU_SETTINGS:
			self.__cfgKeyNumberGlobal(number)
		elif self.__curMenu == self.MENU_BOOKMARKS:
			self.__bmKeyNumberGlobal(number)
		elif self.__curMenu == self.MENU_HISTORY:
			self.__hisKeyNumberGlobal(number)

	def __onMenuChanged(self):
		self.__bmFilterTimer.stop()
		self.__hisFilterTimer.stop()
		self.__dlRefreshTimer.stop()

		self.__curMenu = self.menu.getCurrent()[1]
		if self.__curMenu == self.MENU_BOOKMARKS:
			self.__showMenuList(True)
			self.__setButtons(_("Delete"), _("Add"), _("Edit"), _("Set as Startpage"))
			self.detailList.style = "default"
			self.__bmBuildList()
			self.detailInput.setText(self.__bmNeedle)
		elif self.__curMenu == self.MENU_HISTORY:
			self.__showMenuList(True)
			self.__setButtons(_("Clear"), "", "", _("Set as Startpage"))
			self.detailList.style = "history"
			self.__hisBuildList()
			self.detailInput.setText(self.__hisNeedle)
		elif self.__curMenu == self.MENU_SETTINGS:
			self.__showConfigList()
			self.__setButtons(_("Cancel"), _("Save"), "", "")
		elif self.__curMenu == self.MENU_DOWNLOADS:
			self.__showMenuList()
			self.__setButtons(_("Abort"), "", "", "")
			self.detailList.style = "downloads"
			self.__dlBuildList()
		elif self.__curMenu == self.MENU_CERTS:
			self.__showMenuList()
			self.__setButtons(_("Delete"), _("Details"), "", "")
			self.detailList.style = "certificates"
			self.__crtBuildList()
		elif self.__curMenu == self.MENU_COOKIES:
			self.__showMenuList()
			self.__setButtons(_("Delete"), "", "", _("Delete All"))
			self.detailList.style = "cookies"
			self.__ckBuildList()

	def __setButtons(self, red, green, yellow, blue):
		self.red.setText(red)
		self.__setButtonPixmapVisible(self["button_red"], red)
		self.green.setText(green)
		self.__setButtonPixmapVisible(self["button_green"], green)
		self.yellow.setText(yellow)
		self.__setButtonPixmapVisible(self["button_yellow"], yellow)
		self.blue.setText(blue)
		self.__setButtonPixmapVisible(self["button_blue"], blue)

	def __setButtonPixmapVisible(self, B, label):
		show = True
		if label == "":
			show = False
		B.setBoolean(show)

	def __showMenuList(self, hasFilter = False):
		if self.detailConfigList.visible:
			self.detailConfigList.hide()

# 		if not self.detailList.instance.visible:
# 			self.detailList.instance.show()
		if hasFilter:
			self.detailInput.show()
		else:
			self.detailInput.hide()

	def __showConfigList(self):
# 		if self.detailList.instance.visible == 1:
# 			self.detailList.instance.hide()
		self.detailInput.hide()
		if self.detailConfigList.visible == 0:
			self.detailConfigList.show()

	def __drawSeparator(self):
		self["line"].fill(0, 0, 4, BrowserMenu.height, 0xFF9900)
		self["line"].flush()

	def __setStatus(self, text):
		print "[BrowserMenu].__setStatus"
		self["statuslabel"].setText(text)
		self["statuslabel"].show()
		self.__statusTimer.startLongTimer(3)

	def __hideStatus(self):
		self["statuslabel"].hide()
		self.__statusTimer.stop()

	# Config List Methods
	def __cfgCreateSetup(self):
		list = [
			getConfigListEntry(_("Home Page"), config.plugins.WebBrowser.home),
			getConfigListEntry(_("Page to load on startup"), config.plugins.WebBrowser.startPage),
			getConfigListEntry(_("Search Provider"), config.plugins.WebBrowser.searchProvider),
			getConfigListEntry(_("Run fullscreen"), config.plugins.WebBrowser.fullscreen),
			getConfigListEntry(_("Offset in scroll mode (px)"), config.plugins.WebBrowser.scrollOffset),
			getConfigListEntry(_("Target directory for downloads"), config.plugins.WebBrowser.downloadpath),
			getConfigListEntry(_("Enable persistent storage"), config.plugins.WebBrowser.storage.enabled),
		]
		if config.plugins.WebBrowser.storage.enabled.value:
			list.append(getConfigListEntry(_("Path for persistent storage"), config.plugins.WebBrowser.storage.path))

		self.detailConfigList.setList(list)

	def __cfgExpandableElementChanged(self, element):
		self.__cfgCreateSetup()

	def __cfgSave(self):
		for x in self.detailConfigList.list:
			x[1].save()
		self.__setStatus(_("Settings have been saved successfully!"))

	def __cfgStoragePathChanged(self, element):
		action = [self.ACTION_STORAGE_PATH,True]
		if not action in self.__actions:
			self.__actions.append(action)

	def __cfgCancel(self):
		dlg = self.session.openWithCallback(self.__cfgCancelCB, MessageBox, _("Do you really want to discard all changes?"), type = MessageBox.TYPE_YESNO)
		dlg.setTitle(_("Discard changed settings?"))

	def __cfgCancelCB(self, confirmed):
		for x in self.detailConfigList.list:
			x[1].cancel()
		self.__setStatus(_("All changes to the settings have been discarded!"))

	def __cfgKeyText(self):
		from Screens.VirtualKeyBoard import VirtualKeyBoard
		self.session.openWithCallback(self.__cfgVirtualKeyBoardCallback, VirtualKeyBoard, title = self.detailConfigList.getCurrent()[0], text = self.detailConfigList.getCurrent()[1].getValue())

	def __cfgVirtualKeyBoardCallback(self, callback = None):
		if callback is not None and len(callback):
			self.detailConfigList.getCurrent()[1].setValue(callback)
			self.detailConfigList.invalidate(self.detailConfigList.getCurrent())

	def  __cfgKeyOK(self):
		self.detailConfigList.handleKey(KEY_OK)

	def  __cfgKeyUp(self):
		self.detailConfigList.instance.moveSelection(eListbox.moveUp)

	def  __cfgKeyDown(self):
		self.detailConfigList.instance.moveSelection(eListbox.moveDown)

	def  __cfgKeyLeft(self):
		self.detailConfigList.handleKey(KEY_LEFT)

	def __cfgKeyRight(self):
		self.detailConfigList.handleKey(KEY_RIGHT)

	def __cfgKeyHome(self):
		self.detailConfigList.handleKey(KEY_HOME)

	def __cfgKeyEnd(self):
		self.detailConfigList.handleKey(KEY_END)

	def __cfgKeyDelete(self):
		self.detailConfigList.handleKey(KEY_DELETE)

	def __cfgKeyBackspace(self):
		self.detailConfigList.handleKey(KEY_BACKSPACE)

	def __cfgKeyToggleOW(self):
		self.detailConfigList.handleKey(KEY_TOGGLEOW)

	def __cfgKeyAscii(self):
		self.detailConfigList.handleKey(KEY_ASCII)

	def __cfgKeyNumberGlobal(self, number):
		self.detailConfigList.handleKey(KEY_0 + number)

	#Bookmark List Methods
	def __bmOk(self):
		print "[BrowserMenu].__bmOk"
		if self.detailList.index > 0 and  self.detailList.getCurrent() != None:
			current = self.detailList.getCurrent()[0]
			print "[BrowserMenu].__bmOk, current = '%s'" %current
			self.__actions.append( (self.ACTION_BOOKMARK, current.url) )
			self.close( self.__actions )
		else:
			self.__bmAdd(Bookmark(-1, self.currentTitle, self.currentUrl))

	def __bmAdd(self, bookmark = None):
		self.session.openWithCallback(self.__bmEditCB, BookmarkEditor, bookmark)

	def __bmEdit(self):
		if self.detailList.index > 0 and  self.detailList.getCurrent() != None:
			cur = self.detailList.getCurrent()[0]
			self.session.openWithCallback(self.__bmEditCB, BookmarkEditor, cur)

	def __bmEditCB(self, bookmark):
		if bookmark != None:
			self.__db.setBookmark(bookmark)
			self.__bmReload()
			self.__setStatus(_("Bookmark '%s' saved succesfully!" %bookmark.name))

	def __bmDelete(self):
		if self.detailList.getCurrent() != None:
			name = self.detailList.getCurrent()[0].name
			print "[BrowserMenu].__bmDelete, name='%s'" %name
			dlg = self.session.openWithCallback( self.__bmDeleteCB, MessageBox, _("Do you really want to delete the bookmark '%s'?") %name, type = MessageBox.TYPE_YESNO )
			dlg.setTitle(_("Delete Bookmark?"))

	def __bmDeleteCB(self, confirmed):
		if confirmed:
			self.__db.deleteBookmark( self.detailList.getCurrent()[0] )
			name = self.detailList.getCurrent()[0]
			self.__setStatus(_("Bookmark '%s' deleted!" %name))
			self.__bmReload()

	def __bmSetCurrentAsHome(self):
		cur = self.detailList.getCurrent()[0]
		self.__setUrlAsHome(cur.url)

	def __bmGetEntryComponent(self, bookmark):
		return ( bookmark, bookmark.name, bookmark.url )

	def __bmBuildList(self):
		print "[BrowserMenu].__bmBuildList"
		list = []
		#Suggest current page for adding

		default = Bookmark(-2, _("Add '%s' to Bookmarks" %self.currentTitle), self.currentUrl)
		list.append(self.__bmGetEntryComponent(default))
		for b in self.__bmList:
			list.append(self.__bmGetEntryComponent(b))
		self.detailList.setList(list)

	def __bmReload(self, needle = ""):
		print "[BrowserMenu].__bmReload"
		self.__bmNeedle = needle
		self.__bmList = self.__db.getBookmarks(needle)
		self.__bmBuildList()

	def __bmFilterCB(self):
		print "[BrowserMenu].__bmFilterCB"
		needle = self.detailInput.getText()
		if needle != self.__bmNeedle:
			self.__bmReload(needle)
		else:
			self.__bmFilterTimer.stop()

	def __bmKeyNumberGlobal(self, number):
		self.detailInput.number(number)
		self.__bmFilterTimer.startLongTimer(1)

	def __bmKeyAscii(self):
		self.detailInput.handleAscii(getPrevAsciiCode())
		self.__bmFilterTimer.startLongTimer(1)

	def __bmKeyDelete(self):
		self.detailInput.delete()
		self.__bmFilterTimer.startLongTimer(1)

	def __bmKeyBackspace(self):
		self.detailInput.deleteBackward()
		self.__bmFilterTimer.startLongTimer(1)

	#History list methods
	def __hisSetCurrentAsHome(self):
		if self.detailList.getCurrent() != None:
			cur = self.detailList.getCurrent()[0]
			self.__setUrlAsHome(cur.url)

	def __setUrlAsHome(self, url):
		config.plugins.WebBrowser.home.value = url
		config.plugins.WebBrowser.home.save()
		self.__setStatus(_("Home page has been set to '%s'" %url))

	def __hisClear(self):
		dlg = self.session.openWithCallback(self.__hisClearCB, MessageBox, _("Do you really want to clear the History?"), type = MessageBox.TYPE_YESNO)
		dlg.setTitle(_("Clear History?"))

	def __hisClearCB(self, confirmed):
		if confirmed:
			self.__db.clearHistory()
			self.__hisReload()
			self.__setStatus(_("History cleared!"))

	def __hisGetEntryComponent(self, historyItem):
		date = strftime("%Y-%m-%d", localtime(historyItem.timestamp))
		time = strftime("%H:%M:%S", localtime(historyItem.timestamp))
		return ( historyItem, date, time, historyItem.title, historyItem.url )

	def __hisReload(self, needle = ""):
		print "[BrowserMenu].__hisReload"
		self.__hisNeedle = needle
		self.__hisList = self.__db.getHistory(needle)
		self.__hisBuildList()

	def __hisBuildList(self):
		print "[BrowserMenu].__hisBuildList"
		history = []
		for h in self.__hisList:
			history.append(self.__hisGetEntryComponent(h))
		self.detailList.setList(history)

	def __hisOk(self):
		if self.detailList.getCurrent() != None:
			current = self.detailList.getCurrent()[0]
			self.__actions.append( (self.ACTION_BOOKMARK, current.url) )
			self.close( self.__actions )

	def __hisFilterCB(self):
		needle = self.detailInput.getText()
		if needle != self.__hisNeedle:
			self.__hisReload(needle)
		else:
			self.__hisFilterTimer.stop()

	def __hisKeyNumberGlobal(self, number):
		self.detailInput.number(number)
		self.__hisFilterTimer.startLongTimer(1)

	def __hisKeyAscii(self):
		self.detailInput.handleAscii(getPrevAsciiCode())
		self.__hisFilterTimer.startLongTimer(1)

	def __hisKeyDelete(self):
		self.detailInput.delete()
		self.__hisFilterTimer.startLongTimer(1)

	def __hisKeyBackspace(self):
		self.detailInput.deleteBackward()
		self.__hisFilterTimer.startLongTimer(1)

	#Download list methods
	def __dlGetEntryComponent(self, job):
		return ( job, job.name, job.getStatustext(), int(100*job.progress/float(job.end)), str(100*job.progress/float(job.end)) + "%")

	def __dlBuildList(self):
		print "[BrowserMenu].__dlBuildList"
		downloads = []
		for job in downloadManager.getPendingJobs():
			downloads.append(self.__dlGetEntryComponent(job))
		self.detailList.setList(downloads)
		if not self.__dlRefreshTimer.isActive():
			self.__dlRefreshTimer.startLongTimer(3)

	def __dlAbort(self):
		print "[BrowserMenu].__dlAbort"
		cur = self.detailList.getCurrent()
		if cur != None:
			job = cur[0]
			dlg = self.session.openWithCallback( self.__dlAbortCB, MessageBox, _("Do you really want to abort downloading '%s'?") %job.name, type = MessageBox.TYPE_YESNO)
			dlg.setTitle(_("Abort Download?"))

	#Certificate list methods
	def __dlAbortCB(self, confirmed):
		if confirmed:
			self.detailList.getCurrent()[0].remove(downloadManager.jobDone)
			self.__dlBuildList()

	def __crtGetEntryComponent(self, cert):
		cn = "CN: %s" %(str(cert.cert.get_subject().commonName))
		return ( cert, str(cert.notBefore()), str(cert.notAfter()), str(cert.host), cn, str(cert.cert.digest("sha1")) )

	def __crtReload(self):
		print "[BrowserMenu].__crtReload"
		self.__crtList = self.__db.getCerts()
		self.__crtBuildList()


	def __crtBuildList(self):
		print "[BrowserMenu].__crtBuildList"
		certs = []
		for c in self.__crtList:
			certs.append(self.__crtGetEntryComponent(c))
		self.detailList.setList(certs)

	def __crtDelete(self):
		if self.detailList.index >= 0 and self.detailList.getCurrent() != None:
			cert = self.detailList.getCurrent()[0]
			print "[BrowserMenu].__crtDelete, host=%s,SHA1 fingerprint=%s" %(cert.host,cert.cert.digest("sha1"))
			text = _("Do you really want to remove the following certificate from the list of trusted certificates?\n\nHostname: %s\nSHA1-Fingerprint: %s") %(cert.host, cert.cert.digest("sha1"))
			dlg = self.session.openWithCallback( self.__crtDeleteCB, MessageBox, text, type = MessageBox.TYPE_YESNO )
			dlg.setTitle(_("Remove trusted certificate?"))

	def __crtDeleteCB(self, confirmed):
		print "[BrowserMenu].__crtDeleteCB"
		if confirmed:
			cert = self.detailList.getCurrent()[0]
			self.__db.deleteCert(cert)
			self.__crtReload()

	def __crtDetails(self):
		print "[BrowserMenu].__crtDetails"
		if self.detailList.index >= 0 and self.detailList.getCurrent() != None:
			cert = self.detailList.getCurrent()[0]

			text = _("Issued for:")
			for item in cert.cert.get_subject().get_components():
				text += "\n%s : %s" %(item[0], item[1])
			text += _("\n\nIssued from:")
			for item in cert.cert.get_issuer().get_components():
				text += "\n%s : %s" %(item[0], item[1])

			text += _("\n\nValidity:\n")
			text += _("From: %s\n") %cert.notBefore()
			text += _("Until: %s\n") %cert.notAfter()
			text += _("Expired: %s\n") %(_("Yes") if cert.cert.has_expired() else _("No"))

			dlg = self.session.open(MessageBox, text, type = MessageBox.TYPE_INFO)
			dlg.setTitle(_("Certificate Details (%s)") %cert.host)

	def __ckReload(self):
		print "[BrowserMenu].__ckReload"
		self.__ckList = self.__db.getCookies()
		self.__ckBuildList()

	def __ckBuildList(self):
		print "[BrowserMenu].__ckBuildList"
		cookies = []
		for c in self.__ckList:
			cookies.append(self.__ckGetEntryComponent(c))
		self.detailList.setList(cookies)

	def __ckGetEntryComponent(self, cookie):
		try:
			date = strftime("%Y-%m-%d", localtime(cookie.expires))
			time = strftime("%H:%M:%S", localtime(cookie.expires))
		except:
			date = _("never")
			time = _("never")
		return ( cookie, date, time, cookie.domain, cookie.path, cookie.raw )

	def __ckDelete(self):
		if self.detailList.index >= 0 and self.detailList.getCurrent() != None:
			cookie = self.detailList.getCurrent()[0]
			text = _("Do you really want to delete the following cookie?\nDomain: %s\nPath: %s\nKey: %s\nRaw-Content:\n%s") %(cookie.domain, cookie.path, cookie.key, cookie.raw)
			dlg = self.session.openWithCallback( self.__ckDeleteCB, MessageBox, text, type = MessageBox.TYPE_YESNO )
			dlg.setTitle(_("Delete Cookie?"))

	def __ckDeleteCB(self, confirmed):
		print "[BrowserMenu].__ckDeleteCB"
		if confirmed:
			self.__db.deleteCookie(self.detailList.getCurrent()[0])
			self.__ckReload()
			action = [self.ACTION_COOKIES,True]
			if not action in self.__actions:
				self.__actions.append(action)

	def __ckDeleteAll(self):
		if self.detailList.index >= 0 and self.detailList.getCurrent() != None:
			text = _("Do you really want to delete ALL cookies?")
			dlg = self.session.openWithCallback( self.__ckDeleteAllCB, MessageBox, text, type = MessageBox.TYPE_YESNO )
			dlg.setTitle(_("Delete Cookie?"))

	def __ckDeleteAllCB(self, confirmed):
		print "[BrowserMenu].__ckDeleteCB"
		if confirmed:
			self.__db.deleteAllCookies()
			self.__ckReload()
			action = [self.ACTION_COOKIES,True]
			if not action in self.__actions:
				self.__actions.append(action)
コード例 #24
0
ファイル: plugin.py プロジェクト: R7UST/oe-alliance-plugins
class BrowserLauncher(ConfigListScreen, Screen):
	skin=   """
		<screen name="BrowserLauncher" position="center,60" size="415,630" title="Web Browser">
			<ePixmap pixmap="skin_default/buttons/red.png" position="75,0" size="140,40" alphatest="on" />
			<ePixmap pixmap="skin_default/buttons/green.png" position="225,0" size="140,40" alphatest="on" />
			<widget source="key_red" render="Label" position="75,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" transparent="1" />
			<widget source="key_green" render="Label" position="225,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" transparent="1" />
			<widget name="config" position="0,50" size="409,100" scrollbarMode="showOnDemand" />
			<ePixmap pixmap="/usr/lib/enigma2/python/Plugins/Extensions/WebBrowser/icons/%s" position="50,155" size="309,435" alphatest="on" />
			<widget name="info" position="50,588" size="309,50" font="Regular;18" halign="center" foregroundColor="blue" transparent="1" />
		</screen>
		""" % model_rc

	def __init__(self, session): 
		Screen.__init__(self, session)
                self.session = session
		self.list = []
		ConfigListScreen.__init__(self, self.list)
		
		#refresh devices
		iInputDevices.getInputDevices()
		self.browser_root = "/usr/bin"
		
		self.browser_name = "arora"
		self.conf_file = "/usr/lib/enigma2/python/Plugins/Extensions/WebBrowser/settings.conf"
		self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", ],
                {	"red": self.keyCancel,
			"green": self.keyGo,
			"cancel": self.keyExit,
                }, -2)
		self.info = Label(_("If you want to quit the Browser,\nPress RED -> EXIT."))
		self["info"] = self.info
		self["key_red"] = StaticText(_("Exit"))
		self["key_green"] = StaticText(_("Start"))

		self.conf_alpha = ""
		self.conf_mouse = ""
		self.conf_keyboard = ""
		self.conf_keymap = ""

		self.usb_mouse = None
		self.usb_keyboard = None
		self.rc_mouse = None
		self.rc_keyboard = None

		self.current_lang_idx = language.getActiveLanguageIndex()

		self.makeConfig()
		#time.sleep(2)
		excute_cmd("echo 1 > /proc/stb/fp/mouse")

		self.lock = False
		self.service = PlayerService(self.session)
		self.service.start(timeout=5)

		self.exit_wait_cond = False
		self.timer_exit_cond = eTimer()
		self.timer_exit_cond.callback.append(self.resetExitCond)

		self.test_cond = True

	def keyNone(self):
		None

	def doExit(self):
		change_galpha(set_const=False, set_value=False)
		self.saveConfig()
		self.service.stop()
		excute_cmd("killall -15 %s"%(self.browser_name))
		excute_cmd("echo 60 > /proc/sys/vm/swappiness")
		excute_cmd("echo 0 > /proc/stb/fp/mouse")
		enable_rc_mouse(False) #rc-mouse off
		language.activateLanguageIndex(self.current_lang_idx)
		fbClass.getInstance().unlock()
		#eRCInput.getInstance().unlock()
		self.close()

	def keyExit(self):
		if self.exit_wait_cond:
			self.doExit()
		if is_process_running(self.browser_name) == False:
			self.doExit()

	def keyLeft(self):
		if is_process_running(self.browser_name) == False:
			ConfigListScreen.keyLeft(self)
			global alpha_value
			alpha_value = self.alpha.value
			#self.saveConfig()

	def keyRight(self):
		if is_process_running(self.browser_name) == False:
			ConfigListScreen.keyRight(self)
			alpha_value = self.alpha.value
			#self.saveConfig()

	def keyCancel(self):
		if is_process_running(self.browser_name) == False:
			self.doExit()
		self.exit_wait_cond = True
		self.timer_exit_cond.start(5000)

	# mouse:keyboard:alpha_value
	def saveConfig(self):
		if is_process_running(self.browser_name) == False:
			command = "echo \"%s:%s:%d:%s\" > %s"%(self.mouse.value, self.keyboard.value, int(self.alpha.value), self.langs.value, self.conf_file)
			excute_cmd(command)

	# mouse:keyboard:alpha_value
	def loadConfig(self):
		if os.path.exists(self.conf_file) == False:
			return
		config_list = open(self.conf_file).readline().strip().split(':')
		if len(config_list) == 3:
			self.conf_mouse 	= config_list[0]
			self.conf_keyboard 	= config_list[1]
			self.conf_alpha 	= config_list[2]
		elif len(config_list) == 4:
			self.conf_mouse 	= config_list[0]
			self.conf_keyboard 	= config_list[1]
			self.conf_alpha 	= config_list[2]
			self.conf_keymap 	= config_list[3]
		print "load config : ", config_list

	def resetExitCond(self):
		self.timer_exit_cond.stop()
		self.exit_wait_cond = False

	def makeConfig(self):
		self.loadConfig()
		self.createConfig()


	def createConfig(self):
		self.name_list  = []
		self.mouse_list = None
		self.keyboard_list = None
		
		self.devices = [(x, iInputDevices.getDeviceName(x).replace("dreambox advanced remote control (native)", "Remote Control").replace("dreambox front panel", "Front Panel") + "(" + x  + ")") for x in iInputDevices.getDeviceList()]

		if self.conf_mouse == "":
			self.conf_mouse = "event1"
		self.mouse = ConfigSelection(default = self.conf_mouse, choices = self.devices)
		self.list.append(getConfigListEntry(_('Mouse'), _(self.mouse)))		

		if self.conf_keyboard == "":
			self.conf_keyboard = "event1"
		self.keyboard = ConfigSelection(default = self.conf_keyboard, choices = self.devices)
		self.list.append(getConfigListEntry(_('Keyboard'), _(self.keyboard)))

		if self.conf_alpha == "":
			self.conf_alpha = "255"
		self.alpha = ConfigSlider(default = int(self.conf_alpha), increment = 10, limits = (0, 255))
		self.list.append(getConfigListEntry(_("Alpha Value"), self.alpha))

		if self.conf_keymap == "":
			self.conf_keymap = self.getLanguage()
		self.lang_list = [("en", "English"), ("de", "German")]
		self.langs = ConfigSelection(default = self.conf_keymap, choices = self.lang_list)
		self.list.append(getConfigListEntry(_("Language"), self.langs))

		self["config"].list = self.list
		self["config"].l.setList(self.list)

	def getLanguage(self, lang=language.getLanguage()):
		if self.current_lang_idx == 1:
			return "de"
		return "en"
		

	def startBrowser(self):
		self.timer_start.stop()

		self.lock = True
		excute_cmd("killall -15 %s"%(self.browser_name))
		excute_cmd("echo 0 > /proc/sys/vm/swappiness")

		kbd_cmd = " "
		mouse_cmd = " "
		extra_cmd = " " 
		browser_cmd = "%s/%s -qws" % (self.browser_root, self.browser_name)

		mouse_param = self.mouse.value

		keyboard_param = self.keyboard.value

		keymap_param = ""
		if self.langs.value == "de":
			keymap_param = ":keymap=/usr/share/keymaps/player/de.qmap"

		cmd = "%s%s%s%s" % (extra_cmd, kbd_cmd, mouse_cmd, browser_cmd)
		print "prepared command : [%s]" % cmd

		self.launcher = eConsoleAppContainer()
		self.launcher.appClosed.append(self.callbackLauncherAppClosed)
		self.launcher.dataAvail.append(self.callbackLauncherDataAvail)

		fbClass.getInstance().lock()
		#eRCInput.getInstance().lock()

		global alpha_value
		alpha_value = self.alpha.value
		change_galpha(set_const=True, set_value=True)

		self.launcher.execute(cmd)
		print "started browser..."

	def keyGo(self):
		self.saveConfig()
		self.info.setText("Starting Webbrowser. Please wait...")
		if self.lock == False:
			if self.langs.value == "de":
				language.activateLanguageIndex(1)
			else:
				language.activateLanguageIndex(0)
			self.timer_start = eTimer()
			self.timer_start.callback.append(self.startBrowser)
			self.timer_start.start(10)

	def callbackLauncherDataAvail(self, ret_data):
		print ret_data
		if ret_data.startswith("--done--"):
			self.lock = False
			self.doExit()

	def callbackLauncherAppClosed(self, retval = 1):
		self.lock = False
コード例 #25
0
    def __init__(self, session, selectedmovie=None):
        #		print "[SF-Plugin] SF:MovieSelection.init, PWD=%s; selmv=%s" % (config.movielist.last_videodir.value, str(selectedmovie))
        Screen.__init__(self, session)
        HelpableScreen.__init__(self)

        self.tags = []
        if selectedmovie:
            self.selected_tags = config.movielist.last_selected_tags.value
        else:
            self.selected_tags = None
        self.selected_tags_ele = None
        self.toggletype = 0

        self.movemode = False
        self.bouquet_mark_edit = False

        self.delayTimer = eTimer()
        self.delayTimer.callback.append(self.updateHDDData)

        self["waitingtext"] = Label(_("Please wait... Loading list..."))

        # create optional description border and hide immediately
        self["DescriptionBorder"] = Pixmap()
        self["DescriptionBorder"].hide()

        if not fileExists(config.movielist.last_videodir.value):
            config.movielist.last_videodir.value = defaultMoviePath()
            config.movielist.last_videodir.save()
#			print "[SF-Plugin] MovieSelection.MovieSelection: save" + config.movielist.last_videodir.value
        self.current_ref = eServiceReference(
            "2:0:1:0:0:0:0:0:0:0:" + config.movielist.last_videodir.value)

        self["list"] = MovieList(
            None, config.movielist.sflisttype.value,
            config.movielist.sfmoviesort.value, config.movielist.sftimes.value,
            config.movielist.sftitle_episode_separator.value, self)

        self.list = self["list"]
        self.selectedmovie = selectedmovie

        # Need list for init
        SelectionEventInfo.__init__(self)

        self["key_red"] = Button(_("All"))
        self["key_green"] = Button("")
        self["key_yellow"] = Button("")
        self["key_blue"] = Button("")

        self["freeDiskSpace"] = self.diskinfo = DiskInfo(
            config.movielist.last_videodir.value, DiskInfo.FREE, update=False)

        if config.usage.setup_level.index >= 2:  # expert+
            self["InfobarActions"] = HelpableActionMap(
                self, "InfobarActions", {
                    "showMovies":
                    (self.doPathSelect, _("select the movie path")),
                })

        self["MovieSelectionActions"] = HelpableActionMap(
            self, "MovieSelectionActions", {
                "contextMenu": (self.doContext, _("menu")),
                "showEventInfo":
                (self.showEventInformation, _("show event details")),
            })

        self["ColorActions"] = HelpableActionMap(
            self, "ColorActions", {
                "red": (self.showAll, _("show all")),
                "green": (self.showTagsFirst, _("show first selected tag")),
                "yellow": (self.showTagsSecond, _("show second selected tag")),
                "blue": (self.showTagsSelect, _("show tag menu")),
            })

        self["OkCancelActions"] = HelpableActionMap(
            self, "OkCancelActions", {
                "cancel": (self.abort, _("exit movielist")),
                "ok": (self.movieSelected, _("select movie")),
            })

        self["NumberActions"] = HelpableActionMap(
            self, "SetupActions", {
                "0":
                (self.toggleSort, _x("Toggle date / alphabetic sort mode")),
                "deleteBackward":
                (self.moveToIndexStrt, _x("Jump to listbegin")),
                "deleteForward": (self.moveToIndexEnd, _x("Jump to listend")),
                "5":
                (self.toggleMinimal, _x("Toggle style minimal / compact")),
                "8":
                (self.toggleTags, _x("Toggle description / tags display")),
            })

        self.onShown.append(self.go)
        self.onLayoutFinish.append(self.saveListsize)
        self.inited = False
コード例 #26
0
ファイル: plugin.py プロジェクト: ahmedmoselhi/easy-ui-4
	def __init__(self, session, parent):
		Screen.__init__(self, session)
		self["text1"] =  Label("SHOUTcast")
		self["text2"] = Label("")
コード例 #27
0
ファイル: plugin.py プロジェクト: ahmedmoselhi/easy-ui-4
	def __init__(self, session):
		self.session = session
		Screen.__init__(self, session)
		self.oldtitle = None
		self.currentcoverfile = 0
		self.currentGoogle = None
		self.nextGoogle = None
		self.currPlay = None
		self.CurrentService = self.session.nav.getCurrentlyPlayingServiceReference()
		self.session.nav.stopService()
		self.session.nav.event.append(self.__event)
		self["cover"] = Cover()
		self["key_red"] = StaticText(_("Record"))
		self["key_green"] = StaticText(_("Genres"))
		self["key_yellow"] = StaticText(_("Stations"))
		self["key_blue"] = StaticText(_("Favorites"))
		self.mode = self.FAVORITELIST
		self["list"] = SHOUTcastList()
		self["list"].connectSelChanged(self.onSelectionChanged)
		self["statustext"] = Label(_("Getting SHOUTcast genre list..."))
		self["actions"] = ActionMap(["WizardActions", "DirectionActions", "ColorActions", "EPGSelectActions"],
		{
			"ok": self.ok_pressed,
			"back": self.close,
			"menu": self.menu_pressed,
			"red": self.red_pressed,
			"green": self.green_pressed,
			"yellow": self.yellow_pressed,
			"blue": self.blue_pressed,
			
		}, -1)
		self.stationList = []
		self.stationListIndex = 0
		self.genreList = []
		self.genreListIndex = 0
		self.favoriteList = []
		self.favoriteListIndex = 0

		self.favoriteConfig = Config()
		if os.path.exists(self.FAVORITE_FILE):
			self.favoriteConfig.loadFromFile(self.FAVORITE_FILE)
		elif os.path.exists(self.FAVORITE_FILE_OLD):
			self.favoriteConfig.loadFromFile(self.FAVORITE_FILE_OLD)
		else:
			self.favoriteConfig.loadFromFile(self.FAVORITE_FILE_DEFAULT)
		self.favoriteConfig.entriescount =  ConfigInteger(0)
		self.favoriteConfig.Entries = ConfigSubList()
		self.initFavouriteConfig()
		self.stationListXML = ""
		self["titel"] = Label()
		self["station"] = Label()
		self["headertext"] = Label()
		self["console"] = Label()
		self.headerTextString = ""
		self.stationListHeader = ""
		self.tunein = ""
		self.searchSHOUTcastString = ""
		self.currentStreamingURL = ""
		self.currentStreamingStation = ""
		self.stationListURL = ""
		self.onClose.append(self.__onClose)
		self.onLayoutFinish.append(self.getFavoriteList)

		self.reloadStationListTimer = eTimer()
		self.reloadStationListTimer.timeout.get().append(self.reloadStationListTimerTimeout)
		self.reloadStationListTimerVar = int(config.plugins.shoutcast.reloadstationlist.value)

		self.visible = True

		global containerStreamripper
		if containerStreamripper is None:
			containerStreamripper = eConsoleAppContainer()

		containerStreamripper.dataAvail.append(self.streamripperDataAvail)
		containerStreamripper.appClosed.append(self.streamripperClosed)

		if containerStreamripper.running():
			self["key_red"].setText(_("Stop record"))
			# just to hear to recording music when starting the plugin...
			self.currentStreamingStation = _("Recording stream station")
			self.playServiceStream("http://localhost:9191")
コード例 #28
0
ファイル: EpgSelection.py プロジェクト: Akki01/enigma2-test
    def __init__(self,
                 session,
                 service,
                 zapFunc=None,
                 eventid=None,
                 bouquetChangeCB=None,
                 serviceChangeCB=None):
        Screen.__init__(self, session)
        self.bouquetChangeCB = bouquetChangeCB
        self.serviceChangeCB = serviceChangeCB
        self.ask_time = -1  #now
        self["key_red"] = Button("")
        self.closeRecursive = False
        self.saved_title = None
        self["Service"] = ServiceEvent()
        self["Event"] = Event()
        self.session = session
        if isinstance(service, str) and eventid != None:
            self.type = EPG_TYPE_SIMILAR
            self["key_yellow"] = Button()
            self["key_blue"] = Button()
            self["key_red"] = Button()
            self.currentService = service
            self.eventid = eventid
            self.zapFunc = None
        elif isinstance(service, eServiceReference) or isinstance(
                service, str):
            self.type = EPG_TYPE_SINGLE
            self["key_yellow"] = Button()
            self["key_blue"] = Button(_("Select Channel"))
            self.currentService = ServiceReference(service)
            self.zapFunc = zapFunc
            self.sort_type = 0
            self.setSortDescription()
        else:
            self.skinName = "EPGSelectionMulti"
            self.type = EPG_TYPE_MULTI
            self["key_yellow"] = Button(
                pgettext("button label, 'previous screen'", "Prev"))
            self["key_blue"] = Button(
                pgettext("button label, 'next screen'", "Next"))
            self["now_button"] = Pixmap()
            self["next_button"] = Pixmap()
            self["more_button"] = Pixmap()
            self["now_button_sel"] = Pixmap()
            self["next_button_sel"] = Pixmap()
            self["more_button_sel"] = Pixmap()
            self["now_text"] = Label()
            self["next_text"] = Label()
            self["more_text"] = Label()
            self["date"] = Label()
            self.services = service
            self.zapFunc = zapFunc
        self["key_green"] = Button(_("Add timer"))
        self.key_green_choice = self.ADD_TIMER
        self.key_red_choice = self.EMPTY
        self["list"] = EPGList(type=self.type,
                               selChangedCB=self.onSelectionChanged,
                               timer=session.nav.RecordTimer)

        self["actions"] = ActionMap(
            ["EPGSelectActions", "OkCancelActions"],
            {
                "cancel": self.closeScreen,
                "ok": self.eventSelected,
                "timerAdd": self.timerAdd,
                "yellow": self.yellowButtonPressed,
                "blue": self.blueButtonPressed,
                "info": self.infoKeyPressed,
                "red": self.zapTo,
                "menu": self.furtherOptions,
                "nextBouquet": self.nextBouquet,  # just used in multi epg yet
                "prevBouquet": self.prevBouquet,  # just used in multi epg yet
                "nextService": self.nextService,  # just used in single epg yet
                "prevService": self.prevService,  # just used in single epg yet
                "preview": self.eventPreview,
            })
        self["actions"].csel = self
        self.onLayoutFinish.append(self.onCreate)
コード例 #29
0
    def __init__(self, session, args=0):
        print("[MakeBouquet][__init__] Starting...")
        print("[MakeBouquet][__init__] args", args)
        self.session = session
        Screen.__init__(self, session)
        Screen.setTitle(self, _("MakeBouquet"))
        self.skinName = ["TerrestrialScan"]

        self.path = "/etc/enigma2"
        self.services_dict = {}
        self.tmp_services_dict = {}
        self.namespace_dict = {
        }  # to store namespace when sub network is enabled
        self.logical_channel_number_dict = {}
        self.ignore_visible_service_flag = False  # make this a user override later if found necessary
        self.VIDEO_ALLOWED_TYPES = [1, 4, 5, 17, 22, 24, 25, 27, 135]
        self.AUDIO_ALLOWED_TYPES = [2, 10]
        self.BOUQUET_PREFIX = "userbouquet.TerrestrialScan."
        self.bouquetsIndexFilename = "bouquets.tv"
        self.bouquetFilename = self.BOUQUET_PREFIX + "tv"
        self.bouquetName = _('Terrestrial')
        self.namespace_complete_terrestrial = not (
            config.usage.subnetwork_terrestrial.value if hasattr(
                config.usage, "subnetwork_terrestrial") else True
        )  # config.usage.subnetwork not available in all images

        self.terrestrialXmlFilename = "terrestrial.xml"

        self.frontend = None
        self.rawchannel = None

        self["background"] = Pixmap()
        self["action"] = Label(_("Starting scanner"))
        self["status"] = Label("")
        self["progress"] = ProgressBar()
        self["progress_text"] = Progress()
        self["tuner_text"] = Label("")
        self["Frontend"] = FrontendStatus(
            frontend_source=lambda: self.frontend, update_interval=100)

        self["actions"] = ActionMap(["SetupActions"], {
            "cancel": self.keyCancel,
        }, -2)

        self.selectedNIM = -1
        self.transponders_unique = {}
        self.FTA_only = False
        self.makebouquet = True
        self.makexmlfile = False
        self.lcndescriptor = 0x83
        self.channel_list_id = 0
        if args:
            if "feid" in args:
                self.selectedNIM = args["feid"]
            if "transponders_unique" in args:
                self.transponders_unique = args["transponders_unique"]
            if "FTA_only" in args:
                self.FTA_only = args["FTA_only"]
            if "makebouquet" in args:
                self.makebouquet = args["makebouquet"]
            if "makexmlfile" in args:
                self.makexmlfile = args["makexmlfile"]
            if "lcndescriptor" in args:
                self.lcndescriptor = args["lcndescriptor"]
            if "channel_list_id" in args:
                self.channel_list_id = args["channel_list_id"]

        self.tsidOnidKeys = list(self.transponders_unique.keys())
        self.index = 0
        self.lockTimeout = 50  # 100ms for tick - 5 sec

        self.onClose.append(self.__onClose)
        self.onFirstExecBegin.append(self.firstExec)
コード例 #30
0
ファイル: Menu.py プロジェクト: catalinii/enigma2
    def __init__(self, session, parent):
        Screen.__init__(self, session)
        HelpableScreen.__init__(self)
        self.parentMenu = parent
        self.menuList = []
        self["menu"] = List(self.menuList)
        self["menu"].enableWrapAround = True
        self["menu"].onSelectionChanged.append(self.selectionChanged)
        self.showNumericHelp = False
        self["green"] = Label()
        self["yellow"] = Label()
        self["blue"] = Label()
        self.sort_mode = False
        self.selected_entry = None
        self.sub_menu_sort = None
        self.createMenuList()
        ProtectedScreen.__init__(self)
        # for the skin: first try a menu_<menuID>, then Menu
        self.skinName = []
        if self.menuID is not None:
            if config.usage.menutype.value == "horzanim" and findSkinScreen(
                    "Animmain"):
                self.skinName.append("Animmain")
            elif config.usage.menutype.value == "horzicon" and findSkinScreen(
                    "Iconmain"):
                self.skinName.append("Iconmain")
            else:
                self.skinName.append("menu_" + self.menuID)
        self.skinName.append("Menu")

        if config.usage.menu_sort_mode.value == "user":

            self["MoveActions"] = ActionMap(
                ["WizardActions"], {
                    "left": self.keyLeft,
                    "right": self.keyRight,
                    "up": self.keyUp,
                    "down": self.keyDown,
                }, -1)
            self["EditActions"] = ActionMap(
                ["ColorActions"], {
                    "green": self.keyGreen,
                    "yellow": self.keyYellow,
                    "blue": self.keyBlue,
                })

        self["menuActions"] = HelpableNumberActionMap(
            self, ["OkCancelActions", "NumberActions", "MenuActions"], {
                "ok": (self.okbuttonClick, _("Select the current menu item")),
                "cancel": (self.closeNonRecursive, _("Exit menu")),
                "close": (self.closeRecursive, _("Exit all menus")),
                "menu": (self.closeRecursive, _("Exit all menus")),
                "1": (self.keyNumberGlobal, _("Direct menu item selection")),
                "2": (self.keyNumberGlobal, _("Direct menu item selection")),
                "3": (self.keyNumberGlobal, _("Direct menu item selection")),
                "4": (self.keyNumberGlobal, _("Direct menu item selection")),
                "5": (self.keyNumberGlobal, _("Direct menu item selection")),
                "6": (self.keyNumberGlobal, _("Direct menu item selection")),
                "7": (self.keyNumberGlobal, _("Direct menu item selection")),
                "8": (self.keyNumberGlobal, _("Direct menu item selection")),
                "9": (self.keyNumberGlobal, _("Direct menu item selection")),
                "0": (self.keyNumberGlobal, _("Direct menu item selection"))
            },
            prio=0,
            description=_("Common Menu Actions"))
        title = parent.get("title", "").encode("UTF-8") if PY2 else parent.get(
            "title", "") or None
        title = title and _(title)
        if title is None:
            title = _(parent.get("text", "").encode(
                "UTF-8", "ignore")) if PY2 else _(parent.get("text", ""))
        else:
            t_history.reset()
        self["title"] = StaticText(title)
        self.setTitle(title)
        self.menu_title = title
        self["thistory"] = StaticText(t_history.thistory)
        history_len = len(t_history.thistory)
        self["title0"] = StaticText("")
        self["title1"] = StaticText("")
        self["title2"] = StaticText("")
        if history_len < 13:
            self["title0"] = StaticText(title)
        elif history_len < 21:
            self["title0"] = StaticText("")
            self["title1"] = StaticText(title)
        else:
            self["title0"] = StaticText("")
            self["title1"] = StaticText("")
            self["title2"] = StaticText(title)
        if t_history.thistory == "":
            t_history.thistory = str(title) + " > "
        else:
            t_history.thistory = t_history.thistory + str(title) + " > "
        if config.usage.menutype.value == "horzanim" and findSkinScreen(
                "Animmain"):
            self["label1"] = StaticText()
            self["label2"] = StaticText()
            self["label3"] = StaticText()
            self["label4"] = StaticText()
            self["label5"] = StaticText()
            self.onShown.append(self.openTestA)
        elif config.usage.menutype.value == "horzicon" and findSkinScreen(
                "Iconmain"):
            self["label1"] = StaticText()
            self["label2"] = StaticText()
            self["label3"] = StaticText()
            self["label4"] = StaticText()
            self["label5"] = StaticText()
            self["label6"] = StaticText()
            self["label1s"] = StaticText()
            self["label2s"] = StaticText()
            self["label3s"] = StaticText()
            self["label4s"] = StaticText()
            self["label5s"] = StaticText()
            self["label6s"] = StaticText()
            self["pointer"] = Pixmap()
            self["pixmap1"] = Pixmap()
            self["pixmap2"] = Pixmap()
            self["pixmap3"] = Pixmap()
            self["pixmap4"] = Pixmap()
            self["pixmap5"] = Pixmap()
            self["pixmap6"] = Pixmap()
            self.onShown.append(self.openTestB)
        self.number = 0
        self.nextNumberTimer = eTimer()
        self.nextNumberTimer.callback.append(self.okbuttonClick)
        if len(self.menuList) == 1:
            self.onExecBegin.append(self.__onExecBegin)
        self.onLayoutFinish.append(self.layoutFinished)
コード例 #31
0
ファイル: PluginBrowser.py プロジェクト: igor20192/enigma2-2
	def __init__(self, session, type = 0, needupdate = True, menu_path="", skin_name=None):
		Screen.__init__(self, session)
		self.menu_path = menu_path
		self.type = type
		self.needupdate = needupdate
		self.skinName = ["PluginDownloadBrowser"]
		if isinstance(skin_name, str):
			self.skinName.insert(0,skin_name)

		self["menu_path_compressed"] = StaticText("")
		if self.type == self.DOWNLOAD:
			config.misc.pluginbrowser.po.value = True
			screentitle = _("Install plugins")
			if config.usage.show_menupath.value == 'large':
				self.menu_path += screentitle
				title = self.menu_path
				self["menu_path_compressed"].setText("")
			elif config.usage.show_menupath.value == 'small':
				title = screentitle
				self["menu_path_compressed"].setText(self.menu_path + " >" if not self.menu_path.endswith(' / ') else self.menu_path[:-3] + " >" or "")
			else:
				title = screentitle
				self["menu_path_compressed"].setText("")
		elif self.type == self.REMOVE:
			config.misc.pluginbrowser.po.value = False
			screentitle = _("Remove plugins")
			if config.usage.show_menupath.value == 'large':
				self.menu_path += screentitle
				title = self.menu_path
				self["menu_path_compressed"].setText("")
			elif config.usage.show_menupath.value == 'small':
				title = screentitle
				self["menu_path_compressed"].setText(self.menu_path + " >" if not self.menu_path.endswith(' / ') else self.menu_path[:-3] + " >" or "")
			else:
				title = screentitle
				self["menu_path_compressed"].setText("")
		self.setTitle(title)
		self.createPluginFilter()
		self.LanguageList = language.getLanguageListSelection()
		self.container = eConsoleAppContainer()
		self.container.appClosed.append(self.runFinished)
		self.container.dataAvail.append(self.dataAvail)
		self.onLayoutFinish.append(self.startRun)

		self.list = []
		self["list"] = PluginList(self.list)
		self.pluginlist = []
		self.expanded = []
		self.installedplugins = []
		self.plugins_changed = False
		self.reload_settings = False
		self.check_settings = False
		self.check_bootlogo = False
		self.install_settings_name = ''
		self.remove_settings_name = ''
		self.onChangedEntry = []
		self["list"].onSelectionChanged.append(self.selectionChanged)

		if self.type == self.DOWNLOAD:
			self["text"] = Label(_("Downloading plugin information. Please wait..."))
		elif self.type == self.REMOVE:
			self["text"] = Label(_("Getting plugin information. Please wait..."))

		self.run = 0
		self.remainingdata = ""
		self["actions"] = ActionMap(["WizardActions"],
		{
			"ok": self.go,
			"back": self.requestClose,
		})
		if os.path.isfile('/usr/bin/opkg'):
			self.ipkg = '/usr/bin/opkg'
			self.ipkg_install = self.ipkg + ' install'
			self.ipkg_remove =  self.ipkg + ' remove --autoremove'
		else:
			self.ipkg = 'ipkg'
			self.ipkg_install = 'ipkg install -force-defaults'
			self.ipkg_remove =  self.ipkg + ' remove'
コード例 #32
0
    def populate(self):
        if isVTISkin:
            self['EnigmaVersion'] = StaticText(
                _('Version') + ': ' + about.getEnigmaVersionString())
            self['ImageVersion'] = StaticText(
                _('Image') + ': ' + about.getImageVersionString())
            self['TunerHeader'] = StaticText(_('Detected NIMs:'))
            fp_version = getFPVersion()
            if fp_version is None:
                fp_version = ''
            else:
                fp_version = _('Frontprocessor version: %d') % fp_version
            self['FPVersion'] = StaticText(fp_version)
            nims = nimmanager.nimList()
            self.tuner_list = []
            if len(nims) <= 4:
                for count in (0, 1, 2, 3, 4, 5, 6, 7):
                    if count < len(nims):
                        self['Tuner' + str(count)] = StaticText(nims[count])
                        self.tuner_list.append(nims[count] + '\n')
                    else:
                        self['Tuner' + str(count)] = StaticText('')

            else:
                desc_list = []
                count = 0
                cur_idx = -1
                while count < len(nims):
                    data = nims[count].split(':')
                    idx = data[0].strip('Tuner').strip()
                    desc = data[1].strip()
                    if desc_list and desc_list[cur_idx]['desc'] == desc:
                        desc_list[cur_idx]['end'] = idx
                    else:
                        desc_list.append({
                            'desc': desc,
                            'start': idx,
                            'end': idx
                        })
                        cur_idx += 1
                    count += 1

                for count in (0, 1, 2, 3, 4, 5, 6, 7):
                    if count < len(desc_list):
                        if desc_list[count]['start'] == desc_list[count][
                                'end']:
                            text = 'Tuner %s: %s' % (desc_list[count]['start'],
                                                     desc_list[count]['desc'])
                        else:
                            text = 'Tuner %s-%s: %s' % (
                                desc_list[count]['start'],
                                desc_list[count]['end'],
                                desc_list[count]['desc'])
                    else:
                        text = ''
                    self['Tuner' + str(count)] = StaticText(text)
                    if text != '':
                        self.tuner_list.append(text + '\n')

            self['HDDHeader'] = StaticText(_('Detected HDD:'))
            hddlist = harddiskmanager.HDDList()
            hdd = hddlist and hddlist[0][1] or None
            if hdd is not None and hdd.model() != '':
                self['hddA'] = StaticText(
                    _('%s\n(%s, %d MB free)') %
                    (hdd.model(), hdd.capacity(), hdd.free()))
            else:
                self['hddA'] = StaticText(_('none'))
            self.enigma2_version = _(
                'Version') + ': ' + about.getEnigmaVersionString()
            self.image_version = _(
                'EGAMI ') + ': ' + about.getImageVersionString()
            cpu_info = parseLines('/proc/cpuinfo')
            cpu_name = 'N/A'
            for line in cpu_info:
                if line.find('model') != -1:
                    cpu_name = line.split(':')
                    if len(cpu_name) >= 2:
                        cpu_name = cpu_name[1].strip()
                    break

            self.cpu = _('CPU') + ': ' + cpu_name
            self.chipset = _('Chipset') + ': ' + parseFile(
                '/proc/stb/info/chipset')
            self.tuner_header = _('Detected NIMs:')
            self.hdd_header = _('Detected HDD:')
            self.hdd_list = []
            if len(hddlist):
                for hddX in hddlist:
                    hdd = hddX[1]
                    if hdd.model() != '':
                        self.hdd_list.append(
                            hdd.model() + '\n   %.2f GB - %.2f GB' %
                            (hdd.diskSize() / 1000.0, hdd.free() / 1000.0) +
                            ' ' + _('free') + '\n\n')

            ifaces = iNetwork.getConfiguredAdapters()
            iface_list = []
            for iface in ifaces:
                iface_list.append(
                    _('Interface') + ' : ' + iNetwork.getAdapterName(iface) +
                    ' (' + iNetwork.getFriendlyAdapterName(iface) + ')\n')
                iface_list.append(
                    _('IP') + ' : ' +
                    parse_ipv4(iNetwork.getAdapterAttribute(iface, 'ip')) +
                    '\n')
                iface_list.append(
                    _('Netmask') + ' : ' + parse_ipv4(
                        iNetwork.getAdapterAttribute(iface, 'netmask')) + '\n')
                iface_list.append(
                    _('Gateway') + ' : ' + parse_ipv4(
                        iNetwork.getAdapterAttribute(iface, 'gateway')) + '\n')
                if iNetwork.getAdapterAttribute(iface, 'dhcp'):
                    iface_list.append(_('DHCP') + ' : ' + _('Yes') + '\n')
                else:
                    iface_list.append(_('DHCP') + ' : ' + _('No') + '\n')
                iface_list.append(
                    _('MAC') + ' : ' +
                    iNetwork.getAdapterAttribute(iface, 'mac') + '\n')
                iface_list.append('\n')

            my_txt = self.enigma2_version + '\n'
            my_txt += self.image_version + '\n'
            my_txt += '\n'
            my_txt += self.cpu + '\n'
            my_txt += self.chipset + '\n'
            my_txt += '\n'
            my_txt += self.tuner_header + '\n'
            for x in self.tuner_list:
                my_txt += '   ' + x

            my_txt += '\n'
            my_txt += _('Network') + ':\n'
            for x in iface_list:
                my_txt += '   ' + x

            my_txt += self.hdd_header + '\n'
            for x in self.hdd_list:
                my_txt += '   ' + x

            my_txt += '\n'
            self['FullAbout'] = ScrollLabel(my_txt)
        else:
            EGAMIVersion = _('EGAMI %s') % about.getImageVersionString()
            self['lab1'] = Label(EGAMIVersion)
            model = None
            AboutText = getAboutText()[0]
            self['AboutScrollLabel'] = ScrollLabel(AboutText)
コード例 #33
0
 def __init__(self, session, parent):
     Screen.__init__(self, session)
     self["text1"] = Label("Playing")
     self["text2"] = Label("")
     self["text3"] = Label("")
     self["text4"] = Label("")
コード例 #34
0
	def __init__(self, session, infobar):
		Screen.__init__(self, session)
		self.infobar = infobar or self.session.infobar

		self.wait = eTimer()
		self.wait.timeout.get().append(self.resyncSubtitles)

		self.resume = eTimer()
		self.resume.timeout.get().append(self.resyncSubtitlesResume)

		self["videofps"] = Label("")

		sub = self.infobar.selected_subtitle
		if sub[0] == 0:  # dvb
			menu = [
				getConfigMenuItem("config.subtitles.dvb_subtitles_yellow"),
				getConfigMenuItem("config.subtitles.dvb_subtitles_centered"),
				getConfigMenuItem("config.subtitles.dvb_subtitles_backtrans"),
				getConfigMenuItem("config.subtitles.dvb_subtitles_original_position"),
				getConfigMenuItem("config.subtitles.subtitle_position"),
				getConfigMenuItem("config.subtitles.subtitle_bad_timing_delay"),
				getConfigMenuItem("config.subtitles.subtitle_noPTSrecordingdelay"),
			]
		elif sub[0] == 1: # teletext
			menu = [
				getConfigMenuItem("config.subtitles.ttx_subtitle_colors"),
				getConfigMenuItem("config.subtitles.ttx_subtitle_original_position"),
				getConfigMenuItem("config.subtitles.subtitle_fontsize"),
				getConfigMenuItem("config.subtitles.subtitle_position"),
				getConfigMenuItem("config.subtitles.subtitle_rewrap"),
				getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
				getConfigMenuItem("config.subtitles.subtitle_alignment"),
				getConfigMenuItem("config.subtitles.subtitle_bad_timing_delay"),
				getConfigMenuItem("config.subtitles.subtitle_noPTSrecordingdelay"),
			]
		else: 		# pango
			menu = [
				getConfigMenuItem("config.subtitles.pango_subtitles_delay"),
				getConfigMenuItem("config.subtitles.pango_subtitle_colors"),
				getConfigMenuItem("config.subtitles.pango_subtitle_fontswitch"),
				getConfigMenuItem("config.subtitles.colourise_dialogs"),
				getConfigMenuItem("config.subtitles.subtitle_fontsize"),
				getConfigMenuItem("config.subtitles.subtitle_position"),
				getConfigMenuItem("config.subtitles.subtitle_alignment"),
				getConfigMenuItem("config.subtitles.subtitle_rewrap"),
				getConfigMenuItem("config.subtitles.pango_subtitle_removehi"),
				getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
				getConfigMenuItem("config.subtitles.pango_subtitles_fps"),
			]
			self["videofps"].setText(_("Video: %s fps") % (self.getFps().rstrip(".000")))

		ConfigListScreen.__init__(self, menu, self.session, on_change = self.changedEntry)

		self["actions"] = NumberActionMap(["SetupActions"],
		{
			"cancel": self.cancel,
			"ok": self.ok,
			"1": self.keyNumber,
			"3": self.keyNumber,
			"4": self.keyNumber,
			"6": self.keyNumber,
			"7": self.keyNumber,
			"9": self.keyNumber,
			"0": self.keyNumber,
		},-2)

		self.onLayoutFinish.append(self.layoutFinished)
コード例 #35
0
	def setText(self, text):
		text = (self.displayLength * ' ') + text
		self.longText = text
		self.offset = 0
		Label.setText(self, text[:self.displayLength].encode('utf-8', 'ignore'))
コード例 #36
0
ファイル: DVD.py プロジェクト: kingvuplus/Test-OBH
	def __init__(self, session, dvd_device = None, dvd_filelist = [ ], args = None):
		Screen.__init__(self, session)
		InfoBarBase.__init__(self)
		InfoBarNotifications.__init__(self)
		InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
		InfoBarShowHide.__init__(self)
		InfoBarAudioSelection.__init__(self)
		InfoBarSubtitleSupport.__init__(self)
		HelpableScreen.__init__(self)
		self.save_infobar_seek_config()
		self.change_infobar_seek_config()
		InfoBarSeek.__init__(self)
		InfoBarPVRState.__init__(self)

		self.oldService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
		self.session.nav.stopService()
		self["audioLabel"] = Label("n/a")
		self["subtitleLabel"] = Label("")
		self["angleLabel"] = Label("")
		self["chapterLabel"] = Label("")
		self["anglePix"] = Pixmap()
		self["anglePix"].hide()
		self.last_audioTuple = None
		self.last_subtitleTuple = None
		self.last_angleTuple = None
		self.totalChapters = 0
		self.currentChapter = 0
		self.totalTitles = 0
		self.currentTitle = 0

		self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
			{
				iPlayableService.evStopped: self.__serviceStopped,
				iPlayableService.evUser: self.__timeUpdated,
				iPlayableService.evUser+1: self.__statePlay,
				iPlayableService.evUser+2: self.__statePause,
				iPlayableService.evUser+3: self.__osdFFwdInfoAvail,
				iPlayableService.evUser+4: self.__osdFBwdInfoAvail,
				iPlayableService.evUser+5: self.__osdStringAvail,
				iPlayableService.evUser+6: self.__osdAudioInfoAvail,
				iPlayableService.evUser+7: self.__osdSubtitleInfoAvail,
				iPlayableService.evUser+8: self.__chapterUpdated,
				iPlayableService.evUser+9: self.__titleUpdated,
				iPlayableService.evUser+11: self.__menuOpened,
				iPlayableService.evUser+12: self.__menuClosed,
				iPlayableService.evUser+13: self.__osdAngleInfoAvail
			})

		self["DVDPlayerDirectionActions"] = ActionMap(["DirectionActions"],
			{
				#MENU KEY DOWN ACTIONS
				"left": self.keyLeft,
				"right": self.keyRight,
				"up": self.keyUp,
				"down": self.keyDown,

				#MENU KEY REPEATED ACTIONS
				"leftRepeated": self.doNothing,
				"rightRepeated": self.doNothing,
				"upRepeated": self.doNothing,
				"downRepeated": self.doNothing,

				#MENU KEY UP ACTIONS
				"leftUp": self.doNothing,
				"rightUp": self.doNothing,
				"upUp": self.doNothing,
				"downUp": self.doNothing,
			})

		self["OkCancelActions"] = ActionMap(["OkCancelActions"],
			{
				"ok": self.keyOk,
				"cancel": self.keyCancel,
			})

		self["DVDPlayerPlaybackActions"] = HelpableActionMap(self, "DVDPlayerActions",
			{
				#PLAYER ACTIONS
				"dvdMenu": (self.enterDVDMenu, _("show DVD main menu")),
				"toggleInfo": (self.toggleInfo, _("toggle time, chapter, audio, subtitle info")),
				"nextChapter": (self.nextChapter, _("forward to the next chapter")),
				"prevChapter": (self.prevChapter, _("rewind to the previous chapter")),
				"nextTitle": (self.nextTitle, _("jump forward to the next title")),
				"prevTitle": (self.prevTitle, _("jump back to the previous title")),
				"tv": (self.askLeavePlayer, _("exit DVD player or return to file browser")),
				"dvdAudioMenu": (self.enterDVDAudioMenu, _("(show optional DVD audio menu)")),
				"AudioSelection": (self.enterAudioSelection, _("Select audio track")),
				"nextAudioTrack": (self.nextAudioTrack, _("switch to the next audio track")),
				"nextSubtitleTrack": (self.nextSubtitleTrack, _("switch to the next subtitle language")),
				"nextAngle": (self.nextAngle, _("switch to the next angle")),
				"seekBeginning": self.seekBeginning,
			}, -2)

		self["DVDPlayerColorActions"] = HelpableActionMap(self, "ColorActions",
			{
				"blue": (self.chapterZap, _("jump to chapter by number")),
			}, -2)

		self.onClose.append(self.__onClose)

		try:
			from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
			hotplugNotifier.append(self.hotplugCB)
		except:
			pass

		self.autoplay = dvd_device or dvd_filelist

		if dvd_device:
			self.physicalDVD = True
		else:
			self.scanHotplug()

		self.dvd_filelist = dvd_filelist
		self.onFirstExecBegin.append(self.opened)
		self.service = None
		self.in_menu = False
		if fileExists("/proc/stb/vmpeg/0/dst_left"):
			self.left = open("/proc/stb/vmpeg/0/dst_left", "r").read()[:-1]
			self.width = open("/proc/stb/vmpeg/0/dst_width", "r").read()[:-1]
			self.top = open("/proc/stb/vmpeg/0/dst_top", "r").read()[:-1]
			self.height = open("/proc/stb/vmpeg/0/dst_height", "r").read()[:-1]
			if self.left != "0" or self.top != "0" or self.width != "2d0" or self.height != "240":
				open("/proc/stb/vmpeg/0/dst_left", "w").write("0")
				open("/proc/stb/vmpeg/0/dst_width", "w").write("2d0")
				open("/proc/stb/vmpeg/0/dst_top", "w").write("0")
				open("/proc/stb/vmpeg/0/dst_height", "w").write("240")
				self.onClose.append(self.__restoreOSDSize)
コード例 #37
0
ファイル: plugin.py プロジェクト: B4RB/HRTunerProxy
    def __init__(self, session, menu_path=""):
        instance = None
        Screen.__init__(self, session)
        if hasattr(config.usage, 'show_menupath'):
            screentitle = _("HR-Tuner Proxy for Enigma2")
            self.menu_path = menu_path
            if config.usage.show_menupath.value == 'large':
                self.menu_path += screentitle
                title = self.menu_path
                self["menu_path_compressed"] = StaticText("")
                self.menu_path += ' / '
            elif config.usage.show_menupath.value == 'small':
                title = screentitle
                condtext = ""
                if self.menu_path and not self.menu_path.endswith(' / '):
                    condtext = self.menu_path + " >"
                elif self.menu_path:
                    condtext = self.menu_path[:-3] + " >"
                self["menu_path_compressed"] = StaticText(condtext)
                self.menu_path += screentitle + ' / '
            else:
                title = screentitle
                self["menu_path_compressed"] = StaticText("")
        else:
            title = _("HR-Tuner Proxy for Enigma2")
            self.menu_path = ""
        Screen.setTitle(self, title)

        self.savedval = config.hrtunerproxy.type.value

        self.onChangedEntry = []
        self.list = []
        ConfigListScreen.__init__(self,
                                  self.list,
                                  session=session,
                                  on_change=self.onChange)

        self["information"] = Label()
        self["hinttext"] = Label()
        self["actions"] = ActionMap(
            ['ColorActions', 'OkCancelActions', 'DirectionActions'], {
                "cancel": self.keyCancel,
                "red": self.keyCancel,
                "green": self.keySave,
                "yellow": self.cleanfiles,
                "blue": self.about
            }, -2)
        self["actions"].setEnabled(False)

        self["okaction"] = ActionMap(['OkCancelActions'], {
            "ok": self.ok,
            "cancel": self.keyCancel,
        }, -2)
        self["okaction"].setEnabled(False)

        self["closeaction"] = ActionMap(['OkCancelActions', 'ColorActions'], {
            "ok": self.keyCancel,
            "cancel": self.keyCancel,
            "red": self.keyCancel
        }, -2)
        self["closeaction"].setEnabled(False)

        self["key_red"] = Button(_("Close"))
        self["key_red"].hide()
        self["button_red"] = Pixmap()
        self["button_red"].hide()
        self["key_green"] = Button()
        self["key_green"].hide()
        self["button_green"] = Pixmap()
        self["button_green"].hide()
        self["key_yellow"] = Button()
        self["key_yellow"].hide()
        self["button_yellow"] = Pixmap()
        self["button_yellow"].hide()
        self["key_blue"] = Button(_("About"))
        self["button_blue"] = Pixmap()

        self.firstrun = True

        assert HRTunerProxy_Setup.instance is None, "class is a singleton class and just one instance of this class is allowed!"
        HRTunerProxy_Setup.instance = self

        self.onLayoutFinish.append(self.LayoutFinish)
        self.onClose.append(self.__onClose)
コード例 #38
0
ファイル: DVD.py プロジェクト: kingvuplus/Test-OBH
	def __init__(self, session, parent):
		Screen.__init__(self, session, parent)
		self["Title"] = Label("")
		self["Time"] = Label("")
		self["Chapter"] = Label("")
コード例 #39
0
    def __init__(self,
                 session,
                 title=None,
                 width=None,
                 height=None,
                 message=None,
                 message_height=None,
                 accep_label=None,
                 accep_height=None,
                 col_num=4,
                 images=[],
                 image_width=160,
                 image_height=160,
                 max_sel_items=None):
        self.iptv_title = title
        self.iptv_width = width
        self.iptv_height = height
        self.iptv_message = message
        self.iptv_message_height = message_height

        self.iptv_accep_label = accep_label
        self.iptv_accep_height = accep_height

        self.iptv_col_num = col_num
        self.iptv_row_num = len(images) / col_num
        if len(images) % col_num > 0:
            self.iptv_row_num += 1

        self.iptv_images = images
        self.iptv_image_width = image_width
        self.iptv_image_height = image_width
        self.iptv_max_sel_items = max_sel_items
        self.iptv_num_sel_items = 0
        self.iptv_images_data = None

        self.iptv_grid = []
        for x in range(self.iptv_col_num):
            self.iptv_grid.append([])
            for y in range(self.iptv_row_num):
                self.iptv_grid[x].append(None)

        self.skin = self.__prepareSkin()
        Screen.__init__(self, session)
        #self.skinName = "IPTVMultipleImageSelectorWidget"

        self.onShown.append(self.onStart)
        self.onClose.append(self.__onClose)

        # create controls
        self["title"] = Label(self.iptv_title)
        if self.iptv_message != None:
            self["message"] = Label(str(self.iptv_message))

        for idx in range(self.iptv_col_num):
            self["col_%d" %
                 idx] = IPTVImagesSelectionList(self.iptv_image_height + 20)

        if self.iptv_accep_label:
            self["accept_button"] = Label(self.iptv_accep_label)

        self["actions"] = ActionMap(
            [
                "SetupActions", "ColorActions", "WizardActions",
                "ListboxActions", "IPTVPlayerListActions"
            ], {
                "cancel": self.key_cancel,
                "ok": self.key_ok,
                "green": self.key_green,
                "read": self.key_read,
                "up": self.key_up,
                "down": self.key_down,
                "moveUp": self.key_up,
                "moveDown": self.key_down,
                "moveTop": self.key_home,
                "moveEnd": self.key_end,
                "home": self.key_home,
                "end": self.key_end,
                "pageUp": self.key_page_up,
                "pageDown": self.key_page_down,
                "left": self.key_left,
                "right": self.key_right,
            }, -2)

        self.column_index = 0
        self.row_index = 0
        self.picload = ePicLoad()
        self.picload.setPara((self.iptv_image_width, self.iptv_image_height, 1,
                              1, False, 1, "#00000000"))
        self.picload_conn = None
コード例 #40
0
    def __init__(self, session, params={}):

        # Skin generator
        maxWidth = 0
        pX = 40
        pY = 60
        dY = 10
        skinItems = ''
        self.icons = []
        self.list = params['list']
        self.withAcceptButton = params.get('with_accept_button', False)
        self.statusText = params.get('status_text', '')
        statusTextHight = params.get('status_text_hight', 80)
        # calcl maxWidth size
        for idx in range(len(self.list)):
            item = self.list[idx]
            if item['label_size'][0] > maxWidth:
                maxWidth = item['label_size'][0]
            if item['input_size'][0] > maxWidth:
                maxWidth = item['input_size'][0]
        maxWidth += pX * 2

        if len(self.statusText):
            skinItems = '<widget name="statustext"   position="10,%d"  zPosition="2" size="%d,%d"  valign="center" halign="center" font="Regular;22" transparent="1" />' % (
                pY + dY, maxWidth - 20, statusTextHight)
            pY += statusTextHight + dY * 2

        for idx in range(len(self.list)):
            item = self.list[idx]
            if 'icon_path' in item:
                self["cover_%d" % idx] = Cover2()
                self.icons.append({
                    'name': "cover_%d" % idx,
                    'path': item['icon_path']
                })
            else:
                self["text_%d" % idx] = Label(item.get('title', ''))
            self["input_%d" % idx] = Input(**item['input'])
            self["border_%d" % idx] = Label("")
            if item.get('useable_chars', None) is not None:
                self["input_%d" % idx].setUseableChars(item['useable_chars'])

            if 'icon_path' in item:
                skinItems += '<widget name="cover_%d" position="%d,%d" size="%d,%d" zPosition="8" />' % (
                    idx, (maxWidth - item['label_size'][0]) / 2, pY,
                    item['label_size'][0], item['label_size'][1])
            else:
                skinItems += '<widget name="text_%d" position="%d,%d" size="%d,%d" font="%s" zPosition="2" />' % (
                    idx, 10, pY, item['label_size'][0], item['label_size'][1],
                    item['label_font'])

            pY += dY + item['label_size'][1]
            skinItems += '<widget name="input_%d" position="%d,%d" size="%d,%d" font="%s" zPosition="2" />' % (
                idx, pX, pY, item['input_size'][0], item['input_size'][1],
                item['input_font'])
            skinItems += '<widget name="border_%d" position="%d,%d" size="%d,%d" font="%s" zPosition="1" transparent="0" backgroundColor="#331F93B9" />' % (
                idx, pX - 5, pY - 5, item['input_size'][0] + 10,
                item['input_size'][1] + 10, item['input_font'])
            if 0 == idx:
                self['marker'] = Cover3()
                skinItems += '<widget name="marker" zPosition="2" position="10,%d" size="16,16" transparent="1" alphatest="blend" />' % (
                    pY + (item['input_size'][1] - 16) / 2)
            skinItems += '<widget name="marker_%d" zPosition="1" position="10,%d" size="16,16" transparent="1" alphatest="blend" />' % (
                idx, pY + (item['input_size'][1] - 16) / 2)
            self['marker_%d' % idx] = Cover3()
            pY += dY * 2 + item['input_size'][1]

        if self.withAcceptButton:
            skinItems += '<widget name="accept_button"  position="10,%d"  zPosition="2" size="%d,50"  valign="center" halign="center" font="Regular;22" foregroundColor="#00FFFFFF" backgroundColor="#320F0F0F" />' % (
                pY, maxWidth - 20)
            pY += dY * 2 + 50
        self.skin = """
        <screen name="IPTVMultipleInputBox" position="center,center" size="%d,%d" title="%s">
            <widget name="key_red"   position="10,10" zPosition="2" size="%d,35" valign="center" halign="left"   font="Regular;22" transparent="1" foregroundColor="red" />
            <widget name="key_ok"    position="10,10" zPosition="2" size="%d,35" valign="center" halign="center" font="Regular;22" transparent="1" foregroundColor="white" />
            <widget name="key_green" position="10,10" zPosition="2" size="%d,35" valign="center" halign="right"  font="Regular;22" transparent="1" foregroundColor="green" />
            %s
        </screen>
        """ % (maxWidth, pY, params.get('title', _("Input")), maxWidth - 20,
               maxWidth - 20, maxWidth - 20, skinItems)

        self["key_green"] = Label(params.get('accep_label', _("Save")))
        self["key_ok"] = Label(_("OK"))
        self["key_red"] = Label(_("Cancel"))
        if len(self.statusText):
            self["statustext"] = Label(str(self.statusText))
        if self.withAcceptButton:
            self["accept_button"] = Label(
                params.get('accep_label', _("Verify")))

        self.params = params

        Screen.__init__(self, session)
        self.onShown.append(self.onStart)
        self.onClose.append(self.__onClose)

        self["actions"] = NumberActionMap(
            [
                "ColorActions", "WizardActions", "InputBoxActions",
                "InputAsciiActions", "KeyboardInputActions"
            ], {
                "gotAsciiCode": self.gotAsciiCode,
                "green": self.keySave,
                "ok": self.keyOK,
                "red": self.keyCancel,
                "back": self.keyCancel,
                "left": self.keyLeft,
                "right": self.keyRight,
                "up": self.keyUp,
                "down": self.keyDown,
                "right": self.keyRight,
                "home": self.keyHome,
                "end": self.keyEnd,
                "deleteForward": self.keyDelete,
                "deleteBackward": self.keyBackspace,
                "tab": self.keyTab,
                "toggleOverwrite": self.keyInsert,
                "1": self.keyNumberGlobal,
                "2": self.keyNumberGlobal,
                "3": self.keyNumberGlobal,
                "4": self.keyNumberGlobal,
                "5": self.keyNumberGlobal,
                "6": self.keyNumberGlobal,
                "7": self.keyNumberGlobal,
                "8": self.keyNumberGlobal,
                "9": self.keyNumberGlobal,
                "0": self.keyNumberGlobal
            }, -1)

        self.idx = 0
        self.activeInput = "input_0"
        self.markerPixmap = [
            LoadPixmap(GetIconDir('radio_button_on.png')),
            LoadPixmap(GetIconDir('radio_button_off.png'))
        ]

        self.started = False
コード例 #41
0
    def __init__(self, session, args=0):

        assert not slManager.instance, "only one slManager instance is allowed!"
        slManager.instance = self
        self.skin = slManager.skin

        Screen.__init__(self, session)

        self.setTitle(_('Sat-Lodge Manager by lululla V. %s' % Version))
        self.session = session

        self.index = 0
        self.emulist = []
        self.namelist = []
        self.oldService = self.session.nav.getCurrentlyPlayingServiceReference(
        )
        self["actions"] = ActionMap(
            ["OkCancelActions", "ColorActions"], {
                "ok": self.action,
                "cancel": self.close,
                "yellow": self.download,
                "green": self.action,
                "blue": self.slpanel,
                "red": self.stop,
            }, -1)
        self["key_green"] = Button(_("Start"))
        # self["key_green2"] = Button(_("ReStart"))

        self["key_blue"] = Button(_("SatLodge Panel"))
        self['key_blue'].hide()
        if fileExists(
                '/usr/lib/enigma2/python/Plugins/SatLodge/slPanel/plugin.pyo'):
            self["key_blue"].show()

        self["key_yellow"] = Button(_("Download"))
        self["key_red"] = Button(_("Stop"))
        self['version'] = Label(_('V. %s' % Version))
        self['maintener'] = Label(_('by ))^^(('))
        self['team'] = Label(_('..:: Sat-Lodge Manager ::..'))
        self['info'] = Label()
        self.currCam = self.readCurrent()
        self.softcamslist = []
        self['desc'] = Label()
        self['ecminfo'] = Label(_('Ecm Info'))
        # self["list"] = MenuList(self.softcamslist)
        self["list"] = m2list([])
        self.timer = eTimer()
        self['desc'].setText(_('Scanning and retrieval list softcam ...'))
        try:
            self.timer.callback.append(self.cgdesc)
        except:
            self.timer_conn = self.timer.timeout.connect(self.cgdesc)
        self.timer.start(200, 1)
        self.readScripts()
        self.ecminfo = GetEcmInfo()
        (newEcmFound, ecmInfo) = self.ecminfo.getEcm()
        self["info"] = ScrollLabel("".join(ecmInfo))
        self.EcmInfoPollTimer = eTimer()
        try:
            self.EcmInfoPollTimer.callback.append(self.setEcmInfo)
        except:
            self.timer_conn = self.EcmInfoPollTimer.timeout.connect(
                self.setEcmInfo)
        self.EcmInfoPollTimer.start(100)
コード例 #42
0
ファイル: plugin.py プロジェクト: popazerty/12
class PositionerSetup(Screen):
	skin = """
		<screen position="100,100" size="560,400" title="Positioner setup..." >
			<widget name="list" position="100,0" size="350,155" />

			<widget name="red" position="0,155" size="140,80" backgroundColor="red" halign="center" valign="center" font="Regular;21" />
			<widget name="green" position="140,155" size="140,80" backgroundColor="green" halign="center" valign="center" font="Regular;21" />
			<widget name="yellow" position="280,155" size="140,80" backgroundColor="yellow" halign="center" valign="center" font="Regular;21" />
			<widget name="blue" position="420,155" size="140,80" backgroundColor="blue" halign="center" valign="center" font="Regular;21" />

			<widget name="snr_db" position="60,245" size="150,22" halign="center" valign="center" font="Regular;21" />
			<eLabel text="SNR:" position="0,270" size="60,22" font="Regular;21" />
			<eLabel text="BER:" position="0,295" size="60,22" font="Regular;21" />
			<eLabel text="Lock:" position="0,320" size="60,22" font="Regular;21" />
			<widget name="snr_percentage" position="220,270" size="60,22" font="Regular;21" />
			<widget name="ber_value" position="220,295" size="60,22" font="Regular;21" />
			<widget name="lock_state" position="60,320" size="150,22" font="Regular;21" />
			<widget name="snr_bar" position="60,270" size="150,22" />
			<widget name="ber_bar" position="60,295" size="150,22" />

			<eLabel text="Frequency:" position="300,245" size="120,22" font="Regular;21" />
			<eLabel text="Symbolrate:" position="300,270" size="120,22" font="Regular;21" />
			<eLabel text="FEC:" position="300,295" size="120,22" font="Regular;21" />
			<widget name="frequency_value" position="420,245" size="120,22" font="Regular;21" />
			<widget name="symbolrate_value" position="420,270" size="120,22" font="Regular;21" />
			<widget name="fec_value" position="420,295" size="120,22" font="Regular;21" />
		</screen>"""
	def __init__(self, session, feid):
		self.skin = PositionerSetup.skin
		Screen.__init__(self, session)
		self.feid = feid
		self.oldref = None

		cur = { }
		if not self.openFrontend():
			self.oldref = session.nav.getCurrentlyPlayingServiceReference()
			service = session.nav.getCurrentService()
			feInfo = service and service.frontendInfo()
			if feInfo:
				cur = feInfo.getTransponderData(True)
			del feInfo
			del service
			session.nav.stopService() # try to disable foreground service
			if not self.openFrontend():
				if session.pipshown: # try to disable pip
					service = self.session.pip.pipservice
					feInfo = service and service.frontendInfo()
					if feInfo:
						cur = feInfo.getTransponderData()
					del feInfo
					del service
					session.pipshown = False
					session.deleteDialog(session.pip)
					del session.pip
					if not self.openFrontend():
						self.frontend = None # in normal case this should not happen

		self.frontendStatus = { }
		self.diseqc = Diseqc(self.frontend)
		self.tuner = Tuner(self.frontend, True) #True means we dont like that the normal sec stuff sends commands to the rotor!

		tp = ( cur.get("frequency", 0) / 1000,
			cur.get("symbol_rate", 0) / 1000,
			cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal),
			cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto),
			cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown),
			cur.get("orbital_position", 0),
			cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
			cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
			cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
			cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))

		self.tuner.tune(tp)
		self.createConfig()

		self.isMoving = False
		self.stopOnLock = False

		self.red = Label("")
		self["red"] = self.red
		self.green = Label("")
		self["green"] = self.green
		self.yellow = Label("")
		self["yellow"] = self.yellow
		self.blue = Label("")
		self["blue"] = self.blue

		self.list = []
		self["list"] = ConfigList(self.list)
		self.createSetup()

		self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus)
		self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus)
		self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus)
		self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus)
		self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus)
		self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus)

		self["frequency_value"] = Label("")
		self["symbolrate_value"] = Label("")
		self["fec_value"] = Label("")

		self["actions"] = ActionMap(["DirectionActions", "OkCancelActions", "ColorActions"],
		{
			"ok": self.go,
			"cancel": self.keyCancel,
			"up": self.up,
			"down": self.down,
			"left": self.left,
			"right": self.right,
			"red": self.redKey,
			"green": self.greenKey,
			"yellow": self.yellowKey,
			"blue": self.blueKey,
		}, -1)

		self.updateColors("tune")

		self.statusTimer = eTimer()
		self.statusTimer_conn = self.statusTimer.timeout.connect(self.updateStatus)
		self.statusTimer.start(50, True)
		self.onClose.append(self.__onClose)

	def __onClose(self):
		self.session.nav.playService(self.oldref)

	def restartPrevService(self, yesno):
		if yesno:
			if self.frontend:
				self.frontend = None
				del self.raw_channel
		else:
			self.oldref=None
		self.close(None)

	def keyCancel(self):
		if self.oldref:
			self.session.openWithCallback(self.restartPrevService, MessageBox, _("Zap back to service before positioner setup?"), MessageBox.TYPE_YESNO)
		else:
			self.restartPrevService(False)

	def openFrontend(self):
		res_mgr = eDVBResourceManager.getInstance()
		if res_mgr:
			self.raw_channel = res_mgr.allocateRawChannel(self.feid)
			if self.raw_channel:
				self.frontend = self.raw_channel.getFrontend()
				if self.frontend:
					return True
				else:
					print "getFrontend failed"
			else:
				print "getRawChannel failed"
		else:
			print "getResourceManager instance failed"
		return False

	def createConfig(self):
		self.positioner_tune = ConfigNothing()
		self.positioner_move = ConfigNothing()
		self.positioner_finemove = ConfigNothing()
		self.positioner_limits = ConfigNothing()
		self.positioner_goto0 = ConfigNothing()
		storepos = []
		for x in range(1,255):
			storepos.append(str(x))
		self.positioner_storage = ConfigSelection(choices = storepos)

	def createSetup(self):
		self.list.append((_("Tune"), self.positioner_tune, "tune"))
		self.list.append((_("Positioner movement"), self.positioner_move, "move"))
		self.list.append((_("Positioner fine movement"), self.positioner_finemove, "finemove"))
		self.list.append((_("Set limits"), self.positioner_limits, "limits"))
		self.list.append((_("Positioner storage"), self.positioner_storage, "storage"))
		self.list.append((_("Goto 0"), self.positioner_goto0, "goto0"))
		self["list"].l.setList(self.list)

	def go(self):
		pass

	def getCurrentConfigPath(self):
		return self["list"].getCurrent()[2]

	def up(self):
		if not self.isMoving:
			self["list"].instance.moveSelection(self["list"].instance.moveUp)
			self.updateColors(self.getCurrentConfigPath())

	def down(self):
		if not self.isMoving:
			self["list"].instance.moveSelection(self["list"].instance.moveDown)
			self.updateColors(self.getCurrentConfigPath())

	def left(self):
		self["list"].handleKey(KEY_LEFT)

	def right(self):
		self["list"].handleKey(KEY_RIGHT)

	def updateColors(self, entry):
		if entry == "tune":
			self.red.setText(_("Tune"))
			self.green.setText("")
			self.yellow.setText("")
			self.blue.setText("")
		elif entry == "move":
			if self.isMoving:
				self.red.setText(_("Stop"))
				self.green.setText(_("Stop"))
				self.yellow.setText(_("Stop"))
				self.blue.setText(_("Stop"))
			else:
				self.red.setText(_("Move west"))
				self.green.setText(_("Search west"))
				self.yellow.setText(_("Search east"))
				self.blue.setText(_("Move east"))
		elif entry == "finemove":
			self.red.setText("")
			self.green.setText(_("Step west"))
			self.yellow.setText(_("Step east"))
			self.blue.setText("")
		elif entry == "limits":
			self.red.setText(_("Limits off"))
			self.green.setText(_("Limit west"))
			self.yellow.setText(_("Limit east"))
			self.blue.setText(_("Limits on"))
		elif entry == "storage":
			self.red.setText("")
			self.green.setText(_("Store position"))
			self.yellow.setText(_("Goto position"))
			self.blue.setText("")
		elif entry == "goto0":
			self.red.setText(_("Goto 0"))
			self.green.setText("")
			self.yellow.setText("")
			self.blue.setText("")
		else:
			self.red.setText("")
			self.green.setText("")
			self.yellow.setText("")
			self.blue.setText("")

	def redKey(self):
		entry = self.getCurrentConfigPath()
		if entry == "move":
			if self.isMoving:
				self.diseqccommand("stop")
				self.isMoving = False
				self.stopOnLock = False
			else:
				self.diseqccommand("moveWest", 0)
				self.isMoving = True
			self.updateColors("move")
		elif entry == "limits":
			self.diseqccommand("limitOff")
		elif entry == "tune":
			fe_data = { }
			self.frontend.getFrontendData(fe_data)
			self.frontend.getTransponderData(fe_data, True)
			feparm = self.tuner.lastparm.getDVBS()
			fe_data["orbital_position"] = feparm.orbital_position
			self.session.openWithCallback(self.tune, TunerScreen, self.feid, fe_data)
		elif entry == "goto0":
			print "move to position 0"
			self.diseqccommand("moveTo", 0)

	def greenKey(self):
		entry = self.getCurrentConfigPath()
		if entry == "move":
			if self.isMoving:
				self.diseqccommand("stop")
				self.isMoving = False
				self.stopOnLock = False
			else:
				self.isMoving = True
				self.stopOnLock = True
				self.diseqccommand("moveWest", 0)
			self.updateColors("move")
		elif entry == "finemove":
			print "stepping west"
			self.diseqccommand("moveWest", 0xFF) # one step
		elif entry == "storage":
			print "store at position", int(self.positioner_storage.value)
			self.diseqccommand("store", int(self.positioner_storage.value))

		elif entry == "limits":
			self.diseqccommand("limitWest")

	def yellowKey(self):
		entry = self.getCurrentConfigPath()
		if entry == "move":
			if self.isMoving:
				self.diseqccommand("stop")
				self.isMoving = False
				self.stopOnLock = False
			else:
				self.isMoving = True
				self.stopOnLock = True
				self.diseqccommand("moveEast", 0)
			self.updateColors("move")
		elif entry == "finemove":
			print "stepping east"
			self.diseqccommand("moveEast", 0xFF) # one step
		elif entry == "storage":
			print "move to position", int(self.positioner_storage.value)
			self.diseqccommand("moveTo", int(self.positioner_storage.value))
		elif entry == "limits":
			self.diseqccommand("limitEast")

	def blueKey(self):
		entry = self.getCurrentConfigPath()
		if entry == "move":
			if self.isMoving:
				self.diseqccommand("stop")
				self.isMoving = False
				self.stopOnLock = False
			else:
				self.diseqccommand("moveEast", 0)
				self.isMoving = True
			self.updateColors("move")
			print "moving east"
		elif entry == "limits":
			self.diseqccommand("limitOn")

	def diseqccommand(self, cmd, param = 0):
		self.diseqc.command(cmd, param)
		self.tuner.retune()

	def updateStatus(self):
		if self.frontend:
			self.frontendStatus.clear()
			self.frontend.getFrontendStatus(self.frontendStatus)
		self["snr_db"].update()
		self["snr_percentage"].update()
		self["ber_value"].update()
		self["snr_bar"].update()
		self["ber_bar"].update()
		self["lock_state"].update()
		transponderdata = ConvertToHumanReadable(self.tuner.getTransponderData(), "DVB-S")
		self["frequency_value"].setText(str(transponderdata.get("frequency")))
		self["symbolrate_value"].setText(str(transponderdata.get("symbol_rate")))
		self["fec_value"].setText(str(transponderdata.get("fec_inner")))
		if self.frontendStatus.get("tuner_locked", 0) == 1 and self.isMoving and self.stopOnLock:
			self.diseqccommand("stop")
			self.isMoving = False
			self.stopOnLock = False
			self.updateColors(self.getCurrentConfigPath())
		self.statusTimer.start(50, True)

	def tune(self, transponder):
		if transponder is not None:
			self.tuner.tune(transponder)
コード例 #43
0
ファイル: Ipkg.py プロジェクト: 1198s/enigma2
class Ipkg(Screen):
	def __init__(self, session, cmdList=None):
		if not cmdList: cmdList = []
		Screen.__init__(self, session)

		self.cmdList = cmdList

		self.sliderPackages = {}

		self.slider = Slider(0, len(cmdList))
		self["slider"] = self.slider
		self.activityslider = Slider(0, 100)
		self["activityslider"] = self.activityslider
		self.status = Label(_("Preparing... Please wait"))
		self["status"] = self.status
		self.package = Label()
		self["package"] = self.package

		self.packages = 0
		self.error = 0
		self.processed_packages = []

		self.activity = 0
		self.activityTimer = eTimer()
		self.activityTimer.callback.append(self.doActivityTimer)
		#self.activityTimer.start(100, False)

		self.ipkg = IpkgComponent()
		self.ipkg.addCallback(self.ipkgCallback)

		self.runningCmd = None
		self.runNextCmd()

		self["actions"] = ActionMap(["WizardActions"],
		{
			"ok": self.exit,
			"back": self.exit
		}, -1)

	def runNextCmd(self):
		if self.runningCmd is None:
			self.runningCmd = 0
		else:
			self.runningCmd += 1
		print len(self.cmdList), self.runningCmd
		if len(self.cmdList) - 1 < self.runningCmd:
			self.activityslider.setValue(0)
			self.slider.setValue(len(self.cmdList))

			self.package.setText("")
			self.status.setText(ngettext("Done - Installed, upgraded or removed %d package (%s)", "Done - Installed, upgraded or removed %d packages (%s)", self.packages) % (self.packages, ngettext("with %d error", "with %d errors", self.error) % self.error))
			return False
		else:
			cmd = self.cmdList[self.runningCmd]
			self.slider.setValue(self.runningCmd)
			self.ipkg.startCmd(cmd[0], args = cmd[1])
			self.startActivityTimer()

	def doActivityTimer(self):
		if not self.ipkg.isRunning():
			self.stopActivityTimer()
		else:
			self.activity += 1
			if self.activity == 100:
				self.activity = 0
			self.activityslider.setValue(self.activity)

	def startActivityTimer(self):
		self.activityTimer.start(100, False)

	def stopActivityTimer(self):
		self.activityTimer.stop()

	def ipkgCallback(self, event, param):
		if event == IpkgComponent.EVENT_DOWNLOAD:
			self.status.setText(_("Downloading"))
		elif event == IpkgComponent.EVENT_UPGRADE:
			if self.sliderPackages.has_key(param):
				self.slider.setValue(self.sliderPackages[param])
			self.package.setText(param)
			self.status.setText(_("Upgrading"))
			if not param in self.processed_packages:
				self.processed_packages.append(param)
				self.packages += 1
		elif event == IpkgComponent.EVENT_INSTALL:
			self.package.setText(param)
			self.status.setText(_("Installing"))
			if not param in self.processed_packages:
				self.processed_packages.append(param)
				self.packages += 1
		elif event == IpkgComponent.EVENT_REMOVE:
			self.package.setText(param)
			self.status.setText(_("Removing"))
			if not param in self.processed_packages:
				self.processed_packages.append(param)
				self.packages += 1
		elif event == IpkgComponent.EVENT_CONFIGURING:
			self.package.setText(param)
			self.status.setText(_("Configuring"))
		elif event == IpkgComponent.EVENT_ERROR:
			self.error += 1
		elif event == IpkgComponent.EVENT_DONE:
			self.runNextCmd()
		elif event == IpkgComponent.EVENT_MODIFIED:
			self.session.openWithCallback(
				self.modificationCallback,
				MessageBox,
				_("A configuration file (%s) was modified since Installation.\nDo you want to keep your version?") % param
			)

	def modificationCallback(self, res):
		self.ipkg.write(res and "N" or "Y")

	def exit(self):
		if not self.ipkg.isRunning():
			self.close()
コード例 #44
0
    def __init__(self, session):
        Screen.__init__(self, session)

        self["actions"] = NumberActionMap(
            ["NumberActions", "RassInteractiveActions"], {
                "exit": self.close,
                "0": lambda x: self.numPressed(0),
                "1": lambda x: self.numPressed(1),
                "2": lambda x: self.numPressed(2),
                "3": lambda x: self.numPressed(3),
                "4": lambda x: self.numPressed(4),
                "5": lambda x: self.numPressed(5),
                "6": lambda x: self.numPressed(6),
                "7": lambda x: self.numPressed(7),
                "8": lambda x: self.numPressed(8),
                "9": lambda x: self.numPressed(9),
                "nextPage": self.nextPage,
                "prevPage": self.prevPage,
                "nextSubPage": self.nextSubPage,
                "prevSubPage": self.prevSubPage
            })

        self.__event_tracker = ServiceEventTracker(
            screen=self,
            eventmap={
                iPlayableService.evUpdatedRassInteractivePicMask:
                self.recvRassInteractivePicMaskChanged
            })

        self["subpages_1"] = Pixmap()
        self["subpages_2"] = Pixmap()
        self["subpages_3"] = Pixmap()
        self["subpages_4"] = Pixmap()
        self["subpages_5"] = Pixmap()
        self["subpages_6"] = Pixmap()
        self["subpages_7"] = Pixmap()
        self["subpages_8"] = Pixmap()
        self["subpages_9"] = Pixmap()
        self["Marker"] = Label(">")

        self.subpage = {
            1: self["subpages_1"],
            2: self["subpages_2"],
            3: self["subpages_3"],
            4: self["subpages_4"],
            5: self["subpages_5"],
            6: self["subpages_6"],
            7: self["subpages_7"],
            8: self["subpages_8"],
            9: self["subpages_9"]
        }

        self.subpage_png = {
            1:
            LoadPixmap(
                resolveFilename(SCOPE_ACTIVE_SKIN, "icons/rass_page1.png")),
            2:
            LoadPixmap(
                resolveFilename(SCOPE_ACTIVE_SKIN, "icons/rass_page2.png")),
            3:
            LoadPixmap(
                resolveFilename(SCOPE_ACTIVE_SKIN, "icons/rass_page3.png")),
            4:
            LoadPixmap(
                resolveFilename(SCOPE_ACTIVE_SKIN, "icons/rass_page4.png"))
        }

        self.current_page = 0
        self.current_subpage = 0
        self.showRassPage(0, 0)
        self.onLayoutFinish.append(self.updateSubPagePixmaps)
コード例 #45
0
ファイル: Browser.py プロジェクト: popazerty/12
	def __init__(self, session, fullscreen = False, url = None, isHbbtv = False, isTransparent = False, hbbtvMenu = None):
		size = getDesktop(0).size()
		width = int(size.width() * 0.9)
		fwidth = int(size.width())
		height = int(size.height() * 0.85)
		fheight = int(size.height())

		Browser.skin = """
			<screen name="Browser" position="center,center" size="%(w)d,%(h)d" title="Web Browser" backgroundColor="#FF000000">
				<widget name="cursor" position="0,0" size="19,30" zPosition="1" alphatest="on"/>
				<widget name="url" position="0,0" zPosition="2" size="%(w)d,25" font="Regular;20" halign="left" valign="bottom" backgroundColor="background"/>
				<widget name="loading" position="%(loadingX)d,0" zPosition="3" size="150,25" font="Regular;20" halign="right" valign="bottom" backgroundColor="background"/>
				<widget name="urlList" position="0,30" zPosition="2" size="%(w)d,150" backgroundColor="background"/>
				<widget name="text" position="%(textX)d,100" size="350,40" font="Regular;20"  zPosition="2" halign="center" valign="center" backgroundColor="background"/>
				<widget source="webnavigation" render="WebView" position="0,25" zPosition="0" size="%(w)d,%(mainH)d" transparent="1"/>
				<widget source="canvas" render="Canvas" position="0,25" zPosition="1" size="%(w)d,%(mainH)d" backgroundColor="#FF000000" transparent="1" alphatest="on"/>

				<group name="_buttonBar">
					<widget name="buttonBar" position="0,%(btnBarY)d" size="%(w)d,30" zPosition="0" backgroundColor="background" transparent="0" />
					<ePixmap pixmap="skin_default/buttons/button_red_off.png" position="5,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_red" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_red.png" position="5,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="red" position="25,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1" />

					<ePixmap pixmap="skin_default/buttons/button_green_off.png" position="195,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_green" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_green.png" position="195,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="green" position="215,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<ePixmap pixmap="skin_default/buttons/button_yellow_off.png" position="385,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_yellow" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_yellow.png" position="385,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="yellow" position="405,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<ePixmap pixmap="skin_default/buttons/button_blue_off.png" position="585,%(btnY)d" size="15,16" alphatest="on" />
					<widget source="button_blue" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_blue.png" position="585,%(btnY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="blue" position="605,%(btnTxtY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>
				</group>
				<widget name="statuslabel" position="%(notifX)d,%(btnTxtY)d" size="350,20" font="Regular;18"  zPosition="3" halign="right" valign="center" backgroundColor="background" />
			</screen>
			""" %{	"w" : width,
					"h" : height,
					"loadingX" : width-150,
					"textX" : (width - 375) / 2,
					"mainH" : height-55,
					"btnY" : height-22,
					"btnTxtY" : height-24,
					"btnBarY" : height - 30,
					"notifX" : width-350
				}

		Browser.skinFullscreen = """
			<screen name="BrowserFullscreen" flags="wfNoBorder" position="center,center" size="%(w)d,%(h)d" title="Web Browser" backgroundColor="#FF000000">
				<widget name="cursor" position="0,0" size="19,30" zPosition="1" alphatest="on"/>
				<widget name="url" position="75,75" zPosition="2" size="%(urlW)d,25" font="Regular;20" halign="left" valign="bottom" backgroundColor="background"/>
				<widget name="loading" position="%(loadingX)d,%(loadingY)d" zPosition="2" size="200,50" font="Regular;20" halign="center" valign="center" backgroundColor="background"/>
				<widget name="urlList" position="75,100" zPosition="2" size="%(urlW)d,150" backgroundColor="background" transparent="0" />
				<widget name="text" position="%(textX)d,100" size="350,40" font="Regular;20"  zPosition="2" halign="center" valign="center" backgroundColor="background" transparent="0" />
				<widget source="webnavigation" render="WebView" position="0,0" zPosition="0" size="%(w)d,%(h)d" transparent="1"/>
				<widget source="canvas" render="Canvas" position="0,0" zPosition="1" size="%(w)d,%(h)d" backgroundColor="#FF000000" transparent="1" alphatest="on"/>

				<group name="_buttonBar">
					<widget name="buttonBar" position="%(btnBarX)d,%(btnBarY)d" size="200,110" zPosition="0" backgroundColor="background" transparent="0" />
					<widget source="button_red_off" render="Pixmap" pixmap="skin_default/buttons/button_red_off.png" position="%(btnX)d,%(btnRedY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_red" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_red.png" position="%(btnX)d,%(btnRedY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="red" position="%(btnTxtX)d,%(btnRedY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<widget source="button_green_off" render="Pixmap" pixmap="skin_default/buttons/button_green_off.png" position="%(btnX)d,%(btnGreenY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_green" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_green.png" position="%(btnX)d,%(btnGreenY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="green" position="%(btnTxtX)d,%(btnGreenY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<widget source="button_yellow_off" render="Pixmap" pixmap="skin_default/buttons/button_yellow_off.png" position="%(btnX)d,%(btnYellowY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_yellow" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_yellow.png" position="%(btnX)d,%(btnYellowY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="yellow" position="%(btnTxtX)d,%(btnYellowY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>

					<widget source="button_blue_off" render="Pixmap" pixmap="skin_default/buttons/button_blue_off.png" position="%(btnX)d,%(btnBlueY)d" size="15,16" zPosition="1" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget source="button_blue" zPosition="2" render="Pixmap" pixmap="skin_default/buttons/button_blue.png" position="%(btnX)d,%(btnBlueY)d" size="15,16" alphatest="on">
						<convert type="ConditionalShowHide" />
					</widget>
					<widget name="blue" position="%(btnTxtX)d,%(btnBlueY)d" size="160,25" zPosition="1" font="Regular;18" halign="left" valign="top" backgroundColor="background" transparent="1"/>
				</group>

				<widget name="statuslabel" position="%(notifX)d,%(loadingY)d" size="350,50" zPosition="1" font="Regular;18" halign="center" valign="center" backgroundColor="background" transparent="0" />
			</screen>
			""" %{	"w" : fwidth,
					"h" : fheight,
					"urlW": fwidth - 150,
					"loadingY" : fheight - 125,
					"loadingX" : ( fwidth / 2 ) - 75,
					"textX" : (fwidth - 375) / 2,
					"mainH" : fheight-55,
					"btnBarX": fwidth - 75 - 200,
					"btnBarY": fheight - 75 - 108,
					"btnX" : fwidth - 75 - 190,
					"btnTxtX" : fwidth - 75 - 165,
					"btnRedY" : fheight - 75 - 100,
					"btnGreenY" : fheight - 75 - 75,
					"btnYellowY" : fheight - 75 - 50,
					"btnBlueY" : fheight - 75 - 25,
					"notifX" : ( fwidth / 2 ) - 175,
				}

		self.__isHbbtv = isHbbtv
		if self.__isHbbtv:
			isTransparent = fullscreen = True

		self.__hbbtvMenu = hbbtvMenu

		self.__isTransparent = isTransparent
		self.__fullscreen = fullscreen
		if self.__fullscreen:
			Browser.skin = Browser.skinFullscreen

		Screen.__init__(self, session)
		HelpableScreen.__init__(self)

		if self.__fullscreen:
			self.skinName = "BrowserFullscreen"

		self.__startUrl = url

		self["loading"] = Label("")

		self.urlInput = EnhancedInput()
		self["url"] = self.urlInput

		self.textInput = Input()
		self["text"] = self.textInput
		self.textInput.hide()

		self.statuslabel = Label("")
		self["statuslabel"] = self.statuslabel
		self.statuslabel.hide();

		self.urlInputEnabled = False

		self.webnavigation = WebNavigation()
		self.webnavigation.zoomFactor = 1.0
		self.__onStoragePathChanged()
		self["webnavigation"] = self.webnavigation

		self.__urlList = MenuList([], enableWrapAround = True, content = eListboxPythonStringContent)
		self["urlList"] = self.__urlList

		self.canvas =  CanvasSource()
		self["canvas"] = self.canvas

		self["buttonBar"] = Label("")
		self["button_red_off"] = Boolean(True)
		self["button_green_off"] = Boolean(True)
		self["button_yellow_off"] = Boolean(True)
		self["button_blue_off"] = Boolean(True)
		self["button_red"] = Boolean(True)
		self["button_green"] = Boolean(False)
		self["button_yellow"] = Boolean(True)
		self["button_blue"] = Boolean(True)
		self["red"] = Label(_("Mouse Off"))
		self["green"] = Label("")
		self["yellow"] = Label(_("Navigation"))
		self["blue"] = Label(_("Pagescroll"))

		self["cursor"] = Pixmap()
		self.__cursorPos = ePoint(50,50)
		self.__mouseMode = False

		self.__db = BrowserDB.getInstance()
		self.pageTitle = ""

		self.__urlSuggestionTimer = eTimer()
		self.__urlSuggestionTimer_conn = self.__urlSuggestionTimer.timeout.connect(self.__onSuggestionTimeout)
		self.__inputTimer = eTimer()
		self.__inputTimer_conn = self.__inputTimer.timeout.connect(self.onInputTimer)
		self.__statusTimer = eTimer()
		self.__statusTimer_conn = self.__statusTimer.timeout.connect(self.__hideStatus)

		self.__scrollMode = False
		self.__zoomMode = False
		self.__isInput = False
		self.__hasSslErrors = False
		self.__handledUnsupportedContent = False
		self.__currentPEM = None
		self.__currentUser = None
		self.__currentPass = None
		self.__currentRealm = None
		self.__keyboardMode = eRCInput.getInstance().getKeyboardMode()

		self.onFirstExecBegin.append(self.__onFirstExecBegin)
		self.onExecEnd = []
		self.onPageLoadFinished = []
		self.onActionTv = []
		self.onActionRecord = []
		self.onUrlChanged = []

		self["helpableactions"] = HelpableActionMap(self, "BrowserActions",
		{
			"exit": (self.__actionExit, _("Close the browser")),
			"url": (self.__actionEnterUrl, _("Enter web address or search term")),
			"back": self.__actionBack,
			"forward": self.__actionForward,
			"left": self.__actionLeft,
			"right": self.__actionRight,
			"up": self.__actionUp,
			"down": self.__actionDown,
			"pageUp": (self.__actionPageUp, _("Page Up / Zoom in")),
			"pageDown": (self.__actionPageDown, _("Page Down / Zoom out")),
			"seekBack": boundFunction(self.__actionNavigate, eWebView.navMediaRewind),
			"seekFwd": boundFunction(self.__actionNavigate, eWebView.navMediaFastForward),
			"tab": (boundFunction(self.__actionNavigate, eWebView.navTab), _("Tab")),
			"backspace": (self.__actionBackspace, _("Backspace / Navigate back")),
			"backtab": boundFunction(self.__actionNavigate, eWebView.navBacktab),
			"delete": (self.__actionDelete, _("Delete / Navigate forward")),
			"ascii": self.__actionAscii,
			"text" : (self.__actionVirtualAscii, _("Open Virtual Keyboard")),
			"ok" : self.__actionOk,
			"enter" : self.__actionEnter,
			"menu" : (self.__actionMenu, _("Menu")),
			"fullscreen" : self.__actionFullscreen,
			"play" : self.__actionPlay,
			"pause" : self.__actionPause,
			"playpause" : self.__actionPlayPause,
			"stop" : self.actionStop,
			"tv" : self.__actionTv,
			"record" : self.__actionRecord,
		}, -2)

		self["coloractions"] = ActionMap(["ColorActions"],
		{
			"red" : self.__actionRed,
			"green" : self.__actionGreen,
			"yellow" : self.__actionYellow,
			"blue" : self.__actionBlue,
		})

		self["numberactions"] = NumberActionMap(["NumberActions"],
		{
			"1": self.keyNumberGlobal,
			"2": self.keyNumberGlobal,
			"3": self.keyNumberGlobal,
			"4": self.keyNumberGlobal,
			"5": self.keyNumberGlobal,
			"6": self.keyNumberGlobal,
			"7": self.keyNumberGlobal,
			"8": self.keyNumberGlobal,
			"9": self.keyNumberGlobal,
			"0": self.keyNumberGlobal
		})
コード例 #46
0
 def __init__(self, session):
     self.session = session
     from Skin.Main import *
     self.skin = skin
     self.skin_path = resolveFilename(SCOPE_PLUGINS, "Extensions/NGsetting")
     Screen.__init__(self, session)									
     self["actions"]  = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", "NumberActions", "MenuActions", "HelpActions", "EPGSelectActions"], {
       "ok"    : self.keyOK,
       "up"    : self.keyUp,
       "down"  : self.keyDown,
       "blue"  : self.Auto,		
       "green"  : self.Lcn,	
       "yellow"  : self.Select,				  
       "cancel": self.exitplug,
       "left"  : self.keyRightLeft,
       "right" : self.keyRightLeft,							
       "red" : self.exitplug   							
     }, -1)							                        
     self['autotimer'] = Label("")  
     self['namesat'] = Label("" )  
     self['text'] = Label("" ) 			
     self['dataDow'] = Label("" )			
     self['Green'] = Pixmap()  
     self['Blue'] = Pixmap()  	
     self['Yellow'] = Pixmap() 			
     self['Green'].hide()	 
     self['Yellow'].show()	
     self['Blue'].show()				
     self["Key_Lcn"] = Label('')
     self.LcnOn = False			
     if os.path.exists(resolveFilename(SCOPE_PLUGINS, 'Extensions/NGsetting/Moduli/NGsetting/Date')) and os.path.exists('/etc/enigma2/lcndb'):		
       self['Key_Lcn'].setText(_("Lcn"))	
       self.LcnOn = True
       self['Green'].show()
     self["Key_Red"] = Label(_("Exit"))
     self["Key_Green"] = Label(_("Setting Installed:"))	
     self["Key_Personal"] = Label("")			
     AutoTimer, NameSat, Data, Type, Personal, DowDate = Load()		
     self['A'] = MenuListiSettingE2A([])
     self['B'] = MenuListiSettingE2([])    
     self["B"].selectionEnabled(1)			
     self["A"].selectionEnabled(1)		
     self.currentlist = 'B'	
     self.ServerOn = True		
     self.DubleClick = True			
     self.MenuA()	
     self.List = DownloadSetting()			
     self.MenuB()	
     self.iTimer = eTimer()				
     self.iTimer.callback.append(self.keyRightLeft) 			
     self.iTimer.start(1000, True)
     self.iTimer1 = eTimer()				
     self.iTimer1.callback.append(self.StartSetting) 
     self.Message = eTimer()				
     self.Message.callback.append(self.MessagePlugin) 
     self.OnWriteAuto = eTimer()				
     self.OnWriteAuto.callback.append(self.WriteAuto) 
     self.StopAutoWrite = False			
     self.ExitPlugin = eTimer()				
     self.ExitPlugin.callback.append(self.PluginClose) 			
     self.Reload = eTimer()				
     self.Reload.callback.append(self.ReloadGui) 			
     self.onShown.append(self.ReturnSelect)
     self.onShown.append(self.Info)	
     self.VersPlugin = Plugin()	
     if self.VersPlugin:
       if self.VersPlugin[0][1] != Version:
         self.Message.start(2000, True)
コード例 #47
0
ファイル: plugin.py プロジェクト: aassww/xta
class MenuStart(Screen):

    def __init__(self, session):
        self.session = session
        path = '/usr/lib/enigma2/python/Plugins/Extensions/iSkin/Skin/Main.xml'
        with open(path, 'r') as f:
            self.skin = f.read()
            f.close()
        mdom = xml.etree.cElementTree.parse(path)
        for x in mdom.getroot():
            if x.tag == 'widget' and x.get('name') == 'cover':
                Size = x.get('size').split(',')
                self.SizeY = int(Size[0])
                self.SizeX = int(Size[1])

        Screen.__init__(self, session)
        self['Key_Red'] = Label(_('Exit'))
        self['Key_Green'] = Label('')
        self['Key_Yellow'] = Label('')
        self['ButtonYellow'] = Pixmap()
        self['ButtonYellow'].hide()
        if os.path.exists('/usr/lib/enigma2/python/Components/Converter/TestConnection.pyo'):
            self['Key_Yellow'].setText(_('Config Connection'))
            self['ButtonYellow'].show()
        self.Region = Label('')
        self['Key_Region'] = self.Region
        self.Key_Blu = Label('')
        self['Key_Blu'] = self.Key_Blu
        self['SkinSelect'] = iMenuList([])
        self.isMoving = False
        self['cover'] = Pixmap()
        self.Loop = eTimer()
        self.Loop.stop()
        self.Loop.callback.append(self.Cover)
        self['setupActions'] = ActionMap(['SkinActionSetup'], {'blue': self.keyBlue,
         'green': self.keyGreen,
         'yellow': self.keyYellow,
         'ok': self.keyOK,
         'up': self.up,
         'down': self.down,
         'red': self.close,
         'cancel': self.close}, -1)
        self.onLayoutFinish.append(self.layoutFinished)
        self.onShown.append(self.SetButtonWeather)

    def SetButtonWeather(self):
        if os.path.exists('/usr/lib/enigma2/python/Plugins/Extensions/iSkin/Weather/Weather.pyo'):
            self.Key_Blu.setText('Config Weather')
            if os.path.exists('/usr/lib/enigma2/python/Plugins/Extensions/iSkin/Weather/Config/Region_id'):
                jRegion_id = open('/usr/lib/enigma2/python/Plugins/Extensions/iSkin/Weather/Config/Region_id').read()
                self.Region.setText(jRegion_id)

    def keyYellow(self):
        if os.path.exists('/usr/lib/enigma2/python/Plugins/Extensions/iSkin/Connection/Connection.pyo'):
            try:
                self.session.open(ConfigConnection)
            except:
                pass

    def keyBlue(self):
        try:
            self.session.open(WeatherSearch)
        except:
            pass

    def keyGreen(self):
        try:
            self.session.open(MeteoMain)
        except:
            pass

    def Cover(self):
        try:
            self.Loop.stop()
        except:
            pass

        try:
            png = loadPic(str(self.getCurrentConfigPath()), self.SizeY, self.SizeX, 0, 0, 0, 1)
            self['cover'].instance.setPixmap(png)
            self['cover'].show()
        except:
            pass

    def getCurrentConfigPath(self):
        return self['SkinSelect'].getCurrent()[0][1]

    def up(self):
        if not self.isMoving:
            self['SkinSelect'].instance.moveSelection(self['SkinSelect'].instance.moveUp)
            self.Loop.start(100, True)

    def down(self):
        if not self.isMoving:
            self['SkinSelect'].instance.moveSelection(self['SkinSelect'].instance.moveDown)
            self.Loop.start(100, True)

    def layoutFinished(self):
        mdom = xml.etree.cElementTree.parse(os.path.dirname(sys.modules[__name__].__file__) + '/Config/SkinSetup.xml')
        self.SkinSelect = []
        for x in mdom.getroot():
            if x.tag == 'ruleset':
                self.SkinSelect.append(self.ListEntry(x.get('name'), x.get('Icon')))

        self.SkinSelect.sort(key=lambda t: tuple(t[0][0].lower()))
        self['SkinSelect'].setList(self.SkinSelect)
        self.Loop.start(100, True)

    def ListEntry(self, name, jpg):
        res = [(name, jpg)]
        icon = '/usr/lib/enigma2/python/Plugins/Extensions/iSkin/Skin/no_icon.png'
        res.append(MultiContentEntryPixmapAlphaTest(pos=(0, 1), size=(75, 40), png=loadPNG(icon)))
        res.append(MultiContentEntryText(pos=(70, 4), size=(600, 30), font=0, text=name, flags=RT_HALIGN_LEFT))
        return res

    def keyOK(self):
        exist = self['SkinSelect'].getCurrent()
        if exist == None:
            return
        selection = self['SkinSelect'].getCurrent()[0][0]
        self.session.open(ConfigSkin, selection)
コード例 #48
0
ファイル: plugin.py プロジェクト: pololoko111/enigma2-plugins
    def __init__(self, session):
        # get framebuffer resolution...
        desk = getDesktop(0)
        wdesktop = int(desk.size().width())

        # cellsize depends from framebuffer resolution...
        if wdesktop == 720:
            CELL_SIZE = 20
        elif wdesktop == 1024:
            CELL_SIZE = 30
        elif wdesktop == 1280:
            CELL_SIZE = 40
        else:
            CELL_SIZE = 20

        # calculate skindata...
        CELL_OFFSET = 2
        cellfield = XMAX * CELL_SIZE + (XMAX - 1) * CELL_OFFSET
        CW = 2 * cellfield + 150  # canvas w
        CH = cellfield  # canvas h
        X0_OFFSET = 0  # xoffset cellfield box
        X1_OFFSET = cellfield + 150  # xoffset cellfield you
        W = CW + 10  # window w
        H = CH + 40  # window h
        WX = cellfield + 10  # widgets xoffset
        W0Y = 25  # widget0 yoffset
        W1Y = cellfield - 116  # widget1 yoffset
        W2Y = cellfield - 66  # widget2 yoffset
        W3Y = cellfield - 16  # widget3 yoffset

        # set skin...
        Schiffe.skin = """
			<screen position="center,center" size="%d,%d" title="Schiffe versenken %s" >
				<widget source="Canvas" render="Canvas" position="5,20" size="%d,%d" />
				<widget name="message" position="%d,%d" size="140,40" valign="center" halign="center" font="Regular;21"/>
				<ePixmap name="green"    position="%d,%d"   zPosition="4" size="140,40" pixmap="buttons/green.png" transparent="1" alphatest="on" />
				<ePixmap name="blue" position="%d,%d" zPosition="4" size="140,40" pixmap="buttons/blue.png" transparent="1" alphatest="on" />
				<ePixmap name="red"   position="%d,%d" zPosition="4" size="140,40" pixmap="buttons/red.png" transparent="1" alphatest="on" />
				<widget name="key_green"    position="%d,%d"   zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
				<widget name="key_blue" position="%d,%d" zPosition="5" size="140,40" valign="center" halign="center"  font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
				<widget name="key_red"   position="%d,%d" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" />
			</screen>""" % (W, H, VERSION, CW, CH, WX, W0Y, WX, W1Y, WX, W2Y, WX, W3Y,
                   WX, W1Y, WX, W2Y, WX, W3Y)

        # get window background color - find xml for actual skin...
        filename = resolveFilename(SCOPE_CURRENT_SKIN, "skin.xml")
        actualSkin = xml.etree.cElementTree.parse(filename).getroot()

        # get colors from skin and write to dictionary
        colorNames = dict()
        for c in actualSkin.findall("colors"):
            for color in c.findall("color"):
                get_attr = color.attrib.get
                name = get_attr("name")
                color = get_attr("value")
                if name and color:
                    colorNames[name] = color

        # find colors for skinned window...
        for windowstyle in actualSkin.findall("windowstyle"):
            # look or skinned window...
            if windowstyle.attrib.get("id") == "0":
                for color in windowstyle.findall("color"):
                    get_attr = color.attrib.get
                    type = get_attr("name")
                    color = get_attr("color")
                    # is it a "named" color?
                    if color[0] != '#':
                        # is "named" color, have to look in dictionary...
                        color = colorNames[color]
                    # at least get the background color...
                    if type == "Background":
                        bgcolor = int(color[1:], 0x10)
        if not bgcolor:
            bgcolor = RGB(0, 0, 0)

        self.skin = Schiffe.skin
        Screen.__init__(self, session)
        self["Canvas"] = CanvasSource()
        self["message"] = Label(_("Status"))
        self["key_green"] = Button(_("new game"))
        self["key_blue"] = Button(_("solve game"))
        self["key_red"] = Button(_("quit game"))

        self.cnt = 0
        self.timer = eTimer()
        self.timer.callback.append(self.timerHandler)

        self.message = 0

        self["actions"] = ActionMap(
            ["WizardActions", "ColorActions", "SetupActions"], {
                "ok": self.ok_pressed,
                "up": self.up_pressed,
                "down": self.down_pressed,
                "left": self.left_pressed,
                "right": self.right_pressed,
                "red": self.quit_game,
                "green": self.new_game,
                "blue": self.solve_game,
                "cancel": self.quit_game
            })

        # fill canvas with background color...
        self["Canvas"].fill(0, 0, CW, CH, bgcolor)

        self.you = []
        self.box = []
        self.youCells = []
        self.boxCells = []

        for j in range(YMAX):
            for i in range(XMAX):
                cell = GameCell(self["Canvas"],
                                i * (CELL_SIZE + CELL_OFFSET) + X0_OFFSET,
                                j * (CELL_SIZE + CELL_OFFSET), CELL_SIZE,
                                CELL_SIZE)
                self.boxCells.append(cell)

        for j in range(YMAX):
            for i in range(XMAX):
                cell = GameCell(self["Canvas"],
                                i * (CELL_SIZE + CELL_OFFSET) + X1_OFFSET,
                                j * (CELL_SIZE + CELL_OFFSET), CELL_SIZE,
                                CELL_SIZE)
                self.youCells.append(cell)

        self.onLayoutFinish.append(self.load_game)
コード例 #49
0
    def __init__(self, session, providers, pcallback=None, noosd=False):
        from Components.Sources.StaticText import StaticText
        from Components.Sources.Progress import Progress
        if (getDesktop(0).size().width() < 800):
            skin = "%s/skins/downloader_sd.xml" % os.path.dirname(
                sys.modules[__name__].__file__)
            self.isHD = 0
        else:
            skin = "%s/skins/downloader_hd.xml" % os.path.dirname(
                sys.modules[__name__].__file__)
            self.isHD = 1
        f = open(skin, "r")
        self.skin = f.read()
        f.close()
        Screen.__init__(self, session)

        self.session = session

        self["background"] = Pixmap()
        self["action"] = Label(_("Starting downloader"))
        self["status"] = Label("")
        self["progress"] = ProgressBar()
        self["progress"].hide()
        self["summary_action"] = StaticText(_("Starting downloader"))
        self["summary_status"] = StaticText()
        self["summary_progress"] = Progress()
        self["actions"] = NumberActionMap(["WizardActions", "InputActions"],
                                          {"back": self.quit}, -1)

        self.__event_tracker = ServiceEventTracker(
            screen=self, eventmap={
                iPlayableService.evTunedIn: self.tuned,
            })

        self.retValue = True
        self.provider_index = 0
        self.status = 0
        self.open = False
        self.saved = False
        self.tune_enabled = False
        self.oldService = self.session.nav.getCurrentlyPlayingServiceReference(
        )
        self.config = CrossEPG_Config()
        self.config.load()
        self.providers = providers
        self.pcallback = pcallback

        self.wrapper = CrossEPG_Wrapper()
        self.wrapper.addCallback(self.wrapperCallback)

        self.timeout = eTimer()
        self.timeout.callback.append(self.quit)

        self.hideprogress = eTimer()
        self.hideprogress.callback.append(self["progress"].hide)

        self.pcallbacktimer = eTimer()
        self.pcallbacktimer.callback.append(self.doCallback)

        self.wrappertimer = eTimer()
        self.wrappertimer.callback.append(self.initWrapper)

        if noosd:
            self.wrappertimer.start(100, 1)
        else:
            self.onFirstExecBegin.append(self.firstExec)
コード例 #50
0
ファイル: plugin.py プロジェクト: mic7131/enigma2-1
	def __init__(self, session, args = None):
		Screen.__init__(self, session)
		InfoBarAudioSelection.__init__(self)
		InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
		InfoBarNotifications.__init__(self)
		InfoBarBase.__init__(self)
		InfoBarScreenSaver.__init__(self)
		InfoBarSubtitleSupport.__init__(self)
		HelpableScreen.__init__(self)
		self.summary = None
		self.oldService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
		self.session.nav.stopService()

		self.setTitle(_("Media player"))

		self.playlistparsers = {}
		self.addPlaylistParser(PlaylistIOM3U, "m3u")
		self.addPlaylistParser(PlaylistIOPLS, "pls")
		self.addPlaylistParser(PlaylistIOInternal, "e2pls")

		# 'None' is magic to start at the list of mountpoints
		defaultDir = config.mediaplayer.defaultDir.getValue()
		self.filelist = FileList(defaultDir, matchingPattern = "(?i)^.*\.(dts|mp3|wav|wave|oga|ogg|flac|m4a|mp2|m2a|wma|ac3|mka|aac|ape|alac|mpg|vob|m4v|mkv|avi|divx|dat|flv|mp4|mov|wmv|asf|3gp|3g2|mpeg|mpe|rm|rmvb|ogm|ogv|m2ts|mts|ts|m3u|e2pls|pls)", useServiceRef = True, additionalExtensions = "4098:m3u 4098:e2pls 4098:pls")
		self["filelist"] = self.filelist

		self.playlist = MyPlayList()
		self.is_closing = False
		self.delname = ""
		self.playlistname = ""
		self["playlist"] = self.playlist

		self["PositionGauge"] = ServicePositionGauge(self.session.nav)

		self["currenttext"] = Label("")

		self["artisttext"] = Label(_("Artist")+':')
		self["artist"] = Label("")
		self["titletext"] = Label(_("Title")+':')
		self["title"] = Label("")
		self["albumtext"] = Label(_("Album")+':')
		self["album"] = Label("")
		self["yeartext"] = Label(_("Year")+':')
		self["year"] = Label("")
		self["genretext"] = Label(_("Genre")+':')
		self["genre"] = Label("")
		self["coverArt"] = MediaPixmap()
		self["repeat"] = MultiPixmap()

		self.seek_target = None

		try:
			from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
			hotplugNotifier.append(self.hotplugCB)
		except Exception, ex:
			print "[MediaPlayer] No hotplug support", ex
コード例 #51
0
    def __init__(self,
                 session,
                 title="",
                 list=None,
                 keys=None,
                 selection=0,
                 skin_name=None,
                 text="",
                 reorderConfig="",
                 var="",
                 windowTitle=None,
                 allow_cancel=True,
                 titlebartext=_("Choice Box")):
        if not windowTitle:  #for compatibility
            windowTitle = titlebartext
        if not list: list = []
        if not skin_name: skin_name = []
        Screen.__init__(self, session)

        self.allow_cancel = allow_cancel

        if isinstance(skin_name, str):
            skin_name = [skin_name]
        self.skinName = skin_name + ["ChoiceBox"]

        self.reorderConfig = reorderConfig
        self["text"] = Label()
        self.var = ""
        if skin_name and 'SoftwareUpdateChoices' in skin_name and var and var in (
                'unstable', 'updating', 'stable', 'unknown'):
            self.var = var
            self['feedStatusMSG'] = Label()
            self['tl_off'] = Pixmap()
            self['tl_red'] = Pixmap()
            self['tl_yellow'] = Pixmap()
            self['tl_green'] = Pixmap()

        title_max = 55
        if 'MetrixHD/' in config.skin.primary_skin.value:
            title_max += 10
        if title:
            title = _(title)
            if len(title) < title_max and title.find('\n') == -1:
                Screen.setTitle(self, title)
            elif title.find('\n') != -1:
                temptext = title.split('\n')
                if len(temptext[0]) < title_max:
                    Screen.setTitle(self, temptext[0])
                    count = 2
                    labeltext = ""
                    while len(temptext) >= count:
                        if labeltext:
                            labeltext += '\n'
                        labeltext = labeltext + temptext[count - 1]
                        count += 1
                        print '[Choicebox] count', count
                    self["text"].setText(labeltext)
                else:
                    self["text"] = Label(title)
            else:
                self["text"] = Label(title)
        elif text:
            self["text"] = Label(_(text))
        self.list = []
        self.summarylist = []
        if keys is None:
            self.__keys = [
                "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red",
                "green", "yellow", "blue", "text"
            ] + (len(list) - 14) * [""]
        else:
            self.__keys = keys + (len(list) - len(keys)) * [""]

        self.keymap = {}
        pos = 0
        if self.reorderConfig:
            self.config_type = eval("config.misc.pluginlist." +
                                    self.reorderConfig)
            if self.config_type.value:
                prev_list = zip(list, self.__keys)
                new_list = []
                for x in self.config_type.value.split(","):
                    for entry in prev_list:
                        if entry[0][0] == x:
                            new_list.append(entry)
                            prev_list.remove(entry)
                list = zip(*(new_list + prev_list))
                list, self.__keys = list[0], list[1]
                number = 1
                new_keys = []
                for x in self.__keys:
                    if (not x or x.isdigit()) and number <= 10:
                        new_keys.append(str(number % 10))
                        number += 1
                    else:
                        new_keys.append(not x.isdigit() and x or "")
                self.__keys = new_keys
        for x in list:
            strpos = str(self.__keys[pos])
            self.list.append(ChoiceEntryComponent(key=strpos, text=x))
            if self.__keys[pos] != "":
                self.keymap[self.__keys[pos]] = list[pos]
            self.summarylist.append((self.__keys[pos], x[0]))
            pos += 1
        self["windowtitle"] = Label(_(windowTitle))
        self["list"] = ChoiceList(list=self.list, selection=selection)
        self["summary_list"] = StaticText()
        self["summary_selection"] = StaticText()
        self.updateSummary(selection)

        self["actions"] = NumberActionMap(
            [
                "WizardActions", "InputActions", "ColorActions",
                "DirectionActions", "MenuActions"
            ],
            {
                "ok": self.go,
                "1": self.keyNumberGlobal,
                "2": self.keyNumberGlobal,
                "3": self.keyNumberGlobal,
                "4": self.keyNumberGlobal,
                "5": self.keyNumberGlobal,
                "6": self.keyNumberGlobal,
                "7": self.keyNumberGlobal,
                "8": self.keyNumberGlobal,
                "9": self.keyNumberGlobal,
                "0": self.keyNumberGlobal,
                "red": self.keyRed,
                "green": self.keyGreen,
                "yellow": self.keyYellow,
                "blue": self.keyBlue,
                "text": self.keyText,
                "up": self.up,
                "down": self.down,
                "left": self.left,
                "right": self.right,
                "moveUp": self.additionalMoveUp,
                "moveDown": self.additionalMoveDown,
                "menu": self.setDefaultChoiceList,
                "back": lambda: 0,  # drop through to self["cancelaction"]
            },
            prio=-2)

        self["cancelaction"] = ActionMap(["WizardActions"], {
            "back": self.cancel,
        },
                                         prio=-1)
        self.onShown.append(self.onshow)
コード例 #52
0
ファイル: plugin.py プロジェクト: mic7131/enigma2-1
	def __init__(self, session, parent):
		Screen.__init__(self, session)
		self["text1"] = Label("Media player")
		self["text3"] = Label("")
		self["text4"] = Label("")
コード例 #53
0
    def __init__(self,
                 session,
                 text="",
                 filename="",
                 currDir=None,
                 bookmarks=None,
                 userMode=False,
                 windowTitle=None,
                 minFree=None,
                 autoAdd=False,
                 editDir=False,
                 inhibitDirs=[],
                 inhibitMounts=[]):
        # Init parents
        Screen.__init__(self, session)
        NumericalTextInput.__init__(self, handleTimeout=False)
        HelpableScreen.__init__(self)

        # Set useable chars
        self.setUseableChars(u'1234567890abcdefghijklmnopqrstuvwxyz')

        # Quickselect Timer
        self.qs_timer = eTimer()
        self.qs_timer.callback.append(self.timeout)
        self.qs_timer_type = 0

        # Initialize Quickselect
        self.curr_pos = -1
        self.quickselect = ""

        # Set Text
        self["text"] = Label(text)
        self["textbook"] = Label(_("Bookmarks"))

        # Save parameters locally
        self.text = text
        self.filename = filename
        self.minFree = minFree
        self.realBookmarks = bookmarks
        self.bookmarks = bookmarks and bookmarks.value[:] or []
        self.userMode = userMode
        self.autoAdd = autoAdd
        self.editDir = editDir
        self.inhibitDirs = inhibitDirs

        # Initialize FileList
        self["filelist"] = FileList(currDir,
                                    showDirectories=True,
                                    showFiles=False,
                                    inhibitMounts=inhibitMounts,
                                    inhibitDirs=inhibitDirs)

        # Initialize BookList
        self["booklist"] = MenuList(self.bookmarks)

        # Buttons
        self["key_green"] = Button(_("OK"))
        self["key_yellow"] = Button(_("Rename"))
        self["key_blue"] = Button(_("Remove bookmark"))
        self["key_red"] = Button(_("Cancel"))

        # Background for Buttons
        self["green"] = Pixmap()
        self["yellow"] = Pixmap()
        self["blue"] = Pixmap()
        self["red"] = Pixmap()

        # Initialize Target
        self["target"] = Label()

        if self.userMode:
            self.usermodeOn()

        # Custom Action Handler
        class LocationBoxActionMap(HelpableActionMap):
            def __init__(self, parent, context, actions={}, prio=0):
                HelpableActionMap.__init__(self, parent, context, actions,
                                           prio)
                self.box = parent

            def action(self, contexts, action):
                # Reset Quickselect
                self.box.timeout(force=True)

                return HelpableActionMap.action(self, contexts, action)

        # Actions that will reset quickselect
        self["WizardActions"] = LocationBoxActionMap(
            self, "WizardActions", {
                "left": self.left,
                "right": self.right,
                "up": self.up,
                "down": self.down,
                "ok": (self.ok, _("select")),
                "back": (self.cancel, _("Cancel")),
            }, -2)

        self["ColorActions"] = LocationBoxActionMap(
            self, "ColorActions", {
                "red": self.cancel,
                "green": self.select,
                "yellow": self.changeName,
                "blue": self.addRemoveBookmark,
            }, -2)

        self["EPGSelectActions"] = LocationBoxActionMap(
            self, "EPGSelectActions", {
                "prevBouquet":
                (self.switchToBookList, _("switch to bookmarks")),
                "nextBouquet":
                (self.switchToFileList, _("switch to filelist")),
            }, -2)

        self["MenuActions"] = LocationBoxActionMap(self, "MenuActions", {
            "menu": (self.showMenu, _("menu")),
        }, -2)

        # Actions used by quickselect
        self["NumberActions"] = NumberActionMap(
            ["NumberActions"], {
                "1": self.keyNumberGlobal,
                "2": self.keyNumberGlobal,
                "3": self.keyNumberGlobal,
                "4": self.keyNumberGlobal,
                "5": self.keyNumberGlobal,
                "6": self.keyNumberGlobal,
                "7": self.keyNumberGlobal,
                "8": self.keyNumberGlobal,
                "9": self.keyNumberGlobal,
                "0": self.keyNumberGlobal
            })

        # Run some functions when shown
        if windowTitle is None:
            windowTitle = _("Select location")
        self.onShown.extend((
            boundFunction(self.setTitle, windowTitle),
            self.updateTarget,
            self.showHideRename,
        ))

        self.onLayoutFinish.append(self.switchToFileListOnStart)

        # Make sure we remove our callback
        self.onClose.append(self.disableTimer)
コード例 #54
0
ファイル: plugin.py プロジェクト: whitemm/IPTV-List-Updater
	def __init__(self, session, args = None):

		self.session = session
		path = "/usr/lib/enigma2/python/Plugins/Extensions/IPTV-List-Updater/skins/original/Start.xml"
		print path
		with open(path, "r") as f:
			self.skin = f.read()
			f.close()
		
		Screen.__init__(self, session)
		
		self["title"] = Label(_("Version %s" % Version))
		self["maintain"] = Label(_("(c) by Nobody28 & satinfo"))
		self["link1"] = Label(_("www.opena.tv"))
		self["link2"] = Label(_("www.gigablue-support.com"))
		self["description"] = Label(_("Install & update IPTV streams from country list"))
		self["description2"] = Label(_("and add into TV Bouquet or Radio Bouquet"))
		self["thanks"] = Label(_("Special thanks goes to HasBahCa & FreeTuxTV for the links"))
		
		self["actions"] = ActionMap(["OkCancelActions", "WizardActions", "ColorActions", "SetupActions", "NumberActions", "EPGSelectActions"],
		{
			"ok": self.go,
			"back": self.close,
			"red": self.close,
			"green": self.go,
			"yellow": self.change,
			"blue": self.credits,
			"info": self.faq,
			"menu": self.mod,
		}, -1)
		self["key_red"] = Label(_("Close"))
		self["key_green"] = Label(_("Start"))
		self["key_yellow"] = Label(_("Changelog"))
		self["key_blue"] = Label(_("Credits"))
コード例 #55
0
ファイル: Wizard.py プロジェクト: BarviX6/openhdf-enigma2
    def __init__(self,
                 session,
                 showSteps=True,
                 showStepSlider=True,
                 showList=True,
                 showConfig=True):
        Screen.__init__(self, session)

        self.isLastWizard = False  # can be used to skip a "goodbye"-screen in a wizard

        self.stepHistory = []

        self.wizard = {}
        parser = make_parser()
        if not isinstance(self.xmlfile, list):
            self.xmlfile = [self.xmlfile]
# 		print "Reading ", self.xmlfile
        wizardHandler = self.parseWizard(self.wizard)
        parser.setContentHandler(wizardHandler)
        for xmlfile in self.xmlfile:
            if xmlfile[0] != '/':
                parser.parse(eEnv.resolve('${datadir}/enigma2/') + xmlfile)
            else:
                parser.parse(xmlfile)

        self.showSteps = showSteps
        self.showStepSlider = showStepSlider
        self.showList = showList
        self.showConfig = showConfig

        self.numSteps = len(self.wizard)
        self.currStep = self.getStepWithID("start") + 1

        self.timeoutTimer = eTimer()
        self.timeoutTimer.callback.append(self.timeoutCounterFired)

        self["text"] = Label()

        if showConfig:
            self["config"] = ConfigList([], session=session)

        if self.showSteps:
            self["step"] = Label()

        if self.showStepSlider:
            self["stepslider"] = Slider(1, self.numSteps)

        if self.showList:
            self.list = []
            self["list"] = List(self.list, enableWrapAround=True)
            self["list"].onSelectionChanged.append(self.selChanged)
            #self["list"] = MenuList(self.list, enableWrapAround = True)

        self.onShown.append(self.updateValues)

        self.configInstance = None
        self.currentConfigIndex = None

        Wizard.instance = self

        self.lcdCallbacks = []
        self.first = False

        self.disableKeys = False

        self["actions"] = NumberActionMap(
            [
                "WizardActions", "DirectionActions", "NumberActions",
                "ColorActions", "SetupActions", "InputAsciiActions",
                "KeyboardInputActions"
            ], {
                "gotAsciiCode": self.keyGotAscii,
                "ok": self.ok,
                "back": self.back,
                "left": self.left,
                "right": self.right,
                "up": self.up,
                "down": self.down,
                "red": self.red,
                "green": self.green,
                "yellow": self.yellow,
                "blue": self.blue,
                "deleteBackward": self.deleteBackward,
                "deleteForward": self.deleteForward,
                "1": self.keyNumberGlobal,
                "2": self.keyNumberGlobal,
                "3": self.keyNumberGlobal,
                "4": self.keyNumberGlobal,
                "5": self.keyNumberGlobal,
                "6": self.keyNumberGlobal,
                "7": self.keyNumberGlobal,
                "8": self.keyNumberGlobal,
                "9": self.keyNumberGlobal,
                "0": self.keyNumberGlobal
            }, -1)

        self["VirtualKB"] = NumberActionMap(
            ["VirtualKeyboardActions"], {
                "showVirtualKeyboard": self.KeyText,
            }, -2)

        self["VirtualKB"].setEnabled(False)
コード例 #56
0
ファイル: InfoBar.py プロジェクト: mike-99/enigma2
	def __init__(self, session):
		Screen.__init__(self, session)
		if config.usage.show_infobar_lite.value and (config.skin.primary_skin.value == "DMConcinnity-HD/skin.xml" or config.skin.primary_skin.value.startswith('MetrixHD/')):
			self.skinName = "InfoBarLite"

		self["actions"] = HelpableActionMap(self, "InfobarActions",
			{
				"showMovies": (self.showMovies, _("Play recorded movies...")),
				"showRadio": (self.showRadioButton, _("Show the radio player...")),
				"showTv": (self.showTvButton, _("Show the tv player...")),
				"toogleTvRadio": (self.toogleTvRadio, _("Toggels between tv and radio...")),
				"openBouquetList": (self.openBouquetList, _("Open bouquetlist...")),
				"showMediaPlayer": (self.showMediaPlayer, _("Show the media player...")),
				"openTimerList": (self.openTimerList, _("Open Timerlist...")),
				"openAutoTimerList": (self.openAutoTimerList, _("Open AutoTimerlist...")),
				"openEPGSearch": (self.openEPGSearch, _("Open EPGSearch...")),
				"openIMDB": (self.openIMDB, _("Open IMDB...")),
				"showMC": (self.showMediaCenter, _("Show the media center...")),
				"openSleepTimer": (self.openSleepTimer, _("Show the Sleep Timer...")),
				"openPowerTimerList": (self.openPowerTimerList, _("Show the Power Timer...")),
				'ZoomInOut': (self.ZoomInOut, _('Zoom In/Out TV...')),
				'ZoomOff': (self.ZoomOff, _('Zoom Off...')),
				'HarddiskSetup': (self.HarddiskSetup, _('Select HDD')),	
				"showWWW": (self.showPORTAL, _("Open MediaPortal...")),
				"showSetup": (self.showSetup, _("Show setup...")),
				"showInformation": (self.showInformation, _("Show Information...")),
				"showFormat": (self.showFormat, _("Show Format Setup...")),
				"showPluginBrowser": (self.showPluginBrowser, _("Show the plugins...")),
				"showBoxPortal": (self.showBoxPortal, _("Show Box Portal...")),
				"openSimpleUnmount": (self.openSimpleUnmount, _("Simple umounter mass storage device.")),
			}, prio=2)

		self["key_red"] = Label()
		self["key_yellow"] = Label()
		self["key_blue"] = Label()
		self["key_green"] = Label()

		self.allowPiP = True
		self.radioTV = 0

		for x in HelpableScreen, \
				InfoBarBase, InfoBarShowHide, \
				InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, \
				InfoBarInstantRecord, InfoBarAudioSelection, InfoBarRedButton, InfoBarTimerButton, InfoBarUnhandledKey, InfoBarLongKeyDetection, InfoBarINFOpanel, InfoBarResolutionSelection, InfoBarVmodeButton, \
				InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, InfoBarAspectSelection, InfoBarBuffer, \
				InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, \
				InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, InfoBarZoom, InfoBarSleepTimer, InfoBarOpenOnTopHelper, InfoBarHandleBsod, \
				InfoBarHdmi, InfoBarPlugins, InfoBarServiceErrorPopupSupport, InfoBarButtonSetup:
			x.__init__(self)

		self.helpList.append((self["actions"], "InfobarActions", [("showMovies", _("Watch recordings..."))]))
		self.helpList.append((self["actions"], "InfobarActions", [("showRadio", _("Listen to the radio..."))]))

		self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
			{
				enigma.iPlayableService.evUpdatedEventInfo: self.__eventInfoChanged
			})

		self.current_begin_time=0
		assert InfoBar.instance is None, "class InfoBar is a singleton class and just one instance of this class is allowed!"
		InfoBar.instance = self

		if config.misc.initialchannelselection.value:
			self.onShown.append(self.showMenu)

		self.zoomrate = 0
		self.zoomin = 1

		self.onShow.append(self.doButtonsCheck)
コード例 #57
0
ファイル: content.py プロジェクト: trtko1964/archivczsk
    def __init__(self, session, archivCZSK):
        provider = ArchivCZSKContentProvider(archivCZSK, os.path.join(settings.PLUGIN_PATH, 'categories'))
        provider.start()
        contentHandler = ArchivCZSKContentHandler(session, self, provider)
        defaultCategory = config.plugins.archivCZSK.defaultCategory.value
        categoryItem = categoryAddons = None
        if defaultCategory != 'categories':
            categoryItem = provider.get_content({'category':defaultCategory})
            categoryAddons = provider.get_content({'category_addons':defaultCategory})
            # dont add PExit() if default category is user created cat.
            gotParrent = True
            try:
                gotParrent = self.getParent() is not None
            except:
                pass
            if gotParrent and (defaultCategory=='all_addons' or defaultCategory=='tv_addons' or defaultCategory=='video_addons'):
                categoryAddons is not None and categoryAddons.insert(0, PExit())
        categoryItems = provider.get_content()
        BaseContentScreen.__init__(self, session, contentHandler, categoryItems)
        if categoryItem is not None  and categoryAddons is not None:
            self.save()
            self.load({'lst_items':categoryAddons,
                            'parent_it':categoryItem,
                            'refresh':False})
        self.ctx_items.append((_("Add Category"), None, self.addCategory))
        self.provider = provider
        self.updateGUITimer = eTimer()
        self.updateGUITimer_conn = eConnectCallback(self.updateGUITimer.timeout, self.updateAddonGUI)

        # include DownloadList
        DownloadList.__init__(self)

        # include TipList
        TipBar.__init__(self, [self.CONTEXT_TIP], startOnShown=True)
        self.onUpdateGUI.append(self.changeAddon)
        self.onClose.append(self.__onClose)

        from Plugins.Extensions.archivCZSK.version import version
        self.setTitle("ArchivCZSK ("+toString(version)+")")
        self["image"] = Pixmap()
        self["title"] = Label("")
        self["author"] = Label("")
        self["version"] = Label("")
        self["about"] = Label("")

        self["key_red"] = Label(_("Manager"))
        self["key_green"] = Label()
        self["key_yellow"] = Label("")
        self["key_blue"] = Label(_("Settings"))

        self["actions"] = ActionMap(["archivCZSKActions"],
            {
                "ok": self.ok,
                "cancel": self.cancel,
                "up": self.up,
                "down": self.down,
                "blue": self.openSettings,
                "red": self.openAddonManagement,
                "menu" : self.menu
            }, -2)
        # after layout show update item "GUI" - edit: shamann
        self.onLayoutFinish.append(self.updateAddonGUI)
コード例 #58
0
    def __init__(self, session, showExtentionMenuOption):
        Screen.__init__(self, session)

        self.setup_title = _("Softcam setup")

        self["actions"] = ActionMap(
            ["OkCancelActions", "ColorActions", "CiSelectionActions"], {
                "cancel": self.cancel,
                "green": self.save,
                "red": self.cancel,
                "blue": self.ppanelShortcut,
            }, -1)

        self.list = []
        ConfigListScreen.__init__(self, self.list, session=session)

        self.softcam = CamControl('softcam')
        self.cardserver = CamControl('cardserver')

        self.ecminfo = GetEcmInfo()
        (newEcmFound, ecmInfo) = self.ecminfo.getEcm()
        self["info"] = ScrollLabel("".join(ecmInfo))
        self.EcmInfoPollTimer = eTimer()
        self.EcmInfoPollTimer.callback.append(self.setEcmInfo)
        self.EcmInfoPollTimer.start(1000)

        softcams = self.softcam.getList()
        cardservers = self.cardserver.getList()

        self.softcams = ConfigSelection(choices=softcams)
        self.softcams.value = self.softcam.current()

        self.list.append(getConfigListEntry(_("Select Softcam"),
                                            self.softcams))
        if cardservers:
            self.cardservers = ConfigSelection(choices=cardservers)
            self.cardservers.value = self.cardserver.current()
            self.list.append(
                getConfigListEntry(_("Select Card Server"), self.cardservers))

        self.list.append(
            getConfigListEntry(_("Restart softcam"),
                               ConfigAction(self.restart, "s")))
        if cardservers:
            self.list.append(
                getConfigListEntry(_("Restart cardserver"),
                                   ConfigAction(self.restart, "c")))
            self.list.append(
                getConfigListEntry(_("Restart both"),
                                   ConfigAction(self.restart, "sc")))

        if showExtentionMenuOption:
            self.list.append(
                getConfigListEntry(_("Show softcam setup in extensions menu"),
                                   config.misc.softcam_setup.extension_menu))

        self["key_red"] = Label(_("Cancel"))
        self["key_green"] = Label(_("OK"))
        self["key_blue"] = Label(_("Info"))

        self.onLayoutFinish.append(self.layoutFinished)
コード例 #59
0
ファイル: plugin.py プロジェクト: popazerty/12
	def __init__(self, session, feid):
		self.skin = PositionerSetup.skin
		Screen.__init__(self, session)
		self.feid = feid
		self.oldref = None

		cur = { }
		if not self.openFrontend():
			self.oldref = session.nav.getCurrentlyPlayingServiceReference()
			service = session.nav.getCurrentService()
			feInfo = service and service.frontendInfo()
			if feInfo:
				cur = feInfo.getTransponderData(True)
			del feInfo
			del service
			session.nav.stopService() # try to disable foreground service
			if not self.openFrontend():
				if session.pipshown: # try to disable pip
					service = self.session.pip.pipservice
					feInfo = service and service.frontendInfo()
					if feInfo:
						cur = feInfo.getTransponderData()
					del feInfo
					del service
					session.pipshown = False
					session.deleteDialog(session.pip)
					del session.pip
					if not self.openFrontend():
						self.frontend = None # in normal case this should not happen

		self.frontendStatus = { }
		self.diseqc = Diseqc(self.frontend)
		self.tuner = Tuner(self.frontend, True) #True means we dont like that the normal sec stuff sends commands to the rotor!

		tp = ( cur.get("frequency", 0) / 1000,
			cur.get("symbol_rate", 0) / 1000,
			cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal),
			cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto),
			cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown),
			cur.get("orbital_position", 0),
			cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
			cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
			cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
			cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))

		self.tuner.tune(tp)
		self.createConfig()

		self.isMoving = False
		self.stopOnLock = False

		self.red = Label("")
		self["red"] = self.red
		self.green = Label("")
		self["green"] = self.green
		self.yellow = Label("")
		self["yellow"] = self.yellow
		self.blue = Label("")
		self["blue"] = self.blue

		self.list = []
		self["list"] = ConfigList(self.list)
		self.createSetup()

		self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus)
		self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus)
		self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus)
		self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus)
		self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus)
		self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus)

		self["frequency_value"] = Label("")
		self["symbolrate_value"] = Label("")
		self["fec_value"] = Label("")

		self["actions"] = ActionMap(["DirectionActions", "OkCancelActions", "ColorActions"],
		{
			"ok": self.go,
			"cancel": self.keyCancel,
			"up": self.up,
			"down": self.down,
			"left": self.left,
			"right": self.right,
			"red": self.redKey,
			"green": self.greenKey,
			"yellow": self.yellowKey,
			"blue": self.blueKey,
		}, -1)

		self.updateColors("tune")

		self.statusTimer = eTimer()
		self.statusTimer_conn = self.statusTimer.timeout.connect(self.updateStatus)
		self.statusTimer.start(50, True)
		self.onClose.append(self.__onClose)
コード例 #60
0
 def __init__(self, session, service, eventName=None, shortDescription=None):
     Screen.__init__(self, session)
     InfoLoadChoice.__init__(self, self.callback_green_pressed)
     self.skinName = SkinTools.appendResolution('TheTVDBMain')
     if not pathExists(temp_dir):
         os.mkdir(temp_dir, 511)
     self['setupActions'] = ActionMap(['ColorActions', 'DirectionActions', 'SetupActions', 'OkCancelActions'], {'exit': self.cancel, 
        'ok': self.ok_pressed, 
        'red': self.red_pressed, 
        'green': self.green_pressed, 
        'blue': self.blue_pressed, 
        'yellow': self.yellow_pressed, 
        'cancel': self.cancel, 
        'upUp': self.pageUp, 
        'leftUp': self.pageUp, 
        'downUp': self.pageDown, 
        'rightUp': self.pageDown})
     self.service = service
     self.ratingstars = -1
     self.searchTitle = eventName
     self.description = shortDescription
     if service is not None:
         info = ServiceCenter.getInstance().info(service)
         self.searchTitle = info.getName(service)
         self.description = info.getInfoString(service, iServiceInformation.sDescription)
     print('[tvdb]', str(self.searchTitle), '-', str(self.description))
     if self.description == self.searchTitle:
         self.description = ''
     self.picload = ePicLoad()
     self.picload.PictureData.get().append(self.paintPosterPixmapCB)
     self.picload2 = ePicLoad()
     self.picload2.PictureData.get().append(self.paintBannerPixmapCB)
     self['cover'] = Pixmap()
     self['banner'] = Pixmap()
     self['stars'] = ProgressBar()
     self['no_stars'] = Pixmap()
     self['description'] = ScrollLabel('')
     self['description_episode'] = ScrollLabel('')
     self['extended'] = Label('')
     self['extended_episode'] = Label('')
     self['status'] = Label('')
     self['result_txt'] = Label('')
     self['voted'] = Label('')
     self['list'] = SeriesList()
     self['episodes_list'] = EpisodesList()
     self['seperator'] = Pixmap()
     self['thetvdb_logo'] = Pixmap()
     self['button_red'] = Pixmap()
     self['button_green'] = Pixmap()
     self['button_yellow'] = Pixmap()
     self['button_blue'] = Pixmap()
     self['key_red'] = StaticText('')
     self['key_green'] = StaticText('')
     self['key_yellow'] = StaticText('')
     self['key_blue'] = StaticText('')
     self.timer = eTimer()
     self.timer.callback.append(self.getSeriesList)
     self.red_button_timer = eTimer()
     self.red_button_timer.callback.append(self.callback_red_pressed)
     self.blue_button_timer = eTimer()
     self.blue_button_timer.callback.append(self.callback_blue_pressed)
     self.onLayoutFinish.append(self.layoutFinished)
     self.onClose.append(self.deleteTempDir)
     self.view_mode = self.SHOW_SEARCH
     self.updateView()
     self.startSearch()
     return