def mod_day(self, arg=None, menuw=None):
""" Modify day
Opens a submenu where the day of the week of a favorite can be configured.
"""
logger.log(9, 'mod_day(arg=%r, menuw=%r)', arg, menuw)
items = []
items.append(
menu.MenuItem(_('ANY DAY'),
action=self.alter_prop,
arg=('dow', 'ANY')))
for i in range(len(self.week_days)):
items.append(
menu.MenuItem(self.week_days[i],
action=self.alter_prop,
arg=('dow', i)))
favorite_menu = menu.Menu(_('Modify Day'),
items,
item_types='tv favorite menu')
favorite_menu.infoitem = self
menuw.pushmenu(favorite_menu)
menuw.refresh()
def getheadlines(self, arg=None, menuw=None):
headlines = []
rawheadlines = []
rawheadlines = self.getsiteheadlines()
for title, link, description in rawheadlines:
mi = menu.MenuItem('%s' % title, self.show_details, 0)
mi.arg = (mi, menuw)
mi.link = link
description = description.replace('\n\n', '&#xxx;').replace('\n', ' ').\
replace('&#xxx;', '\n')
description = description.replace('<p>',
'\n').replace('<br>', '\n')
description = description.replace('<p>',
'\n').replace('<br/>', '\n')
description = description + '\n \n \nLink: ' + link
description = util.htmlenties2txt(description)
mi.description = re.sub('<.*?>', '', description)
headlines.append(mi)
if (len(headlines) == 0):
headlines += [
menu.MenuItem(_('No Headlines found'), menuw.goto_prev_page, 0)
]
headlines_menu = menu.Menu(_('Headlines'), headlines)
rc.app(None)
menuw.pushmenu(headlines_menu)
menuw.refresh()
def resolve_conflict(self, menuw, conflictingProgs):
prog_text = self.prog.getattr('time') + u' ' + self.prog.title
other_prog_text = u''
menu_items = []
for progs in conflictingProgs:
remove_text = ''
for cprog in progs:
if other_prog_text:
other_prog_text += u'\n'
other_prog_text += cprog.getattr('time') + u' ' + cprog.title
if not remove_text:
remove_text = cprog.title
else:
remove_text += u', ' + cprog.title
other_prog_text += u'\n\n'
menu_items.append(
menu.MenuItem(
_('Remove ') + remove_text, self.remove_and_schedule,
progs))
self.conflict_info = _(
'How do you want to resolve the conflict?\n%s\nconflicts with\n%s'
) % (prog_text, other_prog_text)
menu_items.append(
menu.MenuItem(
_('Cancel scheduling ') + self.prog.title,
menuw.back_one_menu))
conflict_menu = menu.Menu(_('Resovle Conflict'),
menu_items,
item_types='tv conflict menu')
conflict_menu.infoitem = self
menuw.delete_submenu(refresh=False)
menuw.pushmenu(conflict_menu)
menuw.refresh()
def subtitle_selection_menu(arg=None, menuw=None):
"""
Subtitle selection menu list
"""
item = arg
menu_items = [ menu.MenuItem(_('no subtitles'), subtitle_selection, (item, -1)) ]
for subtitle in item.info['subtitles']:
s = copy.copy(subtitle)
if not s.has_key('id') or not s['id']:
s['id'] = item.info['subtitles'].index(subtitle)
if not s.has_key('language') or not s['language']:
s['language'] = _('Stream %s') % s['id']
if not s.has_key('title') or not s['title']:
s['title'] = ''
if s['title'] == 'Undefined':
s['title'] = ''
if s['title'] != '':
s['title'] = ' (%s)' % s['title']
txt = '%(language)s%(title)s' % s
menu_items.append(menu.MenuItem(txt, subtitle_selection, (item, s['id'])))
moviemenu = menu.Menu(_('Subtitle Menu'), menu_items, fxd_file=item.skin_fxd)
menuw.pushmenu(moviemenu)
def mod_time(self, arg=None, menuw=None):
""" Modify time
Opens a submenu where the time of a favorite can be configured.
"""
items = []
items.append(
menu.MenuItem('ANY TIME',
action=self.alter_prop,
arg=('mod', 'ANY')))
for i in range(48):
mod = i * 30
items.append(
menu.MenuItem(strftime(config.TV_TIMEFORMAT,
gmtime(float(mod * 60))),
action=self.alter_prop,
arg=('mod', mod)))
favorite_menu = menu.Menu(_('Modify Time'),
items,
item_types='tv favorite menu')
favorite_menu.infoitem = self
menuw.pushmenu(favorite_menu)
menuw.refresh()
def create_first_menu(self):
first_menu = menu.MenuChoiceInput("Do you want to...",
"Enter the number of your choice: ")
first_menu.add_menu_item(menu.MenuItem("Start a new game", "c1", 1))
first_menu.add_menu_item(menu.MenuItem("Exit", "c2", 2))
first_menu.add_menu_item(menu.MenuItem("Get help", "c3", 3))
return first_menu
def tools_menu():
"""
Fonction representant le menu qui contient les applications d'alertes
:return: (str) Le nom du state dans lequel le programme doit etre
"""
tools_menu = menu.Menu()
tools_menu.add_item(
menu.MenuItem("ressources/images/humidity.png", "alert_humidity"))
tools_menu.add_item(
menu.MenuItem("ressources/images/pressure.png", "alert_pressure"))
tools_menu.add_item(
menu.MenuItem("ressources/images/thermometre.png",
"alert_temperature"))
tools_menu.add_item(menu.MenuItem("ressources/images/map.png", "map"))
tools_menu.add_item(
menu.MenuItem("ressources/images/compass.png", "compass"))
tools_menu.show_selected_item_image()
while True:
direction = userinput.get_joystick_direction()
if direction is not None:
if direction == "middle":
sense.clear()
return tools_menu.get_selected_item().get_target_state()
elif direction == "down":
return "home_screen"
else:
tools_menu.navigate(direction)
def create_podcast_menu(self, arg=None, menuw=None):
popup = PopupBox(text=_('Fetching podcasts...'))
popup.show()
podcast_menu_items = []
for location in config.APODCAST_LOCATIONS:
url = location[1]
image_path = config.APODCAST_DIR + '/' + location[
0] + '/' + 'cover.jpg'
if self.check_logo(image_path):
p = podcast()
p.open_rss(url)
p.rss_title()
name = p.rss_title
image_url = p.rss_image
self.download(image_url, image_path)
if (len(config.APODCAST_DIR) == 0):
podcast_items += [
menu.MenuItem(_('Set APODCAST_DIR in local_conf.py'),
menwu.goto_prev_page, 0)
]
podcast_menu_items += [
menu.MenuItem(_(location[0]),
action=self.create_podcast_submenu,
arg=location,
image=image_path)
]
popup.destroy()
podcast_main_menu = menu.Menu(_('AUDIO PODCAST'), podcast_menu_items)
rc.app(None)
menuw.pushmenu(podcast_main_menu)
menuw.refresh()
def create_backup_items(self, arg, menuw):
items = []
if config.LAME_CMD:
items.append(
menu.MenuItem(_('Backup CD to hard drive in mp3 format'),
self.cd_backup,
arg=(arg, 'mp3')))
if config.OGGENC_CMD:
items.append(
menu.MenuItem(_('Backup CD to hard drive in Ogg format'),
self.cd_backup,
arg=(arg, 'ogg')))
if config.FLAC_CMD:
items.append(
menu.MenuItem(_('Backup CD to hard drive in FLAC format'),
self.cd_backup,
arg=(arg, 'flac')))
items.append(
menu.MenuItem(_('Backup CD to hard drive in wav format'),
self.cd_backup,
arg=(arg, 'wav')))
backupmenu = menu.Menu(_('CD Backup'),
items,
reload_func=self.create_backup_menu)
return backupmenu
def add_toogle(name, item, var):
"""
Toggle a menu item over two choices menu
"""
if item[var]:
return menu.MenuItem(_('Turn off %s') % name, toggle, (name, item, var))
return menu.MenuItem(_('Turn on %s') % name, toggle, (name, item, var))
def select_profile(self, arg=None, menuw=None):
_debug_('select_profile(self, arg=None, menuw=None)', 2)
menu_items = []
menu_items += [
menu.MenuItem(_('Xvid Low Quality'),
action=self.select_encoding_profile,
arg='xvid_low')
]
menu_items += [
menu.MenuItem(_('Xvid High Quality'),
action=self.select_encoding_profile,
arg='xvid_high')
]
menu_items += [
menu.MenuItem(_('iPod'),
action=self.select_encoding_profile,
arg='ipod')
]
menu_items += [
menu.MenuItem(_('DVD'),
action=self.select_encoding_profile,
arg='MPEG 2 (lavc)')
]
encoding_menu = menu.Menu(_('Select Profile'),
menu_items,
item_types='video encoding menu')
encoding_menu.infoitem = self
menuw.pushmenu(encoding_menu)
menuw.refresh()
def get_items(item):
next_start = 0
items = []
if item.filename or (item.mode in ('dvd', 'vcd')
and item.player_rating >= 20):
if item.info.has_key('audio') and len(item.info['audio']) > 1:
items.append(
menu.MenuItem(_('Audio selection'), audio_selection_menu,
item))
if item.info.has_key('subtitles') and len(item.info['subtitles']) > 1:
items.append(
menu.MenuItem(_('Subtitle selection'), subtitle_selection_menu,
item))
if item.info.has_key('chapters') and item.info['chapters'] > 1:
items.append(
menu.MenuItem(_('Chapter selection'), chapter_selection_menu,
item))
if item.subitems:
# show subitems as chapter
items.append(
menu.MenuItem(_('Chapter selection'), subitem_selection_menu,
item))
if item.mode in ('dvd', 'vcd') or \
(item.filename and item.info.has_key('type') and \
item.info['type'] and item.info['type'].lower().find('mpeg') != -1):
items += [add_toogle(_('deinterlacing'), item, 'deinterlace')]
return items
def configure(self, arg=None, menuw=None):
"""
show the configure dialog for folder specific settings in folder.fxd
"""
items = []
for i, name, descr, type_list in self.all_variables:
if name == '':
continue
name += '\t' + self.configure_set_name(i)
mi = menu.MenuItem(name, self.configure_set_var, i)
mi.description = descr
items.append(mi)
if self.parent and self.parent.display_type:
if self.display_type:
name = u'\tICON_RIGHT_OFF_' + _('off')
else:
name = u'\tICON_RIGHT_ON_' + _('on')
mi = menu.MenuItem(
_('Show all kinds of items') + name,
self.configure_set_display_type)
mi.description = _(
'Show video, audio and image items in this directory')
items.append(mi)
m = menu.Menu(_('Configure'), items)
m.table = (80, 20)
m.back_one_menu = 2
menuw.pushmenu(m)
def chapter_selection_menu(arg=None, menuw=None):
"""
Chapter selection menu list
"""
item = arg
menu_items = []
if isinstance(arg.info['chapters'], int):
for c in range(1, arg.info['chapters']):
menu_items += [ menu.MenuItem(_('Play chapter %s') % c, chapter_selection, (arg, ' -chapter %s' % c)) ]
elif arg.info['chapters']:
for chapter in arg.info['chapters']:
c = copy.copy(chapter)
if not c.has_key('id') or not c['id']:
c['id'] = item.info['chapters'].index(chapter)
if not c.has_key('name') or not c['name']:
c['name'] = ''
if not c.has_key('pos') or not c['pos']:
c['pos'] = 0
if c['name']:
txt = '%(name)s (%(pos)s)' % c
else:
txt = '%(id)s (%(pos)s)' % c
menu_items.append(menu.MenuItem(txt, chapter_selection, (item, ' -ss %s' % c['pos'])))
moviemenu = menu.Menu(_('Chapter Menu'), menu_items, fxd_file=item.skin_fxd)
menuw.pushmenu(moviemenu)
def generate_station_list(self, arg=None, menuw=None):
"""
Generates the Station List
"""
stationlist = []
pop = ProgressBox(text=_('Fetching station list for %s') % arg, full=2)
pop.show()
xmlfile = self.retrievexml(arg)
pop.tick()
if xmlfile == None:
stationlist = [
menu.MenuItem(_('Error retrieving stations'),
action=menuw.back_one_menu,
arg=None)
]
else:
try:
parser = make_parser()
parseStationXML = StationParser()
parser.setContentHandler(parseStationXML)
parser.parse(xmlfile)
for station in parseStationXML.stationlist:
statid = urllib2.quote(station["id"])
statname = station["name"]
statbr = station["br"]
statct = station['ct']
if int(statbr) >= self.min_bitrate and (
self.max_bitrate == 0
or int(statbr) <= self.max_bitrate):
stationitem = AudioItem(
'http://www.shoutcast.com%s?id=%s' %
(parseStationXML.tunein, statid), self, statname,
False)
stationitem.player = 'mplayer'
stationitem.reconect = True
stationitem.network_play = True
stationitem.is_playlist = True
stationitem.bitrate = int(statbr)
stationitem.length = 0
stationitem.remain = 0
stationitem.info = {
'title':
statname,
'description':
'%s - %skbs' % (station['genre'], statbr)
}
stationlist.append(stationitem)
stationlist.sort(key=self.stationsortkey)
except:
stationlist = [
menu.MenuItem(_('Error retrieving stationlist'),
action=menuw.back_one_menu,
arg=None)
]
stationmenu = menu.Menu(arg, stationlist, item_types='audio')
menuw.pushmenu(stationmenu)
menuw.refresh()
pop.destroy()
def games_menu():
"""
Fonction representant le menu qui contient les applications d'alertes
:return: (str) Le nom du state dans lequel le programme doit etre
"""
game_menu = menu.Menu()
game_menu.add_item(menu.MenuItem("ressources/images/snake.png", "snake"))
game_menu.add_item(menu.MenuItem("ressources/images/simon.png", "simon"))
game_menu.add_item(
menu.MenuItem("ressources/images/morpion.png", "morpion"))
game_menu.add_item(menu.MenuItem("ressources/images/dice.png", "dice"))
game_menu.add_item(
menu.MenuItem("ressources/images/nihon.png", "romaji_QCM"))
game_menu.show_selected_item_image()
while True:
direction = userinput.get_joystick_direction()
if direction is not None:
if direction == "middle":
sense.clear()
return game_menu.get_selected_item().get_target_state()
elif direction == "down":
return "home_screen"
else:
game_menu.navigate(direction)
def getheadlines(self, arg=None, menuw=None):
headlines = []
rawheadlines = []
rawheadlines = self.getsiteheadlines()
for title, link, description in rawheadlines:
mi = menu.MenuItem('%s' % title, self.show_details, 0)
mi.arg = mi
mi.link = link
description = description.replace('\n\n', '&#xxx;').replace('\n', ' ').\
replace('&#xxx;', '\n')
description = description.replace('<p>',
'\n').replace('<br>', '\n')
description = description.replace('<p>',
'\n').replace('<br/>', '\n')
description = description + '\n \n \nLink: ' + link
description = unicode(
BeautifulStoneSoup(
description,
convertEntities=BeautifulStoneSoup.HTML_ENTITIES))
description = util.htmlenties2txt(description, 'unicode')
mi.description = re.sub('<.*?>', '', description)
headlines.append(mi)
if (len(headlines) == 0):
headlines += [
menu.MenuItem(_('No Headlines found'), menuw.back_one_menu, 0)
]
headlines_menu = menu.Menu(_('Headlines'), headlines)
menuw.pushmenu(headlines_menu)
menuw.refresh()
def subtitle_selection_menu(arg=None, menuw=None):
item = arg
menu_items = [
menu.MenuItem(_('no subtitles'), subtitle_selection, (item, -1))
]
try:
for s in item.info['subtitles']:
if s.has_key('languagedesc') and s['languagedesc']:
s['language'] = s['languagedesc']
elif not s.has_key('language') or not s['language']:
s['language'] = _('Stream %s') % s['id']
if not s.has_key('content') or not s['content']:
s['content'] = ''
if s['content'] == 'Undefined':
s['content'] = ''
if s['content'] != '':
s['content'] = format(' (%s)' % s['content'])
txt = '%s%s' % (s['language'], s['content'])
menu_items.append(
menu.MenuItem(txt, subtitle_selection, (item, s['number'])))
except AttributeError:
for s in range(len(item.info['subtitles'])):
menu_items.append(
menu.MenuItem(item.info['subtitles'][s], subtitle_selection,
(item, s)))
moviemenu = menu.Menu(_('Subtitle Menu'),
menu_items,
fxd_file=item.skin_fxd)
menuw.pushmenu(moviemenu)
def onchoose_node(self, arg=None, menuw=None):
"""
browse through a tree specification
"""
tree = arg[0]
data = arg[1]
title = '-'.join(data)
mylistofitems = []
if len(tree.spec) -1 <> len(data): #non-tracks
for tree_item, count in tree.execute(data):
mylistofitems.append(
menu.MenuItem("%s(%i)" % \
(tree_item, count), action=self.onchoose_node, arg=[tree, data + [tree_item]]))
else: #tracks
self.onchoose_last_node(tree, data, menuw)
return
#should be impossible?
if (len(mylistofitems) == 0):
mylistofitems += [menu.MenuItem(_('No Objects found'),
menuw.back_one_menu, 0)]
myobjectmenu = menu.Menu(title, mylistofitems)
#reload_func=menuw.back_one_menu )
rc.app(None)
menuw.pushmenu(myobjectmenu)
menuw.refresh()
def CreateMainMenu():
mainmenu = menu.Menu("Main Menu")
mainmenu.addItem(menu.MenuItem("exit program", mm_exit))
mainmenu.addItem(menu.MenuItem("create project", mm_createProj))
mainmenu.addItem(menu.MenuItem("load project", mm_loadProj))
mainmenu.addItem(menu.MenuItem("delete project", mm_delProj))
mainmenu.addItem(menu.MenuItem("wipe", mm_wipe))
return mainmenu
def create_cool_menu(self, arg=None, menuw=None):
myitems = []
myitems += [menu.MenuItem(_('Cool Choice1'), action=self.doChoice1)]
myitems += [menu.MenuItem(_('Cool Choice2'), action=self.doChoice2)]
cool_menu = menu.Menu(_('Cool Menu'), myitems)
rc.app(None)
menuw.pushmenu(cool_menu)
menuw.refresh()
def userlist(self, arg=None, menuw=None):
"""Menu for choose user"""
logger.log(9, 'userlist(arg=%r, menuw=%r)', arg, menuw)
users = []
for item in config.YOUTUBE_VIDEOS:
users.append(menu.MenuItem(item[1], self.videolist, item))
users.append(menu.MenuItem('Search video', self.search_video, 0))
menuw.pushmenu(menu.Menu(_('Choose please'), users))
def userlist(self, arg=None, menuw=None):
"""Menu for choose user"""
_debug_('userlist(arg=%r, menuw=%r)' % (arg, menuw), 2)
users = []
for user, description in config.YOUTUBE_VIDEOS:
users.append(menu.MenuItem(description, self.videolist, (user, description)))
users.append(menu.MenuItem('Search video',self.search_video,0))
menuw.pushmenu(menu.Menu(_('Choose please'), users))
def add_toogle3(name, item, var):
if item[var] == -1:
return menu.MenuItem(_('Activate TOP field first'), toggle3,
(name, item, var))
elif item[var] == 0:
return menu.MenuItem(_('Activate BOTTOM field first'), toggle3,
(name, item, var))
else:
return menu.MenuItem(_('Activate AUTO field first'), toggle3,
(name, item, var))
def add_toogle3(name, item, var):
"""
Toggle a menu item over three choices field dominance
"""
if item[var] == -1:
return menu.MenuItem(_('Activate TOP field first'), toggle3, (name, item, var))
elif item[var] == 0:
return menu.MenuItem(_('Activate BOTTOM field first'), toggle3, (name, item, var))
else:
return menu.MenuItem(_('Activate AUTO field first'), toggle3, (name, item, var))
def display_recitem(self, arg=None, menuw=None):
_debug_('display_recitem(self, arg=None, menuw=None)', 2)
self.make_newprog()
items = []
items.append(menu.MenuItem(_('Modify name'), action=self.mod_name))
items.append(
menu.MenuItem(_('Modify channel'), action=self.mod_channel))
items.append(
menu.MenuItem(_('Modify start month'),
action=self.mod_start_month))
items.append(
menu.MenuItem(_('Modify start day'), action=self.mod_start_day))
items.append(
menu.MenuItem(_('Modify start time'), action=self.mod_start_time))
items.append(
menu.MenuItem(_('Modify stop month'), action=self.mod_stop_month))
items.append(
menu.MenuItem(_('Modify stop day'), action=self.mod_stop_day))
items.append(
menu.MenuItem(_('Modify stop time'), action=self.mod_stop_time))
items.append(menu.MenuItem(_('Save'), action=self.save_changes))
manualrecord_menu = menu.Menu(_('Record Item Menu'),
items,
item_types='tv manual record menu')
manualrecord_menu.infoitem = self
menuw.pushmenu(manualrecord_menu)
menuw.refresh()
def display_recitem(self, arg=None, menuw=None):
logger.log(9, 'display_recitem(self, arg=None, menuw=None)')
if not self.recordclient.pingNow():
AlertBox(self.recordclient.recordserverdown).show()
return
self.make_newprog()
items = []
items.append(menu.MenuItem(_('Modify name'), action=self.mod_name))
items.append(
menu.MenuItem(_('Modify channel'), action=self.mod_channel))
items.append(
menu.MenuItem(_('Modify start month'),
action=self.mod_start_month))
items.append(
menu.MenuItem(_('Modify start day'), action=self.mod_start_day))
items.append(
menu.MenuItem(_('Modify start time'), action=self.mod_start_time))
items.append(
menu.MenuItem(_('Modify stop month'), action=self.mod_stop_month))
items.append(
menu.MenuItem(_('Modify stop day'), action=self.mod_stop_day))
items.append(
menu.MenuItem(_('Modify stop time'), action=self.mod_stop_time))
items.append(menu.MenuItem(_('Save'), action=self.save_changes))
manualrecord_menu = menu.Menu(_('Record Item Menu'),
items,
item_types='tv manual record menu')
manualrecord_menu.infoitem = self
menuw.pushmenu(manualrecord_menu)
menuw.refresh()
def encoding_profile_menu(self, menuw=None, arg=None):
_debug_('encoding_profile_menu(self, menuw=None, arg=None)')
#create a menu with a few encoding options (1cd, 2cd, xvid, mpeg4)
#args : tuple, (videocodec, size, multipass
menu_items = [
menu.MenuItem("XviD, 800bps", self.create_job,
(0, 0, 1, None, 700, False, 800))
]
menu_items.append(
menu.MenuItem("XviD, 800bps, High Quality", self.create_job,
(0, 0, 1, None, 700, True, 800)))
menu_items.append(
menu.MenuItem("XviD, 1200bps", self.create_job,
(0, 0, 1, None, 1400, False, 1200)))
menu_items.append(
menu.MenuItem("XviD, 1200bps, High Quality", self.create_job,
(0, 0, 1, None, 1400, True, 1200)))
menu_items.append(
menu.MenuItem("DivX, 800bps", self.create_job,
(0, 0, 0, None, 700, False, 800)))
menu_items.append(
menu.MenuItem("DivX, 800bps, High Quality", self.create_job,
(0, 0, 0, None, 700, True, 800)))
menu_items.append(
menu.MenuItem("DivX, 1200bps", self.create_job,
(0, 0, 0, None, 1400, False, 1200)))
menu_items.append(
menu.MenuItem("DivX, 1200bps, High Quality", self.create_job,
(0, 0, 0, None, 1400, True, 1200)))
menu_items.append(
menu.MenuItem("iPod", self.create_job,
(2, 2, 2, None, None, False, 1200)))
encoding_menu = menu.Menu(_('Choose your encoding profile'),
menu_items)
menuw.pushmenu(encoding_menu)
def create_turn_menu(self):
turn_choice_menu = menu.MenuChoiceInput("Do you want to...",
"Enter the number of your choice:")
self.debug_print(self.current_player())
if self.current_player().total_num_chips() < 10:
turn_choice_menu.add_menu_item(menu.MenuItem("Choose chips", "c1", 1))
turn_choice_menu.add_menu_item(menu.MenuItem("Buy card", "c2", 2))
turn_choice_menu.add_menu_item(
menu.MenuItem("* display decks *", "c3", 3))
turn_choice_menu.display()
return turn_choice_menu
def FetchData(self):
G.LastUpdate = datetime.datetime.now()
#Get the user data from the API
DEBUG.Display("Connecting...")
user_json = self.FetchUserData()
task_json = self.FetchUserTasks()
DEBUG.Display("Connected")
time.sleep(1)
DEBUG.Display(" ")
# Initialize User Stats
G.user = U.User(user_json)
# These will contain the menu items passed to create the Habit, Daily
# and Todo menus
habit_items = []
dailies_items = []
todos_items = []
logger.debug("Found %d tasks" % len(task_json))
for i in task_json:
logger.debug("Processing a TODO: %s" %
i['text'].encode("utf-8").strip())
if (i['type'] == "habit"):
item = T.Habit(i)
habit_items += [M.MenuItem(item, "habit", item.text)]
elif (i['type'] == "daily"):
item = T.Daily(i)
dailies_items += [M.MenuItem(item, "daily", item.text)]
elif (i['type'] == "todo"):
if i['completed']:
continue
item = T.TODO(i)
todos_items += [M.MenuItem(item, "todo", item.text)]
elif (i['type'] == "reward"):
logger.warn(
"Custom Rewards aren't implemented yet, but the user has one: %s"
% i['text'])
else:
logger.debug(
"Weird task %s with type: %s" %
(i['text'].encode("utf-8"), i['type'].encode("utf-8")))
raise ValueError("Unknown task type %s" %
i['type'].encode("utf-8"))
# Generate the menus for the display
G.HabitMenu = M.Menu(habit_items, "Habits")
G.DailyMenu = M.Menu(dailies_items, "Dailies")
G.TODOMenu = M.Menu(todos_items, "TODOs")
