def build_keymap(args):
"""
Function build_keymap returns a dictionary from curses keys to game.Keys.
"""
if args.vimkeys:
return {
ord('k'): Keys.UP,
ord('j'): Keys.DOWN,
ord('h'): Keys.LEFT,
ord('l'): Keys.RIGHT,
ord(' '): Keys.PROBE,
ord('f'): Keys.FLAG,
}
return {
curses.KEY_UP: Keys.UP,
curses.KEY_DOWN: Keys.DOWN,
curses.KEY_LEFT: Keys.LEFT,
curses.KEY_RIGHT: Keys.RIGHT,
ord('\n'): Keys.PROBE,
ord('f'): Keys.FLAG,
}
python类KEY_DOWN的实例源码
def input_stream(self):
"""Waiting an input and run a proper method according to type of input"""
while True:
self.search(self.query)
self.display()
ch = self.search_window.getch()
if curses.ascii.isprint(ch):
self.write(ch)
self.reset_top()
elif ch in (curses.ascii.BS, curses.ascii.DEL, curses.KEY_BACKSPACE):
self.delete()
self.reset_top()
elif ch == curses.KEY_UP:
self.scroll(self.UP)
elif ch == curses.KEY_DOWN:
self.scroll(self.DOWN)
elif ch in (curses.ascii.LF, curses.ascii.NL):
self.open_link()
elif ch == curses.ascii.ESC:
break
def update(cls):
key = cls.getch()
if key is not None:
if key == curses.KEY_UP:
cls.PAD_Y = max(cls.PAD_Y - 1, 0)
elif key == curses.KEY_DOWN:
cls.PAD_Y = min(
cls.PAD_Y + 1,
cls.PAD_HEIGHT - (cls.HEIGHT + 1)
)
elif key == curses.KEY_LEFT:
cls.PAD_X = max(cls.PAD_X - 1, 0)
elif key == curses.KEY_RIGHT:
cls.PAD_X = min(
cls.PAD_X + 1,
cls.PAD_WIDTH - (cls.WIDTH + 1)
)
elif key == ord('q'):
cls.trigger('quit')
for y in range(cls.PAD_Y, cls.PAD_Y + cls.HEIGHT):
s = cls.MAP[y][cls.PAD_X:cls.PAD_X + cls.PAD_HEIGHT]
s = ''.join(x for x in s)
cls.addstr(s, cls.PAD_X, y)
cls.refresh()
def _handle_key(self, x):
if x == curses.KEY_UP:
if self.history_point < len(self.search_history):
self.history_point += 1
self.inp.erase()
self.inp.addstr(0, 0, self.search_history[-self.history_point])
if x == curses.KEY_DOWN:
if self.history_point > 1:
self.history_point -= 1
self.inp.erase()
self.inp.addstr(0, 0, self.search_history[-self.history_point])
if x == 27:
self.canceled = True
return 7
if x == 10:
return 7
return x
def on_key(self, ch):
if ch not in (curses.KEY_UP, curses.KEY_DOWN, curses.KEY_PPAGE, curses.KEY_NPAGE):
return
if ch == curses.KEY_UP:
self.scroll = max(self.scroll - 1, 0)
if ch == curses.KEY_DOWN:
self.scroll = min(self.scroll + 1, self.maxscroll)
if ch == curses.KEY_PPAGE:
self.scroll = max(self.scroll - self.perpage, 0)
if ch == curses.KEY_NPAGE:
self.scroll = min(self.scroll + self.perpage, self.maxscroll)
self.update()
def focus(self):
modeline.update_activeWindow("Map")
curses.curs_set(0)
while True:
event = self.mapwin.getch()
# if event == -1:
# continue
logging.info(event)
try_handle_global_event(event)
if event == curses.KEY_UP:
self.pan("up")
if event == curses.KEY_DOWN:
self.pan("down")
if event == curses.KEY_LEFT:
self.pan("left")
if event == curses.KEY_RIGHT:
self.pan("right")
if event == curses.KEY_NPAGE:
self.zoom_out(5)
if event == curses.KEY_PPAGE:
self.zoom_in(5)
def update_screen():
"""
Updates the screen each time a key is pressed.
"""
if not GUI.gui_stopped:
if GUI.key == curses.KEY_DOWN:
GUI.on_key_down()
elif GUI.key == curses.KEY_UP:
GUI.on_key_up()
elif GUI.key == curses.KEY_LEFT:
GUI.on_key_left()
elif GUI.key == curses.KEY_RIGHT:
GUI.on_key_right()
if GUI.key == ord("\n") and GUI.row_num != 0:
GUI.on_key_enter()
GUI.box.erase()
GUI.display_list()
GUI.add_bottom_menus()
GUI.screen.refresh()
GUI.box.refresh()
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
#0 Append The Snake's range to the Body object for Snakes Body
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
#1 Define and append the snakes head
self.body_list.append(Body(x, y, '0'))
#2 define the window
self.window = window
#3 Move snake to right when game starts
self.direction = KEY_RIGHT
#4 set snakes lst head coordinate
self.last_head_coor = (x, y)
#5 define direction map
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def __init__(self, x, y, window):
self.body_list = []
self.hit_score = 0
self.timeout = TIMEOUT
for i in range(SNAKE_LENGTH, 0, -1):
self.body_list.append(Body(x - i, y))
self.body_list.append(Body(x, y, '0'))
self.window = window
self.direction = KEY_RIGHT
self.last_head_coor = (x, y)
self.direction_map = {
KEY_UP: self.move_up,
KEY_DOWN: self.move_down,
KEY_LEFT: self.move_left,
KEY_RIGHT: self.move_right
}
def handle_key(self, k):
if k == ord('q'):
self.close(None)
elif k == ord('d'):
self._change_date()
elif k == ord('l'):
self._change_level()
elif k == ord('f'):
self._change_facility()
elif k == ord('h'):
self._change_host()
elif k == ord('p'):
self._change_program()
elif k == curses.KEY_NPAGE:
self._buf.go_to_next_page()
elif k == curses.KEY_PPAGE:
self._buf.go_to_previous_page()
elif k == curses.KEY_DOWN:
self._buf.go_to_next_line()
elif k == curses.KEY_UP:
self._buf.go_to_previous_line()
elif k == curses.KEY_RIGHT:
self.scroll_right()
elif k == curses.KEY_LEFT:
self.scroll_left()
def main(self):
# self.set_banner("14.076.00", "JT65/JT9", "Tx")
#
# self.thread_flag = True
# thread.start_new_thread(self.add_to_window, ())
key = ''
while True:
key = self.stdscr.getch()
if key == ord('q'):
# self.thread_flag = False
# break
pass
elif key == curses.KEY_DOWN:
# scroll down ?
self.main_win.scroll(-1)
pass
elif key == curses.KEY_UP:
# scroll up ?
self.main_win.scroll(1)
pass
self.exit_now()
def loop(self):
while True:
key = self.left.getkey()
if key.lower() == 'q':
return
elif key.lower() == 'v':
status = self.get_selected_status()
if status:
webbrowser.open(status['url'])
elif key.lower() == 'j' or key == curses.KEY_DOWN:
self.select_next()
elif key.lower() == 'k' or key == curses.KEY_UP:
self.select_previous()
def keys_init_noedit(self):
"""Define methods for each key for non-editing mode.
"""
self.keys = {
curses.ascii.ETX: self.close,
curses.KEY_DOWN: self.down_noedit,
CTRL('n'): self.down_noedit,
'j': self.down_noedit,
curses.KEY_F1: self.help,
curses.KEY_NPAGE: self.page_down,
'J': self.page_down,
CTRL('f'): self.page_up,
curses.KEY_PPAGE: self.page_up,
'K': self.page_up,
CTRL('b'): self.page_up,
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_UP: self.up_noedit,
CTRL('p'): self.up_noedit,
'k': self.up_noedit,
}
def get_user_input(self):
# gets the user's input
try:
user_in = self.screen.getch() # Gets user input
except Exception as e:
self.__exit__()
## DEBUG KEYS - enable these lines to see curses key codes
# self.screen.addstr(1, 1, str(user_in), curses.A_NORMAL)
# self.screen.refresh()
# Resize sends curses.KEY_RESIZE, update display
if user_in == curses.KEY_RESIZE:
self.maxy,self.maxx = self.screen.getmaxyx()
self.screen.clear()
self.screen.refresh()
# enter and exit Keys are special cases
if user_in == 10:
return self.options[self.selected]
if user_in == 27:
return self.options[-1]
# this is a number; check to see if we can set it
if user_in >= ord('1') and user_in <= ord(str(min(9,len(self.options)+1))):
self.selected = user_in - ord('0') - 1 # convert keypress back to a number, then subtract 1 to get index
return
# increment or Decrement
down_keys = [curses.KEY_DOWN, 14, ord('j')]
up_keys = [curses.KEY_UP, 16, ord('k')]
if user_in in down_keys: # down arrow
self.selected += 1
if user_in in up_keys: # up arrow
self.selected -=1
# modulo to wrap menu cursor
self.selected = self.selected % len(self.options)
return
def display(self):
self.panel.top()
self.panel.show()
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 = '%d. %s' % (index, item[0])
self.window.addstr(1+index, 1, msg, mode)
key = self.window.getch()
if key in [curses.KEY_ENTER, ord('\n')]:
# Handle exit from menu
if self.position == len(self.items)-1 or str(self.items[self.position][1]) == "exit":
break
else:
if self.rootmenu.set_selection(self.items[self.position][1]):
break
elif key == curses.KEY_UP:
self.navigate(-1)
elif key == curses.KEY_DOWN:
self.navigate(1)
self.window.clear()
self.panel.hide()
panel.update_panels()
curses.doupdate()
def runDay(scr, rollover, topString, bottomString, start=None):
if(rollover):
if(start is None):
day = date.today()
else:
day = date(start.year, start.month, start.day)
else:
if(start is None):
day = datetime.date.today()
else:
day = datetime.date(start.year, start.month, start.day)
c = curses.KEY_MAX
cursor = 3
while(c != 10):
displayDay(scr, day, cursor, topString, bottomString)
c = scr.getch()
if(c == curses.KEY_RIGHT) and cursor < len(str(day))-1:
cursor += 1
if(cursor == 4 or cursor == 7):
cursor += 1
elif(c == curses.KEY_LEFT) and cursor > 0:
cursor -= 1
if(cursor == 4 or cursor == 7):
cursor -= 1
elif(c == curses.KEY_UP):
day = alterDigitDay(cursor, day, 1)
elif(c == curses.KEY_DOWN):
day = alterDigitDay(cursor, day, -1)
else:
try:
i = int(c) - 48
if(i >= 0 and i < 10):
day = updateDigitDay(cursor, day, i)
except ValueError:
pass
return datetime.date(day.year, day.month, day.day)
def runTime(scr, rollover, topString, bottomString, start=None):
if(rollover):
if(start is None):
t = time()
else:
t = time(start.hour, start.minute, start.second)
else:
if(start is None):
t = datetime.time()
else:
t = datetime.time(start.hour, start.minute, start.second)
c = curses.KEY_MAX
cursor = 3
while(c != 10):
displayTime(scr, t, cursor, topString, bottomString)
c = scr.getch()
if(c == curses.KEY_RIGHT) and cursor < len(str(t))-1:
cursor += 1
if(cursor == 2 or cursor == 5):
cursor += 1
elif(c == curses.KEY_LEFT) and cursor > 0:
cursor -= 1
if(cursor == 2 or cursor == 5):
cursor -= 1
elif(c == curses.KEY_UP):
t = alterDigitTime(cursor, t, 1)
elif(c == curses.KEY_DOWN):
t = alterDigitTime(cursor, t, -1)
else:
try:
i = int(c) - 48
if(i >= 0 and i < 10):
t = updateDigitTime(cursor, t, i)
except ValueError:
pass
return datetime.time(t.hour, t.minute, t.second)
def processkey(self, key, win):
h, w = win.getmaxyx()
if (key == ord(' ')):
weapon = self.arsenal[self.active_weapon]
if (weapon[1] != 0):
self.shoot()
if(weapon[1] != -1):
weapon[1] = max(0, weapon[1] - 1)
return True
else:
self.weapon_display_timer = 50
elif (key == curses.KEY_LEFT):
if self.angle <= pi/2:
self.angle = pi - self.angle
else:
self.move(-1)
elif (key == curses.KEY_RIGHT):
if self.angle >= pi/2:
self.angle = pi - self.angle
else:
self.move(1)
elif (key == curses.KEY_UP):
if (self.angle <= pi/2):
self.angle = min(pi/2.001, self.angle+0.01)
else:
self.angle = max(pi/1.999, self.angle-0.01)
elif (key == curses.KEY_DOWN):
if (self.angle <= pi/2):
self.angle = max(0, self.angle-0.01+pi/8)-pi/8
else:
self.angle = min(pi*9/8, self.angle+0.01)
elif (key == ord('+')):
self.power = min(1.00, self.power+0.01)
elif (key == ord('-')):
self.power = max(0.00, self.power-0.01)
elif (key in map(lambda k : ord(str(k)), range(10))):
n = int(chr(key))
self.active_weapon = (n-1) % len(self.arsenal)
self.weapon_display_timer = 50
return False
def run_main_loop(self):
self.draw_ui()
while 1:
c = self.window.getch()
if curses.keyname(c) in [b'h', b'H']:
self.show_help()
elif curses.keyname(c) in [b'p', b'P']:
self.play()
elif curses.keyname(c) in [b'q', b'Q']:
return None
elif c == 27:
self.returnString = self.dir.get_current_path()
return self.returnString
elif c == curses.KEY_ENTER or c == 10:
self.returnString = self.dir.get_current_path()
return self.returnString
elif c == curses.KEY_UP:
if self.selected_index > 0:
self.selected_index -= 1
self.draw_ui()
elif c == curses.KEY_DOWN:
if self.selected_index < self.dir.max_entries_on_level()-1:
self.selected_index += 1
self.draw_ui()
elif c == curses.KEY_LEFT:
self.leave_dir()
self.draw_ui()
elif c == curses.KEY_RIGHT:
self.enter_dir()
self.draw_ui()
elif c == curses.KEY_RESIZE:
self.draw_ui()
def mainloop(self):
"""
Called after HUD has been set up. Handles rendering and user input.
"""
# Disable cursor display by default
curses.curs_set(0)
# Display initial state
self.render()
while True:
# Render before fetching input
self.render()
# note: call is non-blocking, per __init__ calling nodelay(True)
c = self.screen.getch()
if c == curses.KEY_RESIZE:
# Terminal has been resized
# must be called so that curses.LINES, curses.COLS will change
curses.update_lines_cols()
# in case old data won't be redrawn after resize
self.screen.clear()
if c == curses.KEY_UP:
# Move up as far as the 0th record
self.selectpos = max(self.selectpos - 1, 0)
if self.selectpos < self.scrollpos:
# Handle scrolling if we were at the first record on screen
self.scrollpos -= 1
if c == curses.KEY_DOWN:
# Move down as far as the Nth record
self.selectpos = min(self.selectpos + 1, len(self.records) - 1)
if self.selectpos >= (self.scrollpos + curses.LINES - 2 - self.bottom_panel_height) :
# Handle scrolling if we were at the last record on screen
self.scrollpos += 1
def configure_settings(self, pos=None, key_in=None):
"""
Perform operations to config settings if `Configure Setting` frame is
active, or just draw the `Configure Setting` frame with no items
selected while it is inactive.
.. note:: Whether the `Configure Setting` frame is inactive is decided
by if :attr:`pos` is `None` or not.
=========== ========
:attr:`pos` Status
=========== ========
None Inactive
int Active
=========== ========
:param pos: Index of selected item in `Configure Setting` frame. The
default value of `pos` is `None`.
:type pos: int or None
:param key_in: A flag indicating the key pressed by user. The default
value of `key_in` is `None`.
:type key_in: int or None
:return: Index of selected item in `Configure Setting` frame.
:rtype: int or None
"""
id_num = range(len(self.settings))
if pos is not None:
if key_in == curses.KEY_DOWN:
pos = list(id_num[1:] + id_num[:1])[pos]
elif key_in == curses.KEY_UP:
pos = list(id_num[-1:] + id_num[:-1])[pos]
elif key_in in [10, 32]:
self.sub_selection(pos)
self.info(pos, 0)
self.configure_settings_frame(pos)
return pos
def sub_selection(self, pos):
"""
Let user to choose settings from `Selection Dialog` specified by
:attr:`pos`.
:param pos: Index of selected item in `Configure Setting` frame.
:type pos: int
.. warning:: The value of `pos` MUST NOT be `None`.
.. seealso:: :meth:`~tui.curses_ui.CursesUI.sub_selection_dialog` in
:class:`~tui.curses_ui.CursesUI`.
"""
screen = self.sub_selection_dialog(pos)
i_pos = self.settings[pos][1]
# Key Press Operations
id_num = range(len(self.settings[pos][2]))
key_in = None
while key_in != 27:
self.sub_selection_dialog_items(pos, i_pos, screen)
key_in = screen.getch()
if key_in == curses.KEY_DOWN:
i_pos = list(id_num[1:] + id_num[:1])[i_pos]
elif key_in == curses.KEY_UP:
i_pos = list(id_num[-1:] + id_num[:-1])[i_pos]
elif key_in in [10, 32]:
if pos == 0 and i_pos != self.settings[pos][1]:
test = self.settings[pos][2][i_pos]["test_url"]
self.check_connection(test)
self.settings[pos][1] = i_pos
return
def main_loop():
while 1:
time.sleep(0.001)
c = mainwindow.getch()
if c == ord('/'):
word = search_window.enter()
found = game_menu.find_word(word)
game_menu.center(found)
if c == ord('j') or c == curses.KEY_DOWN:
game_menu.move_down()
if c == ord('k') or c == curses.KEY_UP:
game_menu.move_up()
if c == ord('n'):
word = search_window.text.gather().strip()
found = game_menu.find_next(word)
game_menu.center(found)
if c == ord('N'):
word = search_window.text.gather().strip()
found = game_menu.find_prev(word)
game_menu.center(found)
if c == ord('\n') or c == ord('l'):
cg = game_menu.current_game()
launch_game(cg)
if c == ord('q'):
return
if c == curses.KEY_RESIZE:
do_resize()
def on_key(self, ch):
if not self.items:
return False
if ch == curses.KEY_UP:
self.selected = max(self.selected - 1, 0)
elif ch == curses.KEY_DOWN:
self.selected = min(len(self.selectable) - 1, self.selected + 1)
elif ch == curses.KEY_HOME:
self.selected = 0
elif ch == curses.KEY_END:
self.selected = len(self.selectable) - 1
elif ch == curses.KEY_ENTER:
key, title = self.items[self.selectable[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:
return
if self.selected:
if ch in (curses.ascii.ESC, curses.KEY_BACKSPACE):
self.cancel_selection()
elif ch == curses.KEY_LEFT:
if self.selection > 0 and self.selection < 4 or self.selection > 4:
self.set_selection(self.selection - 1)
elif ch == curses.KEY_RIGHT:
if self.selection < 3 or self.selection > 3 and self.selection < 7:
self.set_selection(self.selection + 1)
elif ch == curses.KEY_UP:
if self.selection > 3:
self.set_selection(self.selection - 4)
elif ch == curses.KEY_DOWN:
if self.selection < 4 and self.selected_source == 'hand':
self.set_selection(self.selection + 4)
elif ch in (curses.KEY_ENTER, curses.ascii.SP):
self.confirm_selection()
else:
if ch == curses.KEY_LEFT:
if self.selection > 0:
self.set_selection(self.selection - 1)
elif ch == curses.KEY_RIGHT:
if self.selection + 1 < len(self.selectable_sources):
self.set_selection(self.selection + 1)
elif ch in (curses.KEY_ENTER, curses.ascii.SP):
self.confirm_selection()
def poll_event(self):
"""
Checks if an event happens and returns a string related to the event.
Returns -1 if nothing happened during self.screen.timeout milliseconds.
If the event is a normal (letter) key press,
the letter is returned (case sensitive)
:return: Event type
"""
self.mutex.acquire()
ch = self.screen.getch()
self.mutex.release()
if ch == -1:
return EVENT_SKIP
elif ch == 27:
return EVENT_ESC
elif ch == curses.KEY_RESIZE:
return EVENT_RESIZE
elif ch == 10 or ch == curses.KEY_ENTER:
return EVENT_ENTER
elif ch == 127 or ch == curses.KEY_BACKSPACE:
return EVENT_BACKSPACE
elif ch == curses.KEY_UP:
return EVENT_UP
elif ch == curses.KEY_DOWN:
return EVENT_DOWN
elif ch == curses.KEY_LEFT:
return EVENT_LEFT
elif ch == curses.KEY_RIGHT:
return EVENT_RIGHT
elif ch == 3:
return EVENT_CTRL_C
elif ch == 409:
return EVENT_CLICK
elif 0 <= ch < 256:
return chr(ch)
else:
return EVENT_UNHANDLED
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]
