示例#1
0
    def load_menu(self):
        """ Load menu items 
        
        :return: dictionary of the items
        """
        items = {}
        i = 0

        for a in ABC:
            state = State()
            state.name = a
            state.l_name = state.name
            state.bgr = self.config[COLORS][COLOR_DARK]
            state.img_x = None
            state.img_y = None
            state.auto_update = True
            state.show_bgr = True
            state.show_img = False
            state.show_label = True
            state.comparator_item = state.name
            if a == "foo":
                state.index = 20.5
            elif a == "bar":
                state.index = 40
            else:
                state.index = i
                i += 1
            items[state.name] = state

        return items
示例#2
0
 def get_favorites_button_state(self, button_bounding_box):
     """ Get Favorites button state
     
     :param button_bounding_box: bounding box
     
     :return: favorites button state
     """
     state = State()
     state.bounding_box = button_bounding_box
     scale_factor = 0.45
     state.icon_base = self.image_util.load_icon_main(
         KEY_FAVORITES, button_bounding_box, scale_factor)
     state.icon_selected = self.image_util.load_icon_on(
         KEY_FAVORITES, button_bounding_box, scale_factor)
     state.name = state.l_name = state.genre = KEY_FAVORITES
     state.bgr = self.config[COLORS][COLOR_DARK]
     state.img_x = None
     state.img_y = None
     state.auto_update = True
     state.show_bgr = False
     state.show_img = True
     state.show_label = False
     state.comparator_item = state.name
     state.index = 0
     state.v_align = V_ALIGN_TOP
     state.v_offset = 0
     state.voice_commands = state.name
     return state
示例#3
0
 def create_station_button(self, s, bb, action=None):
     """ Create station button
     
     :param s: button state
     :param bb: bounding box
     :param action: event listener
     
     :return: station logo button
     """
     state = State()
     state.icon_base = s.icon_base
     state.index_in_page = s.index_in_page
     state.index = s.index
     state.scaled = getattr(s, "scaled", False)
     state.icon_base_scaled = s.icon_base_scaled
     state.name = "station_menu." + s.name
     state.l_name = s.l_name
     state.url = s.url
     state.keyboard_key = kbd_keys[KEY_SELECT]
     state.bounding_box = bb
     state.img_x = bb.x
     state.img_y = bb.y
     state.auto_update = False
     state.show_bgr = True
     state.show_img = True
     state.image_align_v = V_ALIGN_BOTTOM
     button = Button(self.util, state)
     button.add_release_listener(action)
     return button        
示例#4
0
    def get_network_info(self, index, name, strength, bb):
        """ Prepare state object for network button

        :param index: network index
        :param name: network name
        :param strength: signal strength
        :param bb: bounding box
        :return: state object with network info
        """
        s = State()
        s.index = index
        s.name = name
        s.l_name = name
        s.strength = strength
        s.comparator_item = s.index
        s.bgr = self.config[COLORS][COLOR_DARK]
        s.show_bgr = True

        if strength <= 25:
            n = "s-1"
        elif strength > 25 and strength <= 50:
            n = "s-2"
        elif strength > 50 and strength <= 75:
            n = "s-3"
        elif strength > 75:
            n = "s-4"

        s.icon_base = self.util.load_mono_svg_icon(n, self.util.COLOR_MAIN, bb,
                                                   0.5)

        return s
示例#5
0
    def change_submenu(self, ch):
        """ Change bottom submenu
        
        :param ch: selected character
        """        
        sub = []
        try:
            sub = FILTERS_RU[ch]
        except:
            pass
        items = {}
        cp = self.buttons.copy()
        backup = {}
        for ch in ABC_RU:
            backup[ch] = cp[ch].state
        
        i = len(ABC_RU)
        for a in sub:
            state = State()
            state.name = a
            state.l_name = state.name
            state.img_x = None
            state.img_y = None
            state.auto_update = True
            state.show_bgr = False
            state.show_img = False
            state.show_label = True
            state.comparator_item = state.name
            state.index = i
            items[state.name] = state
            i += 1     

        items.update(backup)
        self.set_items(items, 0, self.abc_action, False)
        self.clean_draw_update()
示例#6
0
    def get_cd_drives(self, font_size, bb):
        """ Return the list of object representing CD drives
        
        :font_size: font size
        
        :return: list of CD drives info
        """
        content = self.get_cd_drives_info()
        if not content:
            return None
        
        items = {}

        for cd in content:
            s = State()
            s.index = cd[0]
            s.name = cd[1]
            s.l_name = cd[1]
            s.file_type = FILE_CD_DRIVE          
            s.icon_base = self.image_util.get_file_icon(s.file_type, "", icon_bb=bb, scale_factor=0.25)
            s.comparator_item = s.index
            s.bgr = self.config[COLORS][COLOR_DARK]
            s.show_bgr = True
            s.fixed_height = int(font_size * 0.8) 
            items[s.name] = s
            
        return items
示例#7
0
 def get_cd_tracks_summary(self, cd_drive_name):
     """ Get the list of CD tracks summaries
     
     :param cd_drive_name: CD drive name
     
     :return: CD tracks summaries
     """
     drive_id = self.get_cd_drive_id_by_name(cd_drive_name)
     names = self.get_cd_track_names(drive_id)
     if not names:
         return None
     
     items = []
     for id, cd in enumerate(names):
         s = State()
         s.index = id
         s.playlist_track_number = id
         s.name = cd
         s.l_name = s.name
         s.file_type = FILE_AUDIO
         s.playback_mode = FILE_AUDIO
         s.file_name = self.get_cd_track_url(cd_drive_name, id + 1)
         s.url = s.file_name       
         items.append(s)
         
     return items
示例#8
0
    def change_track(self, track_index):
        """ Change track
        
        :param track_index: index track
        """
        a = [AUDIOBOOKS, CD_PLAYER]
        m = self.config[CURRENT][MODE]
        if not (m in a):
            self.config[FILE_PLAYBACK][CURRENT_FILE] = self.get_filename(
                track_index)

        self.stop_timer()
        time.sleep(0.3)
        s = State()
        if m == FILE_PLAYBACK:
            s.playback_mode = self.config[FILE_PLAYBACK][
                CURRENT_FILE_PLAYBACK_MODE]

        s.playlist_track_number = track_index
        s.index = track_index
        s.source = ARROW_BUTTON
        s.file_name = self.get_filename(track_index)

        if self.cd_album != None:
            s.album = self.cd_album

        self.set_current(True, s)
示例#9
0
 def create_book_genre_items(self, genres, base_url):
     """ Create dictionary with genres
     
     :param genres: list of genres
     :param base_url: base url
     
     :return: dictionary with genres
     """
     items = {}
     for i, g in enumerate(genres):
         state = State()
         state.name = g[0]
         state.genre = base_url + g[1]
         state.l_name = state.name
         state.bgr = self.config[COLORS][COLOR_DARK]
         state.img_x = None
         state.img_y = None
         state.auto_update = True
         state.show_bgr = True
         state.show_img = False
         state.show_label = True
         state.comparator_item = state.name
         state.index = i
         items[state.name] = state
     return items
示例#10
0
    def get_page(self, page, devices):
        """ Get page of devices for provided page number

        :param page: page number
        :param devices: list of all devices

        :return: page of devices
        """
        p = {}
        if len(devices) == 0:
            return p

        start_index = (page - 1) * PAGE_SIZE_BLUETOOTH
        end_index = start_index + PAGE_SIZE_BLUETOOTH

        for i, d in enumerate(devices):
            s = State()
            s.index = i
            s.name = d["name"]
            s.l_name = s.name
            s.mac_address = d["mac_address"]
            s.comparator_item = i
            s.bgr = self.config[COLORS][COLOR_DARK]
            s.show_bgr = True
            if i >= start_index and i < end_index:
                p[d["name"]] = s

        return p
示例#11
0
    def create_book_author_items(self, authors):
        """ Create dictionary with author books

        :param authors: list of author books

        :return: dictionary with author books
        """
        items = {}
        for i, g in enumerate(authors):
            state = State()
            state.name = g[AUTHOR_NAME]
            state.url = g[AUTHOR_URL] + "/"
            try:
                state.l_name = state.name + " (" + g[AUTHOR_BOOKS] + ")"
            except:
                state.l_name = state.name
            state.bgr = self.config[COLORS][COLOR_DARK]
            state.img_x = None
            state.img_y = None
            state.auto_update = True
            state.show_bgr = True
            state.show_img = False
            state.show_label = True
            state.comparator_item = state.name
            state.index = i
            items[state.name] = state
        return items
示例#12
0
    def get_podcast_info_from_disk(self, index, podcast):
        """ Get the info of loaded podcast as State object
        
        :param index: podcast index
        :param podcast: podcast dictionary
        
        :return: podcast info as State object
        """
        s = State()
        s.index = index
        s.name = podcast["name"]
        s.l_name = s.name
        s.url = podcast["url"]
        s.online = False
        s.description = podcast["summary"]
        s.fixed_height = int(self.podcast_button_font_size * 0.8)
        s.file_type = PODCASTS
        s.comparator_item = s.index
        s.bgr = self.config[COLORS][COLOR_DARK]
        s.show_bgr = True

        try:
            img = os.path.join(self.config[PODCASTS_FOLDER], podcast["image"])
        except:
            img = ''

        s.image_name = img
        s.icon_base = self.get_podcast_image(img, 0.5, 0.8,
                                             self.podcast_button_bb, False)
        self.summary_cache[s.url] = s

        return s
示例#13
0
    def set_tracks(self, tracks, page):
        """ Set tracks in menu
        
        :param tracks: list of tracks
        :param page: page number
        """
        if tracks == None:
            return
        self.tracks = tracks
        items = {}
        start_index = TRACKS_PER_PAGE * (page - 1)
        end_index = start_index + TRACKS_PER_PAGE

        layout = GridLayout(self.bb)
        layout.set_pixel_constraints(TRACK_ROWS, TRACK_COLUMNS, 1, 1)
        constr = layout.get_next_constraints()
        fixed_height = int((constr.h * LABEL_HEIGHT_PERCENT) / 100.0)

        for i, a in enumerate(self.tracks[start_index:end_index]):
            state = State()
            state.name = a["title"]
            state.l_name = state.name
            state.bgr = self.config[COLORS][COLOR_DARK]
            state.img_x = None
            state.img_y = None
            state.auto_update = True
            state.show_bgr = True
            state.show_img = False
            state.show_label = True
            state.comparator_item = state.name
            state.index = i
            state.fixed_height = fixed_height
            state.file_name = a["file_name"]
            items[state.name] = state
        self.set_items(items, 0, self.play_track, False)
示例#14
0
    def create_station_button(self, s, bb, action=None):
        """ Create station button

        :param s: button state
        :param bb: bounding box
        :param action: event listener

        :return: station logo button
        """
        state = State()
        state.icon_base = s.icon_base
        state.index_in_page = s.index_in_page
        state.index = s.index
        state.genre = s.genre
        state.scaled = getattr(s, "scaled", False)
        state.icon_base_scaled = s.icon_base_scaled
        state.name = "station_menu." + s.name
        state.l_name = s.l_name
        state.url = s.url
        state.keyboard_key = kbd_keys[KEY_SELECT]
        state.bounding_box = bb
        state.img_x = bb.x
        state.img_y = bb.y
        state.auto_update = False
        state.show_bgr = True
        state.show_img = True
        state.image_align_v = V_ALIGN_BOTTOM
        button = Button(self.util, state)
        button.add_release_listener(action)
        return button
示例#15
0
文件: util.py 项目: Rucia1/Peppy
    def load_playlist(self, state, playlist_provider, rows, columns):
        """ Handle playlist
        
        :param state: state object defining playlist
        :param playlist_provider: provider
        :param rows: menu rows 
        :param columns: menu columns
        
        :return: playlist 
        """
        n = getattr(state, "file_name", None)
        if n == None:
            state.file_name = self.config[FILE_PLAYBACK][FILE_AUDIO]

        p = playlist_provider(state)

        if not p:
            return

        play_list = []

        for i, n in enumerate(p):
            s = State()
            s.index = i
            s.playlist_track_number = i
            s.file_name = n
            s.file_type = FILE_AUDIO
            s.url = state.folder + os.sep + n
            s.playback_mode = FILE_PLAYLIST
            play_list.append(s)

        return self.load_playlist_content(play_list, rows, columns)
示例#16
0
文件: util.py 项目: thekismet/Peppy
    def load_m3u(self, path, folder, top_folder, items_per_page,
                 default_icon_path):
        """ Load m3u playlist
        
        :param path: base path
        :param folder: main folder
        :param top_folder: top folder
        :param items_per_page: items per page
        :param default_icon_path: path to the default icon
        
        :return: list of State objects representing playlist
        """
        items = []
        lines = []
        item_name = None
        index = 0

        for encoding in ["utf8", "utf-8-sig", "utf-16"]:
            try:
                lines = codecs.open(path, "r", encoding).read().split("\n")
                break
            except Exception as e:
                logging.error(e)

        for line in lines:
            if len(line.rstrip()) == 0:
                continue

            if line.startswith("#") and not item_name:
                item_name = line[1:].rstrip()
                continue

            name = item_name.rstrip()
            path = os.path.join(folder, name + EXT_PNG)
            icon = self.image_util.load_image(path)

            if not icon:
                path = os.path.join(folder, name + EXT_JPG)
                icon = self.image_util.load_image(path)

            if not icon:
                icon = self.image_util.load_image(default_icon_path)

            state = State()
            state.index = index
            state.genre = top_folder
            state.url = line.rstrip()
            state.name = str(index)
            state.l_name = name
            state.icon_base = icon
            state.comparator_item = NAME
            state.index_in_page = index % items_per_page
            items.append(state)
            index += 1
            item_name = None

        return items
示例#17
0
文件: util.py 项目: thekismet/Peppy
    def load_stations_folders(self, button_bounding_box):
        """ Load languages menu items
        
        :param button_bounding_box: bounding box
        
        :return: dictionary with menu items
        """
        items = collections.OrderedDict()
        i = 0
        current_language = self.config[CURRENT][LANGUAGE]
        folders = self.get_stations_folders()
        top_folder = self.get_stations_top_folder()

        for folder in folders:
            name = folder
            path = os.path.join(os.getcwd(), FOLDER_LANGUAGES,
                                current_language, FOLDER_RADIO_STATIONS,
                                top_folder, folder, FILE_FOLDER)
            folder_image = self.image_util.load_image(path)
            path_on = os.path.join(os.getcwd(), FOLDER_LANGUAGES,
                                   current_language, FOLDER_RADIO_STATIONS,
                                   top_folder, folder, FILE_FOLDER_ON)
            folder_image_on = self.image_util.load_image(path_on)

            state = State()
            state.name = state.l_name = state.genre = name

            if folder_image:
                scale_ratio = self.image_util.get_scale_ratio(
                    (button_bounding_box.w, button_bounding_box.h),
                    folder_image[1])
                scaled_image = self.image_util.scale_image(
                    folder_image, scale_ratio)
                state.icon_base = (path, scaled_image)
                if folder_image_on:
                    scaled_image_on = self.image_util.scale_image(
                        folder_image_on, scale_ratio)
                    state.icon_selected = (path_on, scaled_image_on)

            state.bgr = self.config[COLORS][COLOR_DARK]
            state.img_x = None
            state.img_y = None
            state.auto_update = True
            state.show_bgr = True
            state.show_img = True
            state.show_label = True
            state.comparator_item = state.name
            state.index = i
            state.v_align = V_ALIGN_TOP
            state.v_offset = 35
            state.voice_commands = name
            items[state.name] = state
            i += 1
        return items
示例#18
0
    def get_episodes(self, podcast_url):
        """ Get podcast episodes
        
        :param podcast_url: podcast URL
        
        :return: dictionary with episodes
        """
        try:
            podcast = self.summary_cache[podcast_url]
            podcast_image_url = podcast.image_name
            episodes = podcast.episodes
            return episodes
        except:
            pass

        episodes = []
        rss = feedparser.parse(podcast_url)
        if rss == None:
            return episodes

        entries = rss.entries

        for i, entry in enumerate(entries):
            try:
                enclosure = entry.enclosures[0]
            except:
                continue
            s = State()
            s.index = i
            s.name = entry.title
            s.l_name = s.name

            s.url = getattr(enclosure, "href", None)
            if s.url == None:
                s.url = getattr(enclosure, "url", None)
            s.length = getattr(enclosure, "length", None)
            s.type = enclosure.type

            s.description = self.clean_summary(entry.summary)
            s.fixed_height = int(self.episode_button_font_size * 0.8)
            s.file_type = PODCASTS
            s.online = podcast.online
            s.comparator_item = s.index
            s.bgr = self.config[COLORS][COLOR_DARK]
            s.show_bgr = True
            s.podcast_name = podcast.name
            s.podcast_url = podcast_url
            s.podcast_image_url = podcast_image_url
            episode_name = s.url.split("/")[-1]
            self.set_episode_icon(episode_name, self.episode_button_bb, s)
            episodes.append(s)

        self.summary_cache[podcast_url].episodes = episodes
        return episodes
示例#19
0
    def create_keyboard(self, keyboard_type, span, transition_map):
        """ Create keyboard

        :param keyboard_type: type
        :param span: span
        :param transition_map: transition map
        """
        layout = self.get_layout(span)
        buttons = []
        keys = None
        self.current_keyboard_type = keyboard_type

        try:
            buttons = self.keyboards[keyboard_type]
            self.components = buttons
            return
        except:
            pass

        if keyboard_type == KEYBOARD_abc:
            keys = KEYBOARD_1
        elif keyboard_type == KEYBOARD_ABC:
            keys = KEYBOARD_2
        elif keyboard_type == KEYBOARD_123:
            keys = KEYBOARD_3
        elif keyboard_type == KEYBOARD_symbol:
            keys = KEYBOARD_4

        for i, k in enumerate(keys):
            if not k:
                c = Component(self.util, layout[i], bgr=self.config[BACKGROUND][MENU_BGR_COLOR])
                c.parent_screen = self.screen
                c.name = "gap" + str(i)
                buttons.append(c)
                continue
            s = State()
            s.index = i
            s.name = k
            s.l_name = k
            s.comparator_item = s.index
            s.bgr = self.config[COLORS][COLOR_DARK]
            s.show_bgr = True
            s.bounding_box = layout[i]
            s.key_map = transition_map[i]
            button = self.factory.create_menu_button(s, layout[i], self.press_key, False, 50, 100, False, True)
            buttons.append(button)
        buttons[0].set_selected(True)
        self.keyboards[keyboard_type] = buttons
        self.components = buttons

        if keyboard_type != KEYBOARD_abc:
            self.set_observers()

        self.buttons = {i : item for i, item in enumerate(buttons)}
示例#20
0
 def load_menu(self):
     """ Load menu items """
     
     items = {}
     i = 0
     
     for a in ABC_RU:
         state = State()
         state.name = a
         state.l_name = state.name
         state.bgr = self.config[COLORS][COLOR_DARK]
         state.img_x = None
         state.img_y = None
         state.auto_update = True
         state.show_bgr = True
         state.show_img = False
         state.show_label = True
         state.comparator_item = state.name
         state.index = i
         items[state.name] = state
         i += 1
         
     sub = FILTERS_RU[INITIAL_CHAR]
     for a in sub:
         state = State()
         state.name = a
         state.l_name = state.name
         state.img_x = None
         state.img_y = None
         state.auto_update = True
         state.show_bgr = False
         state.show_img = False
         state.show_label = True
         state.comparator_item = state.name
         state.index = i
         items[state.name] = state
         i += 1         
                 
     return items
示例#21
0
    def get_episodes_from_disk(self, podcast_url):
        """ Get podcast episodes from disk
        
        :param podcast_url: podcast URL
        
        :return: dictionary with episodes
        """
        try:
            podcast = self.summary_cache[podcast_url]
            podcast_image_url = podcast.image_name
            episodes = podcast.episodes
            return episodes
        except:
            pass

        episodes = []
        podcast = self.summary_cache[podcast_url]

        entries = []
        for p in self.podcasts_json:
            if p["url"] == podcast_url:
                try:
                    entries = p["episodes"]
                except:
                    pass
        if len(entries) == 0:
            return []

        for i, entry in enumerate(entries):
            s = State()
            s.index = i
            s.name = entry["name"]
            s.l_name = s.name
            s.file_name = entry["filename"]
            s.description = entry["summary"]
            s.fixed_height = int(self.episode_button_font_size * 0.8)
            s.file_type = PODCASTS
            s.online = podcast.online
            s.comparator_item = s.index
            s.bgr = self.config[COLORS][COLOR_DARK]
            s.show_bgr = True
            s.podcast_url = podcast_url
            s.podcast_name = podcast.name
            s.url = ""
            s.podcast_image_url = podcast_image_url
            self.set_episode_icon(s.name, self.episode_button_bb, s, False)
            episodes.append(s)

        self.summary_cache[podcast_url].episodes = episodes
        return episodes
示例#22
0
    def load_favorites(self, p, items_per_page, default_icon_path):
        """ Load m3u playlist
        
        :param p: base path
        :param items_per_page: items per page
        :param items_per_page: items per page
        :param default_icon_path: path to the default icon
        
        :return: list of State objects representing playlist
        """
        favorites = []
        lines = []
        state = None
        index = 0

        if p == None:
            return favorites

        try:
            path = os.path.join(p, FILE_FAVORITES)
            lines = codecs.open(path, "r", UTF8).read().split("\n")
        except Exception as e:
            pass

        for line in lines:
            if len(line.rstrip()) == 0:
                continue

            if line.startswith("#") and state == None:
                state = State()
                state.favorite = True
                state.index = index
                state.name = str(index)
                state.index_in_page = index % items_per_page
                state.genre = line[1:].rstrip()
            elif line.startswith("#") and state != None:
                state.l_name = line[1:].rstrip()
                path = os.path.join(p, state.genre, state.l_name + EXT_PNG)
                icon = self.image_util.load_image(path)
                if not icon:
                    icon = self.image_util.load_image(default_icon_path)
                state.icon_base = icon
                state.comparator_item = NAME
            elif line.startswith("http"):
                state.url = line.rstrip()
                favorites.append(state)
                state = None
                index += 1
        return favorites
示例#23
0
    def prepare_page(self):
        """ Prepare topic page

        :return: page dictionary
        """
        page, self.first_item, self.last_item = self.get_current_page()
        p = {}
        for i, n in enumerate(page):
            s = State()
            s.index = i
            if "\x00" in n:
                n = n.replace("\x00", "")
            s.name = n
            s.l_name = n
            p[str(i)] = s
        return p
示例#24
0
    def get_podcast_info(self, index, podcast_url):
        """ Get podcast info as state object
        
        :param index: podcast index
        :param podcast_url: podcast url
        
        :return: podcast info as State object
        """
        try:
            response = requests.get(podcast_url)
            if response.status_code == 404:
                return None
            rss = feedparser.parse(response.content)
            if rss and getattr(rss, "bozo_exception", None):
                return None
        except:
            return None

        s = State()
        s.index = index
        s.name = rss.feed.title
        s.l_name = s.name
        s.description = rss.feed.subtitle
        s.url = podcast_url
        s.online = True
        s.fixed_height = int(self.podcast_button_font_size * 0.8)
        s.file_type = PODCASTS
        s.comparator_item = s.index
        s.bgr = self.config[COLORS][COLOR_DARK]
        s.show_bgr = True

        if 'image' in rss.feed and 'href' in rss.feed.image:
            img = rss.feed.image.href.strip()
        else:
            img = ''

        s.image_name = img
        s.icon_base = self.get_podcast_image(img, 0.48, 0.8,
                                             self.podcast_button_bb)
        self.summary_cache[s.url] = s

        return s
示例#25
0
文件: util.py 项目: Rucia1/Peppy
 def get_screensaver_delays(self):
     """ Get screensaver delay button states
     
     :return: dictionary with button states
     """
     names = [
         KEY_SCREENSAVER_DELAY_1, KEY_SCREENSAVER_DELAY_3,
         KEY_SCREENSAVER_DELAY_OFF
     ]
     delays = {}
     index = 0
     for n in names:
         state = State()
         state.name = n
         state.index = index
         state.l_name = self.config[LABELS][n]
         state.comparator_item = index
         state.bgr = self.config[COLORS][COLOR_DARK]
         delays[state.name] = state
         index += 1
     return delays
示例#26
0
    def get_center_button(self, s):
        """ Create the center button

        :param s: button state

        :return: station logo button
        """
        bb = Rect(self.layout.CENTER.x + 1, self.layout.CENTER.y + 1,
                  self.layout.CENTER.w - 1, self.layout.CENTER.h - 1)
        if not hasattr(s, "icon_base"):
            self.util.add_icon(s)

        state = State()
        state.icon_base = s.icon_base
        self.factory.set_state_scaled_icons(s, bb)
        state.index = s.index
        state.genre = s.genre
        state.scaled = getattr(s, "scaled", False)
        state.icon_base_scaled = s.icon_base_scaled
        state.name = "station." + s.name
        state.l_name = s.l_name
        state.url = s.url
        state.keyboard_key = kbd_keys[KEY_SELECT]
        state.bounding_box = bb
        state.img_x = bb.x
        state.img_y = bb.y
        state.auto_update = False
        state.show_bgr = True
        state.show_img = True
        state.logo_image_path = s.image_path
        state.image_align_v = V_ALIGN_BOTTOM
        state.comparator_item = self.current_state.comparator_item
        button = Button(self.util, state)

        img = button.components[1]
        self.logo_button_content = (img.image_filename, img.content,
                                    img.content_x, img.content_y)

        return button
示例#27
0
    def change_track(self, track_index):
        """ Change track
        
        :param track_index: index track
        """
        self.config[COLLECTION_PLAYBACK][COLLECTION_FILE] = self.get_filename(
            track_index)
        self.stop_timer()
        time.sleep(0.3)
        s = State()
        s.playlist_track_number = track_index
        s.index = track_index
        s.source = ARROW_BUTTON
        s.file_name = self.get_filename(track_index)

        folder = self.current_folder
        if not folder.endswith(os.sep):
            folder += os.sep
        s.folder = os.path.join(self.config[COLLECTION][BASE_FOLDER], folder)
        s.url = os.path.join(s.folder, s.file_name)

        self.set_current(True, s)
示例#28
0
    def get_books_objects(self, books, rows, cols, bounding_box):
        """ Prepare book objects  
        
        :param books: list of books
        :param rows: menu rows
        :param cols: menu columns
        :param bounding_box: bounding box
        
        :return: books objects
        """
        items = []

        for index, b in enumerate(books):
            s = State()
            s.index = index
            s.name = {}
            title = b[BOOK_TITLE]
            s.l_name = title
            s.show_img = False
            s.show_bgr = True
            s.bgr = (255, 255, 255)
            s.book_url = b[BOOK_URL]
            s.comparator_item = index
            s.index_in_page = index % (cols * rows)
            s.show_label = True

            self.add_title(s.name, title)

            if self.show_author:
                self.add_author(b, s.name)

            if self.show_genre:
                self.add_genre(b, s.name)

            self.add_image(b, s, bounding_box, cols, rows)

            items.append(s)
        return items
示例#29
0
文件: util.py 项目: Rucia1/Peppy
    def load_languages_menu(self, button_bounding_box):
        """ Load languages menu items
        
        :param button_bounding_box: menu button bounding box
        
        :return: dictionary with menu items
        """
        items = {}
        i = 0
        current_language = self.get_current_language()
        labels = current_language[TRANSLATIONS]
        va_commands = self.get_va_language_commands()

        for language in self.config[KEY_LANGUAGES]:
            name = language[NAME]
            state = State()
            state.name = name
            state.l_name = labels[name]

            path = os.path.join(os.getcwd(), FOLDER_LANGUAGES, name, FILE_FLAG)
            img = self.prepare_flag_image(path, button_bounding_box)
            state.icon_base = (path, img)

            state.bgr = self.config[COLORS][COLOR_DARK]
            state.img_x = None
            state.img_y = None
            state.auto_update = True
            state.show_bgr = True
            state.show_img = True
            state.show_label = True
            state.comparator_item = state.name
            state.index = i
            state.voice_commands = va_commands[name]
            state.v_align = V_ALIGN_TOP

            items[state.name] = state
            i += 1
        return items
示例#30
0
    def load_menu(self):
        """ Load menu items 
        
        :return: dictionary of the items
        """
        items = {}

        for i, a in enumerate(ABC):
            state = State()
            state.name = a
            state.l_name = state.name
            state.bgr = self.config[COLORS][COLOR_DARK]
            state.img_x = None
            state.img_y = None
            state.auto_update = True
            state.show_bgr = True
            state.show_img = False
            state.show_label = True
            state.comparator_item = state.name
            state.index = i
            items[state.name] = state

        return items
示例#31
0
 def load_stations(self, language, genre, stations_per_page):
     """ Load stations for specified language and genre
     
     :param language: the language
     :param genre: the genre
     :param stations_per_page: stations per page used to assign indexes
     
     :return: list of button state objects. State contains station icons, index, genre, name etc.
     """
     stations = []
     folder = os.path.join(FOLDER_STATIONS, language, genre)
     path = os.path.join(folder, genre + EXT_M3U)
     lines = []
     try:
         lines = codecs.open(path, "r", UTF_8).read().split("\n")
     except Exception as e:
         logging.error(str(e))
         pass
     for i in range(0, len(lines), 3):
         if len(lines[i].rstrip()) == 0: 
             continue
         index = int(lines[i].rstrip()[1:])
         localized_name = lines[i + 1][1:]
         url = lines[i + 2]
         icon = self.load_station_icon(folder, index)
         state = State()
         state.index = index
         state.genre = genre
         state.url = url.rstrip()
         state.name = str(index)
         state.l_name = localized_name.rstrip()
         state.icon_base = icon
         state.comparator_item = INDEX
         state.index_in_page = index % stations_per_page
         stations.append(state)    
     return stations
示例#32
0
    def turn_page(self):
        """ Turn page """

        topic = self.get_topic()

        self.current_page_items = self.selector.get_topic_detail_page(
            topic, self.selection, self.current_page, self.prev_page,
            self.first_item, self.last_item, PAGE_SIZE)
        self.prev_page = self.current_page

        if not self.current_page_items:
            self.current_page_items = []
            return

        self.current_item = self.current_page_items[0]
        self.first_item = self.current_item
        self.last_item = self.current_page_items[len(self.current_page_items) -
                                                 1]

        p = {}
        for i, f in enumerate(self.current_page_items):
            s = State()
            s.index = i
            s.folder = f
            if "\x00" in f:
                f = f.replace("\x00", "")
            if "/" in f:
                parts = f.split("/")
                if len(parts) > 1:
                    last = parts[len(parts) - 1]
                    if len(last) > 6:
                        f = last
                    else:
                        f = parts[len(parts) - 2] + "/" + last
            s.name = f
            s.l_name = s.name
            if self.filename:
                s.file_name = self.filename
            if self.title:
                s.title = self.title
            p[str(i)] = s

        self.collection_list_menu.set_items(p, 0, self.select_item, False)

        keys = list(p.keys())

        if len(keys) != 0 and self.navigator and self.total_pages > 1:
            self.navigator.left_button.change_label(str(self.current_page - 1))
            self.navigator.right_button.change_label(
                str(self.total_pages - self.current_page))

        self.collection_list_menu.clean_draw_update()

        if hasattr(self, "update_observer"):
            self.collection_list_menu.add_menu_observers(
                self.update_observer, self.redraw_observer)

        self.collection_list_menu.unselect()
        for i, b in enumerate(self.collection_list_menu.buttons.values()):
            if self.current_item[0] == b.state.name:
                self.collection_list_menu.select_by_index(b.state.index)
                return
        index = (self.current_page - 1) * PAGE_SIZE
        self.collection_list_menu.select_by_index(index)