def create_locations_menu(self, arg=None, menuw=None):
locations = []
autoselect = 0
# create menu items
for location in config.PLUGIN_WEATHER_LOCATIONS:
weather_item = WeatherItem(self, location)
# Only display this entry if no errors were found
if weather_item.isValid():
locations.append(weather_item)
# if only 1 valid location, autoselect it and go right to the detail screen
if locations.__len__() == 1:
autoselect = 1
menuw.hide(clear=False)
# if no locations were found, add a menu entry indicating that
if not locations:
nolocation = menu.MenuItem(_('No locations specified'),
menuw.goto_prev_page, 0)
locations.append(nolocation)
# if only 1 valid menu entry present, autoselect it
if autoselect:
locations[0](menuw=menuw)
else:
# create menu
weather_site_menu = menu.Menu(_('Locations'), locations)
menuw.pushmenu(weather_site_menu)
menuw.refresh()
def handle_event(self, pygame_event):
"""
Käsittelee pygamen puolelta tulevat tapahtumat.
"""
if pygame_event.type == pygame.QUIT:
self.game_state = self.State.EXITING
elif pygame_event.type == pygame.MOUSEBUTTONDOWN:
self.input_handler.mouse_pressed(pygame.mouse.get_pressed())
elif pygame_event.type == pygame.MOUSEBUTTONUP:
self.input_handler.mouse_released(pygame.mouse.get_pressed())
elif pygame_event.type == pygame.KEYDOWN and self.game_state == self.State.PLAYING:
if pygame_event.key == pygame.K_r:
self.game_screen = game.Game(self.settings["GridWidth"],
self.settings["GridHeight"],
self.settings["MineCount"],
self.frame_timer)
self.game_screen.add_listener(self)
if pygame_event.key == pygame.K_ESCAPE:
self.game_state = self.State.AT_MENU
self.main_menu = menu.Menu()
self.main_menu.add_listener(self)
if pygame_event.key == pygame.K_w:
self.game_screen.win_game()
if pygame_event.key == pygame.K_e:
self.game_screen.lose_game()
def __init__(self, *args, **kwargs):
super(win, self).__init__(*args, **kwargs)
self.Show()
self.SetIcon(wx.Icon("icons/icon.ico"))
self.Center()
# self.SetSize(1000,600)
self.Maximize(True)
self.cfg = configparser.RawConfigParser()
self.cfg.read('style.cfg')
self.par = dict(self.cfg.items("settings"))
for p in self.par:
self.par[p] = self.par[p].split("#", 1)[0].strip()
globals().update(self.par)
self.statusbar = self.CreateStatusBar(3)
self.statusbar.SetStatusWidths([-1, -4, -1])
self.statusbar.SetBackgroundColour('#BDBDBD')
self.statusbar.SetForegroundColour('#FFFFFF')
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.statlineinfo)
self.timer.Start(40)
self.Bind(wx.EVT_CLOSE, self.close)
menu.Menu(self)
style.style(self)
self.init()
def select_profile(self, arg=None, menuw=None):
logger.log(9, 'select_profile(self, arg=None, menuw=None)')
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 encoding_profile_menu(self, menuw=None, arg=None):
logger.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 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 find_more(self, arg=None, menuw=None):
"""
Find more of this program
"""
_debug_(String('searching for: %s' % self.prog.title))
pop = AlertBox(text=_('Searching, please wait...'))
pop.show()
items = []
(result, matches) = record_client.findMatches(self.prog.title)
pop.destroy()
if result:
_debug_('search found %s matches' % len(matches))
f = lambda a, b: cmp(a.start, b.start)
matches.sort(f)
for prog in matches:
items.append(ProgramItem(self, prog, context='search'))
else:
if matches == 'no matches':
msgtext = _('No matches found for %s') % self.prog.title
AlertBox(text=msgtext).show()
return
AlertBox(text=_('findMatches failed: %s') % matches).show()
return
search_menu = menu.Menu(_('Search Results'),
items,
item_types='tv program menu')
menuw.pushmenu(search_menu)
menuw.refresh()
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 make_menu(self, arg=None, menuw=None):
category = []
keylist = self.categories_tv.keys()
keylist.sort()
for key in keylist:
category.append(Nation(key, self.categories_tv[key], self))
menuw.pushmenu(menu.Menu(_('Choose a Category'), category))
def show_choices(self, menuw, info):
items = []
soup = BeautifulStoneSoup(info, selfClosingTags=['feat'])
results = soup.findAll('result')
for result in results[:20]:
# for performance reasons show the first possibilities only,
# the more sensible hits are at the beginning of the list
hid = result['hid']
title = result.titleTag.string.replace('&', '&')
artist = result.artistTag.nameTag.string.replace('&', '&')
items.append(
menu.MenuItem('%s - %s' % (title, artist),
action=self.fetch_lyric,
arg=hid))
if len(items) > 0:
msgtext = _('No exact match. ')
msgtext += _('Here are some sugestions.')
box = PopupBox(text=msgtext)
box.show()
time.sleep(2)
box.destroy()
choices_menu = menu.Menu(_('Choices'), items)
menuw.pushmenu(choices_menu)
else:
box = PopupBox(text=_('Lyrics not found, sorry...'))
box.show()
time.sleep(3)
box.destroy()
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 find_long_and_frequent(self):
print(
'Программа, которая принимает текст и выводит два слова: наиболее часто встречающееся и самое длинное.'
)
string = self.input_string()
string = string.split(' ')
longword = max(string, key=len)
def counter(string):
count = 0
dict = {}
for x in string:
for j in string:
if x == j:
count += 1
dict[count] = x
count = 0
return dict[max(dict)]
print('Самое длинное слово: ', longword,
'.Самое часто встречаемое слова: ', counter(string))
menu.Menu().menu_after_task(
repeat='task_strings.Tasks_string().find_long_and_frequent()',
back='self.menu_string()')
def start(self):
# 显示初始菜单
self.__logger.somewhere_info("client start!")
table = menu.Menu()
table.login_menu()
choose = input()
if '1' == choose:
nm_ps = table.login_input_message()
id = user.User(nm_ps[0], nm_ps[1])
# 给服务端发送用户名密码消息
connect = sock.Sock()
connect.load_message(message.Message(type='1', is_end='5', message_length='0',
user_name=id.username, pass_word=id.password))
if connect.send_message():
root = tk.Tk()
root.title('somewhere')
app = Application(master=root, username=id.username)
app.mainloop()
elif '2' == choose:
print("bye ~ see you then")
else:
print("wrong choose")
print("bye ~ see you then")
def display_recitem(self, arg=None, menuw=None):
_debug_('display_recitem(self, arg=None, menuw=None)', 2)
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 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 __init__(self, ui, state, opts, desc):
self.ui = ui
self.state = state
self.items = self._create_menu(opts, desc)
self.menu = menu.Menu(ui, self.items)
self.in_menu = False
self.last_level = ""
self.last_level_ts = 0
self.audio_state = "init"
self.last_button_ts = None
self.is_blanking = False
self.last_backlight = self.ui.BACK_OFF
self.allow_blank = True
self.allow_chime = True
self.ping_state = None
self.ping_step = 0
self.restart_ts = None
# state
self.is_connected = False
self.is_audio_active = False
self.is_audio_muted = False
self.is_audio_playing = False
self.is_audio_listen = False
self._print_state()
self._print_title()
self._print_value()
def event(self, e):
if e.type is MOUSEMOTION:
for n, r in self.rects:
if r.collidepoint(e.pos):
self.cur = n
#self.repaint()
elif e.type == JOYAXISMOTION:
if e.axis == 1:
if round(e.value) < 0:
self.cur = (self.cur - 1 + len(self.menu)) % len(self.menu)
elif round(e.value) > 0:
self.cur = (self.cur + 1 + len(self.menu)) % len(self.menu)
elif e.type is KEYDOWN:
if e.key == K_UP:
self.cur = (self.cur - 1 + len(self.menu)) % len(self.menu)
#self.repaint()
if e.key == K_DOWN:
self.cur = (self.cur + 1 + len(self.menu)) % len(self.menu)
#self.repaint()
if (e.type is KEYDOWN and e.key == K_RETURN) or e.type in [
MOUSEBUTTONDOWN, JOYBUTTONDOWN
]:
text, action = self.menu[self.cur]
if action == 'start':
if pygame.mixer:
pygame.mixer.music.stop()
g = self.game
g.data_reset()
import menu
return menu.Menu(self.game)
else:
return action(self.game)
def draw(self):
pygame.init()
pygame.display.set_caption("Records")
while True:
self.timer.tick(200)
self.screen.blit(self.bg, (0, 0))
font = pygame.font.Font(None, 25)
text = font.render("Name", True, (255, 255, 255))
self.screen.blit(text, [10, 15])
text = font.render("Levels", True, (255, 255, 255))
self.screen.blit(text, [150, 15])
text = font.render("Score", True, (255, 255, 255))
self.screen.blit(text, [250, 15])
x = 50
for i in range(0, min(10, len(self.players))):
color = (255, 255, 255)
if i == self.player_index:
color = (0, 255, 0)
text = font.render(self.players[i].name, True, color)
self.screen.blit(text, [10, x])
text = font.render(self.players[i].levels, True, color)
self.screen.blit(text, [150, x])
text = font.render(str(self.players[i].score), True, color)
self.screen.blit(text, [250, x])
x += 25
for e in pygame.event.get():
if e.type == pygame.QUIT:
sys.exit()
if e.type == pygame.KEYDOWN and e.key == pygame.K_ESCAPE:
menu.Menu()
pygame.display.update()
def handle_server_coms(self):
if (not self.is_socket_connected_to_server):
self.logger.add_message("Connecting to server...")
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self.socket.connect((HOST, PORT))
except ConnectionRefusedError:
menu.Menu(self.client, "Connection to server failed")
self.logger.add_message("Connection successful.")
self.is_socket_connected_to_server = True
if (self.session_state == "nosession"):
self.logger.add_message("Trying to join a session...")
self.session_state = "request"
send_serveur.connect(self.socket, self.username)
elif (self.session_state == "jeu"):
# send_serveur.newpos(self.socket, self.main_player.pos)
if (time.time() - self.last_newcom > 1 / SERVER_TICKRATE):
send_serveur.newcom(self.socket,
self.main_player.command_angle,
self.main_player.command_thrust,
self.main_player.hasShoot)
self.main_player.hasShoot = False
self.last_newcom = time.time()
# Commands sent, reset
self.main_player.command_angle = 0
self.main_player.command_thrust = 0
self.handle_server_responses()
def start_module(selfURL):
menu.cfg.title = "SystemInfo"
menu.Menu()
SystemInfo()
menu.print_footer()
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 __init__(self):
self.screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Painter")
self.clock = pygame.time.Clock()
self.brush = brush.Brush(self.screen)
self.menu = menu.Menu(self.screen)
self.menu.set_brush(self.brush)
def lose(self):
if int(self.lives) <= 0:
self.win.fill((0, 0, 0))
self.win.blit(
pygame.font.SysFont("arial", 35,
"light").render(self.loss_text, True,
(255, 255, 255)),
(300, 200))
self.Texts = [
f"score : {self.scoreNum}", f"wave : {self.waveNum}",
f"lives : {self.lives}",
f"prepare for wave number {self.waveNum}"
]
for i in range(3):
self.win.blit(
self.font.render(self.Texts[i], True, (255, 255, 255)),
(320, 240 + i * 40))
self.refresh()
time.sleep(5)
m = menu.Menu()
st = m.main()
if st[0]:
g = Game(st[1])
g.gameLoop()
for i, v in enumerate(self.details):
if v[1] > 600:
self.lives = str(int(self.lives) - 1)
self.details.remove(v)
self.Texts = [
f"score : {self.scoreNum}", f"wave : {self.waveNum}",
f"lives : {self.lives}"
]
def decTimer(self, gameDisplay):
if not self._loseGame:
self._timer -= 1
if self._beginWaveTimer == 0 and not self._waveOn:
self._wave.incWaveNumber()
self._waveOn = True
else:
if not self._enemiesList and (self._spawnEnemieCount == 10
or self._spawnEnemieCount == 0):
self._waveOn = False
self._spawnEnemieCount = 0
self._beginWaveTimer -= 1
if self._waveOn:
self._enemieTimer -= 1
for towerAux in self.getTowers():
towerAux.decReloadTime()
for trapAux in self.getTraps():
trapAux.decReloadTime()
for enemieAux in self.getEnemies():
enemieAux.executeEffects(self)
else:
self._endTimer -= 1
self.paintLoseGameMessage(gameDisplay)
if self._endTimer == 0:
pygame.quit()
menu = MENU.Menu()
menu.start()
def Action(self):
time.sleep(5)
new = menu.Menu()
new.menuRun()
mainFrame.MainFrame.check = False
pygame.display.update()
'''for event in pygame.event.get():
def info_showdata(self, arg=None, menuw=None):
"""
show info for this item
"""
actions = self.item.actions()
plugins = plugin.get('item') + plugin.get('item_video')
plugins.sort(lambda l, o: cmp(l._level, o._level))
for p in plugins:
if p != self:
for a in p.actions(self.item):
if isinstance(a, menu.MenuItem):
actions.append(a)
else:
actions.append(a[:2])
items = []
for a in actions:
if not isinstance(a, item.Item):
a = menu.MenuItem(a[1], a[0])
a.subtitle = self.item.name
a.title = self.item.name
items.append(a)
m = menu.Menu(_('Details'), items)
m.infoitem = self.item
m.viewitem = self.item
m.item_types = 'video details'
m.is_submenu = True
menuw.pushmenu(m)
def create_stations_menu(self, arg=None, menuw=None):
station_items = []
for rstation in config.RADIO_STATIONS:
radio_item = RadioItem()
radio_item.name = rstation[0]
radio_item.station = rstation[1]
radio_item.url = 'radio://' + str(rstation[1])
radio_item.type = 'radio'
radio_item.station_index = config.RADIO_STATIONS.index(rstation)
radio_item.length = 0
radio_item.remain = 0
radio_item.elapsed = 0
radio_item.info = {
'album': '',
'artist': '',
'trackno': '',
'title': ''
}
station_items += [radio_item]
if (len(station_items) == 0):
station_items += [
menu.MenuItem(_('No Radio Stations found'),
menwu.goto_prev_page, 0)
]
station_menu = menu.Menu(_('Radio Stations'), station_items)
rc.app(None)
menuw.pushmenu(station_menu)
menuw.refresh()
def create_commands_menu(self, arg=None, menuw=None):
"""
create a list with commands
"""
command_items = []
for command in os.listdir(config.COMMANDS_DIR):
if os.path.splitext(command)[1] in ('.jpg', '.png'):
continue
if os.path.splitext(command)[1] in ('.fxd', '.xml'):
fxd_file = os.path.join(config.COMMANDS_DIR, command)
# create a basic fxd parser
parser = util.fxdparser.FXD(fxd_file)
# create items to add
parser.setattr(None, 'items', command_items)
# set handler
parser.set_handler('command', fxdparser)
# start the parsing
parser.parse()
else:
cmd_item = CommandItem(command, config.COMMANDS_DIR)
command_items.append(cmd_item)
command_items.sort(lambda l, o: cmp(l.name.upper(), o.name.upper()))
command_menu = menu.Menu(_('Commands'), command_items)
menuw.pushmenu(command_menu)
menuw.refresh()
def create_podcast_menu(self, arg=None, menuw=None):
popup = PopupBox(text=_('Fetching podcast...'))
popup.show()
podcast_menu_items = []
for location in config.APODCAST_LOCATIONS:
url = location[1]
image_path = os.path.join(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.back_one_menu, 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)
menuw.pushmenu(podcast_main_menu)
menuw.refresh()
def cwd(self, arg=None, menuw=None):
"""
make a menu item for each file in the directory
"""
items = []
parentPath = self.path
if len(parentPath) == 1:
parentPath = ""
print "cwd for" + parentPath
# Append Folders
folders = pygphoto.gp_getsubfolders(self.gCamera, self.path)
number = pygphoto.gp_list_count(folders)
while number > 0:
number = number - 1
name = pygphoto.gp_name(folders, number)
subFolder = CameraFolder(self, self.gCamera,
parentPath + "/" + name, name)
items.append(subFolder)
files = pygphoto.gp_getfiles(self.gCamera, self.path)
number = pygphoto.gp_list_count(files)
while number > 0:
number = number - 1
name = pygphoto.gp_name(files, number)
subFile = CameraFile(self, self.gCamera, parentPath, name)
items.append(subFile)
item_menu = menu.Menu(self.name, items)
menuw.pushmenu(item_menu)
return items
