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 keycode_to_name(code, meta):
if type(code) in (unicode, str):
num_code = ord(code)
if num_code >= 0x10000:
return "\\U%08x" % (num_code, )
elif num_code >= 0x100:
return "\\u%04x" % (num_code, )
else:
code = num_code
if code >= 256:
name = curses.keyname(code)
if name.startswith("KEY_"):
name = name[4:]
if name.startswith("key_"):
name = name[4:].upper()
if name.startswith("F("):
name = "F" + name[2:-1]
elif code >= 128:
name = "\\%03o" % (code, )
elif code == 27:
name = "ESCAPE"
elif code == 32:
name = "SPACE"
else:
name = curses.keyname(code)
if meta:
return "M-" + name
else:
return name
def foo(scr):
#notify_resize(scr)
scr.scrollok(True)
maxy, maxx = scr.getmaxyx()
win = scr.subwin(1, maxx, maxy-1, 0)
win.overwrite(scr)
win.addstr('1')
win.clear()
while True:
key = scr.getch()
if key == curses.KEY_RESIZE:
#notify_resize(scr)
pass
else:
try:
#scr.addstr(str(curses.keyname(key)) + "\t: ",
win.addstr('2')
#win.clear()
scr.addstr(curses.keyname(key) + "\t: ",
#curses.A_BLINK)
#curses.A_BOLD)
#curses.A_NORMAL)
curses.A_REVERSE)
#curses.A_STANDOUT)
#curses.A_UNDERLINE)
#scr.addstr(str(key) + "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n\n", curses.A_REVERSE)
scr.addstr(str(key) + "\n", curses.A_REVERSE)
scr.refresh()
except:
scr.scroll()
win.addstr(curses.keyname(key))
win.refresh()
def potato(bananawindow):
""" Curses is controlled from here.
This might be called 'the loop' in a game.
"""
def background():
""" Writes the default background each screen rewrite.
"""
bananawindow.border()
bananawindow.bkgdset('+')
winheight, winwidth = bananawindow.getmaxyx()
winheight_str = str(winheight)
winwidth_str = str(winwidth)
bananawindow.addstr(winheight - 2, winwidth - 10, winheight_str)
bananawindow.addstr(winheight - 2, winwidth - 10 + len(winheight_str),
"," + winwidth_str)
background()
keypress = int()
# 113 is the lowercase 'q' key.
while curses.keyname(keypress) != '^D':
keypress = bananawindow.getch()
bananawindow.erase()
background()
# Lets actually add the character to the screen now.
bananawindow.addch(1, 10, keypress)
bananawindow.addstr(2, 10, curses.unctrl(keypress))
bananawindow.addstr(3, 10, curses.keyname(keypress))
def ListenForKey(self): while True: if not self.pauseMode: c = self.screen.getch() if curses.keyname(c) == "KEY_DOWN": self.moveYCursor(1) elif curses.keyname(c) == "KEY_UP": self.moveYCursor(-1) elif curses.keyname(c) == "KEY_RIGHT": self.moveXCursor(1) elif curses.keyname(c) == "KEY_LEFT": self.moveXCursor(-1) if c == curses.KEY_ENTER or c == 10 or c == 13: if not self.editMode: self.editMode = True else: self.editMode = False if c == 330: #Delete key self.pauseMode = True self.deleteMode = True if c == 14: self.newMode = True self.createTable() self.createInfoField()
def run_command_intercept_key(self, key):
if curses.keyname(key) == b'^?':
key = curses.KEY_BACKSPACE
elif curses.keyname(key) == b'^I':
# TODO handle completion
return None
return key
def keycode_to_name(code, meta):
if type(code) in (unicode, str):
num_code = ord(code)
if num_code >= 0x10000:
return "\\U%08x" % (num_code,)
elif num_code >= 0x100:
return "\\u%04x" % (num_code,)
else:
code = num_code
if code>=256:
name=curses.keyname(code)
if name.startswith("KEY_"):
name=name[4:]
if name.startswith("key_"):
name=name[4:].upper()
if name.startswith("F("):
name="F"+name[2:-1]
elif code>=128:
name="\\%03o" % (code,)
elif code==27:
name="ESCAPE"
elif code==32:
name="SPACE"
else:
name=curses.keyname(code)
if meta:
return "M-"+name
else:
return name
def potato(bananawindow):
""" Curses is controlled from here.
This might be called 'the loop' in a game.
"""
def background():
""" Writes the default background each screen rewrite.
"""
bananawindow.border()
bananawindow.bkgdset('+')
winheight, winwidth = bananawindow.getmaxyx()
winheight_str = str(winheight)
winwidth_str = str(winwidth)
bananawindow.addstr(winheight-2, winwidth-10, winheight_str)
bananawindow.addstr(winheight-2, winwidth-10+len(winheight_str), ","+winwidth_str)
background()
keypress = int()
# 113 is the lowercase 'q' key.
while curses.keyname(keypress) != '^D':
keypress = bananawindow.getch()
bananawindow.erase()
background()
# Lets actually add the character to the screen now.
bananawindow.addch(1,10,keypress)
bananawindow.addstr(2,10,curses.unctrl(keypress))
bananawindow.addstr(3,10,curses.keyname(keypress))
def check(self, event=None):
event = event if event is not None else self.win.getch()
try:
if event == curses.KEY_RESIZE:
return event
elif event == curses.KEY_LEFT:
return None
elif event == curses.KEY_RIGHT:
return None
elif event == curses.KEY_UP:
return None
elif event == curses.KEY_DOWN:
return None
elif self.trigs.get(event):
self.trigs.get(event)()
elif self.trigs.get(int(event)):
self.trigs.get(int(event))()
elif self.trigs.get(str(event)):
self.trigs.get(str(event))()
elif self.trigs.get(chr(event)):
self.trigs.get(chr(event))()
elif self.trigs.get(str(curses.keyname(event))):
self.trigs.get(str(curses.keyname(event)))()
elif self.trigs.get('rest'):
self.trigs.get('rest')(event)
return event
except ValueError, e:
drawMessage(str(e)+"\n Press Enter.", self.win)
self.win.addstr(1, 4, 'key: \'%s\' <=> %c <=> 0x%X <=> %d' % (curses.keyname(event), event & 255, event, event))
def make_line():
for c, f in list(ed.nmap.items()):
if f.__doc__:
yield '{0} {1}: {2}'.format(
curses.keyname(c), f.__name__, f.__doc__)
else:
yield '{0} {1}'.format(
curses.keyname(c), f.__name__, f.__doc__)
def make_line():
for c, f in ed.nmap.items():
if f.__doc__:
yield '{0} {1}: {2}'.format(
curses.keyname(c), f.__name__, f.__doc__)
else:
yield '{0} {1}'.format(
curses.keyname(c), f.__name__, f.__doc__)
def handle_input(scr):
global active_tab
global is_running
global keysdown
code = scr.getch()
if (code == curses.ERR): # If no keypress, move on to next loop
return
key = curses.keyname(code) # convert to printable (readable keycaps)
if key == '^[': # meta (alt)? get *one* more char (this may be wrong?) More?
ch = scr.getch()
if (ch != curses.ERR): # Its a real character
code = 255 * code + ch # Add them (16 bits)
key = key + curses.keyname(ch) # concat
#sp = 32 tab = 9
if key == 'q': # quit!
is_running = False
elif key == '^[1': # alt-1
active_tab = 0
# Reset whatever state tab 0 is in?
elif key == '^[2':
active_tab = 1
#Reset tab 1
elif key == '^[3':
active_tab = 2
#Reset tab 2
elif key == '^[4': # alt-4
active_tab = 3
elif key == 'z':
queue.append(queue.pop(0))
stale_queue = True
#Reset Tab 3
elif code in (ord('h'), curses.KEY_UP):
keysdown[KEY_UP] = 1
elif code in (ord('l'), curses.KEY_DOWN):
keysdown[KEY_DOWN] = 1
elif code in (ord('j'), curses.KEY_LEFT):
keysdown[KEY_LEFT] = 1
elif code in (ord('k'), curses.KEY_RIGHT):
keysdown[KEY_RIGHT] = 1
elif code == 10: # Enter key
keysdown[KEY_CONFIRM] = 1
elif code == 27: # Esc key
keysdown[KEY_CANCEL] = 1
elif code == 330: # Del key
keysdown[KEY_DELETE] = 1
elif key == 'e': # Eject key
keysdown[KEY_EJECT] = 1
elif key == 'r': # Rename key
keysdown[KEY_RENAME] = 1
elif key == 'i': # Insert key
keysdown[KEY_INSERT] = 1
else:
scr.addstr(22, 3, str(code))
curses.flash() # Flash on non-mapped key
def run_main_loop(self):
self.draw_ui()
self.window.move(1, 1)
while 1:
c = self.window.getch()
if curses.keyname(c) in [b'q', b'Q']:
break
elif c == 27:
break
elif curses.keyname(c) in [b'i', b'I']:
break
self.show_notification_state(uuid_store)
curses.endwin()
def print_key(w, key, alt):
if isinstance(key, str):
nr = ord(key)
w.addstr(0, 0, _MSG)
if nr < 128:
w.addstr(1, 0, str((nr, alt * "!" + curses.keyname(ord(key)).decode(), alt)))
w.addstr(2, 0, str((nr, alt * "!" + ascii.unctrl(key), alt)))
else:
w.addstr(1, 0, str((nr, alt * "!" + key, alt)))
else:
w.addstr(0, 0, _MSG)
w.addstr(1, 0, str((key, alt * "!" + curses.keyname(key).decode(), alt)))
def inputFunc(self, c):
if(curses.keyname(c) == '^J' or curses.keyname(c) == '^M'): # Enter/Return \n
if(self.buf in self.cmds):
self.func = self.buf
self.cmdRef = self.cmds[self.func][1]
if(self.cmds[self.buf][1]):
if(len(self.cmdRef[0]) == 3): # Do we have helpText for our first arg?
self.buf += self.cmdRef[0][2]
else:
self.buf += ":"
self.argPrompt = self.buf
self.cX = len(self.buf)
else:
self.msg = self.buf + " [Unknown Command]"
elif(curses.keyname(c) == '^I'): # TAB completion
opts = []
for k,v in self.cmds.iteritems():
if(k.startswith(self.buf)):
opts.append(k)
if(len(opts) == 0):
self.msg = self.buf + " [Nothing found]"
elif(len(opts) == 1):
self.buf = opts.pop()
self.cX = len(self.buf)
else:
ii = -1
brk = False
while not brk:
ii += 1
c = opts[0][ii]
for o in opts:
if(o[ii] != c):
self.buf = o[:ii]
self.cX = len(self.buf)
brk = True
opts.sort()
msg = self.buf + " ["
for ii in xrange(len(opts)):
if((ii == self.tabOptions - 1) and (len(opts) > self.tabOptions)):
msg += opts[ii] + "|..."
break
elif(ii == self.tabOptions - 1):
msg += opts[ii]
break
else:
msg += opts[ii] + "|"
self.msg = msg.rstrip("|") + "]"
def _key_name(self, key):
"""Return the curses key name for keys received from get_wch (and getch)."""
# Handle multibyte get_wch input in Python 3.3
if type(key) == type(""):
return str(curses.keyname(ord(key)).decode("utf-8"))
# Fallback to try and handle Python < 3.3
if type(key) == type(1): # getch fallback
try: # Try to convert to a curses key name
return str(curses.keyname(key).decode("utf-8"))
except: # Otherwise try to convert to a character
try:
return chr(key)
except:
return False
return key
def _key_name(self, key):
"""Return the curses key name for keys received from get_wch (and getch)."""
# Handle multibyte get_wch input in Python 3.3
if type(key) == type(""):
return str(curses.keyname(ord(key)).decode("utf-8"))
# Fallback to try and handle Python < 3.3
if type(key) == type(1): # getch fallback
try: # Try to convert to a curses key name
return str(curses.keyname(key).decode("utf-8"))
except: # Otherwise try to convert to a character
try:
return chr(key)
except:
return False
return key
def run(self):
'''
run: The main loop of the application. Waits for user inputs, and acts accordingly.
:return: None
'''
thread.start_new_thread(self.poll_for_messages, tuple())
self.addCmdLine("Welcome to Chat!")
self.addCmdLine("Login to start chatting, or type help to get a list of valid commands.")
while True:
try:
assert not curses.isendwin()
if self.mode == -1:
self.display.setLines(self.cmd_history)
else:
if self.mode not in self.current_user.formatted_messages:
self.current_user.formatted_messages[self.mode] = []
self.display.setLines(self.current_user.formatted_messages[self.mode])
self.displayScreen()
# get user command
c = self.screen.getch()
if c == curses.KEY_UP:
self.display.updown(self.UP)
elif c == curses.KEY_DOWN:
self.display.updown(self.DOWN)
elif c == self.ESC_KEY:
self.mode = -1
self.display.setLines(self.cmd_history, adjust=True)
elif curses.keyname(c) == '^U':
self.display.pageup()
elif curses.keyname(c) == '^D':
self.display.pagedown()
elif c == ord('\n'):
# Interpret command
if self.mode == -1:
self.execute_cmd(self.input_w.line)
else:
self.P.send_message(from_name=self.current_user.username,
dest_id=self.mode,
msg=self.input_w.line)
self.input_w.clearLine()
else:
self.input_w.putchar(c)
except KeyboardInterrupt as e:
self.exited = True
raise e
except Exception as e:
pass
def get_guess(mimick=None):
s = ""
while True:
display_guess(s)
key = curses.keyname(SCREEN.getch()).decode()
if key == '^?': # BACKSPACE
s = s[:-1]
elif key == '^J' and not mimick: # ENTER
return s
elif key == '^W': # CTRL-W(quit deck)
return False
ch = ''
if key == '^K': # CTRL-K(Enter digraph)
dig1 = SCREEN.getkey()
dig2 = SCREEN.getkey()
dig = (dig1, dig2)
if dig in DIGRAPHS:
ch = DIGRAPHS[dig]
elif key in USER_CHARS:
ch = key
if mimick and not mimick.startswith(s + ch):
continue
else:
s += ch
if s == mimick:
return s
def setQuestion(cls,
title,
text="",
underline="",
justWait=False,
noUserInput=False):
cls.stdscr.erase()
# draw rectangle
editwin = curses.newwin(5, cls.maxx - 4, cls.maxy - 9, 2)
rectangle(cls.stdscr, cls.maxy - 10, 1, cls.maxy - 4,
1 + cls.maxx - 4 + 1)
# new textbox
cls.box = graphics.Textbox(editwin)
# Title, text and underline
cls.stdscr.addstr(cls.maxy - 16, 2, title, curses.A_BOLD)
cls.stdscr.addstr(cls.maxy - 13, 2, text)
cls.stdscr.addstr(cls.maxy - 3, 2, underline)
# refesh screen
cls.stdscr.refresh()
# if just want char
if justWait:
char = cls.stdscr.getch()
return curses.keyname(char).decode("utf-8")
# get user input
if not noUserInput:
return cls.box.gather()
return ""
def _read(self):
handles = [sys.stdin]
try:
while not self._quit.is_set():
try:
select.select(handles,[],handles)
except select.error:
pass
if self._quit.is_set():
break
while True:
try:
with self._lock:
with self._curseslock:
ch = self._window.getch()
if ch == -1:
break
key = curses.keyname(ch)
self._key = key
self.update()
self._clear_timer.start()
event = self._charmap[key].strip()
event_formatted = event.format(b=self._buffer)
if not self.emit("event",event_formatted):
self.emit('error','Failed to parse: "{0}"'.format(event))
except (KeyError, IndexError):
pass
finally:
self._quit.set()
def mainTUI(*args, **kwds):
# just wait for a while
mainw, model = args
# setup curses
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
curses.curs_set(0) # invisible cursor
mainw.nodelay(0) # wait for user input
# start metazoom layout engine
mz = MZlayout(mainw, model)
mz.printAtCenter("Welcome to MetaZoom")
# Main loop
while True:
# get command
key = mainw.getch()
try:
keyname = curses.keyname(key)
except Exception, e:
pass
# keyname="LOG: invalid key:"+str(key)
# prepare new screen
mainw.erase()
# execute command
mz.command(keyname)
# update screen
mz.redraw()
mainw.noutrefresh()
curses.doupdate()
def curse_main(screen):
curses.curs_set(False)
curses.init_pair(1, curses.COLOR_YELLOW, curses.COLOR_RED)
curses.init_pair(2, curses.COLOR_BLUE, curses.COLOR_GREEN)
screen.bkgd(" ", curses.color_pair(0))
screen.border()
window = screen.subwin(15, 20, 10, 10)
window.bkgd(" ", curses.color_pair(1))
window.move(1, 0)
screen.refresh()
while True:
char = screen.getch()
screen.move(1, 1)
screen.addstr("%-10s" % curses.keyname(char), curses.A_BOLD)
screen.refresh()
window.move(0, 0)
window.addstr("%-3d" % char, curses.A_UNDERLINE)
window.refresh()
if char == ord('q') or char == 27:
break
curses.curs_set(True)
def wait(self):
# Ensure the screen is entirely up-to-date before entering blocking
# mode. (Or, at least, normally this will be blocking mode.)
self.stdscr.refresh()
ch = self.stdscr.getch()
if ch < 0:
# If .getch() returns -1 then we're in non-blocking mode which is
# only the case when this has been specifically requested. Thus
# we allow the event to be handled.
self.redraw()
try:
self._nonblocking_handler()
except RemoveHorseHandler:
self._nonblocking_handler = None
self.stdscr.nodelay(0)
return
# Check if we can resolve this character in our mapping and otherwise
# use the .keyname() function to resolve it.
key = self.characters.get(ch, curses.keyname(ch))
log.debug('Received character %r (%d)', key, ch)
# Handle this event.
try:
if not hasattr(self, '_handle_%s' % key):
raise AngryHorseException('Unknown keybinding: %r.' % key)
getattr(self, '_handle_%s' % key)()
except AngryHorseException as e:
self.angry_horse(e.message)
def curse_main(screen):
curses.curs_set(False)
curses.init_pair(1,curses.COLOR_YELLOW,curses.COLOR_RED)
curses.init_pair(2,curses.COLOR_BLUE,curses.COLOR_GREEN)
screen.bkgd(" ",curses.color_pair(0))
screen.border()
window = screen.subwin(15,20,10,10)
window.bkgd(" ",curses.color_pair(1))
window.move(1,0)
screen.refresh()
while True:
char = screen.getch()
screen.move(1,1)
screen.addstr("%-10s" % curses.keyname(char),curses.A_BOLD)
screen.refresh()
window.move(0,0)
window.addstr("%-3d" % char,curses.A_UNDERLINE)
window.refresh()
if char == ord('q') or char == 27:
break
curses.curs_set(True)
def run_key_test(self): # pragma: no cover
try:
self.initialise_display()
y = 1
self.win.addstr(0, 0, "Terminal type: " + os.environ['TERM'])
while True:
key = self.win.get_wch()
if type(key) is int:
hexstr = hex(key)
name = curses.keyname(key).decode('utf-8')
else:
name = ''
hexstr = key.encode().hex()
info = "{0} {1} {2} (0x{3})".format(repr(key), type(key), name,
hexstr)
self.win.addstr(y, 0, info)
y += 1
if y >= self.win_height - 1:
self.win.clear()
y = 0
finally:
self.finalise_display()
def input_thread(**kwargs):
glopnet = kwargs.get('glopnet')
stop_lock = kwargs.get('stop_lock')
input_queue = kwargs.get('input_queue')
curses_lock = kwargs.get('curses_lock')
assert isinstance(glopnet, Glopnet)
while True:
if stop_lock.acquire(blocking=False):
break
curses_lock.acquire(
) # =============================================================== CURSES LOCK ACQUIRE
while True:
ch = glopnet.stdscr.getch()
if ch == -1:
break
elif ch == curses.KEY_MOUSE:
mouseinfo = (-1, -1, -1, -1, -1)
try:
mouseinfo = curses.getmouse()
except curses.error:
pass
input_queue.put(Mouse(info=mouseinfo))
elif ch == curses.KEY_RESIZE:
glopnet.resize_screen()
else:
s = str(curses.keyname(ch))
input_queue.put(Key(ch, mod=False, s=s))
curses_lock.release(
) # =============================================================== CURSES LOCK RELEASE
sleep(SPF / 16.0)
def c_main(stdscr):
stdscr.insstr(curses.LINES - 1, curses.COLS - len(Q_TO_QUIT), Q_TO_QUIT)
stdscr.move(0, 0)
i = 0
while True:
wch = stdscr.get_wch()
if wch == '\033':
stdscr.nodelay(True)
try:
while True:
try:
wch += stdscr.get_wch()
except curses.error:
break
finally:
stdscr.nodelay(False)
if isinstance(wch, str) and len(wch) > 1:
stdscr.insstr(i, 0, f'(sequence) {wch!r}')
else:
key = wch if isinstance(wch, int) else ord(wch)
keyname = curses.keyname(key)
stdscr.insstr(i, 0, f'{wch!r} {key!r} {keyname.decode()!r}')
i += 1
stdscr.move(i, 0)
if wch == 'q':
return
def check_key(self, player):
c = self.screen.getch()
if c == -1:
return 0
rv = self.modeScreens[self.mode].check_key(c, player)
if rv:
return rv
k = curses.keyname(c)
if k in ('^I', ):
self.rotate_mode(+1)
elif k in ('KEY_BTAB', ):
self.rotate_mode(-1)
elif k in ('1', ):
self.choose_mode(CursesVisualizer.Mode.MAIN)
elif k in ('2', ):
self.choose_mode(CursesVisualizer.Mode.VOICE)
elif k in ('3', ):
self.choose_mode(CursesVisualizer.Mode.SCALES)
elif k in ('4', ):
self.choose_mode(CursesVisualizer.Mode.CONTROLS)
elif k in ('5', ):
self.choose_mode(CursesVisualizer.Mode.READER)
elif k in ('^[', '^D', ):
return 1
return 0
def tui(stdscr):
''' Main function. This must be called by curses.wrapper() '''
init_curses(stdscr)
draw_title(stdscr)
search_input = create_searchbar(stdscr)
repolist = create_repolist()
draw_help(stdscr)
curses.doupdate()
while True:
char = stdscr.getch()
if char is KEY_EXIT:
break
elif char == KEY_CLONE:
thread = Thread(target=clone, args=(repolist.current(), ))
thread.start()
break
elif char == KEY_SEARCH:
search(search_input.value(), repolist)
draw_nav_help(stdscr)
elif char == KEY_BACK:
search_input.delete()
elif char == KEY_DOWN:
repolist.selection_down()
elif char == KEY_UP:
repolist.selection_up()
else:
search_input.append(curses.keyname(char).decode('utf-8'))
curses.doupdate()
def show_edits(date, edits, area_id):
"""Show all edits of an entry as a scrollable list."""
from writelightly.screen import ScreenManager
from writelightly.utils import format_time, format_size
from writelightly.scrollable_list import ScrollableList
import curses
formatted = ['%s, created' % format_time(edits[0][0], full=True)]
formatted += ['%s, %s' % (format_time(ts, full=True),
format_size(size)) for ts, size in edits[1:]]
sl = ScrollableList(formatted, area_id=area_id)
sl.draw()
while 1:
kn = curses.keyname(sl.window.getch())
if kn in Config.general_keys['quit']:
raise WLQuit
if kn in Config.general_keys['quit_mode']:
break
if kn == 'KEY_RESIZE':
ScreenManager.resize()
if sl.hidden:
continue
elif kn in Config.edits_keys['open']:
index = sl.get_current_index()
fn = save_tmp_version(date, edits, index)
edit_file(fn)
sl.draw()
else:
sl.handle_keypress(kn)
def main(stdscr):
while True:
c = stdscr.getch()
kn = 'key name: %s' % curses.keyname(c)
kv = 'key value: %d' % c
stdscr.addstr(0, 0, kn + ' ' * (32 - len(kn))) # row 0
stdscr.addstr(1, 0, kv + ' ' * (32 - len(kv))) # row 1
def main_app(screen, server, debugging):
"""Main command-loop, to be run within curses.wrapper."""
curses.raw()
screen.nodelay(0)
info_layout(screen)
stale = False
while True:
ch = screen.getch()
if stale or debugging:
info_layout(screen)
stale = False
if ch in (-1, 3, 4, ord('q')):
# We forcibly use ^C and ^D, even if stty has remapped intr & eof
break
if ch == 12: # ^L
screen.refresh()
continue
if ch == ord('D'):
debugging = False if debugging else True
screen.addstr(1, 10, 'Debugging %s' % ('enabled' if debugging else 'disabled'))
screen.move(0, 0)
stale = True
continue
handled = process_command(ch, server, screen, debugging)
if debugging and not handled:
screen.addstr(1, 10, 'Character %d %s' % (ch, curses.keyname(ch)))
screen.move(0, 0)
stale = True
def curse_main(screen):
curses.curs_set(False)
curses.init_pair(1,curses.COLOR_YELLOW,curses.COLOR_RED)
curses.init_pair(2,curses.COLOR_BLUE,curses.COLOR_GREEN)
screen.bkgd("*",curses.color_pair(1))
screen.border()
window = screen.subwin(15,20,10,10)
window.bkgd(" ",curses.color_pair(2))
window.move(1,0)
colors = [color for color in curses.__dict__.keys() if "COLOR_" in color and "PAIRS" not in color]
for kk,color in enumerate(colors):
curses.init_pair(3+kk,curses.COLOR_BLACK,curses.__dict__[color])
window.addstr("%s\n" % color,curses.color_pair(3+kk))
screen.refresh()
while True:
char = screen.getch()
screen.move(1,1)
screen.addstr("%-10s" % curses.keyname(char),curses.A_BOLD)
screen.refresh()
window.move(0,0)
window.addstr("%-3d" % char,curses.A_UNDERLINE)
window.refresh()
if char == ord('q') or char == 27:
break
curses.curs_set(True)
def doStuff(stdscr, pages, pg_nums, name):
i=0
data = []
while i < len(pg_nums):
if i!=0 and i%2==0:
write_data(data)
data = []
lines = poetryhelper.get_all_lines(pages[i])
pg_dim = poetryhelper.get_page_dimensions(pages[i])
num = pg_nums[i]
# url = "http://www.archive.org/download/%s/page/n%d.jpg" % (name, int(num))
# webbrowser.open(url)
j=0
while j < len(lines):
stdscr.clear()
stdscr.move(0, 0)
stdscr.addstr("Page %s, Line %d\n\r" % (num, j))
stdscr.addstr(poetryhelper.get_line_text(lines[j]))
inp = stdscr.getch()
c = curses.keyname(inp)
if c in statedict:
state = statedict[c]
elif inp==curses.KEY_BACKSPACE:
if j>0:
j -= 1
elif i>0:
oldi = i
oldj = j
foundline = False
while i>0 and not foundline:
i -= 1
newlines = poetryhelper.get_all_lines(pages[i])
newpg_dim = poetryhelper.get_page_dimensions(pages[i])
newnum = pg_nums[i]
j = len(newlines) - 1
if len(newlines)>0:
foundline = True
pg_dim = newpg_dim
lines = newlines
num = newnum
if not foundline: # first line in the book at oldi, oldj
i = oldi
j = oldj
if len(data)>0:
l = data[-1].split(' ')[0].split('_')
# ONLY remove last piece of data if it's the prev line
if l[0]==name and l[1]==num and int(l[2])==j:
del data[-1]
continue
elif c=='q':
i = len(pg_nums)
break
else:
j += 1
continue
data.append(classify_line(name, num, j, state))
j += 1
i += 1
write_data(data)
def mainloop(self):
curses.raw()
self.updateFrames()
self.redrawAll("viewLog","startup")
while (1):
c = self._Window.getch()
extraMessage = ""
if ( c == curses.KEY_UP ):
self.currentFrame().cursorUp()
elif (c == curses.KEY_DOWN ):
self.currentFrame().cursorDown()
elif (c == ord("t") or c == ord(" ") ):
self.currentFrame().toggleCurrentNode()
elif (c == ord("o") ):
self.currentFrame().openCurrentNode()
elif (c == ord("c") ):
self.currentFrame().closeCurrentNode()
elif (c == 22 ): # C-v
self.currentFrame().pageDown()
elif (c == 118 ): # M-v
self.currentFrame().pageUp()
elif ( c == ord("C") ):
self.currentFrame().nodeCrawlerCursor().node().closeAllChildren()
elif ( c == ord("u") ):
self.currentFrame().parentNode()
elif (c == 19 ): # C-s
self.enterSearchString("Forward search")
extraMessage = self.currentFrame().forwardSearch(self._LastSearch)
elif (c == 18 ): # C-r
self.enterSearchString("Reverse search")
extraMessage = self.currentFrame().reverseSearch(self._LastSearch)
elif ( c == ord("m") ):
m = self._Window.getch()
self._Locations[m] = self.currentFrame().nodeCrawlerCursor()
extraMessage = "Saved location in register <%c>" % m
elif ( c == ord("'") ):
m = self._Window.getch()
if ( m in self._Locations ):
self.currentFrame().setNodeCrawlerCursor(self._Locations[m])
self.currentFrame().nodeCrawlerCursor().node().openAllParents()
extraMessage = "Restored location in register <%c>" % m
else:
extraMessage = "Unknown register <%c>" % m
elif ( c == 24 ):
m = self._Window.getch()
if ( m == ord("2") ):
self.insertFrameBeforeCurrent()
elif ( m == ord("o") ):
self.nextFrame()
elif ( m == ord("0") ):
self.deleteCurrentFrame()
elif (c == ord("Q") or ( c == 3 ) ):
return
elif (curses.keyname(c) == "^v" ):
self.pageDown()
statusLine = self.cursorStatus(extraMessage)
self._Window.erase()
self.updateFrames()
self.redrawAll(statusLine,"last key: %d" % c)
def putchar(self, c):
'''
Writes a character to the input window. The written characters are also logged
to a log file (log.txt).
Special keys, such as arrow keys, shift the position of the cursor on the window
screen or display a history of commands.
Deletion of characters is also supported,
along with certain Emacs commands for moving the cursor (e.g. Ctrl-A, Ctrl-E, Ctrl-K).
:param c: the character read from the keyboard
:return: void
'''
with open('log.txt', 'a') as f:
f.write('Received %s\n' % curses.keyname(c))
if c == ord('\b') or c == curses.KEY_BACKSPACE or c == curses.KEY_DC or c == 127:
self.line = self.line[:-1]
if self.pos > 0:
self.pos -= 1
elif c == curses.KEY_LEFT:
if self.pos > 0:
self.pos -= 1
elif c == curses.KEY_RIGHT:
if self.pos < len(self.line):
self.pos += 1
elif curses.keyname(c) == '^A':
self.pos = 0
elif curses.keyname(c) == '^E':
self.pos = len(self.line)
elif curses.keyname(c) == '^U':
self.line = self.line[self.pos:]
self.pos = 0
elif curses.keyname(c) == '^K':
self.line = self.line[:self.pos]
elif c == curses.KEY_SR:
if self.historypos > -len(self.history):
self.historypos -= 1
self.line = self.history[self.historypos]
self.pos = len(self.line)
elif c == curses.KEY_SF:
if self.historypos < -1:
self.historypos += 1
self.line = self.history[self.historypos]
self.pos = len(self.line)
else:
self.line = self.line[:self.pos] + chr(c) + self.line[self.pos:]
self.pos += 1
def get_keyname(self, key):
try:
if not isinstance(key, int):
key = ord(key)
return str(curses.keyname(key), 'utf-8', 'replace')
except Exception:
return '?'
def mainLoopTesting(self): event_dict = self.getDict() while True: c = self.screen.getch() keyname = curses.keyname(c) print(c) print(keyname) key = event_dict[ keyname ]
def main(stdscr):
global log
# help(stdscr)
stdscr.keypad(True)
curses.curs_set(0)
curses.mousemask(curses.BUTTON1_CLICKED)
if platform == 'win32':
curses.resize_term(16, 34)
init_color()
log = Logger(stdscr)
board = Board(stdscr)
# board.set(Knight('BLUE'), (0, 0))
# board.set(Knight('BLUE'), (0, 1))
# board.set(Frost('RED'), (2, 2))
# board.set(Knight('RED'), (2, 3))
# board.set(Frost('RED'), (0, 2))
board.draw()
time.sleep(1)
card_selected = None
while True:
s = stdscr.getch()
# stdscr.addstr(4, x,curses.keyname(s), curses.A_BOLD)
cmd = ''
if 32 <= s <= 127:
cmd += str(curses.keyname(s))
stdscr.addstr(curses.keyname(s), curses.A_BOLD)
if s == ord('q'): # or x>=curses.LINES-3:
break
# else:
# stdscr.addstr(str(s))
if s == curses.KEY_MOUSE:
signal, pos = mouse_where(len(board.teams[board.turn].cards))
log(signal, pos)
if signal == 'END':
board.proceed()
# board.draw(stdscr)
elif signal == 'DECK':
card_selected = pos
elif signal == 'ABORT':
card_selected = None
elif signal == 'BOARD':
if card_selected is not None:
board.play(card_selected, pos)
# clear selection no matter play is valid or not
card_selected = None
board.draw()
def nameFromKey(key):
if key in prenamed:
return prenamed[key]
try:
keyname = curses.keyname(key)
except ValueError:
return None
return str(keyname, "utf-8")
def get_keyname(self, key):
try:
if not isinstance(key, int):
key = ord(key)
return str(curses.keyname(key), 'utf-8', 'replace')
except Exception:
return '?'
def test_midi(self, stdscr):
# loop
while 1:
c = stdscr.getch()
self.midi_out.note_on(64, 64)
time.sleep(0.5)
self.midi_out.note_off(64)
if curses.keyname(c)=="q" :
break
def handle_search(self):
"""Let user search through items of the list."""
self.search_mode = True
self.resize()
initial = self.current
maxx = 50
tw = curses.newwin(1, maxx, self.window.getbegyx()[0] +
self.window.getmaxyx()[0], 0)
t = TextInput(tw, '/')
try:
curses.curs_set(1)
except curses.error:
pass
while 1:
try:
ch = get_char(tw)
except KeyboardInterrupt:
self._goto(initial)
break
try:
kn = curses.keyname(ch)
except TypeError:
kn = ''
if kn == '^J':
self.term = t.gather()[1:].lower()
break
elif kn == 'KEY_RESIZE':
self.resize()
tw = curses.newwin(1, maxx, self.window.getbegyx()[0] +
self.window.getmaxyx()[0], 0)
t.move_to_new_window(tw)
continue
t.do_command(ch)
pat = t.gather()
if not pat:
self._goto(initial)
break
pat = pat[1:].lower()
if not pat:
self._goto(initial)
found = False
for index, line in self.get_items(initial, initial - 1):
if pat in line.lower():
found = True
self._goto(index)
break
if not found:
self._goto(initial)
try:
curses.curs_set(0)
except curses.error:
pass
self.search_mode = False
self.resize()
self.draw()
def test_midi(self, stdscr):
# loop
while 1:
c = stdscr.getch()
self.midi_out.note_on(64, 64)
time.sleep(0.5)
self.midi_out.note_off(64)
if curses.keyname(c) == "q":
break
def check_key(self, key, player):
kn = curses.keyname(key)
buflen = len(self.parent.fakeOut.buffer)
rows = self.winLog.getmaxyx()[0] - 2
if kn in ('F', 'f'):
self.parent.fakeOut.flush()
elif navkey(kn, buflen, rows):
self.scrollLog(navkey(kn, buflen, rows))
return 0
def _handle_key(self, key):
char = curses.keyname(key).decode()
if char == "^R":
self.restart()
if key in (curses.KEY_BACKSPACE, 127):
self.input = self.input[:-1]
elif chr(key) == " ":
self._finish_word_event()
else:
self.input += chr(key)
def get_key_name(screen):
key = screen.getch()
key_name = curses.keyname(key).decode()
if ' ' == key_name:
key_name = 'KEY_SPACE'
elif '^J' == key_name:
key_name = '\n'
elif '^I' == key_name:
key_name = '\t'
return key_name
def input(self, c):
if curses.keyname(c) == '^?' or curses.keyname(c) == 'KEY_BACKSPACE': # Backspace
if(len(self.buf) > len(self.argPrompt)):
self.buf = self.buf[:len(self.buf)-1]
self.cX -= 1
elif(c == curses.KEY_RIGHT):
if(self.cX < len(self.buf)):
self.cX += 1
elif(c == curses.KEY_LEFT):
if(self.cX > 0):
self.cX -= 1
elif c == curses.KEY_UP :
if self.historyPtr < len(self.history) - 1:
self.historyPtr += 1
self.buf = self.history[self.historyPtr][0]
self.cX = len(self.buf)
elif c == curses.KEY_DOWN:
if self.historyPtr == 0:
self.resetPrompt()
elif self.historyPtr > -1:
self.historyPtr -= 1
self.buf = self.history[self.historyPtr][0]
self.cX = len(self.buf)
elif(curses.keyname(c) == '^A'): # Goto beginning of line
self.cX = len(self.argPrompt)
elif(curses.keyname(c) == '^E'): # Goto end of line
self.cX = len(self.buf)
elif(curses.keyname(c) == '^U'): # Goto beginning of line and clear line
self.cX = len(self.argPrompt)
self.buf = self.argPrompt
elif(curses.keyname(c) == '^J' or curses.keyname(c) == '^M' or curses.keyname(c) == '^I'): # Enter/Return/TAB
if(len(self.argPrompt) > 0):
self.inputArgs(c)
else:
self.inputFunc(c)
elif(c in self.allowedChars):
if(self.cX >= len(self.buf)):
self.buf += chr(c)
elif(self.cX == 0):
self.buf = chr(c) + self.buf
else:
self.buf = self.buf[:self.cX -1] + chr(c) + self.buf[self.cX:]
self.cX += 1
def mainLoop(self): event_dict = self.getDict() while True: c = self.screen.getch() keyname = curses.keyname(c) try: key = event_dict[ keyname ] except KeyError: self.Headless.handleChars(keyname) else: self.Headless.handleKeyInputEvent(key)
def main(scrn):
curses.raw() # disable Ctrl-C, Ctrl-Z
scrn.addstr(0,0, "Press any key... please!")
while True:
ch = scrn.getch()
scrn.addstr(2,0, " ")
scrn.addstr(2,0, "Key code: " + str(ch))
scrn.addstr(3,0, " ")
scrn.addstr(3,0, "Key name: " + curses.keyname(ch))
def read_keychord(screen, timeout=0, receive_input=False):
key = screen.getch()
if key == -1:
return None, None
if key == 27:
try:
screen.timeout(0)
key = screen.getch()
if key == -1:
return '<esc>', False
else:
return translate_keychord(curses.keyname(key).decode('utf-8'),
meta=True), False
finally:
screen.timeout(timeout)
else:
keyname = curses.keyname(key).decode('utf-8')
if receive_input and len(keyname) == 1:
return keyname, True
return translate_keychord(keyname), False
def main(stdscr):
# Clear screen
stdscr.clear()
while True:
#key = stdscr.getkey()
#stdscr.addstr(i, 0, '10 divided by {} is {}'.format(v, 10/v))
keyId = stdscr.getch()
keyName = curses.keyname(keyId)
printToScreen(stdscr, keyName)
sendKey(keyName)
def echokey(w):
curses.noecho()
w.keypad(1)
curses.cbreak()
w.addstr(19, 20, "value")
w.addstr(19, 40, "name")
ch = w.getch()
while (1 == 1):
w.addstr(20, 20, str(ch))
w.addstr(20, 40, curses.keyname(ch))
ch = w.getch()
w.deleteln()
def mainloop(self):
curses.raw()
self.updateLines()
self.redrawLines("viewLog", "startup")
while (1):
c = self._Window.getch()
extraMessage = ""
if (c == curses.KEY_UP):
self.cursorUp()
elif (c == curses.KEY_DOWN):
self.cursorDown()
elif (c == ord("t") or c == ord(" ")):
self.toggleCurrent()
elif (c == ord("o")):
self.openCurrent()
elif (c == ord("c")):
self.closeCurrent()
elif (c == 22): # C-v
self.pageDown()
elif (c == 118): # M-v
self.pageUp()
elif (c == 19): # C-s
extraMessage = self.forwardSearch()
elif (c == 18): # C-r
extraMessage = self.reverseSearch()
elif (c == ord("C")):
self.closeAllChildren()
elif (c == ord("u")):
self.parentNode()
elif (c == ord("<")):
self.firstNode()
elif (c == ord(">")):
self.lastNode()
elif (c == ord("m")):
m = self._Window.getch()
self._Locations[m] = self._NodeCrawlerCursor
extraMessage = "Saved location in register <%c>" % m
elif (c == ord("'")):
m = self._Window.getch()
if (m in self._Locations):
self._NodeCrawlerCursor = self._Locations[m]
self.openAllParents(self._NodeCrawlerCursor.node())
extraMessage = "Restored location in register <%c>" % m
else:
extraMessage = "Unknown register <%c>" % m
elif (c == ord("Q") or (c == 3)):
return
elif (curses.keyname(c) == "^v"):
self.pageDown()
statusLine = self.cursorStatus(extraMessage)
self.updateLines()
self.redrawLines(statusLine, "last key: %d" % c)
def get_key_mapping(code):
if isinstance(code, str):
return code, 0
s = curses.keyname(code)
s = str(s, encoding='utf-8')
if s in SHIFT_NAMES:
return _generic_get(code)
if s[:-1] in CYGWIN_KEYS:
key = CYGWIN_KEYS[s[:-1]]
mod = CYGWIN_MODIFIERS[s[-1]]
return key, mod
return code, 0
def input_string(key):
global tile
tile = ''
while key != keys['ENTER']:
if key > 0 and key != keys['ENTER']:
if key == keys['BACKSPACE']:
tile = tile[:-1]
else:
tile += curses.keyname(key)
redraw_board()
graphics.drawCurrentMenu()
key = graphics.screen.getch()
def input_string(key):
global tile
tile = ''
while key != keys['ENTER']:
if key > 0 and key != keys['ENTER']:
if key == keys['BACKSPACE']:
tile = tile[:-1]
else:
tile += curses.keyname(key)
redraw_board()
graphics.drawCurrentMenu()
key = graphics.screen.getch()
def keyboard_loop():
window = curses.initscr()
#use cbreak to not require a return key press
curses.cbreak()
# don't echo back the user's commands
curses.noecho()
while 1:
c = window.getch()
#seq.tick()
window.addstr(0, 0, seq.to_string())
if curses.keyname(c) == "q":
break