def get_and_use_key_press(self): curses.raw() curses.cbreak() curses.meta(1) self.form.curses_pad.keypad(1) if self.form.keypress_timeout: curses.halfdelay(self.form.keypress_timeout) ch = self._get_ch() if ch == -1: log.debug('calling {0}.while_waiting'.format(self.form)) return self.form.while_waiting() else: self.form.curses_pad.timeout(-1) ch = self._get_ch() if ch == curses.ascii.ESC: #self.form.curses_pad.timeout(1) self.form.curses_pad.nodelay(1) ch2 = self.form.curses_pad.getch() if ch2 != -1: ch = curses.ascii.alt(ch2) self.form.curses_pad.timeout(-1) # back to blocking mode #curses.flushinp() self.handle_input(ch) if self.check_value_change: self.when_check_value_changed() if self.check_cursor_move: self.when_check_cursor_moved()
def update_loop(self): while self.exit_code is None: self.update_screen() curses.halfdelay(50) v = self.stdscr.getch() #print("v=%s" % (v,)) if v in EXIT_KEYS: self.exit_code = 0 elif v == 258: #down arrow self.position += 1 elif v == 259: #up arrow self.position = max(self.position - 1, 0) elif v == 10 and self.selected_session: #show this session: cmd = get_nodock_command() + ["top", self.selected_session] try: self.cleanup() proc = Popen(cmd) exit_code = proc.wait() #TODO: show exit code, especially if non-zero finally: self.stdscr = curses_init() elif v in (ord("s"), ord("S")): self.run_subcommand("stop") elif v in (ord("a"), ord("A")): self.run_subcommand("attach") elif v in (ord("d"), ord("D")): self.run_subcommand("detach")
def __init__(self, lives_remaining=3): self.stdscr = curses.initscr() curses.start_color() curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_WHITE) curses.init_pair(3, curses.COLOR_BLACK, curses.COLOR_RED) curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_GREEN) curses.noecho() curses.cbreak() curses.halfdelay(1) self.stdscr.keypad(True) self.board = np.zeros((10, 60)) self.next_spike = 5 self.board[8][20] = 2 self.posx = 5 self.posy = 8 self.y_move_index = 0 self.y_move_speeds = [0, -3, -2, -1, 0, 1, 2, 3] self.score = 0 self.difficulty = 0 self.difficulties = [(1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (2, 5), (3, 5), (4, 5), (4, 6), (5, 6), (6, 6)] self.game_over = 0 self.lives_remaining = lives_remaining for j in range(60): self.board[9][j] = 1
def gather_input(self, win): """ Read and process a part of the available input from stdin, possibly pausing a few ms to wait for additional input. Execute all functions enqueued by run_soon() at the end. You should call this in a loop. """ curses.halfdelay(7) win.nodelay(1) while True: try: key = win.get_wch() except curses.error: break curses.cbreak() if key == curses.KEY_MOUSE: try: self.input_mouse(*curses.getmouse()) except curses.error: pass else: self.input_key(key) if self.runqueue: rq = self.runqueue self.runqueue = [] for f in rq: f() return self.key_events != [] or self.mouse_events != []
def input_thread(self): self.log("input thread: signal handlers=%s" % signal.getsignal(signal.SIGINT)) while self.exit_code is None: if not self.paused and self.modified: self.stdscr.erase() try: self.do_update_screen() except Exception as e: self.err(e) finally: self.stdscr.refresh() self.modified = False try: curses.halfdelay(10) v = self.stdscr.getch() except Exception as e: self.log("getch() %s" % e) v = -1 self.log("getch()=%s" % v) if v == -1: continue if v in EXIT_KEYS: self.log("exit on key '%s'" % v) self.quit(0) break if v in SIGNAL_KEYS: self.log("exit on signal key '%s'" % v) self.quit(128 + SIGNAL_KEYS[v]) break if v in PAUSE_KEYS: self.paused = not self.paused
def _dbg_instr(self): # messy input string (intended for debugging) curses.echo() self.s.nodelay(0) curses.halfdelay(100) str = self.s.getstr() curses.noecho() return str
def initialize(self): """initialize curses, then call setup (at the first time) and resize.""" self.win.leaveok(0) self.win.keypad(1) self.load_mode = False curses.cbreak() curses.noecho() curses.halfdelay(20) try: curses.curs_set(int(bool(self.settings.show_cursor))) except: pass curses.start_color() curses.use_default_colors() self.settings.signal_bind('setopt.mouse_enabled', _setup_mouse) _setup_mouse(dict(value=self.settings.mouse_enabled)) if not self.is_set_up: self.is_set_up = True self.setup() self.win.addstr("loading...") self.win.refresh() self._draw_title = curses.tigetflag('hs') # has_status_line self.update_size() self.is_on = True if self.settings.update_tmux_title: sys.stdout.write("\033kranger\033\\") sys.stdout.flush()
def write_prologue(self,string): yindex = 20 xreturn = (self.len_x /2) -25 xloc = xreturn writing_prologue = True curses.halfdelay(1) for char in string: brkchar = self.win.getch() if brkchar == ord('Q'): curses.nocbreak() curses.cbreak() return True break if char == '"': time.sleep(2) yindex += 1 xloc = xreturn if char != '"': txt = ord(char) self.win.addch(yindex,xloc,txt) self.win.refresh() #time.sleep(.1) xloc += 1 time.sleep(4) return True
def run_curses(self, screen): # init some curses geometry self.screen = screen # set up curses colors curses.use_default_colors() curses.curs_set(0) assert len(self.colors) <= 4, 'Too many colors defined' assert len(self.colors) > 0, 'Not enough colors defined' global ATTRIBUTES for i,c in enumerate(self.colors): background = getattr(curses, 'COLOR_' + c[0].upper()) foreground = getattr(curses, 'COLOR_' + c[1].upper()) curses.init_pair(i + 1, background, foreground) ATTRIBUTES[str(i + 1)] = curses.color_pair(i+1) # wait for a character for only 0.1s curses.halfdelay(1) # use the first window as the default window self.current_window = self.windows['default'] self.render() while 1: input_value = screen.getch() # handle non-character input try: key = chr(input_value) except ValueError: key = input_value # pass the character input to the event loop try: self.handle(key) except Exit: return
def do_start(self): assert not self.started if utk._running_from_pytest: self._started = True return self.s = curses.initscr() self.has_color = curses.has_colors() if self.has_color: curses.start_color() if curses.COLORS < 8: # not colourful enough self.has_color = False if self.has_color: try: curses.use_default_colors() self.has_default_colors = True except _curses.error: self.has_default_colors = False curses.noecho() curses.meta(1) curses.halfdelay(10) # use set_input_timeouts to adjust self.s.keypad(0) self._started = True
def __init__(self, refresh_interval, total_columns): """Initialize the window with various settings.""" self.total_columns = total_columns self.window = curses.initscr() # Initialize colors with red, green, yellow, blue, and white curses.start_color() curses.use_default_colors() for i in range(1, 5): curses.init_pair(i, i, -1) curses.init_pair(7, 7, -1) # Use the orange color if the terminal supports it, and magenta # otherwise if curses.COLORS == 256: self.COLOR_ORANGE = 208 else: self.COLOR_ORANGE = curses.COLOR_MAGENTA curses.init_pair(self.COLOR_ORANGE, self.COLOR_ORANGE, -1) # Disable typing echo and hide the cursor curses.noecho() curses.curs_set(0) # Set the refresh interval curses.halfdelay(refresh_interval) self._update_dimensions()
def main(stdscr): # turn off cursor blinking curses.curs_set(0) curses.halfdelay(5) # color scheme for selected row curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE) # specify the current selected row current_row = 0 # print the menu print_menu(stdscr, current_row) while 1: key = stdscr.getch() if key == curses.KEY_UP and current_row > 0: current_row -= 1 elif key == curses.KEY_DOWN and current_row < len(menu) - 1: current_row += 1 elif key == curses.KEY_ENTER or key in [10, 13]: if current_row == 0: get_rice_loop(stdscr) if current_row == 1: curses.halfdelay(20) print_center(stdscr, "Just one question, GotRice?") stdscr.getch() break print_menu(stdscr, current_row)
def start(): global READY global thr global scr global win_input global pan_input global win_status global pan_status global win_msg global pan_msg if not READY: scr = curses.initscr() scr.keypad(1) curses.noecho() curses.halfdelay(1) win_msg = curses.newwin(11,53,0,0) win_msg.scrollok(1) pan_msg = panel.new_panel(win_msg) pan_msg.show() win_input = curses.newwin(3,53,12,0) pan_input = panel.new_panel(win_input) pan_input.show() win_status = curses.newwin(3,53,14,0) pan_status = panel.new_panel(win_status) pan_status.show() READY = True thr = threading.Thread(target=reading_thread) thr.start()
def run_curses(self, screen): # init some curses geometry self.screen = screen # set up curses colors curses.use_default_colors() curses.curs_set(0) assert len(self.colors) <= 4, 'Too many colors defined' assert len(self.colors) > 0, 'Not enough colors defined' global ATTRIBUTES for i, c in enumerate(self.colors): background = getattr(curses, 'COLOR_' + c[0].upper()) foreground = getattr(curses, 'COLOR_' + c[1].upper()) curses.init_pair(i + 1, background, foreground) ATTRIBUTES[str(i + 1)] = curses.color_pair(i + 1) # wait for a character for only 0.1s curses.halfdelay(1) # use the first window as the default window self.current_window = self.windows['default'] self.render() while 1: input_value = screen.getch() # handle non-character input try: key = chr(input_value) except ValueError: key = input_value # pass the character input to the event loop try: self.handle(key) except Exit: return
def MainLoop(args): global errorCount, respawn curses.halfdelay(20) while 1: PollSystem() try: Display() except curses.error: 0 # destroy the exception. we're not interested in display errors c = stdscr.getch() try: if c == ord('0'): StartStopAll() elif c == ord('q'): break elif c == ord('r'): respawn = not respawn elif c >= ord('1') and c <= ord('9'): StartStop(c - ord('0')) elif c >= ord('a') and c <= ord('m'): StartStop(c - ord('a') + 10) except: errorCount = errorCount + 1
def get_and_use_key_press(self): curses.raw() curses.cbreak() curses.meta(1) self.parent.curses_pad.keypad(1) if self.parent.keypress_timeout: curses.halfdelay(self.parent.keypress_timeout) ch = self._get_ch() if ch == -1: return self.try_while_waiting() else: self.parent.curses_pad.timeout(-1) ch = self._get_ch() # handle escape-prefixed rubbish. if ch == curses.ascii.ESC: #self.parent.curses_pad.timeout(1) self.parent.curses_pad.nodelay(1) ch2 = self.parent.curses_pad.getch() if ch2 != -1: ch = curses.ascii.alt(ch2) self.parent.curses_pad.timeout(-1) # back to blocking mode #curses.flushinp() self.handle_input(ch) if self.check_value_change: self.when_check_value_changed() if self.check_cursor_move: self.when_check_cursor_moved() self.try_adjust_widgets()
def update_loop(self): while self.exit_code is None: self.update_screen() elapsed = int(1000 * monotonic() - self.last_getch) delay = max(100, min(1000, 1000 - elapsed)) // 100 curses.halfdelay(delay) try: v = self.stdscr.getch() except Exception: v = -1 self.last_getch = int(1000 * monotonic()) if v in EXIT_KEYS: self.exit_code = 0 if v in SIGNAL_KEYS: self.exit_code = 128 + SIGNAL_KEYS[v] if v == 258: #down arrow self.position += 1 elif v == 259: #up arrow self.position = max(self.position - 1, 0) elif v == 10 and self.selected_session: self.show_selected_session() elif v in (ord("s"), ord("S")): self.run_subcommand("stop") elif v in (ord("a"), ord("A")): self.run_subcommand("attach") elif v in (ord("d"), ord("D")): self.run_subcommand("detach")
def start(self): """ Initialize the screen and input mode. """ assert self._started == False self.s = curses.initscr() self.has_color = curses.has_colors() if self.has_color: curses.start_color() if curses.COLORS < 8: # not colourful enough self.has_color = False if self.has_color: try: curses.use_default_colors() self.has_default_colors=True except _curses.error: self.has_default_colors=False self._setup_colour_pairs() curses.noecho() curses.meta(1) curses.halfdelay(10) # use set_input_timeouts to adjust self.s.keypad(0) if not self._signal_keys_set: self._old_signal_keys = self.tty_signal_keys() super(Screen, self).start()
def setup(curses, session): stdscr = curses.initscr() curses.start_color() curses.use_default_colors() curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE) curses.init_pair(2, curses.COLOR_CYAN, -1) curses.init_pair(3, curses.COLOR_GREEN, -1) curses.init_pair(4, curses.COLOR_RED, -1) curses.init_pair(10, 166, curses.COLOR_WHITE) curses.init_pair(11, curses.COLOR_BLUE, curses.COLOR_WHITE) curses.init_pair(12, 23, curses.COLOR_WHITE) curses.noecho() curses.cbreak() # Listing for 1/10th of second at a time curses.halfdelay(1) stdscr.keypad(True) stdscr.clear() session.set_current_schema('sys') query = session.sql("select @@version, @@version_comment, @@hostname, @@port") result = query.execute() info = {} for row in result.fetch_all(): info['version'] = row[0] info['comment'] = row[1] info['hostname'] = row[2] info['port'] = row[3] return stdscr, info
def initialize(self): """initialize curses, then call setup (at the first time) and resize.""" self.win.leaveok(0) self.win.keypad(1) self.load_mode = False curses.cbreak() curses.noecho() curses.halfdelay(20) try: curses.curs_set(int(bool(self.settings.show_cursor))) except: pass curses.start_color() try: curses.use_default_colors() except: pass self.settings.signal_bind('setopt.mouse_enabled', _setup_mouse) _setup_mouse(dict(value=self.settings.mouse_enabled)) if not self.is_set_up: self.is_set_up = True self.setup() self.win.addstr("loading...") self.win.refresh() self._draw_title = curses.tigetflag('hs') # has_status_line self.update_size() self.is_on = True if self.settings.update_tmux_title: sys.stdout.write("\033kranger\033\\") sys.stdout.flush()
def main_cli(self, stdscr): # Block each getch() for 10 tenths of a second curses.halfdelay(10) # Visibility 0 is invisible curses.curs_set(0) try: while True: ps_str = self.get_ps_str() lines = ps_str.split('\n') max_y, max_x = stdscr.getmaxyx() stdscr.erase() for i, line in enumerate(lines): # We don't want to draw on the last line because the # Press q to exit message goes there if i >= max_y - 1: break stdscr.addstr(i, 0, line[:max_x]) # Assumes that terminal size is greater than 15 character # Will crash otherwise...but who uses terminals 15 characters wide? stdscr.addstr(max_y - 1, 0, 'Press q to exit', curses.A_REVERSE) stdscr.refresh() if stdscr.getch() == ord('q'): break except KeyboardInterrupt: pass
def main(stdscr): curses.use_default_colors() stdscr.clear() curses.curs_set(0) curses.cbreak() stdscr.nodelay(True) curses.halfdelay(5) curses.start_color() O = ((0,0), (0,1), (1,0), (1,1)) L = ((0,0), (1,0), (2,0), (2,1)) L1 = ((0,0), (1,0), (2,0), (2,-1)) I = ((0,0), (1,0), (2,0), (3,0)) T = ((0,0), (0,1), (0,2), (1,1)) Z = ((0,0), (0,1), (1,1), (1,2)) Z1 = ((0,0), (0,1), (1,0), (1,-1)) pieces = (O, L, L1, I, T, Z, Z1) game = Tetris(stdscr) #game.set(3, 4, 5, 3) prevcol = 1 random.seed() for id in range(1, 1000): color = random.choice(range(1, 7)) game.fall(id, random.choice(pieces), color) stdscr.refresh() while(game.getkey() != "q"): pass
async def motion(lwin: LevelWindow): just_grounded = True curses.halfdelay(int(TIMER_SEC * 10)) while True: async with level_locker: if just_grounded: lwin.float_new(any_block()) undo_move = lwin.float_move('down') try: lwin.draw() except NotDrawable: undo_move() lwin.make_grounded() lwin.draw() just_grounded = True continue just_grounded = False try: await asyncio.wait_for(interact(lwin), timeout=TIMER_SEC) except asyncio.TimeoutError: continue
def setScreen(self, scr): """ Set the screen and create the different windows """ log(self.__class__.__name__, sys._getframe().f_code.co_name) self.stdscr = scr if self.stdscr != None: curses.curs_set(0) curses.start_color() curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE) curses.halfdelay(2 * 10) # setup all windows self.mainWindow = MainDisplay(0, self.stdscr) # self.stdscr.hline(self.WinPositions.headerBlock+self.headerWindow.getmaxyx()[0], 0, '-', 130) self.jobWindow = JobDisplay(0, self.stdscr) # self.stdscr.hline(self.WinPositions.summaryBlock+self.jobsWindow.getmaxyx()[0], 0, '-', 130) ##self.stdscr.hline(self.WinPositions.submitBlock+self.submitWindow.getmaxyx()[0], 0, '-', 130) ##self.erroWindow = curses.newwin(5, self.stdscr.getmaxyx()[1], self.WinPositions.debugBlock, 0) ##self.finalWindow = curses.newwin(3, self.stdscr.getmaxyx()[1], self.WinPositions.finalizeBlock, 0) ##self.finalWindow.addstr(0, 50, "Finalization job result") ##self.stdscr.hline(self.WinPositions.finalizeBlock+self.submitWindow.getmaxyx()[0], 0, '-', 130) ## ##self.stdscr.nooutrefresh() ##self.repaint() self.mainWindow.generate() self.jobWindow.generate() self.stdscr.refresh() self.activateMainWindow()
def _start_hearts(win, names): curses.use_default_colors() curses.init_pair(1, curses.COLOR_RED, -1) curses.init_pair(2, curses.COLOR_BLACK, -1) curses.nonl() curses.resetty() curses.curs_set(0) curses.halfdelay(1) game = HeartsGame(names) #game.force_first_card() game.render(win) curses.doupdate() while True: try: c = win.getch() if c == -1: idle(game, win) continue if c == ord('q'): break win.clear() if c in bindings: bindings[c](game) else: win.addstr(0, 0, "Unhandled input: %d" % c) game.render(win) curses.doupdate() except Exception: idle(game, win)
def _start(self): """ Initialize the screen and input mode. """ self.s = curses.initscr() self.has_color = curses.has_colors() if self.has_color: curses.start_color() if curses.COLORS < 8: # not colourful enough self.has_color = False if self.has_color: try: curses.use_default_colors() self.has_default_colors = True except _curses.error: self.has_default_colors = False self._setup_colour_pairs() curses.noecho() curses.meta(1) curses.halfdelay(10) # use set_input_timeouts to adjust self.s.keypad(0) if not self._signal_keys_set: self._old_signal_keys = self.tty_signal_keys() super(Screen, self)._start()
def main(window=curses.initscr()): curses.curs_set(0) curses.halfdelay(2) direction = { 'w': Direction.UP, 'a': Direction.LEFT, 's': Direction.DOWN, 'd': Direction.RIGHT } height = 10 width = 20 window.resize(height + 2, width + 2) game = Game(width=width, height=height, snake=Snake(cells=[Cell(3, 1), Cell(2, 1), Cell(1, 1)], direction=Direction.RIGHT), apples=Apples(width=width, height=height, cells=frozenset( [Cell.get_random(width - 1, height - 1)]))) input_ch = 0 pause = False while chr(input_ch) != 'q': draw(window, game) input_ch = max(window.getch(), 0) if chr(input_ch) == 'p': pause = not pause if not pause: game = game.update(direction.get(chr(input_ch)))
def run(stdscr): def paint(b): board = b.get_board() for i, r in enumerate(board.T): for j, c in enumerate(r): stdscr.addstr(j, i, c) k = 0 b = Board(20, 40) curses.start_color() stdscr = curses.initscr() stdscr.clear() curses.halfdelay(2) stdscr.keypad(True) MOVE_KEYS = { curses.KEY_LEFT: b.move_left, curses.KEY_RIGHT: b.move_right, curses.KEY_UP: b.move_up, curses.KEY_DOWN: b.move_down } while k != ord('q'): paint(b) k = stdscr.getch() if k in MOVE_KEYS: MOVE_KEYS.get(k)() b.play()
def _main(stdscr): curses.use_default_colors() curses.halfdelay(2) setup_colors() stdscr.clear() establish_base_size(stdscr) loop(stdscr)
def run(self, scr): """ Initialize and run the application """ m = AsciiMap() curses.halfdelay(self.sleep) while True: now = int(time.time()) refresh = self.fetch_data(now) m.set_data(self.data) try: m.draw(scr) except curses.error: raise Exception('Terminal window too small') scr.addstr(0, 1, 'Shodan Radar', curses.A_BOLD) scr.addstr(0, 40, time.strftime("%c UTC", time.gmtime(now)).rjust(37), curses.A_BOLD) # Key Input # q - Quit event = scr.getch() if event == ord('q'): break # redraw window (to fix encoding/rendering bugs and to hide other messages to same tty) # user pressed 'r' or new data was fetched if refresh: m.window.redrawwin()
def init(): # Don't display user input curses.noecho() # React to keys without pressing enter (700ms delay) curses.halfdelay(7) # Enumerate keys stdscr.keypad(True)
def MainLoop(args): global errorCount, respawn curses.halfdelay(20) while 1: PollSystem() try: Display() except curses.error: 0 # destroy the exception. we're not interested in display errors c = stdscr.getch() try: if c == ord('0'): StartStopAll() elif c == ord('q'): break elif c == ord('r'): respawn = not respawn elif c >= ord('1') and c <= ord('9'): StartStop(c - ord('0')) elif c >= ord('a') and c <= ord('m'): StartStop(c - ord('a')+10) except: errorCount = errorCount + 1
def __init__(self, stdscr, state): self.state = state self.scr = stdscr curses.mousemask(curses.BUTTON1_CLICKED) curses.init_pair(1, WHITE_PIECES, DARK_SQUARES) # White piece on dark square curses.init_pair(2, WHITE_PIECES, LIGHT_SQUARES) # White on bright curses.init_pair(3, BLACK_PIECES, DARK_SQUARES) # Black on dark curses.init_pair(4, BLACK_PIECES, LIGHT_SQUARES) # Black on bright curses.init_pair(5, 0, 12) # Status bar curses.init_pair(6, 15, 9) # [FAIL] curses.init_pair(7, 15, 2) # [OK] curses.init_pair(8, 9, 0) # Logo curses.init_pair(9, 14, 0) # Bright white on black curses.init_pair(10, 10, 0) # Past move from/to marker, move text curses.init_pair(11, 9, 4) # Move selector from/to marker curses.halfdelay(1) self.scr.clear() self.widgets = [ MoveReady(stdscr, state), Logo(stdscr, state), HelpPane(stdscr, state), Status(stdscr, state), ChessBoard(stdscr, state), StatusBar(stdscr, state), Engine(stdscr, state), Timer(stdscr, state), Info(stdscr, state), MoveList(stdscr, state), Promotions(stdscr, state), MoveInput(stdscr, state), ]
def start(self): """ Initialize the screen and input mode. """ assert self._started == False self.s = curses.initscr() self._started = True self.has_color = curses.has_colors() if self.has_color: curses.start_color() if curses.COLORS < 8: # not colourful enough self.has_color = False if self.has_color: try: curses.use_default_colors() self.has_default_colors = True except _curses.error: self.has_default_colors = False self._setup_colour_pairs() curses.noecho() curses.meta(1) curses.halfdelay(10) # use set_input_timeouts to adjust self.s.keypad(0)
def appInit(self): # Init curses mode self._mainWin = curses.initscr() curses.noecho() # turn off key echo curses.cbreak() # turn of input buffering self._mainWin.keypad( 1) # Process function key escape sequences as single key events curses.curs_set(0) if curses.has_colors(): curses.start_color() curses.init_pair(1, curses.COLOR_BLUE, curses.COLOR_BLACK) curses.init_pair(2, curses.COLOR_CYAN, curses.COLOR_BLACK) curses.init_pair(3, curses.COLOR_GREEN, curses.COLOR_BLACK) curses.init_pair(4, curses.COLOR_MAGENTA, curses.COLOR_BLACK) curses.init_pair(5, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(6, curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair(7, curses.COLOR_YELLOW, curses.COLOR_BLACK) curses.init_pair(8, curses.COLOR_WHITE, curses.COLOR_BLUE) self._ttyCols = curses.COLS self._ttyRows = curses.LINES curses.halfdelay(30) self._mainWin.clear() self._mainWin.refresh()
def main(): a = CarControl() screen = curses.initscr() screen.keypad(True) curses.noecho() curses.cbreak() curses.halfdelay(5) try: while True: char = screen.getch() screen.clear() if char == curses.KEY_RIGHT: a.turn_right() elif char == curses.KEY_LEFT: a.turn_left() elif char == curses.KEY_UP: a.forward() elif char == curses.KEY_DOWN: a.backward() elif char == ord(' '): a.stop() elif char == ord('w'): a.speed_up(30) elif char == ord('s'): a.speed_down(30) elif char == -1: a.straight() a.stop() except KeyboardInterrupt: a.exit()
def main(window): next_key = None while True: curses.halfdelay(1) if next_key is None: key = window.getch() else: key = next_key next_key = None sleep(0.2) if key != -1: # KEY DOWN curses.halfdelay(3) action = actions.get(key) if action is not None: # action() pos = mc.player.getPos() x = pos.x y = pos.y z = pos.z mc.setBlock(x,y,z block,1) next_key = key while next_key == key: next_key = window.getch() # KEY UP robot.stop()
def initialize(self): """initialize curses, then call setup (at the first time) and resize.""" self.win.leaveok(0) self.win.keypad(1) self.load_mode = False curses.cbreak() curses.noecho() curses.halfdelay(20) try: curses.curs_set(int(bool(self.settings.show_cursor))) except: pass curses.start_color() curses.use_default_colors() self.settings.signal_bind("setopt.mouse_enabled", _setup_mouse) _setup_mouse(dict(value=self.settings.mouse_enabled)) if not self.is_set_up: self.is_set_up = True self.setup() self.win.addstr("loading...") self.win.refresh() self.update_size() self.is_on = True
def get_input(self, word: str, timeout: float, stdscr: Window) -> str: stdscr.addstr(INPUT_ROW, 0, f"{word} > ") stdscr.refresh() result = "" ch = 0 while True: start = time.time() curses.halfdelay(int(timeout * 10)) ch = stdscr.getch() if ch in (curses.KEY_BACKSPACE, 8, 127): result = result[:-1] stdscr.delch(INPUT_ROW, len(f"{word} > ") + len(result)) else: result += chr(ch) if not word.startswith(result): curses.beep() stdscr.attron(curses.color_pair(1)) stdscr.addch(INPUT_ROW, len(f"{word} > ") + len(result) - 1, ch) if not word.startswith(result): stdscr.attroff(curses.color_pair(1)) stdscr.refresh() elapsed = time.time() - start timeout -= elapsed if result == word: return
def __init__(self, stdscr, args): self.stdscr = stdscr self.num_leds = args.number_leds self.server = args.SERVER self.ddp = DDP(args.SERVER, self.num_leds, args.lpc) self.assign_color_index = 0 self.red = self.assign_color(curses.COLOR_BLACK, curses.COLOR_RED) self.green = self.assign_color(curses.COLOR_BLACK, curses.COLOR_GREEN) self.blue = self.assign_color(curses.COLOR_BLACK, curses.COLOR_BLUE) self.white = self.assign_color(curses.COLOR_BLACK, curses.COLOR_WHITE) self.off = self.assign_color(curses.COLOR_WHITE, curses.COLOR_BLACK) self.status_text = self.assign_color(curses.COLOR_WHITE, curses.COLOR_BLUE, curses.A_BOLD) self.error_text = self.assign_color(curses.COLOR_WHITE, curses.COLOR_RED, curses.A_BOLD) self.box = Box self.box_color = self.off self.box_index = 0 curses.curs_set(False) curses.halfdelay(10) self.set_all_leds(self.off) self.resize() while True: self.send() self.draw() self.handle_input()
def setup_curses(self): self.stdscr = curses.initscr() self.maxy, self.maxx = self.stdscr.getmaxyx() if (self.maxy < 6) or (self.maxx < 60): sys.stderr.write("Terminal window too small! Minimum size [70 x 6], actual [%d x %d]\n" % (self.maxx, self.maxy)) print ("Terminal window too small! Minimum size [70 x 6], actual [%d x %d]\n" % (self.maxx, self.maxy)) self.keep_running = False return curses.noecho() curses.halfdelay(1) self.title_bar = curses.newwin(1, self.maxx, 0, 0) self.help_bar = curses.newwin(1, self.maxx, self.maxy-1, 0) self.top_bar = curses.newwin(1, self.maxx, 1, 0) self.freq_list = curses.newwin(self.maxy-5, self.maxx, 2, 0) self.active1 = curses.newwin(1, self.maxx-15, self.maxy-3, 0) self.active2 = curses.newwin(1, self.maxx-15, self.maxy-2, 0) self.status1 = curses.newwin(1, 15, self.maxy-3, self.maxx-15) self.status2 = curses.newwin(1, 15, self.maxy-2, self.maxx-15) self.prompt = curses.newwin(1, 10, self.maxy-1, 0) self.text_win = curses.newwin(1, 11, self.maxy-1, 10) self.textpad = curses.textpad.Textbox(self.text_win) self.stdscr.refresh() self.title_help()
def mifunc(stdscr): curses.halfdelay(1) w = curses.newwin(3, 20, 10, 1) ac = open("/dev/actuator", "rw") while 1: c = stdscr.getch() if c == ord('q'): break elif c == ord(' '): # stop ioctl(ac, AC_MSTOP) elif c == curses.KEY_RIGHT: ioctl(ac, AC_MWEST) elif c == curses.KEY_LEFT: ioctl(ac, AC_MEAST) elif c == ord('g'): newpos = int(curses.textpad.Textbox(w).edit()) ioctl(ac, AC_WTARGET, struct.pack("i", newpos)) elif c == ord('p'): newpos = int(curses.textpad.Textbox(w).edit()) ioctl(ac, AC_WPOS, struct.pack("i", newpos)) stat = ioctl(ac, AC_RSTATUS, " ") mode = struct.unpack("I", stat[0:4])[0] state = struct.unpack("I", stat[4:8])[0] target = struct.unpack("i", stat[8:12])[0] position = struct.unpack("i", stat[12:16])[0] stdscr.addstr(2, 1, str(position)) stdscr.clrtoeol() stdscr.addstr(3, 1, str(target)) stdscr.clrtoeol() stdscr.addstr(4, 1, modes[mode]) stdscr.clrtoeol() stdscr.addstr(5, 1, states[state]) stdscr.clrtoeol()
def init(self): self.screen = curses.initscr() curses.noecho() curses.cbreak() self.screen.keypad(1) try: curses.curs_set(0) except: logging.warning("Cursor hiding is not supported") curses.halfdelay(1) # block for 0.1s if curses.has_colors(): self.colors = True curses.start_color() curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK) curses.init_pair(2, curses.COLOR_CYAN, curses.COLOR_BLACK) curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK) curses.init_pair(5, curses.COLOR_BLUE, curses.COLOR_BLACK) else: self.colors = False logging.warning("Colors are not supported") logging.info("Console I/O initialized")
def __init__(self, stdscr, clock_args=None): self.stdscr = stdscr curses.halfdelay(10) curses.curs_set(0) curses.use_default_colors() self.clock = PyClock(self.stdscr, clock_args) self.running = False
def restore_state(): global play_process if play_process != None: return draw_help() draw_results() curses.halfdelay(10)
def setup_screen(self): self.screen = curses.initscr() curses.noecho() # no echo, we will render it curses.cbreak() # curses.curs_set(0) # hide cursor, we will fake it with inverted space curses.halfdelay(1) # wait for 1/10 second when waiting for input self.screen.keypad(1) self.setup()
def __init__(self,screen,options): self.screen = screen curses.halfdelay(1) self.infolines=['no port open'] self.mode='main' self.options=options self.currcur=-1 self.dlog=open('gui.log','w')
def main(): global stdscr global pause global toggle_digital global window_is_too_small stdscr = curses.initscr() curses.start_color() curses.noecho() curses.cbreak() stdscr.keypad(1) stdscr.nodelay(1) curses.halfdelay(1) curses.init_pair(10, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(11, curses.COLOR_BLACK, curses.COLOR_BLACK) curses.init_pair(12, curses.COLOR_GREEN, curses.COLOR_BLACK) curses.init_pair(13, curses.COLOR_BLUE, curses.COLOR_BLACK) fetch_screensize() recalc_coords(my_width, my_height) if window_is_too_small: curses.echo() curses.endwin() print "Screen too small." sys.exit(1) cas = time.time() while 1: try: c = stdscr.getch() except KeyboardInterrupt: break if c in [-1, curses.KEY_RESIZE]: if c == -1: pass elif c == curses.KEY_RESIZE: resize_handler() else: if c == ord('d'): toggle_digital = not toggle_digital recalc_coords(my_width, my_height) elif c == ord('q'): break elif c == ord('p'): pause = not pause else: pass if not pause: cas = time.time() cas2 = time.localtime(cas) year, month, day, hour, minute, second, weekday = cas2[:7] hds = int(math.fmod(math.floor(cas * 100), 100)) draw_watch(year, month, day, hour, minute, second, weekday, hds) curses.echo() curses.endwin()
def _getch(self, wait_tenths): if wait_tenths==0: return self._getch_nodelay() if wait_tenths is None: curses.cbreak() else: curses.halfdelay(wait_tenths) self.s.nodelay(0) return self.s.getch()
def Welcome(self,stdscr): bootstrap.CursesInstall.CenterAddStr(stdscr,1,'Welcome to the ASE Project Installer') bootstrap.CursesInstall.CenterAddStr(stdscr,3,'The SIDL Language and compiler included were developed') bootstrap.CursesInstall.CenterAddStr(stdscr,4,'by the LLNL Babel Team (http://www.llnl.gov/CASC/components)') bootstrap.CursesInstall.CenterAddStr(stdscr,5,'(hit any key to continue)') stdscr.refresh() curses.halfdelay(50) c = stdscr.getch() curses.nocbreak()
def notWrapperInit(): screen = curses.initscr() curses.noecho() curses.cbreak() screen.keypad(1) # set custom tenths of a second to wait before giving up on waiting for input curses.start_color() curses.halfdelay(5) return screen
def init_window(): "initialize the curses window" stdscr = curses.initscr() curses.noecho() curses.cbreak() stdscr.keypad(True) curses.halfdelay(delay) return stdscr
def main(scr): #scr.nodelay(1) scr.keypad(1) try: width = 90 data = sp.check_output(['nvidia-smi', '-q', '-x']) root = ET.fromstring(data) timestamp = root.find('timestamp').text driver = root.find('driver_version').text n = int(root.find('attached_gpus').text) scr.addstr(0, 0, 'nvidia-top' + '%*s' % (width-10, 'ESC to quit')) scr.addstr(1, 0, 'Timestamp:\t' + timestamp) scr.addstr(2, 0, 'Driver Version:\t' + driver) scr.addstr(3, 0, 'Number of GPUs:\t' + repr(n)) gpus = root.findall('gpu') for ind in range(len(gpus)): memt = gpus[ind].find('fb_memory_usage').find('total').text scr.addstr(3+ind*2, 0, 'GPU %d Memory: ' % ind + memt) powt = gpus[ind].find('power_readings').find('power_limit').text scr.addstr(4+ind*2, 0, 'GPU %d Power Limit: ' % ind + powt) n*=2 # Drawing header scr.addstr(5+n, 0, '-' * width) scr.addstr(6+n, 0, '%3s' % '#' + '%23s' % 'Name' + '%13s' % 'Mem. Use' + '%10s' % '% Mem.' + '%13s' % 'GPU Util.' +'%12s' % 'Power Use' + '%9s' % 'Temp.') scr.addstr(7+n, 0, '-' * width) # 10 tenths = 1 sec <- this is the polling frequency crs.halfdelay(8) #t0 = 0 while (1): #if (time.clock() - t0) > 1.0: data = sp.check_output(['nvidia-smi', '-q', '-x']) root = ET.fromstring(data) timestamp = root.find('timestamp').text scr.addstr(1, 0, 'Timestamp:\t' + timestamp) display_info(root, scr) #t0 = time.clock() scr.refresh() if scr.getch() == 27: break except: print 'Something went wrong! Exception handling is pretty basic right now.'
def main(): arg_parser = argparse.ArgumentParser(description="ifstat - network interface statistics utility") arg_parser.add_argument(dest='device', help='The device name to get stats for') arg_parser.add_argument('--interval', '-i', dest='interval', default=1.0, type=float, help='Interval to gather and display stats') args = arg_parser.parse_args() if args.device not in pcap.findalldevs(): sys.stderr.write('Error: No such device %s \n' % (args.device, )) return collector = getstats.StatCollector(args.device) collector.start() raw_stats = collector.get_stats() stat_processor = StatProcessor(raw_stats) locale.setlocale(locale.LC_ALL, '') window = curses.initscr() curses.noecho() curses.cbreak() curses.curs_set(0) window.keypad(1) # XXX: halfdelay is in tenths of seconds curses.halfdelay(int(args.interval * 10)) colors = _init_colors() last_time = time.time() sessions_pad = SessionsPad(colors=colors) device_pad = DevicePad(args.device, args.interval, colors=colors, ylocation=sessions_pad.get_y_size()) current_stats = {"device": {}, "sessions": []} try: running = True while running: # XXX: Get & process new stats only when the intervals have passed current_time = time.time() if current_time - last_time >= args.interval: raw_stats = collector.get_stats() current_stats = stat_processor.process_new_stats(raw_stats, args.interval) last_time = current_time maxy, maxx = window.getmaxyx() sessions_pad.display(maxy, maxx, current_stats["sessions"]) device_pad.display(maxy, maxx, current_stats["device"]) key = window.getch() if key != -1: sessions_pad.key(key) device_pad.key(key) if key == ord('q'): collector.stop() running = False finally: curses.nocbreak() curses.echo() curses.endwin()
def get_and_use_key_press(self): global TEST_SETTINGS trace = False if (TEST_SETTINGS['TEST_INPUT'] is None) and (TEST_SETTINGS['INPUT_GENERATOR'] is None): curses.raw() curses.cbreak() curses.meta(1) self.parent.curses_pad.keypad(1) if self.parent.keypress_timeout: curses.halfdelay(self.parent.keypress_timeout) ch = self._get_ch() if ch == -1: return self.try_while_waiting() else: self.parent.curses_pad.timeout(-1) ch = self._get_ch() # handle escape-prefixed rubbish. if ch == curses.ascii.ESC: #self.parent.curses_pad.timeout(1) self.parent.curses_pad.nodelay(1) ch2 = self.parent.curses_pad.getch() if ch2 != -1: ch = curses.ascii.alt(ch2) self.parent.curses_pad.timeout(-1) # back to blocking mode #curses.flushinp() elif (TEST_SETTINGS['INPUT_GENERATOR']): self._last_get_ch_was_unicode = True try: ch = next(TEST_SETTINGS['INPUT_GENERATOR']) except StopIteration: if TEST_SETTINGS['CONTINUE_AFTER_TEST_INPUT']: TEST_SETTINGS['INPUT_GENERATOR'] = None return else: raise ExhaustedTestInput else: self._last_get_ch_was_unicode = True try: ch = TEST_SETTINGS['TEST_INPUT'].pop(0) TEST_SETTINGS['TEST_INPUT_LOG'].append(ch) except IndexError: if TEST_SETTINGS['CONTINUE_AFTER_TEST_INPUT']: TEST_SETTINGS['TEST_INPUT'] = None return else: raise ExhaustedTestInput # if trace: g.trace('Widget', self.__class__.__name__, ch, chr(ch)) if trace: g.pr('Widget', self.__class__.__name__, 'get_and_use_key_press', ch, chr(ch)) self.handle_input(ch) if self.check_value_change: self.when_check_value_changed() if self.check_cursor_move: self.when_check_cursor_moved() self.try_adjust_widgets()