예제 #1
0
파일: plugin.py 프로젝트: popazerty/e2-gui
			def __init__(self, player, contexts=None, actions=None, prio=0):
				if not contexts:
					contexts = []
				if not actions:
					actions = {}
				NumberActionMap.__init__(self, contexts, actions, prio)
				self.player = player
예제 #2
0
파일: CCcamInfo.py 프로젝트: 1198s/enigma2
	def __init__(self, parent, context, actions, prio):
		alist = []
		adict = {}
		for (action, funchelp) in actions.iteritems():
			alist.append((action, funchelp[1]))
			adict[action] = funchelp[0]
		NumberActionMap.__init__(self, [context], adict, prio)
		parent.helpList.append((self, context, alist))
예제 #3
0
 def action(self, contexts, action):
     print '[MENU][MenuSelectionActionMap] action:', action
     if action == 'up' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     elif action == 'down' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     elif action == 'left' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     elif action == 'right' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     elif action == 'upRepeated' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     elif action == 'downRepeated' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     elif action == 'leftRepeated' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     elif action == 'rightRepeated' and self.menu.currentlist == self.menu.MENU_LIST:
         return 0
     else:
         return NumberActionMap.action(self, contexts, action)
예제 #4
0
	def __init__(self, session, service, isVirtualDir = False):
		Screen.__init__(self, session)
		
		self.allowPiP = SystemInfo["CanPiP"]
		self.allowPiPSwap = False
		try:
			import Plugins.Extensions.GraphMultiEPG.plugin
			self.zap_to_orig = Plugins.Extensions.GraphMultiEPG.plugin.zapToService
			Plugins.Extensions.GraphMultiEPG.plugin.zapToService = self.zapToServiceGMEPG
		except ImportError:
			self.zap_to_orig = False
		
		vtiactions = {
				"showEPGBar":(self.showEPGBar, _("show service EPGBar...")),
				"showSingleEPG":(self.showSingleEPG, _("show single service EPG...")),
				"setPlayMode":(self.setPlayMode, _("change play mode...")),
				"cancel": (self.moviebar_hide, _("leave movie player...")),
			}
		if self.allowPiP:
			vtiactions.update({"show_hide_pip": (self.showPiP, _("(de)activate Picture in Picture..."))})
		
		self["actionsVTi"] = HelpableActionMap(self, "MoviePlayerActionsVTi",vtiactions,-1)
		
		self["NumberActions"] = NumberActionMap( [ "NumberActions"],
			{
				"1": self.keyNumber,
				"2": self.keyNumber,
				"3": self.keyNumber,
				"4": self.keyNumber,
				"5": self.keyNumber,
				"6": self.keyNumber,
				"7": self.keyNumber,
				"8": self.keyNumber,
				"9": self.keyNumber,
				"0": self.keyNumber,
			}, -2)
		
		self["actions"] = HelpableActionMap(self, "MoviePlayerActions",
			{
				"showSubtitle":(self.showSubtitle, _("Show the Subtitle...")),
				"leavePlayer": (self.leavePlayer, _("leave movie player...")),
			})

		self["ChannelUpDownActions"] = HelpableActionMap(self, "ChannelUpDownActions",
			{
				"channelUp": (self.nextMedia, _("Play next media file in directory")),
				"channelDown": (self.previousMedia, _("Play previous media file in directory")),
			})

		for x in HelpableScreen, InfoBarShowHide, InfoBarMenu, \
				InfoBarBase, InfoBarSeek, InfoBarShowMovies, \
				InfoBarAudioSelection, InfoBarNotifications, InfoBarSimpleEventView, \
				InfoBarServiceNotifications, InfoBarPVRState, InfoBarCueSheetSupport, \
				InfoBarMoviePlayerSummarySupport, InfoBarSubtitleSupport, \
				InfoBarTeletextPlugin, InfoBarServiceErrorPopupSupport, InfoBarExtensions, \
				InfoBarPlugins, InfoBarPiP, InfoBarInstantRecord:
			x.__init__(self)
		self.isVirtualDir = isVirtualDir
		self.movie_playlist = None
		self.random_play = None
		self.playmode = None
		self.movie_start_config = None
		self.random_history = []
		if isinstance(service, tuple):
			self.movie_playlist = service[1]
			if len(service) >= 3:
				self.playmode = service[2]
				if self.playmode:
					self.movie_start_config = config.usage.on_movie_start.value
					config.usage.on_movie_start.value = "beginning"
			service = service[0]
		self.lastservice = session.nav.getCurrentlyPlayingServiceReference()
		if service:
			config.usage.movielist_last_played_movie.value = service.toString()
			config.usage.movielist_last_played_movie.save()
		session.nav.playService(service)
		self.returning = False
		self.InfoBar_Instance = None
		self.orig_openSingleServiceEPG = InfoBar.openSingleServiceEPG
		InfoBar.openSingleServiceEPG = self.movieEPG
		self.got_service_sel = None
		self.__InfoBar_Instance__()
		self.onClose.append(self.__onClose)
예제 #5
0
    def __init__(self,
                 session,
                 text='',
                 filename='',
                 currDir=None,
                 bookmarks=None,
                 userMode=False,
                 windowTitle=_('Select location'),
                 minFree=None,
                 autoAdd=False,
                 editDir=False,
                 inhibitDirs=None,
                 inhibitMounts=None):
        if not inhibitDirs:
            inhibitDirs = []
        if not inhibitMounts:
            inhibitMounts = []
        Screen.__init__(self, session)
        NumericalTextInput.__init__(self, handleTimeout=False)
        HelpableScreen.__init__(self)
        self.setUseableChars(u'1234567890abcdefghijklmnopqrstuvwxyz')
        self.qs_timer = eTimer()
        self.qs_timer.callback.append(self.timeout)
        self.qs_timer_type = 0
        self.curr_pos = -1
        self.quickselect = ''
        self['text'] = Label(text)
        self['textbook'] = Label(_('Bookmarks'))
        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
        self['filelist'] = FileList(currDir,
                                    showDirectories=True,
                                    showFiles=False,
                                    inhibitMounts=inhibitMounts,
                                    inhibitDirs=inhibitDirs)
        self['booklist'] = MenuList(self.bookmarks)
        self['key_green'] = Button(_('OK'))
        self['key_yellow'] = Button(_('Rename'))
        self['key_blue'] = Button(_('Remove bookmark'))
        self['key_red'] = Button(_('Cancel'))
        self['green'] = Pixmap()
        self['yellow'] = Pixmap()
        self['blue'] = Pixmap()
        self['red'] = Pixmap()
        self['target'] = Label()
        if self.userMode:
            self.usermodeOn()

        class LocationBoxActionMap(HelpableActionMap):
            def __init__(self, parent, context, actions=None, prio=0):
                if not actions:
                    actions = {}
                HelpableActionMap.__init__(self, parent, context, actions,
                                           prio)
                self.box = parent

            def action(self, contexts, action):
                self.box.timeout(force=True)
                return HelpableActionMap.action(self, contexts, action)

        self['WizardActions'] = LocationBoxActionMap(self, 'WizardActions', {
            'ok': (self.ok, _('select')),
            'back': (self.cancel, _('Cancel'))
        }, -2)
        self['DirectionActions'] = LocationBoxActionMap(
            self, 'DirectionActions', {
                'left': self.left,
                'right': self.right,
                'up': self.up,
                'down': self.down
            }, -2)
        self['ColorActions'] = LocationBoxActionMap(
            self, 'ColorActions', {
                'red': self.cancel,
                'green': self.select,
                'yellow': self.changeName,
                'blue': self.addRemoveBookmark
            }, -2)
        self['EPGSelectActions'] = LocationBoxActionMap(
            self, 'EPGSelectActions', {
                'prevService':
                (self.switchToBookList, _('switch to bookmarks')),
                'nextService': (self.switchToFileList, _('switch to filelist'))
            }, -2)
        self['MenuActions'] = LocationBoxActionMap(
            self, 'MenuActions', {'menu': (self.showMenu, _('menu'))}, -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
            })
        self.onShown.extend((boundFunction(self.setTitle,
                                           _('Select Location')),
                             self.updateTarget, self.showHideRename))
        self.onLayoutFinish.append(self.switchToFileListOnStart)
        self.onClose.append(self.disableTimer)
예제 #6
0
    def __init__(self, session, title="", **kwargs):
        Screen.__init__(self, session)
        self.keys_list = []
        self.shiftkeys_list = []
        self.lang = language.getLanguage()
        self.nextLang = None
        self.shiftMode = False
        self.selectedKey = 0
        self.smsChar = None
        self.sms = NumericalTextInput(self.smsOK)

        self.key_bg = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_bg.png"))
        self.key_sel = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_sel.png"))
        self.key_backspace = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_backspace.png"))
        self.key_all = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_all.png"))
        self.key_clr = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_clr.png"))
        self.key_esc = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_esc.png"))
        self.key_ok = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_ok.png"))
        self.key_shift = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_shift.png"))
        self.key_shift_sel = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_shift_sel.png"))
        self.key_space = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_space.png"))
        self.key_left = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_left.png"))
        self.key_right = LoadPixmap(path=resolveFilename(
            SCOPE_CURRENT_SKIN, "skin_default/vkey_right.png"))

        self.keyImages = {
            "BACKSPACE": self.key_backspace,
            "ALL": self.key_all,
            "EXIT": self.key_esc,
            "OK": self.key_ok,
            "SHIFT": self.key_shift,
            "SPACE": self.key_space,
            "LEFT": self.key_left,
            "RIGHT": self.key_right
        }
        self.keyImagesShift = {
            "BACKSPACE": self.key_backspace,
            "CLEAR": self.key_clr,
            "EXIT": self.key_esc,
            "OK": self.key_ok,
            "SHIFT": self.key_shift_sel,
            "SPACE": self.key_space,
            "LEFT": self.key_left,
            "RIGHT": self.key_right
        }

        self["country"] = StaticText("")
        self["header"] = Label(title)
        self["text"] = Input(currPos=len(
            kwargs.get("text", "").decode("utf-8", 'ignore')),
                             allMarked=False,
                             **kwargs)
        self["list"] = VirtualKeyBoardList([])

        self["actions"] = NumberActionMap(
            [
                "OkCancelActions", "WizardActions", "ColorActions",
                "KeyboardInputActions", "InputBoxActions", "InputAsciiActions"
            ], {
                "gotAsciiCode": self.keyGotAscii,
                "ok": self.okClicked,
                "cancel": self.exit,
                "left": self.left,
                "right": self.right,
                "up": self.up,
                "down": self.down,
                "red": self.exit,
                "green": self.ok,
                "yellow": self.switchLang,
                "blue": self.shiftClicked,
                "deleteBackward": self.backClicked,
                "deleteForward": self.forwardClicked,
                "back": self.exit,
                "pageUp": self.cursorRight,
                "pageDown": self.cursorLeft,
                "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.setLang()
        self.onExecBegin.append(self.setKeyboardModeAscii)
        self.onLayoutFinish.append(self.buildVirtualKeyBoard)
        self.onClose.append(self.__onClose)
예제 #7
0
 def __init__(self, menu, contexts = [], actions = {}, prio = -1):
     NumberActionMap.__init__(self, contexts, actions, prio)
     self.menu = menu
예제 #8
0
파일: DVD.py 프로젝트: wslee2/enigma2
    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["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,
            })

        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
예제 #9
0
파일: ChoiceBox.py 프로젝트: wedebe/enigma2
    def __init__(self,
                 session,
                 title="",
                 list=None,
                 keys=None,
                 selection=0,
                 skin_name=None,
                 text="",
                 reorderConfig="",
                 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()

        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)
                if text != "":
                    self["text"] = Label(_(text))
            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 = [i for i in 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 = [i for i in 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,
                "shiftUp": self.additionalMoveUp,
                "shiftDown": self.additionalMoveDown,
                "menu": self.setDefaultChoiceList,
                "back": lambda: 0,  # drop through to self["cancelaction"]
            },
            prio=-2)

        self["cancelaction"] = ActionMap(["WizardActions"], {
            "back": self.cancel,
        },
                                         prio=-1)
예제 #10
0
 def __init__(self, session, tlist, menuTitle):
     Screen.__init__(self, session)
     self.skinName = 'Animmain'
     self.tlist = tlist
     ipage = 1
     list = []
     nopic = len(tlist)
     self.pos = []
     self.index = 0
     title = menuTitle
     self['title'] = Button(title)
     list = []
     tlist = []
     self['label1'] = StaticText()
     self['label2'] = StaticText()
     self['label3'] = StaticText()
     self['label4'] = StaticText()
     self['label5'] = StaticText()
     self['red'] = Button(_('Exit'))
     self['green'] = Button(_('Select'))
     self['yellow'] = Button(_('Config'))
     self['actions'] = NumberActionMap(
         [
             'OkCancelActions', 'MenuActions', 'DirectionActions',
             'NumberActions', 'ColorActions'
         ], {
             'ok': self.okbuttonClick,
             'cancel': self.closeNonRecursive,
             'left': self.key_left,
             'right': self.key_right,
             'up': self.key_up,
             'down': self.key_down,
             'red': self.cancel,
             'green': self.okbuttonClick,
             'yellow': self.key_menu,
             'menu': self.closeRecursive,
             '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
         })
     nop = len(self.tlist)
     self.nop = nop
     nh = 1
     if nop == 1:
         nh = 1
     elif nop == 2:
         nh = 2
     elif nop == 3:
         nh = 2
     elif nop == 4:
         nh = 3
     elif nop == 5:
         nh = 3
     else:
         nh = int(float(nop) / 2)
     self.index = nh
     i = 0
     self.onShown.append(self.openTest)
예제 #11
0
    def __init__(self,
                 session,
                 text="",
                 filename="",
                 currDir=None,
                 bookmarks=None,
                 userMode=False,
                 windowTitle=_("Select location"),
                 minFree=None,
                 autoAdd=False,
                 editDir=False,
                 inhibitDirs=None,
                 inhibitMounts=None):
        # Init parents
        if not inhibitDirs: inhibitDirs = []
        if not inhibitMounts: inhibitMounts = []
        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()
        self["targetfreespace"] = Label()

        if self.userMode:
            self.usermodeOn()

        # Custom Action Handler
        class LocationBoxActionMap(HelpableActionMap):
            def __init__(self, parent, context, actions=None, prio=0):
                if not actions: actions = {}
                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", {
            "ok": (self.ok, _("select")),
            "back": (self.cancel, _("Cancel")),
        }, -2)

        self["DirectionActions"] = LocationBoxActionMap(
            self, "DirectionActions", {
                "left": self.left,
                "right": self.right,
                "up": self.up,
                "down": self.down,
            }, -2)

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

        self["EPGSelectActions"] = LocationBoxActionMap(
            self, "EPGSelectActions", {
                "prevService":
                (self.switchToBookList, _("switch to bookmarks")),
                "nextService":
                (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
        self.onShown.extend((
            boundFunction(self.setTitle, _("Select Location")),
            self.updateTarget,
            self.showHideRename,
        ))

        self.onLayoutFinish.append(self.switchToFileListOnStart)

        # Make sure we remove our callback
        self.onClose.append(self.disableTimer)
    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)
예제 #13
0
	def __init__(self, session, servicelist=None):
		Screen.__init__(self, session)
		self.session = session
		if SystemInfo.get("NumVideoDecoders", 1) > 1 and config.plugins.virtualzap.usepip.value and config.plugins.virtualzap.showpipininfobar.value:
			self.skinName = "VirtualZap"
			self.pipAvailable = True
		else:
			self.skinName = "VirtualZapNoPiP"
			self.pipAvailable = (SystemInfo.get("NumVideoDecoders", 1) > 1) and config.plugins.virtualzap.usepip.value and not config.plugins.virtualzap.showpipininfobar.value
		self.epgcache = eEPGCache.getInstance()
		self.CheckForEPG = eTimer()
		self.CheckForEPG.callback.append(self.CheckItNow)
		self["NowChannel"] = Label()
		self["NowEPG"] = Label()
		self["NextEPG"] = Label()
		self["NowTime"] = Label()
		self["NextTime"] = Label()
		self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ChannelSelectBaseActions", "ChannelSelectEPGActions", "ColorActions"],
		{
			"ok": self.ok,
			"cancel": self.closing,
			"right": self.nextService,
			"left": self.prevService,
			"nextBouquet": self.showFavourites,
			"prevBouquet": self.openServiceList,
			"showEPGList": self.openEventView,
			"blue": self.standardPiP,
			"yellow": self.switchAndStandardPiP,
			"down": self.switchChannelDown,
			"up": self.switchChannelUp,
		}, -2)
		self["actions2"] = NumberActionMap(["NumberActions"],
		{
			"0": self.swap,
			"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,
		}, -1)
		self.onLayoutFinish.append(self.onLayoutReady)
		# PiP
		if self.pipAvailable:
			# activate PiP support
			if config.plugins.virtualzap.usepip.value and not config.plugins.virtualzap.showpipininfobar.value:
				# activate standard PiP
				self["video"] = VideoWindow()
			else:
				# show PiP in Infobar
				self["video"] = VideoWindow(fb_width=getDesktop(0).size().width(), fb_height=getDesktop(0).size().height())
			self.currentPiP = ""
		else:
			# no PiP
			self["video"] = Label()
		# this is the servicelist from ChannelSelectionBase
		self.servicelist = servicelist
		# save orig. method of zap in servicelist
		self.servicelist_orig_zap = self.servicelist.zap
		# when displaying ChannelSelection, do not zap when pressing "ok", so new method is needed
		self.servicelist.zap = self.servicelist_overwrite_zap
		# overwrite the actionmap of ChannelSelection
		self.servicelist["actions"] = ActionMap(["OkCancelActions"],
			{
				"cancel": self.cancelChannelSelection,
				"ok": self.servicelist.channelSelected,
			})
		# temp. vars, needed when pressing cancel in ChannelSelection
		self.curSelectedRef = None
		self.curSelectedBouquet = None
		# needed, because if we won't zap, we have to go back to the current bouquet and service
		self.curRef = ServiceReference(self.servicelist.getCurrentSelection())
		self.curBouquet = self.servicelist.getRoot()
		# start with last used service
		if config.plugins.virtualzap.saveLastService.value:
			# get service and bouquet ref
			ref = eServiceReference(config.plugins.virtualzap.curref.value)
			bouquet = eServiceReference(config.plugins.virtualzap.curbouquet.value)
			if ref.valid() and bouquet.valid():
				# select bouquet and ref in servicelist
				self.setServicelistSelection(bouquet, ref)
		# prepare exitTimer
		self.exitTimer = eTimer()
		self.exitTimer.timeout.get().append(self.standardPiP)
		# reverse changes of ChannelSelection when closing plugin
		self.onClose.append(self.__onClose)
		# if PiPServiceRelation is installed, get relation dict
		if plugin_PiPServiceRelation_installed:
			self.pipServiceRelation = getRelationDict()
		else:
			self.pipServiceRelation = {}
    def __init__(self, session, infobar=None, page=PAGE_AUDIO):
        Screen.__init__(self, session)

        self["streams"] = List([], enableWrapAround=True)
        self["key_red"] = Boolean(False)
        self["key_green"] = Boolean(False)
        self["key_yellow"] = Boolean(True)
        self["key_blue"] = Boolean(False)
        self["key_left"] = Pixmap()
        self["key_right"] = Pixmap()
        self["switchdescription"] = Label(
            _("Switch between Audio-, Subtitlepage"))
        self["summary_description"] = StaticText("")

        self.protectContextMenu = True

        ConfigListScreen.__init__(self, [])
        self.infobar = infobar or self.session.infobar

        self.__event_tracker = ServiceEventTracker(
            screen=self,
            eventmap={iPlayableService.evUpdatedInfo: self.__updatedInfo})
        self.cached_subtitle_checked = False
        self.__selected_subtitle = None

        self["actions"] = NumberActionMap(
            [
                "ColorActions", "OkCancelActions", "DirectionActions",
                "MenuActions", "InfobarAudioSelectionActions",
                "InfobarSubtitleSelectionActions"
            ], {
                "red": self.keyRed,
                "green": self.keyGreen,
                "yellow": self.keyYellow,
                "subtitleSelection": self.keyAudioSubtitle,
                "audioSelection": self.keyAudioSubtitle,
                "blue": self.keyBlue,
                "ok": self.keyOk,
                "cancel": self.cancel,
                "up": self.keyUp,
                "down": self.keyDown,
                "volumeUp": self.volumeUp,
                "volumeDown": self.volumeDown,
                "volumeMute": self.volumeMute,
                "menu": self.openAutoLanguageSetup,
                "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,
            }, -2)

        self.settings = ConfigSubsection()
        choicelist = [(PAGE_AUDIO, ""), (PAGE_SUBTITLES, "")]
        self.settings.menupage = ConfigSelection(choices=choicelist,
                                                 default=page)
        self.onLayoutFinish.append(self.__layoutFinished)
예제 #15
0
    def __init__(self, session, services):
        Screen.__init__(self, session)

        self.session = session
        self.oldService = self.session.nav.getCurrentlyPlayingServiceReference(
        )
        self.consoleCmd = ""
        self.Console = Console()
        self.serviceHandler = eServiceCenter.getInstance()
        self.ref_list = services
        self.window_refs = [
            None, None, None, None, None, None, None, None, None
        ]
        self.current_refidx = 0
        self.current_window = 1
        self.countdown = config.plugins.Mosaic.countdown.value
        self.working = False
        self.state = self.PLAY

        self["playState"] = Pixmap()
        for i in range(1, 10):
            self["window" + str(i)] = Pixmap()
            self["video" + str(i)] = VideoWindow(decoder=0,
                                                 fb_width=self.width,
                                                 fb_height=self.height)
            self["video" + str(i)].hide()
            self["channel" + str(i)] = Label("")
            self["event" + str(i)] = Label("")
            self["event" + str(i)].hide()
        self["video1"].decoder = 0
        self["video1"].show()
        self["countdown"] = Label()
        self.updateCountdownLabel()
        self["count"] = Label()

        self["actions"] = NumberActionMap(
            ["MosaicActions"], {
                "ok": self.exit,
                "cancel": self.closeWithOldService,
                "green": self.play,
                "yellow": self.pause,
                "channelup": self.countdownPlus,
                "channeldown": self.countdownMinus,
                "1": self.numberPressed,
                "2": self.numberPressed,
                "3": self.numberPressed,
                "4": self.numberPressed,
                "5": self.numberPressed,
                "6": self.numberPressed,
                "7": self.numberPressed,
                "8": self.numberPressed,
                "9": self.numberPressed
            },
            prio=-1)

        self.updateTimer = eTimer()
        self.updateTimer_conn = self.updateTimer.timeout.connect(
            self.updateCountdown)
        self.checkTimer = eTimer()
        self.checkTimer_conn = self.checkTimer.timeout.connect(self.checkGrab)
        self.checkTimer.start(500, 1)
예제 #16
0
파일: Menu.py 프로젝트: dream-alpha/enigma2
	def __init__(self, session, parent):
		Screen.__init__(self, session)
		list = []

		menuID = None
		count = 0
		for x in parent:	#walk through the actual nodelist
			if x.tag == 'item':
				item_level = int(x.get("level", 0))
				if item_level <= config.usage.setup_level.index:
					self.addItem(list, x)
					count += 1
			elif x.tag == 'menu':
				self.addMenu(list, x)
				count += 1
			elif x.tag == "id":
				menuID = x.get("val")
				count = 0

			if menuID is not None:
				# menuupdater?
				if menuupdater.updatedMenuAvailable(menuID):
					for x in menuupdater.getUpdatedMenu(menuID):
						if x[1] == count:
							description = six.ensure_str(x.get("description", "")) or None
							description = description and _(description)
							menupng = MenuEntryPixmap(menuID, self.png_cache, lastMenuID)
							list.append((x[0], boundFunction(self.runScreen, (x[2], x[3] + ", ")), x[4], description, menupng))
							count += 1

		if menuID is not None:
			# plugins
			for l in plugins.getPluginsForMenu(menuID):
				# check if a plugin overrides an existing menu
				plugin_menuid = l[2]
				for x in list:
					if x[2] == plugin_menuid:
						list.remove(x)
						break
				description = l[4] if len(l) == 5 else plugins.getDescriptionForMenuEntryID(menuID, plugin_menuid)
				menupng = MenuEntryPixmap(l[2], self.png_cache, lastMenuID)
				list.append((l[0], boundFunction(l[1], self.session), l[2], l[3] or 50, description, menupng))

		# for the skin: first try a menu_<menuID>, then Menu
		self.skinName = [ ]
		if menuID is not None:
			self.skinName.append("menu_" + menuID)
		self.skinName.append("Menu")

		# Sort by Weight
		list.sort(key=lambda x: int(x[3]))

		self._list = List(list)
		self._list.onSelectionChanged.append(self._onSelectionChanged)
		self["menu"] = self._list
		self["pixmap"] = Pixmap()
		self["description"] = StaticText()

		self["actions"] = NumberActionMap(["OkCancelActions", "MenuActions", "NumberActions"],
			{
				"ok": self.okbuttonClick,
				"cancel": self.closeNonRecursive,
				"menu": self.closeRecursive,
				"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
			})

		a = six.ensure_str(parent.get("title", "")) or None
		a = a and _(a)
		if a is None:
			a = _(six.ensure_str(parent.get("text", "")))
		self["title"] = StaticText(a)
		self.menu_title = a
		self.onLayoutFinish.append(self._onLayoutFinish)
예제 #17
0
    def __init__(self, session, parent):
        self.parentmenu = parent
        Screen.__init__(self, session)
        self["key_blue"] = StaticText("")
        self["menu"] = List([])
        self["menu"].enableWrapAround = True
        self.showNumericHelp = False
        self.createMenuList()

        # for the skin: first try a menu_<menuID>, then Menu
        self.skinName = []
        if 'horz' in config.usage.menutype.value:
            skfile = '/usr/share/enigma2/' + config.skin.primary_skin.value
            f1 = open(skfile, 'r')
            self.sktxt = f1.read()
            f1.close()
        if self.menuID is not None:
            if config.usage.menutype.value == 'horzanim' and '<screen name="Animmain" ' in self.sktxt:
                self.skinName.append('Animmain')
            elif config.usage.menutype.value == 'horzicon' and '<screen name="Iconmain" ' in self.sktxt:
                self.skinName.append('Iconmain')
            else:
                self.skinName.append('menu_' + self.menuID)
        self.skinName.append("Menu")
        ProtectedScreen.__init__(self)
        self["actions"] = NumberActionMap(
            [
                "OkCancelActions", "MenuActions", "NumberActions",
                "HelpActions", "ColorActions"
            ], {
                "ok": self.okbuttonClick,
                "cancel": self.closeNonRecursive,
                "menu": self.closeRecursive,
                "0": self.keyNumberGlobal,
                "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,
                "displayHelp": self.showHelp,
                "blue": self.keyBlue,
            })
        title = parent.get("title", "").encode("UTF-8") or None
        title = title and _(title) or _(parent.get("text", "").encode("UTF-8"))
        title = self.__class__.__name__ == "MenuSort" and _(
            "Menusort (%s)") % title or title
        if title is None:
            title = _(parent.get('text', '').encode('UTF-8'))
        else:
            t_history.reset()
        self["title"] = StaticText(title)
        self.setScreenPathMode(True)
        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 '<screen name="Animmain" ' in self.sktxt:
            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 '<screen name="Iconmain" ' in self.sktxt:
            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.list) == 1:
            self.onExecBegin.append(self.__onExecBegin)
예제 #18
0
    def __init__(self,
                 session,
                 title='',
                 list=None,
                 keys=None,
                 selection=0,
                 skin_name=None,
                 text='',
                 reorderConfig='',
                 var=''):
        if not list:
            list = []
        if not skin_name:
            skin_name = []
        Screen.__init__(self, session)
        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()
        if title:
            title = _(title)
            if len(title) < 55 and title.find('\n') == -1:
                Screen.setTitle(self, title)
            elif title.find('\n') != -1:
                temptext = title.split('\n')
                if len(temptext[0]) < 55:
                    Screen.setTitle(self, temptext[0])
                    count = 2
                    labeltext = ''
                    while len(temptext) >= count:
                        if labeltext:
                            labeltext += '\n'
                        labeltext = labeltext + temptext[count - 1]
                        count += 1
                        print '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'
            ] + (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['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,
                'up': self.up,
                'down': self.down,
                'left': self.left,
                'right': self.right,
                'shiftUp': self.additionalMoveUp,
                'shiftDown': self.additionalMoveDown,
                'menu': self.setDefaultChoiceList
            }, -1)
        self['cancelaction'] = NumberActionMap(
            ['WizardActions', 'InputActions', 'ColorActions'],
            {'back': self.cancel}, -1)
        self.onShown.append(self.onshow)
        return
예제 #19
0
    def __init__(self, session, parent):
        Screen.__init__(self, session)

        self.sort_mode = False
        self.selected_entry = None
        self.sub_menu_sort = None

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

        m_list = []

        menuID = None
        for x in parent:  #walk through the actual nodelist
            if not x.tag:
                continue
            if x.tag == 'item':
                item_level = int(x.get("level", 0))
                if item_level <= config.usage.setup_level.index:
                    self.addItem(m_list, x)
                    count += 1
            elif x.tag == 'menu':
                item_level = int(x.get("level", 0))
                if item_level <= config.usage.setup_level.index:
                    self.addMenu(m_list, x)
                    count += 1
            elif x.tag == "id":
                menuID = x.get("val")
                count = 0

            if menuID is not None:
                # menuupdater?
                if menuupdater.updatedMenuAvailable(menuID):
                    for x in menuupdater.getUpdatedMenu(menuID):
                        if x[1] == count:
                            description = six.ensure_str(
                                x.get("description", "")) or None
                            description = description and _(description)
                            menupng = MenuEntryPixmap(menuID, self.png_cache,
                                                      lastMenuID)
                            m_list.append(
                                (x[0],
                                 boundFunction(self.runScreen,
                                               (x[2], x[3] + ", ")), x[4],
                                 description, menupng))
                            count += 1

        self.menuID = menuID
        if config.ParentalControl.configured.value:
            ProtectedScreen.__init__(self)

        if menuID is not None:
            # plugins
            for l in plugins.getPluginsForMenu(menuID):
                # check if a plugin overrides an existing menu
                plugin_menuid = l[2]
                for x in m_list:
                    if x[2] == plugin_menuid:
                        m_list.remove(x)
                        break
                description = plugins.getDescriptionForMenuEntryID(
                    menuID, plugin_menuid)
                menupng = MenuEntryPixmap(l[2], self.png_cache, lastMenuID)
                if len(l) > 4 and l[4]:
                    m_list.append(
                        (l[0], boundFunction(l[1], self.session,
                                             self.close), l[2], l[3]
                         or 50, description, menupng))
                else:
                    m_list.append(
                        (l[0], boundFunction(l[1], self.session), l[2], l[3]
                         or 50, description, menupng))

        # for the skin: first try a menu_<menuID>, then Menu
        self.skinName = []
        if 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_' + menuID)
        self.skinName.append("Menu")
        self.menuID = menuID
        ProtectedScreen.__init__(self)

        if config.usage.menu_sort_mode.value == "user" and menuID == "mainmenu":
            plugin_list = []
            id_list = []
            for l in plugins.getPlugins([
                    PluginDescriptor.WHERE_PLUGINMENU,
                    PluginDescriptor.WHERE_EXTENSIONSMENU,
                    PluginDescriptor.WHERE_EVENTINFO
            ]):
                l.id = (l.name.lower()).replace(' ', '_')
                if l.id not in id_list:
                    id_list.append(l.id)
                    plugin_list.append(
                        (l.name, boundFunction(l.__call__,
                                               session), l.id, 200))

        self.list = m_list

        if menuID is not None and config.usage.menu_sort_mode.value == "user":
            self.sub_menu_sort = NoSave(ConfigDictionarySet())
            self.sub_menu_sort.value = config.usage.menu_sort_weight.getConfigValue(
                self.menuID, "submenu") or {}
            idx = 0
            for x in self.list:
                entry = list(self.list.pop(idx))
                m_weight = self.sub_menu_sort.getConfigValue(
                    entry[2], "sort") or entry[3]
                entry.append(m_weight)
                self.list.insert(idx, tuple(entry))
                self.sub_menu_sort.changeConfigValue(entry[2], "sort",
                                                     m_weight)
                idx += 1
            self.full_list = list(m_list)

        if config.usage.menu_sort_mode.value == "a_z":
            # Sort by Name
            m_list.sort(key=self.sortByName)
        elif config.usage.menu_sort_mode.value == "user":
            self["blue"].setText(_("Edit mode on"))
            self.hide_show_entries()
            m_list = self.list
        else:
            # Sort by Weight
            m_list.sort(key=lambda x: int(x[3]))

        if config.usage.menu_show_numbers.value:
            m_list = [(str(x[0] + 1) + " " + x[1][0], x[1][1], x[1][2])
                      for x in enumerate(m_list)]

        self["menu"] = List(m_list)
        self["menu"].enableWrapAround = True
        if config.usage.menu_sort_mode.value == "user":
            self["menu"].onSelectionChanged.append(self.selectionChanged)

        self["actions"] = NumberActionMap(
            ["OkCancelActions", "MenuActions", "NumberActions"],
            {
                "ok": self.okbuttonClick,
                "cancel": self.closeNonRecursive,
                "menu": self.closeRecursive,
                #"0": self.resetSortOrder,
                "0": self.keyNumberGlobal,
                "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
            })

        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,
                })

        a = six.ensure_str(parent.get("title", "")) or None
        a = a and _(a)
        if a is None:
            a = _(six.ensure_str(parent.get("text", "")))
        else:
            t_history.reset()
        self["title"] = StaticText(a)
        Screen.setTitle(self, a)
        self.menu_title = a

        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(a)
        elif history_len < 21:
            self["title0"] = StaticText('')
            self["title1"] = StaticText(a)
        else:
            self["title0"] = StaticText('')
            self["title1"] = StaticText('')
            self["title2"] = StaticText(a)

        if (t_history.thistory == ''):
            t_history.thistory = str(a) + ' > '
        else:
            t_history.thistory = t_history.thistory + str(a) + ' > '

        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)
예제 #20
0
 def __init__(self, session, title='', **kwargs):
     Screen.__init__(self, session)
     self.setTitle(_('Virtual KeyBoard'))
     self.keys_list = []
     self.shiftkeys_list = []
     self.lang = language.getLanguage()
     self.nextLang = None
     self.shiftMode = False
     self.selectedKey = 0
     self.smsChar = None
     self.sms = NumericalTextInput(self.smsOK)
     self.key_bg = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_bg.png'))
     self.key_sel = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_sel.png'))
     self.key_backspace = LoadPixmap(path=resolveFilename(
         SCOPE_ACTIVE_SKIN, 'buttons/vkey_backspace.png'))
     self.key_all = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_all.png'))
     self.key_clr = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_clr.png'))
     self.key_esc = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_esc.png'))
     self.key_ok = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_ok.png'))
     self.key_shift = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_shift.png'))
     self.key_shift_sel = LoadPixmap(path=resolveFilename(
         SCOPE_ACTIVE_SKIN, 'buttons/vkey_shift_sel.png'))
     self.key_space = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_space.png'))
     self.key_left = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_left.png'))
     self.key_right = LoadPixmap(
         path=resolveFilename(SCOPE_ACTIVE_SKIN, 'buttons/vkey_right.png'))
     self.keyImages = {
         'BACKSPACE': self.key_backspace,
         'ALL': self.key_all,
         'EXIT': self.key_esc,
         'OK': self.key_ok,
         'SHIFT': self.key_shift,
         'SPACE': self.key_space,
         'LEFT': self.key_left,
         'RIGHT': self.key_right
     }
     self.keyImagesShift = {
         'BACKSPACE': self.key_backspace,
         'CLEAR': self.key_clr,
         'EXIT': self.key_esc,
         'OK': self.key_ok,
         'SHIFT': self.key_shift_sel,
         'SPACE': self.key_space,
         'LEFT': self.key_left,
         'RIGHT': self.key_right
     }
     self['country'] = StaticText('')
     self['header'] = Label()
     self['text'] = Input(currPos=len(
         kwargs.get('text', '').decode('utf-8', 'ignore')),
                          allMarked=False,
                          **kwargs)
     self['list'] = VirtualKeyBoardList([])
     self['actions'] = NumberActionMap(
         [
             'OkCancelActions', 'WizardActions', 'ColorActions',
             'KeyboardInputActions', 'InputBoxActions', 'InputAsciiActions'
         ], {
             'gotAsciiCode': self.keyGotAscii,
             'ok': self.okClicked,
             'OKLong': self.okLongClicked,
             'cancel': self.exit,
             'left': self.left,
             'right': self.right,
             'up': self.up,
             'down': self.down,
             'red': self.exit,
             'green': self.ok,
             'yellow': self.switchLang,
             'blue': self.shiftClicked,
             'deleteBackward': self.backClicked,
             'deleteForward': self.forwardClicked,
             'back': self.exit,
             'pageUp': self.cursorRight,
             'pageDown': self.cursorLeft,
             '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.setLang()
     self.onExecBegin.append(self.setKeyboardModeAscii)
     self.onLayoutFinish.append(self.buildVirtualKeyBoard)
     self.onClose.append(self.__onClose)
     return
예제 #21
0
 def __init__(self, session, tlist, menuTitle):
     Screen.__init__(self, session)
     self.skinName = 'Iconmain'
     self.tlist = tlist
     ipage = 1
     list = []
     nopic = len(self.tlist)
     self.pos = []
     self.ipage = 1
     self.index = 0
     title = menuTitle
     self['title'] = Button(title)
     self.icons = []
     self.indx = []
     n1 = len(tlist)
     self.picnum = n1
     list = []
     tlist = []
     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['red'] = Button(_('Exit'))
     self['green'] = Button(_('Select'))
     self['yellow'] = Button(_('Config'))
     self['actions'] = NumberActionMap(
         [
             'OkCancelActions', 'MenuActions', 'DirectionActions',
             'NumberActions', 'ColorActions'
         ], {
             'ok': self.okbuttonClick,
             'cancel': self.closeNonRecursive,
             'left': self.key_left,
             'right': self.key_right,
             'up': self.key_up,
             'down': self.key_down,
             'red': self.cancel,
             'green': self.okbuttonClick,
             'yellow': self.key_menu,
             'menu': self.closeRecursive,
             '1': self.keyNumberGlobal,
             '2': self.keyNumberGlobal,
             '3': self.keyNumberGlobal,
             '4': self.keyNumberGlobal,
             '5': self.keyNumberGlobal,
             '6': self.keyNumberGlobal,
             '7': self.keyNumberGlobal,
             '8': self.keyNumberGlobal,
             '9': self.keyNumberGlobal
         })
     self.index = 0
     i = 0
     self.maxentry = 29
     self.istart = 0
     i = 0
     self.onShown.append(self.openTest)
예제 #22
0
파일: plugin.py 프로젝트: vuteam/dvbapp
 def __init__(self, player, contexts=[], actions={}, prio=0):
     NumberActionMap.__init__(self, contexts, actions, prio)
     self.player = player
예제 #23
0
    def __init__(self,
                 session,
                 title="",
                 list=None,
                 keys=None,
                 selection=0,
                 skin_name=None,
                 text="",
                 reorderConfig="",
                 var="",
                 menu_path=""):
        if not list: list = []
        if not skin_name: skin_name = []
        Screen.__init__(self, session)

        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()
        if skin_name and 'SoftwareUpdateChoices' in skin_name:
            self["menu_path_compressed"] = StaticText(menu_path)

        if title:
            title = _(title)
            if len(title) < 55 and title.find('\n') == -1:
                Screen.setTitle(self, title)
            elif title.find('\n') != -1:
                temptext = title.split('\n')
                if len(temptext[0]) < 55:
                    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"
            ] + (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["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,
                "up": self.up,
                "down": self.down,
                "left": self.left,
                "right": self.right,
                "shiftUp": self.additionalMoveUp,
                "shiftDown": self.additionalMoveDown,
                "menu": self.setDefaultChoiceList
            }, -1)

        self["cancelaction"] = NumberActionMap(
            ["WizardActions", "InputActions", "ColorActions"], {
                "back": self.cancel,
            }, -1)
        self.onShown.append(self.onshow)
예제 #24
0
    def __init__(self, session, args=0):
        Screen.__init__(self, session)
        ProtectedScreen.__init__(self)
        screentitle = _("ViX")
        self.menu_path = _("Main menu") + ' / ' + _("Setup") + ' / '
        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("")
        Screen.setTitle(self, title)
        self.menu = args
        self.list = []
        if self.menu == 0:
            self.list.append(("backup-manager", _("Backup manager"),
                              _("Manage the backups of your settings."), None))
            self.list.append(
                ("image-manager", _("Image manager"),
                 _("Create and flash complete images of your system."), None))
            self.list.append(("ipkg-install", _("Install local extension"),
                              _("Install IPK's from your tmp folder."), None))
            self.list.append(("mount-manager", _("Mount manager"),
                              _("Manage your devices mount points."), None))
            self.list.append(("script-runner", _("Script runner"),
                              _("Run your shell scripts."), None))
            self.list.append(("swap-manager", _("SWAP manager"),
                              _("Create and Manage your SWAP files."), None))
            if SystemInfo["canMultiBoot"]:
                self.list.append(("multiboot manager", _("MultiBoot manager"),
                                  _("Create empty slot."), None))
            if SystemInfo["HasH9SD"]:
                self.list.append(("H9SDcard manager", _("H9SDcard Manager"),
                                  _("Move Nand root to SD card"), None))
        self["menu"] = List(self.list)
        self["key_red"] = StaticText(_("Close"))

        self["shortcuts"] = NumberActionMap(
            [
                "ShortcutActions", "WizardActions", "InfobarEPGActions",
                "MenuActions", "NumberActions"
            ], {
                "ok": self.go,
                "back": self.close,
                "red": self.close,
                "menu": self.closeRecursive,
                "1": self.go,
                "2": self.go,
                "3": self.go,
                "4": self.go,
                "5": self.go,
                "6": self.go,
                "7": self.go,
                "8": self.go,
                "9": self.go,
            }, -1)
        self.onLayoutFinish.append(self.layoutFinished)
        self.onChangedEntry = []
        self["menu"].onSelectionChanged.append(self.selectionChanged)
예제 #25
0
파일: plugin.py 프로젝트: neodela/enigma2-1
	def __init__(self, session, feid):
		self.session = session
		Screen.__init__(self, session)
		self.feid = feid
		self.oldref = None
		log.open(self.LOG_SIZE)
		if config.Nims[self.feid].configMode.value == 'advanced':
			self.advanced = True
			self.advancedconfig = config.Nims[self.feid].advanced
			self.advancedsats = self.advancedconfig.sat
			self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid))
		else:
			self.advanced = False

		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(True)
					del feInfo
					del service
					from Screens.InfoBar import InfoBar
					InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
				if not self.openFrontend():
					self.frontend = None # in normal case this should not happen
					if hasattr(self, 'raw_channel'):
						del self.raw_channel

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

		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.isMoving = False
		self.stopOnLock = False

		self.red = Button("")
		self["key_red"] = self.red
		self.green = Button("")
		self["key_green"] = self.green
		self.yellow = Button("")
		self["key_yellow"] = self.yellow
		self.blue = Button("")
		self["key_blue"] = self.blue

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

		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["polarisation"] = Label("")
		self["status_bar"] = Label("")
		self.statusMsgTimeoutTicks = 0
		self.statusMsgBlinking = False
		self.statusMsgBlinkCount = 0
		self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL	# milliseconds
		self.tuningChangedTo(tp)

		self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"],
		{
			"ok": self.keyOK,
			"cancel": self.keyCancel,
			"up": self.keyUp,
			"down": self.keyDown,
			"left": self.keyLeft,
			"right": self.keyRight,
			"red": self.redKey,
			"green": self.greenKey,
			"yellow": self.yellowKey,
			"blue": self.blueKey,
			"log": self.showLog,
			"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.updateColors("tune")

		self.statusTimer = eTimer()
		self.statusTimer.callback.append(self.updateStatus)
		self.collectingStatistics = False
		self.statusTimer.start(self.UPDATE_INTERVAL, True)
		self.dataAvailable = Event()
		self.onClose.append(self.__onClose)

		self.createConfig()
		self.createSetup()
예제 #26
0
	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
		
		self.lcdCallbacks = []
		
		self.disableKeys = False
		
		self["actions"] = NumberActionMap(["WizardActions", "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)
예제 #27
0
    def __init__(self,
                 session,
                 title="",
                 list=None,
                 keys=None,
                 selection=0,
                 skin_name=None,
                 text=""):
        self.setTitle(_("Choice Box"))
        if not list: list = []
        if not skin_name: skin_name = []
        Screen.__init__(self, session)

        if isinstance(skin_name, str):
            skin_name = [skin_name]
        self.skinName = skin_name + ["ChoiceBox"]
        self["text"] = Label()
        if title:
            title = _(title)
            if len(title) < 55 and title.find('\n') == -1:
                Screen.setTitle(self, title)
            elif title.find('\n') != -1:
                temptext = title.split('\n')
                if len(temptext[0]) < 55:
                    Screen.setTitle(self, temptext[0])
                    count = 2
                    labeltext = ""
                    while len(temptext) >= count:
                        if labeltext:
                            labeltext += '\n'
                        labeltext = labeltext + temptext[count - 1]
                        count += 1
                        print '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"
            ] + (len(list) - 10) * [""]
        else:
            self.__keys = keys + (len(list) - len(keys)) * [""]

        self.keymap = {}
        pos = 0
        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["list"] = ChoiceList(list=self.list, selection=selection)
        self["summary_list"] = StaticText()
        self["summary_selection"] = StaticText()
        self.updateSummary(selection)

        self["actions"] = NumberActionMap(
            ["WizardActions", "InputActions", "ColorActions"], {
                "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,
                "up": self.up,
                "down": self.down,
                "left": self.left,
                "right": self.right
            }, -1)

        self["cancelaction"] = NumberActionMap(
            ["WizardActions", "InputActions", "ColorActions"], {
                "back": self.cancel,
            }, -1)
예제 #28
0
    def __init__(self, session, number, servicelist=None):
        Screen.__init__(self, session)
        self.digits = 4
        self.field = str(number)
        self.servicelist = servicelist
        self.acount = config.plugins.NumberZapExt.acount.value
        self.startBouquet = None
        self.bouquets = None
        if self.servicelist is not None:
            self.bouquets = self.servicelist.getBouquetList()
        else:
            self.bouquets = None
        self.BouquetsPriority = False
        if config.plugins.NumberZapExt.bouquets_enable.value:
            if config.usage.multibouquet.value:
                self.bouquet_root_tv = eServiceReference(
                    '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
                )
                self.bouquet_root_radio = eServiceReference(
                    '1:7:1:0:0:0:0:0:0:0:FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
                )
            else:
                self.bouquet_root_tv = eServiceReference(
                    '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'
                    % (service_types_tv))
                self.bouquet_root_radio = eServiceReference(
                    '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'
                    % (service_types_radio))
            self.Bouquetlist = self.getBouquetlist(
                self.bouquet_root_tv) + self.getBouquetlist(
                    self.bouquet_root_radio)
            self.hotkeys_bouquets = eval(
                config.plugins.NumberZapExt.hotkeys_bouquets.value)
        self.kdelay = config.plugins.NumberZapExt.kdelay.value
        self.bouqSelDlg = None
        self.bouquet = None
        self.action = ''
        self.bouquet_action = None
        self.defpicon = None
        if config.plugins.NumberZapExt.picons.value:
            for scope, path in [(SCOPE_CURRENT_SKIN, "picon_default.png"),
                                (SCOPE_SKIN_IMAGE,
                                 "skin_default/picon_default.png")]:
                tmp = resolveFilename(scope, path)
                if pathExists(tmp) and getSize(tmp):
                    self.defpicon = tmp
                    break

        self["Title"].setText(_("Service"))
        self["number"] = Label(_("Number:"))
        self["channel"] = Label(_("Channel:"))
        self["bouquet"] = Label(_("Bouquet:"))
        self["chNum"] = Label()
        self["chName"] = Label()
        self["chBouq"] = Label()
        self["chPicon"] = Pixmap()
        self["actions"] = NumberActionMap(
            ["ShortcutActions", "SetupActions", "MenuActions"], {
                "red": self.keyRed,
                "cancel": self.quit,
                "ok": self.keyOK,
                "green": self.keyGreen,
                "yellow": self.keyYellow,
                "blue": self.keyBlue,
                "menu": self.keyMenu,
                "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
            })
        self.Timer = eTimer()
        self.Timer.callback.append(self.keyOK)
        self.onFirstExecBegin.append(self.__onStart)
예제 #29
0
    def __init__(self, session):
        Screen.__init__(self, session)

        self["red"] = Pixmap()
        self["green"] = Pixmap()
        self["yellow"] = Pixmap()
        self["blue"] = Pixmap()
        self["red_text"] = Label()
        self["green_text"] = Label()
        self["yellow_text"] = Label()
        self["blue_text"] = Label()
        self["current_status"] = Label()
        self.is_active = self.session.nav.SleepTimer.isActive()
        if self.is_active:
            self["current_status"].setText(
                _("Timer status:") + " " + _("Enabled"))
        else:
            self["current_status"].setText(
                _("Timer status:") + " " + _("Disabled"))

        if self.is_active:
            self.time = self.session.nav.SleepTimer.getCurrentSleepTime()
        else:
            self.time = config.SleepTimer.defaulttime.value
        self["input"] = Input(text=str(self.time),
                              maxSize=False,
                              type=Input.NUMBER)

        self.status = True
        self.updateColors()

        self["pretext"] = Label(_("Shutdown Settop Box after"))
        self["aftertext"] = Label(_("minutes"))

        self["actions"] = NumberActionMap(
            [
                "SleepTimerEditorActions", "TextEntryActions",
                "KeyboardInputActions"
            ], {
                "exit": self.cancel,
                "select": self.select,
                "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,
                "selectLeft": self.selectLeft,
                "selectRight": self.selectRight,
                "left": self.selectLeft,
                "right": self.selectRight,
                "home": self.selectHome,
                "end": self.selectEnd,
                "deleteForward": self.deleteForward,
                "deleteBackward": self.deleteBackward,
                "disableTimer": self.disableTimer,
                "toggleAction": self.toggleAction,
                "toggleAsk": self.toggleAsk,
                "useServiceTime": self.useServiceTime
            }, -1)
예제 #30
0
    def __init__(self, session, parent):
        Screen.__init__(self, session)

        list = []

        menuID = None
        for x in parent:  #walk through the actual nodelist
            if not x.tag:
                continue
            if x.tag == 'item':
                item_level = int(x.get("level", 0))
                if item_level <= config.usage.setup_level.index:
                    self.addItem(list, x)
                    count += 1
            elif x.tag == 'menu':
                self.addMenu(list, x)
                count += 1
            elif x.tag == "id":
                menuID = x.get("val")
                count = 0

            if menuID is not None:
                # menuupdater?
                if menuupdater.updatedMenuAvailable(menuID):
                    for x in menuupdater.getUpdatedMenu(menuID):
                        if x[1] == count:
                            list.append(
                                (x[0],
                                 boundFunction(self.runScreen,
                                               (x[2], x[3] + ", ")), x[4]))
                            count += 1

        if menuID is not None:
            # plugins
            for l in plugins.getPluginsForMenu(menuID):
                # check if a plugin overrides an existing menu
                plugin_menuid = l[2]
                for x in list:
                    if x[2] == plugin_menuid:
                        list.remove(x)
                        break
                list.append(
                    (l[0], boundFunction(l[1], self.session,
                                         close=self.close), l[2], l[3] or 50))

        # for the skin: first try a menu_<menuID>, then Menu
        self.skinName = []
        if menuID is not None:
            self.skinName.append("menu_" + menuID)
        self.skinName.append("Menu")

        # Sort by Weight
        list.sort(key=lambda x: int(x[3]))

        self["menu"] = List(list)

        self["actions"] = NumberActionMap(
            ["OkCancelActions", "MenuActions", "NumberActions"], {
                "ok": self.okbuttonClick,
                "cancel": self.closeNonRecursive,
                "menu": self.closeRecursive,
                "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
            })

        a = parent.get("title", "").encode("UTF-8") or None
        a = a and _(a)
        if a is None:
            a = _(parent.get("text", "").encode("UTF-8"))
        self["title"] = StaticText(a)
        self.menu_title = a
예제 #31
0
    def __init__(self,
                 session,
                 slotid,
                 action,
                 handler=eDVBCI_UI.getInstance(),
                 wait_text="",
                 screen_data=None):
        Screen.__init__(self, session)

        print "MMIDialog with action" + str(action)

        self.mmiclosed = False
        self.tag = None
        self.slotid = slotid

        self.timer = eTimer()
        self.timer.callback.append(self.keyCancel)

        #else the skins fails
        self["title"] = Label("")
        self["subtitle"] = Label("")
        self["bottom"] = Label("")
        self["entries"] = ConfigList([])

        self["actions"] = NumberActionMap(
            ["SetupActions", "MenuActions"],
            {
                "ok": self.okbuttonClick,
                "cancel": self.keyCancel,
                "menu": self.forceExit,
                #for PIN
                "left": self.keyLeft,
                "right": self.keyRight,
                "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.action = action
        self.screen_data = screen_data

        self.is_pin_list = -1
        self.handler = handler
        if wait_text == "":
            self.wait_text = _("wait for ci...")
        else:
            self.wait_text = wait_text

        if action == 2:  #start MMI
            handler.startMMI(self.slotid)
            self.showWait()
        elif action == 3:  #mmi already there (called from infobar)
            self.showScreen()
예제 #32
0
			def __init__(self, player, contexts=None, actions=None, prio=0):
				if not contexts: contexts = []
				if not actions: actions = {}
				NumberActionMap.__init__(self, contexts, actions, prio)
				self.player = player
예제 #33
0
파일: plugin.py 프로젝트: MOA-2011/enigma2
			def __init__(self, player, contexts = [ ], actions = { }, prio=0):
				NumberActionMap.__init__(self, contexts, actions, prio)
				self.player = player
예제 #34
0
			def action(self, contexts, action):
				self.player.show()
				return NumberActionMap.action(self, contexts, action)
예제 #35
0
파일: plugin.py 프로젝트: popazerty/e2-gui
			def action(self, contexts, action):
				self.player.show()
				return NumberActionMap.action(self, contexts, action)
예제 #36
0
	def __init__(self, session, title="", list=[], keys=None, selection=0, skin_name=[], reorderConfig="", windowTitle=None):
		Screen.__init__(self, session)

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

		self.reorderConfig = reorderConfig
		self["autoresize"] = Label("") # do not remove, used for autoResize()
		self["description"] = Label()
		self["text"] = Label(title)
		self.list = []
		self.summarylist = []
		if keys is None:
			self.__keys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ] + (len(list) - 14) * ["dummy"]
		else:
			self.__keys = keys + (len(list) - len(keys)) * ["dummy"]

		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:
			if x:
				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["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,
			"back": self.cancel,
			"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,
			"up": self.up,
			"down": self.down,
			"moveUp": self.additionalMoveUp,
			"moveDown": self.additionalMoveDown,
			"menu": self.setDefaultChoiceList,
			"rightUp": self.rightUp,
			"leftUp": self.leftUp
		}, -1)
		self.setTitle(windowTitle or _("Select"))