def open_menu(stdscr, items):
"""Opens a menu containing items and returns the selected item.
Blocks until the user selected an item.
"""
width = max(map(len, items)) + 20
height = len(items*2)-1 + 4 # +2 for frame, +2 for padding
curses.curs_set(False)
selected = 0
while True:
center = (curses.COLS//2, curses.LINES//2)
menu_rect = Rect(center[0]-width//2, center[1]-height//2, width, height)
menu_rect = draw_frame(stdscr, menu_rect, thick_border=True)
for i, item in enumerate(items):
attr = curses.A_NORMAL
if i == selected:
attr = curses.A_STANDOUT
stdscr.addstr(menu_rect.y + 1 + i*2, center[0] - len(item)//2, item, attr)
c = stdscr.getch()
if c == curses.KEY_UP:
selected -= 1
if c == curses.KEY_DOWN:
selected += 1
if c == curses.KEY_ENTER or c == 10:
break
selected = clamp(selected, 0, len(items)-1)
curses.curs_set(True)
return items[selected]
python类KEY_UP的实例源码
def test_should_handle_key_up(self):
self._parent_window.getmaxyx.return_value = (9, 30)
win = Select(self._manager, 'Letter', ['a', 'b', 'c'])
win.handle_key(curses.KEY_DOWN)
win.handle_key(curses.KEY_UP)
self.assertEqual(0, win.position)
def test_should_handle_key_up(self):
self._parent_window.getmaxyx.return_value = (9, 30)
dt = datetime.datetime(2016, 6, 27, 22, 6, 28)
win = Datetime(self._manager, 'Date', dt)
win.handle_key(curses.KEY_UP)
win.refresh()
self.assertEqual([((0, 8, '|Date|'),), ((2, 2, '2017-06-27 22:06:28'),)],
self._child_window.addstr.call_args_list)
def handle_key(self, k):
if k == ord('\n'):
self.close(True)
elif k == 27:
self.close(False)
elif k == curses.KEY_DOWN:
self.position = min(self._count - 1, self.position + 1)
elif k == curses.KEY_UP:
self.position = max(0, self.position - 1)
def handle_key(self, k):
if k == ord('\n'):
self.close(True)
elif k == 27:
if self._parent.getch() == -1:
self.close(False)
elif k == curses.KEY_RIGHT:
self._datetime_state.move_right()
elif k == curses.KEY_LEFT:
self._datetime_state.move_left()
elif k == curses.KEY_UP:
self._datetime_state.increment()
elif k == curses.KEY_DOWN:
self._datetime_state.decrement()
def command(self, char):
"""handle page specific commands"""
if char == curses.KEY_DOWN or char == ord('j'):
if self.pad_pos < self.row_count-1:
self.pad_pos += 1
elif char == curses.KEY_UP or char == ord('k'):
if self.pad_pos > 0:
self.pad_pos -= 1
elif char == curses.KEY_NPAGE or char == ord('J'):
if self.pad_pos < self.row_count-((self.max_y)/2):
self.pad_pos += (self.max_y)/2
else:
self.pad_pos = self.row_count-1
elif char == curses.KEY_PPAGE or char == ord('K'):
if self.pad_pos > ((self.max_y)/2):
self.pad_pos -= (self.max_y)/2
else:
self.pad_pos = 0
elif char == curses.KEY_RIGHT or char == ord('l'):
if self.row_index[self.pad_pos][0] == 'vessel':
vessel = self.row_index[self.pad_pos][1]
return ('VESSEL_DETAIL', vessel)
if self.row_index[self.pad_pos][0] == 'target':
vessel = self.row_index[self.pad_pos][1]
path = self.row_index[self.pad_pos][2]
return ('TARGET_DETAIL', (vessel, path))
return (None, None)
def _select_account(self):
row_len = 20
selected = 0
while True:
self.screen.clear()
self.screen.addstr(1, 2, "Select an account:")
rows = self._account_names + ["New account"]
for i, account in enumerate(rows):
row_string = " %s" % account
row_string += " " * (row_len - len(row_string))
if i == selected:
color = self._active_account_color()
else:
color = self._inactive_account_color()
self.screen.addstr(i + 3, 2, row_string, color)
self._display_status()
self.screen.refresh()
c = self.screen.getch()
if c == curses.KEY_UP:
selected -= 1
if selected < 0:
selected = len(rows) - 1
elif c == curses.KEY_DOWN:
selected += 1
if selected >= len(rows):
selected = 0
elif c == curses.KEY_ENTER or c == 10 or c == 13:
if selected == len(rows) - 1:
await self._new_account()
break
else:
account_name = rows[selected]
password = self._enter_password()
ec = await api.Account.set(self._ws, account_name, password)
if ec:
self.screen.addstr(10, 2, "Error: %s" % ec.name)
else:
return
def curses_loop(self, stdscr):
while 1:
self.redraw()
c = stdscr.getch()
if c == ord('q') or c == ord('Q'):
self.aborted = True
break
elif c == curses.KEY_UP:
self.cursor = self.cursor - 1
elif c == curses.KEY_DOWN:
self.cursor = self.cursor + 1
# elif c == curses.KEY_PPAGE:
# elif c == curses.KEY_NPAGE:
elif c == ord(' '):
self.all_options[self.selected]["selected"] = \
not self.all_options[self.selected]["selected"]
elif c == 10:
break
# deal with interaction limits
self.check_cursor_up()
self.check_cursor_down()
# compute selected position only after dealing with limits
self.selected = self.cursor + self.offset
temp = self.getSelected()
self.selcount = len(temp)
def display(self):
self.window.clear()
self.showdetail()
while True:
self.has_focus = True
self.next_window.has_focus = False
self.window.refresh()
curses.doupdate()
self.update()
key = self.window.getch()
if key in [curses.KEY_ENTER, ord('\n')]:
return self.position
if key == curses.KEY_UP:
if self.position == 0:
self.navigate(self.last_item_index)
else:
self.navigate(-1)
elif key == curses.KEY_DOWN:
self.navigate(1)
elif key == curses.KEY_RIGHT or key == curses.KEY_LEFT:
self.has_focus = False
self.update()
self.next_window.display()
def display(self):
self.window.clear()
self.showdetail()
while True:
self.has_focus = True
self.next_window.has_focus = False
self.window.refresh()
curses.doupdate()
self.update()
key = self.window.getch()
if key in [curses.KEY_ENTER, ord('\n')]:
self.action()
return
if key == curses.KEY_UP:
if self.position == 0:
self.navigate(self.last_item_index)
else:
self.navigate(-1)
elif key == curses.KEY_DOWN:
self.navigate(1)
elif key == curses.KEY_RIGHT or key == curses.KEY_LEFT:
self.has_focus = False
self.update()
return
# TODO: scrolling this
def display(self):
self.window.clear()
while True:
self.window.refresh()
curses.doupdate()
for index, item in enumerate(self.items):
if index == self.position:
mode = curses.A_REVERSE
else:
mode = curses.A_NORMAL
msg = '- %s\n (Features: %s, Design: %s)' % (item, item.features, item.design_need)
self.window.addstr(1+index*2, 2, msg, mode)
key = self.window.getch()
if key in [curses.KEY_ENTER, ord('\n')]:
if self.position == len(self.items)-1:
return None
else:
return self.position
if key == curses.KEY_UP:
self.navigate(-1)
elif key == curses.KEY_DOWN:
self.navigate(1)
def start(self):
"""
start iterates the file and paints the text on the screen.
exits when q is pressed.
"""
try:
fileptr = 0
key = ''
lines = 1
while True:
# get the cursor position for further manipulation
y, x = self.stdscr.getyx()
key = self.stdscr.getch()
if key == curses.KEY_BACKSPACE or key == curses.KEY_DC or \
key == curses.KEY_DL or key == 127 :
# handle backspace
if x == 0 and y == 0:
continue
# take the file pointer back one step
fileptr -= 1
# update the screen
if x == 0:
lines -= 1
self.stdscr.addstr(y-1, len(self.virtualfile[lines-1]), ' ')
self.stdscr.move(y-1, len(self.virtualfile[lines-1]))
else:
self.stdscr.addstr(y, x-1, ' ')
self.stdscr.move(y, x-1)
elif key == curses.KEY_UP or key == curses.KEY_DOWN or \
key == curses.KEY_RESIZE or key == -1:
# ignore
continue
else:
text = self.get_text(fileptr)
# increase the lines if there are "\n" s
lines += sum([1 if c == '\n' else 0 for c in text])
fileptr += self.n
self.stdscr.addstr(text)
self.stdscr.refresh()
# graceful exit
curses.endwin()
except KeyboardInterrupt:
curses.endwin()
exit()
def main():
environ["TERM"] = 'Eterm'
initscr()
curs_set(0)
try:
win = newwin(16, 60, 0, 0)
win.keypad(True)
win.nodelay(True)
win.border('|', '|', '-', '-', '+', '+', '+', '+')
win.addch(4, 44, '@')
win.addstr(0, 5, ' Eat all the OPNFV bugs by FunTest! ')
win.addstr(15, 7, ' Left,Right,Up,Down: move; other keys: quit ')
snake = [[20, 7], [19, 7], [18, 7], [17, 7],
[16, 7], [15, 7], [14, 7], [13, 7]]
key = KEY_RIGHT
body = '~FUNTEST'
ind = 0
while key != 27:
win.addstr(0, 44, ' Score: ' + str(len(snake) - len(body)) + ' ')
win.timeout(140 - 2 * len(snake))
getkey = win.getch()
key = key if getkey == -1 else getkey
snake.insert(
0, [snake[0][0] + (key == KEY_RIGHT and 1 or
key == KEY_LEFT and -1),
snake[0][1] + (key == KEY_DOWN and 1 or
key == KEY_UP and -1)])
win.addch(snake[len(snake) - 1][1], snake[len(snake) - 1][0], ' ')
if win.inch(snake[0][1], snake[0][0]) & 255 == 32:
snake.pop()
elif win.inch(snake[0][1], snake[0][0]) & 255 == ord('@'):
c = [n for n in [[randrange(1, 58, 1), randrange(1, 14, 1)]
for x in range(len(snake))] if n not in snake]
win.addch(c == [] and 4 or c[0][1],
c == [] and 44 or c[0][0], '@')
else:
break
ind += 1
win.addch(snake[0][1], snake[0][0], body[ind % len(body)])
finally:
endwin()
print('\nSnake.PY-26ines by Kris Cieslak (defaultset.blogspot.com).')
print('OPNFV adaptation by Functest dream team.')
score = str(len(snake) - len(body) - 1)
print ('Thanks for playing, your score: %s.' % score)
print('Find and fix more bugs in your real OPNFV setup!\n')
def keys_init(self):
"""Define methods for each key.
"""
self.keys = {
curses.KEY_BACKSPACE: self.backspace,
CTRL('h'): self.backspace,
curses.ascii.BS: self.backspace,
curses.ascii.DEL: self.backspace,
curses.ascii.ETX: self.close,
curses.KEY_DC: self.del_char,
CTRL('d'): self.del_char,
CTRL('u'): self.del_to_bol,
CTRL('k'): self.del_to_eol,
curses.KEY_DOWN: self.down,
CTRL('n'): self.down,
curses.KEY_END: self.end,
CTRL('e'): self.end,
curses.KEY_F1: self.help,
curses.KEY_HOME: self.home,
CTRL('a'): self.home,
curses.KEY_ENTER: self.insert_line_or_quit,
curses.ascii.NL: self.insert_line_or_quit,
curses.ascii.LF: self.insert_line_or_quit,
"\n": self.insert_line_or_quit,
curses.KEY_LEFT: self.left,
CTRL('b'): self.left,
curses.KEY_NPAGE: self.page_down,
curses.KEY_PPAGE: self.page_up,
CTRL('v'): self.paste,
CTRL('x'): self.quit,
curses.KEY_F2: self.quit,
curses.KEY_F3: self.quit_nosave,
curses.ascii.ESC: self.quit_nosave,
curses.KEY_RESIZE: self.resize,
-1: self.resize,
curses.KEY_RIGHT: self.right,
CTRL('f'): self.right,
curses.KEY_UP: self.up,
CTRL('p'): self.up,
}
def keypress(self, char):
# right arrow select a user/group to chat with
if char == curses.KEY_RIGHT:
self.refresh_body()
self.update_chat()
self.showing = self.selection
current_id = self.slack_client.active[self.showing].id
current_name = self.slack_client.active[self.showing].name
for m in self.slack_client.last_messages(current_id):
self.push_chat(m['user'], m['text'])
return
# moves to the user/group below current selection
elif char == curses.KEY_DOWN:
if self.selection < len(self.slack_client.active) - 1:
self.set_body_selection(self.selection + 1)
self.refresh_body()
return
# move cursor one position up
elif char == curses.KEY_UP:
if self.selection > 0:
self.set_body_selection(self.selection - 1)
self.refresh_body()
return
# send the content on the textbox
elif char == curses.KEY_ENTER or chr(char) == "\n":
# Fixme: send message as 'me', should be username
self.push_chat('me', self.text)
self.send_text()
return
# delete a character
elif chr(char) == self.del_char or chr(char) == "\x7f":
self.backspace()
return
# send the char to textbox area
else:
self.text += chr(char)
self.refresh_textarea(char)
return
# This method is callable for testing porpuses only
def runDateTime(scr, rollover, topString, bottomString, start=None):
if(rollover):
if(start is None):
d = date.today()
t = time()
else:
d = date(start.year, start.month, start.day)
t = time(start.hour, start.minute, start.second)
else:
if(start is None):
d = datetime.date.today()
t = datetime.time()
else:
d = datetime.date(start.year, start.month, start.day)
t = datetime.time(start.hour, start.minute, start.second)
c = curses.KEY_MAX
cursor = 3
while(c != 10):
displayDateTime(scr, d, t, cursor, topString, bottomString)
c = scr.getch()
if(c == curses.KEY_RIGHT) and cursor < 18:
cursor += 1
if(cursor in (4, 7, 10, 13, 16)):
cursor += 1
elif(c == curses.KEY_LEFT) and cursor > 0:
cursor -= 1
if(cursor in (4, 7, 10, 13, 16)):
cursor -= 1
elif(c == curses.KEY_UP):
if(cursor < 10):
d = alterDigitDay(cursor, d, 1)
else:
t = alterDigitTime(cursor - 11, t, 1)
elif(c == curses.KEY_DOWN):
if(cursor < 10):
d = alterDigitDay(cursor, d, -1)
else:
t = alterDigitTime(cursor - 11, t, -1)
else:
try:
i = int(c) - 48
if(i >= 0 and i < 10):
if(cursor < 10):
d = updateDigitDay(cursor, d, i)
else:
t = updateDigitTime(cursor - 11, t, i)
except ValueError:
pass
return datetime.datetime(d.year, d.month, d.day,
t.hour, t.minute, t.second)
def c_main(stdscr):
cargo_cult_routine(stdscr)
stdscr.nodelay(0)
mydir = factory(start)
mydir.expand()
curidx = 3
pending_action = None
pending_save = False
while True:
stdscr.clear()
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)
line = 0
offset = max(0, curidx - curses.LINES + 3)
for data, depth in mydir.traverse():
if line == curidx:
stdscr.attrset(curses.color_pair(1) | curses.A_BOLD)
if pending_action:
getattr(data, pending_action)()
pending_action = None
elif pending_save:
global result
result = data.name
return
else:
stdscr.attrset(curses.color_pair(0))
if 0 <= line - offset < curses.LINES - 1:
stdscr.addstr(line - offset, 0,
data.render(depth, curses.COLS))
line += 1
stdscr.refresh()
ch = stdscr.getch()
if ch == curses.KEY_UP:
curidx -= 1
elif ch == curses.KEY_DOWN:
curidx += 1
elif ch == curses.KEY_PPAGE:
curidx -= curses.LINES
if curidx < 0: curidx = 0
elif ch == curses.KEY_NPAGE:
curidx += curses.LINES
if curidx >= line: curidx = line - 1
elif ch == curses.KEY_RIGHT:
pending_action = 'expand'
elif ch == curses.KEY_LEFT:
pending_action = 'collapse'
elif ch == ESC:
return
elif ch == ord('\n'):
pending_save = True
curidx %= line
################################################################################
def on_key(self, ch):
if not self.items:
return False
if ch == curses.KEY_UP:
if self.selected == 0:
return False
self.selected -= 1
# Selection is outside view, scroll up
if self.selected - self.offset < 0:
self.offset = self.selected
elif ch == curses.KEY_DOWN:
if self.selected == len(self.items) - 1:
return False
self.selected += 1
# Selection is outside view, scroll down
if self.selected - self.offset >= self.h:
self.offset = self.selected - self.h + 1
elif ch == curses.KEY_HOME:
self.selected = 0
self.offset = 0
elif ch == curses.KEY_END:
self.selected = len(self.items) - 1
self.offset = max(0, self.selected - self.h + 1)
elif ch == curses.KEY_ENTER:
key, title, action = self.items[self.selected]
self.select(key)
return True # no update necessary
else:
return False
self.update()
return True
def on_key(self, ch):
if not self.active or self.disabled:
return
if not self.active.on_key(ch):
y, x = self.position(self.active)
if ch == curses.KEY_UP:
if y > 0:
self.set_active(self.rows[y - 1][self.defaults[y - 1]])
elif ch in (curses.KEY_DOWN, curses.KEY_ENTER):
if y < len(self.rows) - 1:
self.set_active(self.rows[y + 1][self.defaults[y + 1]])
elif ch == curses.KEY_LEFT:
if x > 0:
self.set_active(self.rows[y][x - 1])
elif ch == curses.KEY_RIGHT:
if x < len(self.rows[y]) - 1:
self.set_active(self.rows[y][x + 1])
elif ch == curses.ascii.TAB:
# Right
if x < len(self.rows[y]) - 1:
self.set_active(self.rows[y][x + 1])
# Down, ignoring defaults
elif y < len(self.rows) - 1:
self.set_active(self.rows[y + 1][0])
else:
self.set_active(self.rows[0][0])
elif ch == curses.KEY_BTAB:
# Left
if x > 0:
self.set_active(self.rows[y][x - 1])
# Up
elif y > 0:
col = len(self.rows[y - 1]) - 1
self.set_active(self.rows[y - 1][col])
else:
row = len(self.rows) - 1
col = len(self.rows[row]) - 1
self.set_active(self.rows[row][col])
def keyloop(stdscr):
# Clear the screen and display the menu of keys
stdscr.clear()
stdscr_y, stdscr_x = stdscr.getmaxyx()
menu_y = (stdscr_y-3)-1
display_menu(stdscr, menu_y)
# Allocate a subwindow for the Life board and create the board object
subwin = stdscr.subwin(stdscr_y-3, stdscr_x, 0, 0)
board = LifeBoard(subwin, char=ord('*'))
board.display(update_board=False)
# xpos, ypos are the cursor's position
xpos, ypos = board.X//2, board.Y//2
# Main loop:
while (1):
stdscr.move(1+ypos, 1+xpos) # Move the cursor
c = stdscr.getch() # Get a keystroke
if 0<c<256:
c = chr(c)
if c in ' \n':
board.toggle(ypos, xpos)
elif c in 'Cc':
erase_menu(stdscr, menu_y)
stdscr.addstr(menu_y, 6, ' Hit any key to stop continuously '
'updating the screen.')
stdscr.refresh()
# Activate nodelay mode; getch() will return -1
# if no keystroke is available, instead of waiting.
stdscr.nodelay(1)
while (1):
c = stdscr.getch()
if c != -1:
break
stdscr.addstr(0,0, '/')
stdscr.refresh()
board.display()
stdscr.addstr(0,0, '+')
stdscr.refresh()
stdscr.nodelay(0) # Disable nodelay mode
display_menu(stdscr, menu_y)
elif c in 'Ee':
board.erase()
elif c in 'Qq':
break
elif c in 'Rr':
board.makeRandom()
board.display(update_board=False)
elif c in 'Ss':
board.display()
else: pass # Ignore incorrect keys
elif c == curses.KEY_UP and ypos>0: ypos -= 1
elif c == curses.KEY_DOWN and ypos<board.Y-1: ypos += 1
elif c == curses.KEY_LEFT and xpos>0: xpos -= 1
elif c == curses.KEY_RIGHT and xpos<board.X-1: xpos += 1
else:
# Ignore incorrect keys
pass
