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 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 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 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