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 __init__ (self): self.board = puzzle_2048() self.screen = curses.initscr() self.screen.keypad(1) self.screen.leaveok(0) curses.start_color() curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK) curses.noecho() curses.curs_set(0) self.screen.addstr(0,0,"To play: combine the tiles that match using the arrow keys, and press esc to exit") #Drawing the lines for the board self.screen.hline(5,10,"-", 29, curses.color_pair(1)) self.screen.hline(9,10,"-", 29, curses.color_pair(1)) self.screen.hline(13,10,"-", 29, curses.color_pair(1)) self.screen.hline(17,10,"-", 29, curses.color_pair(1)) self.screen.hline(21,10,"-", 29, curses.color_pair(1)) self.screen.vline(5,10,"|", 17, curses.color_pair(1)) self.screen.vline(5,17,"|", 17, curses.color_pair(1)) self.screen.vline(5,24,"|", 17, curses.color_pair(1)) self.screen.vline(5,31,"|", 17, curses.color_pair(1)) self.screen.vline(5,38,"|", 17, curses.color_pair(1)) self.Update_screen() self.run()
def init(self): self.window = curses.initscr() self.initted = True self.ymax, self.xmax = self.window.getmaxyx() terminfo = curses.longname() assert '256' in terminfo # your env TERM must be xterm-256color! assert curses.has_colors() curses.start_color() curses.use_default_colors() ctr = 1 for fg in CLRS: for bg in CLRS: if ctr <= curses.COLORS-1 and fg != bg: curses.init_pair(ctr, CLRS[fg], CLRS[bg]) pairs[(fg,bg)] = curses.color_pair(ctr) ctr += 1 curses.meta(1) curses.noecho() curses.cbreak() curses.curs_set(0) curses.delay_output(0) curses.mouseinterval(150) availmask,_ = curses.mousemask(curses.ALL_MOUSE_EVENTS) assert availmask != 0 # mouse must be available! self.window.leaveok(1) self.window.scrollok(0) self.window.keypad(1) if NONBLOCKING: self.window.nodelay(1) self.window.timeout(NONBLOCKING_TIMEOUT) else: self.window.nodelay(0) self.window.timeout(-1) self.window.refresh()
def setup_colors(self): curses.start_color() #0:black, 1:red, 2:green, 3:yellow, 4:blue, 5:magenta, 6:cyan, and 7:white #curses.init_pair(0, curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair( 1, curses.COLOR_WHITE, curses.COLOR_RED) curses.init_pair( 2, curses.COLOR_WHITE, curses.COLOR_GREEN) curses.init_pair( 3, curses.COLOR_WHITE, curses.COLOR_YELLOW) curses.init_pair( 4, curses.COLOR_WHITE, curses.COLOR_BLUE) curses.init_pair( 5, curses.COLOR_WHITE, curses.COLOR_MAGENTA) curses.init_pair( 6, curses.COLOR_WHITE, curses.COLOR_CYAN) ## Black Text on Colored Background curses.init_pair(10, curses.COLOR_BLACK, curses.COLOR_WHITE) curses.init_pair(11, curses.COLOR_BLACK, curses.COLOR_RED) curses.init_pair(12, curses.COLOR_BLACK, curses.COLOR_GREEN) curses.init_pair(13, curses.COLOR_BLACK, curses.COLOR_YELLOW) curses.init_pair(14, curses.COLOR_BLACK, curses.COLOR_BLUE) curses.init_pair(15, curses.COLOR_BLACK, curses.COLOR_MAGENTA) curses.init_pair(16, curses.COLOR_BLACK, curses.COLOR_CYAN) ## Red Text on Colored Background curses.init_pair(20, curses.COLOR_RED, curses.COLOR_WHITE) curses.init_pair(21, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(22, curses.COLOR_RED, curses.COLOR_GREEN) curses.init_pair(23, curses.COLOR_RED, curses.COLOR_YELLOW) curses.init_pair(24, curses.COLOR_RED, curses.COLOR_BLUE) curses.init_pair(25, curses.COLOR_RED, curses.COLOR_MAGENTA) curses.init_pair(26, curses.COLOR_RED, curses.COLOR_CYAN)
def init_curses(self): self.screen = curses.initscr() curses.noecho() curses.start_color() curses.cbreak() self.screen.keypad(0) curses.curs_set(0)
def __init__(self, screen, encoding): self.screen = screen self.encoding = encoding self.parser = markup.MarkupParser() curses.start_color() self.has_default_colors = curses.COLORS > COLOR_COUNT if self.has_default_colors: # xterm-256color curses.use_default_colors() FG_COLORS["default"] = -1 BG_COLORS["on_default"] = -1 self.init_color_pairs() elif curses.COLORS != 0: # ansi linux rxvt ...etc. curses.use_default_colors() self.init_color_pairs() FG_COLORS["default"] = curses.COLOR_WHITE BG_COLORS["on_default"] = curses.COLOR_BLACK else: # monochrome, curses.COLORS == 0 # vt100 x10term wy520 ...etc. FG_COLORS["default"] = curses.COLOR_WHITE BG_COLORS["on_default"] = curses.COLOR_BLACK self.update_screen_size()
def nstart(stdscr): global logw global cw global netstatw global trash global player global kingdom global opponent curses.start_color() maxY, maxX = stdscr.getmaxyx() logw = GameInput(windowX=math.floor(maxX/2), windowY=math.floor(maxY/3), height=math.floor(maxY*2/3)-2, width=maxX-math.floor(maxX/2)-1, scrollDepth=1000) cw = NetInput(windowX=math.floor(maxX/4), windowY=math.floor(maxY/8*7), height=maxY-math.floor(maxY/8*7)-2, width=math.floor(maxX/4)-1) netstatw = curses.newwin(maxY-math.floor(maxY/8*7), math.floor(maxX/4)-1, math.floor(maxY/8*7), 0) trash = curses.newwin(math.floor(maxY/8), math.floor(maxX/2), math.floor(maxY*7/16), 0) player = Player(math.floor(maxY*7/16), math.floor(maxX/2), 0, 0) kingdom = Kingdom(math.floor(maxY/3), math.floor(maxX/2), 0, math.floor(maxX/2)) opponent = Opponent(math.floor(maxY*5/16), math.floor(maxX/2), math.floor(maxY*9/16), 0) trash.addstr('trash') trash.refresh() if os.path.exists('cccnfg.cfg'): with open('cccnfg.cfg', 'r') as f: for ln in f.read().splitlines(): cw.command(ln) while True: cw.run() logw.run()
def __init__(self, evm): self.evm = evm evm.RegisterListener(self) # first we must create a window object; it will fill the whole screen self.scrn = curses.initscr() # turn off keystroke echo curses.noecho() # keystrokes are honored immediately, rather than waiting for the # user to hit Enter curses.cbreak() self.scrn.keypad(1) self.scrn.nodelay(1) # start color display (if it exists; could check with has_colors()) curses.start_color() curses.mousemask(curses.BUTTON1_PRESSED) curses.curs_set(0) # clear screen self.scrn.clear() i = 1 for color_background in self.list_of_colors: for color_foreground in self.list_of_colors: curses.init_pair(i, color_foreground, color_background) self.mapping[color_foreground, color_background] = i i += 1 # implement the actions done so far (just the clear()) self.scrn.refresh()
def initColors (self): curses.start_color() if self.conf.params_transparency: curses.use_default_colors() bgcolor = -1 else: bgcolor = 0 # Setup colors # TODO, check the term capability before if curses.can_change_color(): for i in range(len(self.conf.color_set)): if not self.conf.color_set[i]: continue else: rgb = self.conf.color_set[i] curses.init_color(i, rgb[0], rgb[1], rgb[2]) curses.init_pair(0, curses.COLOR_BLACK, bgcolor) # 1 black curses.init_pair(1, curses.COLOR_RED, bgcolor) # 2 red curses.init_pair(2, curses.COLOR_GREEN, bgcolor) # 3 green curses.init_pair(3, curses.COLOR_YELLOW, bgcolor) # 4 yellow curses.init_pair(4, curses.COLOR_BLUE, bgcolor) # 5 blue curses.init_pair(5, curses.COLOR_MAGENTA, bgcolor) # 6 magenta curses.init_pair(6, curses.COLOR_CYAN, bgcolor) # 7 cyan curses.init_pair(7, curses.COLOR_WHITE, bgcolor) # 8 white
def initializeScreen (self): self.screen = curses.initscr () curses.start_color () curses.noecho () curses.cbreak () (self.screenHeight, self.screenWidth) = self.screen.getmaxyx () pass
def init(self): """init(self) -> None Colour initialization. """ curses.start_color() for key, color in self._ColorSets.items(): curses.init_pair( color['id'], color['pair'][0], color['pair'][1] )
def main(): """ Main entry point for gunicorn_console. """ # Set up curses. stdscr = curses.initscr() curses.start_color() curses.init_pair(1, foreground_colour, background_colour) curses.noecho() stdscr.keypad(True) stdscr.nodelay(True) try: curses.curs_set(False) except: pass try: # Run main event loop until quit. while True: try: update_gunicorns() handle_keypress(stdscr) display_output(stdscr) curses.napms(int(screen_delay * 1000)) except KeyboardInterrupt: break finally: # Tear down curses. curses.nocbreak() stdscr.keypad(False) curses.echo() curses.endwin()
def __init__(self, player_sub): self.player_sub = player_sub # self.sea = sea self.display_screen = '' # setlocale enables UTF chars # see: https://docs.python.org/2/library/curses.html locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') self.strcode = locale.getpreferredencoding() # print(self.strcode) screen = curses.initscr() self.screen = screen # Applications will also commonly need to react to keys instantly, without requiring the Enter key # to be pressed; this is called cbreak mode, as opposed to the usual buffered input mode. curses.cbreak() # Usually curses applications turn off automatic echoing of keys to the screen, in order to be able to read # keys and only display them under certain circumstances. This requires calling the noecho() function. curses.noecho() screen.nodelay(1) curses.curs_set(0) screen.keypad(True) curses.start_color() curses.use_default_colors()
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 main(argv): def __call__(self): pass dlog = DebugLog("debug.log") dlog.msg("Logging started\n") stdscr = curses.initscr() curses.noecho() curses.cbreak() stdscr.keypad(1) curses.start_color() try: wl = WindowLogic(stdscr) wl.start() ci = CommandInterpreter(stdscr, wl) ci.start() except Exception as e: dlog.excpt(e) raise ci.join() dlog.msg("Command Interpreter joined.\n") wl.stop() wl.join() dlog.msg("Thread Fetcher joined.\n") curses.nocbreak() stdscr.keypad(0) curses.echo() curses.endwin() curses.resetty() dlog.msg("Terminal restored.\n")
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 __init__(self, irc, server, room, screen, theme): self.theme = theme self.screen = screen self.irc = irc self.server = server self.room = room self.height, self.width = self._limits(); self.topic = Line('topic', '', False) self.status = Line('status', '', False) self.input_line = Line('input', '', False) self.lines = [] curses.echo() curses.start_color() self.screen.clear() self.screen.timeout(0) self.screen.scrollok(True) self.screen.setscrreg(1, self.height-3) self._draw_chat() self.irc.add_global_handler("welcome", self.on_connect) self.irc.add_global_handler("motd", self.on_motd) self.irc.add_global_handler("pubmsg", self.on_pubmsg) self.irc.add_global_handler("currenttopic", self.on_currenttopic)
def main(scr): curses.curs_set(False) curses.start_color() for i in range(1, 16): curses.init_pair(i, i, curses.COLOR_BLACK) scry, scrx = scr.getmaxyx() pady = scry * 2 padx = scrx * 2 pad = curses.newpad(pady, padx) pad.nodelay(True) mandel(pad) oy = 1 ox = 0 while True: pad.refresh(oy, ox, 0, 0, scry-1, scrx-1) key = pad.getch() if key in (ord('q'), ord('Q')): break elif key in (ord('w'), curses.KEY_UP): oy = max(oy - 1, 0) elif key in (ord('s'), curses.KEY_DOWN): oy = min(oy + 1, pady - scry - 1) elif key in (ord('a'), curses.KEY_LEFT): ox = max(ox - 2, 0) elif key in (ord('d'), curses.KEY_RIGHT): ox = min(ox + 2, padx - scrx) elif key == curses.KEY_RESIZE: scry, scrx = scr.getmaxyx()
def maze(): curses.start_color() curses.initscr() curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK) for i in range(8, 17): # penis screen.addstr(i, 22, "â–ˆ") for i in range(22, 27): screen.addstr(8, i, "â–ˆ") for i in range(29, 43): screen.addstr(8, i, "â–ˆ") for i in range(46, 68): screen.addstr(8, i, "â–ˆ") for i in range(22, 32): screen.addstr(17, i, "â–ˆ") for i in range(34, 50): screen.addstr(17, i, "â–ˆ") for i in range(52, 68): screen.addstr(17, i, "â–ˆ") for i in range(8, 12): screen.addstr(i, 68, "â–ˆ") for i in range(14, 18): screen.addstr(i, 68, "â–ˆ") for i in range(15, 18): screen.addstr(i, 26, "â–ˆ") for i in range(13, 18): screen.addstr(i, 36, "â–ˆ") for i in range(8, 12): screen.addstr(i, 48, "â–ˆ") for i in range(8, 12): screen.addstr(i, 61, "â–ˆ") for i in range(13, 18): screen.addstr(i, 57, "â–ˆ") for i in range(54, 58): screen.addstr(13, i, "â–ˆ")
def start(self): """Initialize curses. Mostly copied from curses/wrapper.py""" # This might do some good locale.setlocale(locale.LC_ALL, "") # Initialize curses stdscr = curses.initscr() # Turn off echoing of keys, and enter cbreak mode, # where no buffering is performed on keyboard input curses.noecho() curses.cbreak() # In keypad mode, escape sequences for special keys # (like the cursor keys) will be interpreted and # a special value like curses.KEY_LEFT will be returned stdscr.keypad(1) # Start color, too. Harmless if the terminal doesn't have # color; user can test with has_color() later on. The try/catch # works around a minor bit of over-conscientiousness in the curses # module -- the error return from C start_color() is ignorable. try: curses.start_color() curses.use_default_colors() for i in range(1, curses.COLORS): curses.init_pair(i, i, -1) except: LOG.exception("Exception in curses color init") self.stdscr = stdscr
def setup(cls): curses.start_color() curses.use_default_colors() # -1 = transparent curses.init_pair(cls.sand, curses.COLOR_YELLOW, curses.COLOR_YELLOW) curses.init_pair(cls.hero, curses.COLOR_GREEN, -1) curses.init_pair(cls.monster, curses.COLOR_RED, -1)
def main(stdscr): curses.start_color() curses.use_default_colors() for bg in range(256): for i in range(0, curses.COLORS): curses.init_pair(i + 1, i, bg) try: for i in range(256): # c = str(i) c = curses.ACS_ULCORNER c = ord('a') c = u'\u239e' c = u'\u2588' # c = 9608 # c = u'\u239e'.encode("utf-8") # c = u'\u0438'.encode('utf-8') stdscr.addstr(c, curses.color_pair(i)) # stdscr.addch(9118) # stdscr.addstr('\\u239e') # stdscr.addch(c) if i < 16: stdscr.addstr(' ', curses.color_pair(i)) if i in (16,52,88,124,160,196,232,): stdscr.addstr('\n', curses.color_pair(i)) stdscr.addstr('\n', curses.color_pair(i)) except curses.error: # End of screen reached pass if stdscr.getch() == ord('q'): break stdscr.clear()
def __init__(self, wallet, config, app=None): self.stdscr = curses.initscr() curses.noecho() curses.cbreak() curses.start_color() curses.use_default_colors() curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE) curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_CYAN) self.stdscr.keypad(1) self.stdscr.border(0) self.maxy, self.maxx = self.stdscr.getmaxyx() curses.curs_set(0) self.w = curses.newwin(10, 50, 5, 5) self.wallet = wallet self.config = config set_verbosity(False) self.tab = 0 self.pos = 0 self.popup_pos = 0 self.str_recipient = "" self.str_description = "" self.str_amount = "" self.str_fee = "" self.wallet.interface.register_callback('updated', self.refresh) self.wallet.interface.register_callback('connected', self.refresh) self.wallet.interface.register_callback('disconnected', self.refresh) self.wallet.interface.register_callback('disconnecting', self.refresh) self.tab_names = [_("History"), _("Send"), _("Receive"), _("Contacts"), _("Wall")] self.num_tabs = len(self.tab_names)
def __init__(self): self.screen = curses.initscr() self.screen.timeout(100) # the screen refresh every 100ms # charactor break buffer curses.cbreak() self.screen.keypad(1) self.netease = NetEase() 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) # term resize handling size = terminalsize.get_terminal_size() self.x = max(size[0], 10) self.y = max(size[1], 25) self.startcol = int(float(self.x) / 5) self.indented_startcol = max(self.startcol - 3, 0) self.update_space() self.lyric = '' self.now_lyric = '' self.tlyric = '' self.storage = Storage() self.config = Config() self.newversion = False
def __init__(self): self.myscreen = curses.initscr() self.thread = None self.threadName = 'CLI' curses.noecho() curses.cbreak() curses.start_color() self.myscreen.keypad(1) curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE) self.myscreen_highlighted = curses.color_pair(1) self.myscreen_normal = curses.A_NORMAL self.menus = { 'title': "Main Menu", 'type': MENU_TYPES.MENU, 'subtitle': "Select an option...", 'options': [ { 'title': "Status", 'type': MENU_TYPES.MENU, 'subtitle': "Select an option..", 'options': [ { 'title': "Media Information", 'type': MENU_TYPES.COMMAND, 'command': 'printMediaInfo' }, { 'title': "Thread Information", 'type': MENU_TYPES.COMMAND, 'command': 'printThreadInfo' } ] } ] } self.commands = { 'printMediaInfo': _printMediaInfo(), 'printThreadInfo': _printThreadInfo() } self.initThread()
def main_loop(stdscr): stdscr.clear() userInput = 'g' evoRate = .5 gameboard = world(stdscr, ord('X')) gameboard.randSeed() stdscr.nodelay(1) #set colors curses.start_color() curses.init_pair(1,curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(2,curses.COLOR_GREEN, curses.COLOR_BLACK) curses.init_pair(3,curses.COLOR_BLUE, curses.COLOR_BLACK) while userInput != ord('q'): userInput = stdscr.getch() gameboard.displayWorld() gameboard.evolveWorld() time.sleep(evoRate) if userInput == curses.KEY_RIGHT: if evoRate > .1: evoRate = evoRate - .02 elif userInput == curses.KEY_LEFT: evoRate = evoRate + .02
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_curses(self): """ This initializes the screen for curses useage. It must be called before Curses can be used. """ self.user_marker_pos = 1 # Used with curses self.curses_row_offset = 0 # Used for marking the visible rows on the screen to allow scrolling self.curses_row_offset_store = 0 # Used for storing the row offset when switching from detailed to non-detailed view modes self.curses_detailed = None # Used with curses self.screen = curses.initscr() curses.start_color() curses.init_pair(1, curses.COLOR_BLUE, curses.COLOR_WHITE) size = self.screen.getmaxyx() if size[0] < CURSES_MIN_Y or size[1] < CURSES_MIN_X: curses.endwin() return 1 self.curses_max_rows = size[0] - 2 # Minus 2 for the border on the top and bottom self.curses_max_columns = size[1] - 2 self.screen.border(0) self.screen.addstr(2, TAB_LENGTH, 'EAPeak Capturing Live') self.screen.addstr(3, TAB_LENGTH, 'Found 0 Networks') self.screen.addstr(4, TAB_LENGTH, 'Processed 0 Packets') self.screen.addstr(self.user_marker_pos + USER_MARKER_OFFSET, TAB_LENGTH, USER_MARKER) self.screen.refresh() try: curses.curs_set(1) curses.curs_set(0) except curses.error: # Ignore exceptions from terminals that don't support setting the cursor's visibility pass curses.noecho() curses.cbreak() self.curses_enabled = True self.curses_lower_refresh_counter = 1 return 0
def GUI_modify_user(env, screen): makechanges = "" s = curses.newwin(20, 78, 3, 1) s.erase() s.keypad(1) curses.start_color() curses.init_pair(1,curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(2,curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair(3,curses.COLOR_BLACK, curses.COLOR_WHITE) s.box() s.addstr(2, 2, "Modify user attributes", curses.color_pair(3)) s.addstr(19, 2, "[Use [ESC] to abort!]", curses.color_pair(1)) s.addstr(4, 2, "Enter username: "******"": s.erase() return error, result = helper_get_userattr(UID, env) if error != "OK": s.addstr(4, 2, error, curses.color_pair(2)) s.getch() return error, result1 = get_Autofs(UID, env) if error != "OK": s.addstr(4, 2, error, curses.color_pair(2)) s.getch() return result['automountInformation'] = result1[0][1]['automountInformation'] modified = deepcopy(result) s.erase() s.box() s.addstr(2, 2, "Modify user attributes", curses.color_pair(3)) if error != "OK": s.addstr(4, 2, error, curses.color_pair(2)) s.getch() return result, modified = helper_modify_userattr(s, env, result, modified) if result != modified: # Modifications have taken place: dofile, undofile, error = helper_modified_user_to_ldif(env, result, modified) # TO LDAPSERVER AND LOG s.addstr(16, 2, "Do you wish to commit the changes? [y|n]", curses.color_pair(1)) makechanges = getInput(s, 15, 40, 1, 0, False) if makechanges == "y" or makechanges == "Y": s.addstr(16, 2, "%s"%env.LOGS, curses.color_pair(1)) content,error=apply_ldif.ldif2dict(dofile) if error != "OK":return error error=apply_ldif.apply_ldif(content,env) WriteLog(dofile, "modify_user.done.%s"%(UID), env) WriteLog(undofile, "modify_user.undo.%s"%(UID), env) s.erase() s.box() s.addstr(2, 2, "Modify user attributes", curses.color_pair(3)) if error == "OK": s.addstr(4, 2, "User %s modified."%(UID), curses.color_pair(2)) else: s.addstr(6, 2, "%s"%(error), curses.color_pair(2)) s.getch() s.erase() return
def GUI_change_password(env,screen): s = curses.newwin(20, 78, 3, 1) s.erase() s.keypad(1) curses.start_color() curses.init_pair(1,curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(2,curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair(3,curses.COLOR_BLACK, curses.COLOR_WHITE) s.box() s.addstr(2, 2, "Change password", curses.color_pair(3)) s.addstr(19, 2, "[Use [ESC] to abort!]", curses.color_pair(1)) s.addstr(4, 2, "Enter username: "******"": s.erase() return error,newpassword = helper_change_password(UID, env) if error != "OK":s.addstr(6, 2, error, curses.color_pair(2)) else: s.addstr(6, 2, "Password reset: %s" % error, curses.color_pair(2)) s.addstr(7, 2, "New Password: %s" % newpassword, curses.color_pair(2)) s.addstr(19, 2, "[Press any key to continue]", curses.color_pair(1)) s.getch() s.erase() return
def main(): parser = argparse.ArgumentParser( description= "Hacker typer to impress your friends! Press ESC at any moment to " "exit the program.") parser.add_argument("-t", "--test", action="store_true", help="Testing mode, uses a shorter file and a shorter" "window.") parser.add_argument("-s", "--speed", help="Typing speed, i.e. number of characters per key" "stroke.", required=False, default=4, type=int) args = parser.parse_args() root = os.path.dirname(os.path.realpath(__file__)) if args.test: input_file = root + "/test" else: input_file = root + "/in" + str(random.randint(1, 8)) text_file = open(input_file) try: speed = args.speed default_screen = curses.initscr() curses.start_color() curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK) default_screen.clear() max_xy = default_screen.getmaxyx() y_dim = max_xy[0] if args.test and y_dim > 10: y_dim = 10 x_dim = max_xy[1] pad = curses.newpad(y_dim, x_dim) pad.attrset(curses.color_pair(1)) pad.refresh(0, 0, 0, 0, y_dim - 1, x_dim - 1) if not args.test: text_file.seek(random.randrange(30000)) exit_program = False pos = 0 while True: key = pad.getch() if key == 27: exit_program = True break out_of_chars = False for i in range(speed): char = text_file.read(1) if not char: out_of_chars = True break try: pad.addstr(char) except curses.error: pos += 1 pad.resize(y_dim + pos, x_dim) pad.addstr(char) pad.refresh(pos, 0, 0, 0, y_dim - 1, x_dim - 1) if out_of_chars: break if not exit_program: pad.erase() default_screen.refresh() pad.resize(3, 8) pad.addstr(1, 0, " HACKED ") pad.border() pad.refresh(0, 0, 0, 0, 2, 7) while pad.getch() != 27: i = 0 finally: text_file.close() curses.endwin()
def __init__(self, gctx, ctx, analyzer): Window.__init__(self, ctx.output, has_statusbar=True) self.ctx = ctx self.gctx = gctx self.mode = MODE_DUMP self.dis = gctx.dis self.analyzer = analyzer self.queue_wait_analyzer = Queue() # Last/first address printed (only in MODE_DUMP) self.last_addr = max(self.output.addr_line) self.first_addr = min(self.output.addr_line) self.stack = [] self.saved_stack = [] # when we enter, go back, then re-enter new_mapping = { b"z": self.main_cmd_line_middle, b"g": self.main_k_top, b"G": self.main_k_bottom, b";": self.view_inline_comment_editor, b"%": self.main_cmd_next_bracket, b"\n": self.main_cmd_enter, b"\x1b": self.main_cmd_escape, b"\t": self.main_cmd_switch_mode, b"c": self.main_cmd_code, b"p": self.main_cmd_set_function, b"{": self.main_k_prev_paragraph, b"}": self.main_k_next_paragraph, b"x": self.main_cmd_xrefs, b"r": self.main_cmd_rename, b"I": self.main_cmd_inst_output, # I wanted ctrl-enter but it cannot be mapped on my terminal b"u": self.main_cmd_reenter, # u for undo } self.mapping.update(new_mapping) saved_quiet = self.gctx.quiet self.gctx.quiet = True self.screen = curses.initscr() (h, w) = self.screen.getmaxyx() h -= 1 # status bar self.goto_address(self.first_addr, h, w) curses.noecho() curses.cbreak() curses.mousemask(curses.ALL_MOUSE_EVENTS | curses.REPORT_MOUSE_POSITION) curses.start_color() curses.use_default_colors() if self.gctx.color: for i in range(0, curses.COLORS): curses.init_pair(i, i, -1) curses.init_pair(1, 253, 66) # for the highlight search else: for i in range(0, curses.COLORS): curses.init_pair(i, 7, -1) # white try: curses.wrapper(self.start_view) except: curses.nocbreak() curses.echo() curses.endwin() traceback.print_exc() return curses.nocbreak() curses.echo() curses.endwin() self.gctx.quiet = saved_quiet if self.stack: print(hex(self.ctx.entry))
def cGame(stdscr=None, p1ai=None, p2ai=None): # Initialize Curses if stdscr is None: stdscr = curses.initscr() curses.noecho() curses.cbreak() stdscr.keypad(True) curses.curs_set(0) curses.start_color() # Setup the color pairs curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_RED) curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLUE) selectedpos = (0, 0) b = board() psturn = 1 def drawface(stdscr, selectedpos, b, psturn): stdscr.erase() stdscr.border() stdscr.addstr(0, 10, "HEX ('q'=quit,Space=move)") stdscr.addstr(0, 40, "P" + str(psturn) + ' turn', curses.color_pair(psturn)) # Draw the winner stat = b.boardstate() stdscr.addstr(17, 10, "Status: " + stat) if not stat == 'No Win': with open('game.txt', 'w') as f: f.write(b.listmoves) # TEMPORARY: Add a debug message # from AI import hyperScoreAI # a = hyperScoreAI(player=1) # b.debug = str(a.lightDistance(b)) # Draw the debug info # stdscr.addstr(18, 10, "Debug :" + b.debug) # stdscr.addstr(19, 10, "Pos :" + str(selectedpos)) scrnpos = [4, 5] count = 0 # Add the top row of -'s for 2 stdscr.addstr(scrnpos[0] - 1, scrnpos[1] + 1, '-' * (b.size[0] * 2 - 1), curses.color_pair(2)) for y, row in enumerate(b.board): count += 1 # Add the left row of \'s for 1 stdscr.addstr(scrnpos[0], scrnpos[1] + count - 1, '\\', curses.color_pair(1)) for x, itm in enumerate(row): if itm in [1, 2]: stdscr.addstr(scrnpos[0], scrnpos[1] + count, str(itm), curses.color_pair(itm)) if (x, y) == selectedpos: stdscr.addstr(scrnpos[0], scrnpos[1] + count - 1, '>', curses.color_pair(itm)) stdscr.addstr(scrnpos[0], scrnpos[1] + count + 1, '<', curses.color_pair(itm)) else: stdscr.addstr( scrnpos[0], scrnpos[1] + count, str(itm) if itm is not 0 else '*', curses.A_REVERSE if selectedpos == (x, y) else curses.A_NORMAL) scrnpos[1] += 2 # Add the right row of \'s for 1 stdscr.addstr(scrnpos[0], scrnpos[1] + count - 1, '\\', curses.color_pair(1)) scrnpos[1] = 5 scrnpos[0] += 1 # Add the bottom row of -'s for 2 stdscr.addstr(scrnpos[0], scrnpos[1] + (b.size[0] * 2 - 11), '-' * (b.size[0] * 2 - 1), curses.color_pair(2)) stdscr.refresh() # Enter main loop drawface(stdscr, selectedpos, b, psturn) while True: # Let the AI move if it exists if psturn is 1 and p1ai is not None: b.move(p1ai(b), 1) psturn = 2 drawface(stdscr, selectedpos, b, psturn) continue if psturn is 2 and p2ai is not None: b.move(p2ai(b), 2) psturn = 1 drawface(stdscr, selectedpos, b, psturn) continue c = stdscr.getch() if c == ord('q'): break # Quit from game elif c == ord('a'): selectedpos = ((selectedpos[0] - 1) % 11, (selectedpos[1]) % 11) drawface(stdscr, selectedpos, b, psturn) elif c == ord('d'): selectedpos = ((selectedpos[0] + 1) % 11, (selectedpos[1]) % 11) drawface(stdscr, selectedpos, b, psturn) elif c == ord('s'): selectedpos = ((selectedpos[0]) % 11, (selectedpos[1] + 1) % 11) drawface(stdscr, selectedpos, b, psturn) elif c == ord('w'): selectedpos = ((selectedpos[0]) % 11, (selectedpos[1] - 1) % 11) drawface(stdscr, selectedpos, b, psturn) elif c == ord(' '): if b.legal(selectedpos): b.move(selectedpos, psturn) psturn = 1 if psturn is 2 else 2 drawface(stdscr, selectedpos, b, psturn) # Clean up the console curses.nocbreak() stdscr.keypad(False) curses.echo() curses.endwin()
import math, fractions import pyautogui, sys, curses # 1366 by 768 # # math syntax: https://docs.python.org/2/library/math.html screen = curses.initscr() curses.noecho() curses.halfdelay(1) screen.keypad(True) curses.start_color() curses.use_default_colors() curses.init_pair(1, curses.COLOR_RED, -1) curses.init_pair(2, curses.COLOR_GREEN, -1) curses.init_pair(3, curses.COLOR_BLUE, -1) xmbase, ymbase = pyautogui.size() xmbase = xmbase / 2 ymbase = ymbase / 2 d_one = 150 #distance from shoulder to elbow d_two = 150 #distance from elbow to wrist pyautogui.moveTo(xmbase, ymbase, duration=.1) while True: #to end loop if 'q' is hit key = screen.getch() screen.clear() xread, yread = pyautogui.position() x = xread - xmbase
def __init__(self, web_port=26000, window_height=40, window_width=130, auto_scoll=True, max_log_lines=500, wait_on_quit=True, min_refresh_rate=1000, bytes_to_str=DEFAULT_HEX_TO_STR): """ :type web_port: int :param web_port: Webinterface port. Default 26000 :type window_height: int :param window_height: Default console heigth, set to on startup. Default 40 :type window_width: int :param window_width: Default console width, set to on startup. Default 130 :type auto_scoll: bool :param auto_scoll: Whether to auto-scoll the cases and crashed windows to allways display the last line if there are too many lines to display all of them. Default True :type max_log_lines: int :param max_log_lines: Maximum log lines to keep in the internal storage. Additional lines exceeding this limit will not be displayed. Default 500 :type wait_on_quit: bool :param wait_on_quit: Whether to keep the GUI open and wait for user-input when the main thread is about to exit. Default True :type min_refresh_rate: int :param min_refresh_rate: The delay between two checks for a resize of the terminal in milliseconds. Increment 100 ms. Default 1000 ms :type bytes_to_str: function :param bytes_to_str: Function that converts sent/received bytes data to string for logging. """ self._title = "boofuzz" self._web_port = web_port self._max_log_lines = max_log_lines self._auto_scroll = auto_scoll self._current_data = None self._log_storage = [] self._fail_storage = [] self._wait_on_quit = wait_on_quit self._quit = False self._status = 0 # 0: Running 1: Paused 2: Done self._refresh_interval = min_refresh_rate self._event_resize = True self._event_log = False self._event_case_close = False self._event_crash = False self._total_index = 0 self._total_num_mutations = 0 self._current_name = "" self._current_index = 0 self._current_num_mutations = 0 self._format_raw_bytes = bytes_to_str self._version = helpers.get_boofuzz_version(helpers) # Resize console to minimum size self._width, self._height = get_terminal_size() if self._height < window_height or self._width < window_width: print("\x1b[8;{};{}t".format(window_height, window_width)) self._height, self._width = window_height, window_width self._height_old = 0 self._width_old = 0 self._min_size_ok = True self._stdscr = curses.initscr() curses.start_color() curses.use_default_colors() curses.noecho() curses.curs_set(0) self._stdscr.nodelay(1) # Curses color pairs curses.init_pair(1, curses.COLOR_WHITE, -1) curses.init_pair(2, curses.COLOR_CYAN, -1) curses.init_pair(3, curses.COLOR_RED, -1) curses.init_pair(4, curses.COLOR_YELLOW, -1) curses.init_pair(5, curses.COLOR_GREEN, -1) curses.init_pair(6, curses.COLOR_MAGENTA, -1) curses.init_pair(7, curses.COLOR_BLACK, curses.COLOR_WHITE) # Start thread and restore the original SIGWINCH handler self._draw_thread = threading.Thread(name="curses_logger", target=self._draw_screen) current_signal_handler = signal.getsignal(signal.SIGWINCH) self._draw_thread.start() signal.signal(signal.SIGWINCH, current_signal_handler)
def _enable_color(self): if curses.has_colors(): curses.start_color()
def up(self): if not self.enabled: logger.info("display not enabled") return logger.info("up") self.screen = curses.initscr() self.running = True # if anything manages to get printed it messes with curses self.prev_stdout = sys.stdout sys.stdout = open(os.devnull, "w") # no cursor curses.curs_set(0) # turn off echoing of keys, and enter cbreak mode, # where no buffering is performed on keyboard input curses.noecho() # in keypad mode, escape sequences for special keys # (like the cursor keys) will be interpreted and # a special value like curses.KEY_LEFT will be returned self.screen.keypad(1) self.screen.nodelay(1) # harmless if the terminal doesn't have color; # user can test with has_color() later on. the try/catch # works around a minor bit of over-conscientiousness in the curses # module -- the error return from C start_color() is ignorable. try: curses.start_color() except: pass curses.use_default_colors() curses.init_pair(1, curses.COLOR_CYAN, curses.COLOR_BLACK) curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK) # fmt: off self.engineCluster = Cluster(0, 0, ("time: {time:.2f}\n" "frame number: {frame}\n" "fps: {fps:.2f}/{cap:.0f}\n" "highest d: {highest_delta:.2f}\n" "memory used: {mem} MiB\n"), name="engine") self.controllerCluster = Cluster(0, 30, ("throttle: {throttle}\n" "strafe: {strafe}\n" "forward: {forward}\n" "spin: {spin}\n"), name="controller") row_2 = 7 self.vehicleCluster = Cluster(row_2, 0, ("altitude: {altitude:>6.2f}cm\n" "throttle: {throttle:>6.2f}\n" "temperature: {temperature:>6.2f}\n"), name="vehicle") self.motorCluster = Cluster(row_2, 22, ("{0:>3.3f} {1:>3.3f}\n" "{2:>3.3f} {3:>3.3f}\n"), name="motors") row_3 = 12 self.accelerometer = Cluster(row_3, 0, ("x: {x:>7.3f}\n" "y: {y:>7.3f}\n" "z: {z:>7.3f}\n"), name="accel") self.gyro = Cluster(row_3, 15, ("x: {x:>7.3f}\n" "y: {y:>7.3f}\n" "z: {z:>7.3f}\n"), name="gyro") self.magnet = Cluster(row_3, 30, ("x: {x:>7.3f}\n" "y: {y:>7.3f}\n" "z: {z:>7.3f}\n"), name="magnet") self.deviation = Cluster(row_3, 45, ("x: {x:>7.3f}\n" "y: {y:>7.3f}\n" "z: {z:>7.3f}\n"), name="deviation") row_4 = 17 self.log = Cluster(row_4, 0, "{0}", name="log")
def main(screen): """ Snake Press 'q' to quit the game. """ screen.clear() curses.curs_set(0) screen.nodelay(1) curses.start_color() curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK) # Get the y,x of the window dims = screen.getmaxyx() # Get the center of the window center = (dims[0]//2), (dims[1]//2) screen.border() # Main loop x = center[1] y = center[0] dirs = {"x": 1, "y": 0} #screen.move(0, 0); screen.refresh() snake = [[y, x], [y, x-1], [y, x-2]] apple = [random.randint(1, dims[0]-2), random.randint(1, dims[1]-2)] appleCh = "ö" screen.addstr(apple[0], apple[1], appleCh, curses.color_pair(1)) ch = "O" screen.addstr(snake[0][0], snake[0][1], ch, curses.color_pair(2)) score = 0 while True: screen.border() screen.addstr(0, 2, "Score : " + str(score) + " ") key = screen.getch() if key == ord("q"): #screen.clear() text = "GAME OVER!" screen.addstr(dims[0]//2, dims[1]//2-len(text)//2, text) screen.refresh() curses.napms(2500) break elif key == KEY_UP: dirs["y"] = -1 dirs["x"] = 0 elif key == KEY_DOWN: dirs["y"] = 1 dirs["x"] = 0 elif key == KEY_LEFT: dirs["x"] = -1 dirs["y"] = 0 elif key == KEY_RIGHT: dirs["x"] = 1 dirs["y"] = 0 x += dirs["x"] y += dirs["y"] # head of snake if y <= 0: y = 1 elif y >= dims[0]-1: y = dims[0] - 2 if x <= 0: x = 1 elif x >= dims[1]-1: x = dims[1] - 2 snake.insert(0, [y, x]) if snake[0] in snake[1:]: #screen.clear() text = "GAME OVER!" screen.addstr(dims[0]//2, dims[1]//2-len(text)//2, text) screen.refresh() curses.napms(2500) break if snake[0] == apple: score += 1 while apple in snake: apple = [random.randint(2, dims[0]-3), random.randint(2, dims[1]-3)] screen.addstr(apple[0], apple[1], appleCh, curses.color_pair(1)) else: last = snake.pop() screen.addch(last[0], last[1], " ", curses.color_pair(2)) screen.addch(snake[0][0], snake[0][1], ch, curses.color_pair(2)) #time.sleep(0.1) nap_time = 100 - len(snake)//2 curses.napms(nap_time) curses.endwin() print("Final score:", score)
def scanner(scanner_args): ''' Execute exploit against given ip list ''' # looks ugly, but since it works well, im not planning a rewrite work_path, exec_path = scanner_args.work_path, scanner_args.exec_path custom_args, jobs = scanner_args.custom_args, scanner_args.jobs if SESSION.use_proxy: e_args = [ 'proxychains4', '-q', '-f', SESSION.proxy_conf, './' + exec_path ] else: e_args = ['./' + exec_path] # add custom arguments for different exploits e_args += custom_args # the last argument is target host e_args += ['-t'] try: target_list = open(SESSION.ip_list) except BaseException as exc: console.print_error('[-] Error occured: {}\n'.format(exc)) debug_except() return try: os.chdir('./exploits/' + work_path) except FileNotFoundError: console.print_error("[-] Can't chdir to " + work_path) debug_except() console.print_warning('\n[!] DEBUG: ' + str(e_args) + '\nWorking in ' + os.getcwd()) # you might want to cancel the scan to correct some errors if input_check('[?] Proceed? [y/n] ', choices=['y', 'n']) == 'n': return console.print_warning('\n[!] It might be messy, get ready!' + '\n') time.sleep(2) # save stdout to logfile try: logfile = open(SESSION.logfile, "a+") except FileNotFoundError: console.print_error("[-] Log file not found") # needed for the loop procs = [] count = len(procs) tested = count # use curses to display output import curses stdscr = curses.initscr() curses.start_color() curses.use_default_colors() curses.init_pair(1, curses.COLOR_CYAN, -1) curses.init_pair(2, curses.COLOR_WHITE, -1) curses.init_pair(3, curses.COLOR_GREEN, -1) for line in target_list: target_ip = line.strip() # clear screen for each output stdscr.refresh() # display progress info on top progress = str(tested) + ' targets found' # tail to get the last line of log file status = tail(SESSION.logfile) # mark this loop as done count = len(procs) tested += 1 try: # start and display current process e_args += [target_ip] stdscr.addstr(0, 0, progress + '\n', curses.A_BOLD | curses.color_pair(1)) stdscr.addstr(2, 0, ' '.join(e_args) + '\n', curses.color_pair(3)) stdscr.addstr(4, 0, status, curses.color_pair(2)) proc = subprocess.Popen(e_args, stdout=logfile, stderr=logfile) procs.append(proc) # continue to next target e_args.remove(target_ip) time.sleep(.11) # process pool if count == jobs: # if returned any exit code, consider the process as done for item in procs: item.communicate() if item.returncode is not None: item.kill() procs = [] except (EOFError, KeyboardInterrupt, SystemExit): curses.endwin() for item in procs: if item.pid is not None: item.kill() logfile.close() console.print_error("[-] Task aborted") # killall running processes check_kill_process(exec_path) return # close logfile, exit curses window, and print done flag curses.endwin() logfile.close() os.chdir(SESSION.init_dir) console.print_success('\n[+] All done!\n')
def main(screen): curses.start_color() curses.use_default_colors() pride = Pride(screen) pride.run()
def __init__(self): self.__scrn = curses.initscr() curses.start_color() curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE) curses.use_default_colors()
def run_curses(testers): rr = RoundRobinSched(0.5, testers) rospy.init_node('CentralizedTester', anonymous=True) burst_size = 1024 * 1024 col1 = 0 # Source col2 = 4 # Dest col3 = 10 # Percentage col4 = 31 # Sending col5 = 35 # Send rate col6 = 46 # Payload size col7 = 53 # tx bitrate col8 = 64 # rx bitrate col9 = 75 # Latency col10 = 88 # RSSI help_row = 2 + len(testers) + 3 help_string = """ Help: q quit up/down (j/k) change selection s start sending selected data S start sending all data g Run round-robin sending r (R) Reset statistics (for all) +/- Increase/decrease transmit rate ]/[ Increase/decrease payload size B Send burst of data }/{ Increase/decrease burst size """ stdscr_orig = curses.initscr() stdscr = curses.newpad(help_row + 15, col10 + 15) curses.noecho() curses.cbreak() curses.start_color() curses.curs_set(0) stdscr.keypad(1) stdscr.nodelay(1) #curses.halfdelay(3) curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_RED) curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_CYAN) for x in testers: x.start() done = False stdscr.addstr(0, 0, 'Comms Test Client') stdscr.addstr(1, 0, '-' * (col8 + 11)) stdscr.addstr(2, col1, 'Src') stdscr.addstr(2, col2, 'Dest') stdscr.addstr(2, col3, '% Recv') stdscr.addstr(2, col4, 'Enb') stdscr.addstr(2, col5, 'Rate (Hz)') stdscr.addstr(2, col6, 'Bytes') stdscr.addstr(2, col7, 'Tx (kbps)') stdscr.addstr(2, col8, 'Rx (kbps)') stdscr.addstr(2, col9, 'Latency (ms)') stdscr.addstr(2, col10, 'RSSI (dBm)') stdscr.addstr(help_row - 2, 0, '-' * (col8 + 11)) stdscr.addstr(help_row - 1, 0, 'Burst size (bytes): {}'.format(burst_size)) stdscr.addstr(help_row, 8, help_string) selected_row_idx = 3 selected_tester = None round_robin_run = False while not done: idx = 3 for x in testers: if idx == selected_row_idx: color_selection = curses.color_pair(1) selected_tester = x else: color_selection = curses.color_pair(0) stdscr.addstr(idx, 0, ' ' * (col10 + 11), color_selection) stats = x.test.GetStatistics() stdscr.addstr(idx, col1, '{}'.format(x.test.name1), color_selection) stdscr.addstr(idx, col2, '{}'.format(x.test.name2), color_selection) stdscr.addstr( idx, col3, '{:2.2f} ({}/{})'.format(stats[0] * 100, stats[1], len(x.test.outgoing_data)), color_selection) # stdscr.addstr(idx,col4,'%d' % x.test.GetAverageRSSI(), color_selection) if x.test.send: stdscr.addstr(idx, col4, 'On', color_selection) else: stdscr.addstr(idx, col4, 'Off', color_selection) stdscr.addstr(idx, col5, '{:2.2f}'.format(x.test.send_rate), color_selection) stdscr.addstr(idx, col6, '{}'.format(x.test.payload_size), color_selection) # stdscr.addstr(idx, col7, '{:2.2f}'.format(x.test.send_rate * float(x.test.payload_size) / 1024.0), color_selection) stdscr.addstr(idx, col7, '{:2.2f}'.format(x.test.GetTXRate() / 1000.0), color_selection) stdscr.addstr(idx, col8, '{:2.2f}'.format(x.test.GetRXRate() / 1000.0), color_selection) stdscr.addstr(idx, col9, '{:2.2f}'.format(x.test.GetLatency() * 1000.0), color_selection) stdscr.addstr(idx, col10, '{:2.2f}'.format(x.test.GetRssi()), color_selection) idx = idx + 1 # stdscr.refresh() height, width = stdscr_orig.getmaxyx() stdscr.refresh(0, 0, 0, 0, height - 1, width - 1) # Key-event handling c = stdscr.getch() if c == ord('q'): done = True if round_robin_run: rr.stop = True rr.join() for x in testers: x.test.done = True x.join() if c == ord('s'): if selected_tester != None: if selected_tester.test.send: selected_tester.test.send = False else: selected_tester.test.send = True if c == ord('S'): for x in testers: if x.test.send: x.test.send = False else: x.test.send = True if c == ord('g'): if round_robin_run: round_robin_run = False rr.stop = True rr.join() else: round_robin_run = True rr.start() if c == ord('r'): if selected_tester != None: selected_tester.test.ResetStatistics() if c == ord('R'): for x in testers: x.test.ResetStatistics() elif c == curses.KEY_UP or c == ord('k'): selected_row_idx = selected_row_idx - 1 if selected_row_idx < 3: selected_row_idx = 3 elif c == curses.KEY_DOWN or c == ord('j'): selected_row_idx = selected_row_idx + 1 if selected_row_idx >= 3 + len(testers): selected_row_idx = 3 + len(testers) - 1 if c == ord('+'): if selected_tester != None: selected_tester.test.UpdateRate( selected_tester.test.send_rate + 1) if c == ord('-'): if selected_tester != None: selected_tester.test.UpdateRate( max(selected_tester.test.send_rate - 1, 1.0)) if c == ord(']'): if selected_tester != None: selected_tester.test.payload_size = min( selected_tester.test.payload_size + 1, 1000000) if c == ord('['): if selected_tester != None: selected_tester.test.payload_size = max( selected_tester.test.payload_size - 1, 0) if c == ord('}'): burst_size = burst_size + 10 stdscr.addstr(help_row - 1, 0, 'Burst size (bytes): {}'.format(burst_size)) if c == ord('{'): burst_size = max(burst_size - 10, 1) stdscr.addstr(help_row - 1, 0, 'Burst size (bytes): {}'.format(burst_size)) if c == ord('B'): if selected_tester != None: selected_tester.test.SendBurst(burst_size) curses.nocbreak() stdscr.keypad(0) curses.echo() curses.endwin()
def main(argv): """If this file is the main, create an instance of EstopNoGui and wait for user to terminate. This has little practical use, because calling the function this way does not give the user any way to trigger an estop from the terminal. """ parser = argparse.ArgumentParser() bosdyn.client.util.add_common_arguments(parser) parser.add_argument('-t', '--timeout', type=float, default=5, help='Timeout in seconds') options = parser.parse_args(argv) # Set up curses screen display to monitor for stop request stdscr = curses.initscr() curses.noecho() curses.cbreak() stdscr.keypad(True) stdscr.nodelay(True) curses.start_color() curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLACK) curses.init_pair(2, curses.COLOR_YELLOW, curses.COLOR_BLACK) curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK) # If terminal cannot handle colors, do not proceed if not curses.has_colors(): return # Create robot object sdk = bosdyn.client.create_standard_sdk('estop_nogui') robot = sdk.create_robot(options.hostname) robot.authenticate(options.username, options.password) # Create estop client for the robot estop_client = robot.ensure_client(EstopClient.default_service_name) # Create nogui estop estop_nogui = EstopNoGui(estop_client, options.timeout, "Estop NoGUI") # Create robot state client for the robot state_client = robot.ensure_client(RobotStateClient.default_service_name) def clean_exit(msg=''): """Shut down curses and exit the program.""" print('Exiting') #pylint: disable=unused-argument estop_nogui.estop_keep_alive.shutdown() # Clean up and close curses curses.nocbreak() stdscr.keypad(False) curses.echo() stdscr.nodelay(False) curses.endwin() print(msg) exit(0) def sigint_handler(sig, frame): """Exit the application on interrupt.""" clean_exit() # Curses eats Ctrl-C keyboard input, but keep a SIGINT handler around for # explicit kill signals outside of the program. signal.signal(signal.SIGINT, sigint_handler) # Clear screen stdscr.clear() # Display usage instructions in terminal stdscr.addstr('Estop w/o GUI running.\n') stdscr.addstr('\n') stdscr.addstr('[q] or [Ctrl-C]: Quit\n', curses.color_pair(2)) stdscr.addstr('[SPACE]: Trigger estop\n', curses.color_pair(2)) stdscr.addstr('[r]: Release estop\n', curses.color_pair(2)) stdscr.addstr('[s]: Settle then cut estop\n', curses.color_pair(2)) # Monitor estop until user exits while True: # Retrieve user input (non-blocking) c = stdscr.getch() try: if c == ord(' '): estop_nogui.stop() if c == ord('r'): estop_nogui.allow() if c == ord('q') or c == 3: clean_exit('Exit on user input') if c == ord('s'): estop_nogui.settle_then_cut() # If the user attempts to toggle estop without valid endpoint except bosdyn.client.estop.EndpointUnknownError: clean_exit("This estop endpoint no longer valid. Exiting...") # Check if robot is estopped by any estops estop_status = 'NOT_STOPPED\n' estop_status_color = curses.color_pair(1) state = state_client.get_robot_state() estop_states = state.estop_states for estop_state in estop_states: state_str = estop_state.State.Name(estop_state.state) if state_str == 'STATE_ESTOPPED': estop_status = 'STOPPED\n' estop_status_color = curses.color_pair(3) break elif state_str == 'STATE_UNKNOWN': estop_status = 'ERROR\n' estop_status_color = curses.color_pair(3) elif state_str == 'STATE_NOT_ESTOPPED': pass else: # Unknown estop status clean_exit() # Display current estop status if not estop_nogui.estop_keep_alive.status_queue.empty(): latest_status = estop_nogui.estop_keep_alive.status_queue.get()[1].strip() if latest_status != '': # If you lose this estop endpoint, report it to user stdscr.addstr(7, 0, latest_status, curses.color_pair(3)) stdscr.addstr(6, 0, estop_status, estop_status_color) # Slow down loop time.sleep(0.5)
def game(stdscr): # init colors curses.start_color() curses.use_default_colors() for i in range(curses.COLORS): curses.init_pair(i + 1, i, -1) # init vars running = True launched = False paddle_x = 27 ball_x, ball_y, ball_v = 32, 18, 0 spin = None block_spin = None # init board blocks = board.checker("yellow", "blue") # gameplay loop while running: ############## # draw scene # ############## # draw board for i in range(len(blocks)): color = blocks[i] stdscr.addstr(i // B_COLS, i % B_COLS * BLOCK_SIZE, ' ' * BLOCK_SIZE, curses.color_pair(color) | curses.A_REVERSE) # draw paddle for i in range(PADDLE_SIZE): stdscr.addstr(HEIGHT, i + paddle_x, ' ', curses.color_pair(0) | curses.A_REVERSE) # draw ball stdscr.addstr(ball_y, ball_x, '*', curses.color_pair(4) | curses.A_BOLD) ################ # handle input # ################ # get key key = stdscr.getch() # move paddle right if key == curses.KEY_RIGHT: if paddle_x < 49: paddle_x += 1 # ball not yet launched if not ball_v: ball_x += 1 # ball spin if ball_y == 18 and ball_v: spin = "left" # move paddle left elif key == curses.KEY_LEFT: if paddle_x > 0: paddle_x -= 1 # ball not yet launched if not ball_v: ball_x -= 1 # ball spin if ball_y == 18 and ball_v: spin = "right" # move up (launch ball) elif key == curses.KEY_UP: if not launched: ball_v = -1 launched = True # quit game elif key == ord('q'): running = False ############## # game logic # ############## # ball top collision if ball_y == 0: ball_v = 1 # ball/paddle collision if launched and ball_y == 18 and \ (paddle_x <= ball_x < paddle_x+PADDLE_SIZE): ball_v = -1 # ball brick collision if ball_y - 1 < B_ROWS: # this is hacky (collision should have its own funcs) for i in range(1): # break block above if (blocks[B_COLS * (ball_y - 1) + ball_x // BLOCK_SIZE] != BLK): ball_v = 1 blocks[B_COLS * (ball_y - 1) + ball_x // BLOCK_SIZE] = BLK break # break block to side and get new spin try: if spin == "right": if (blocks[B_COLS * (ball_y) + (ball_x + 1) // BLOCK_SIZE] != BLK): blocks[B_COLS * (ball_y) + (ball_x + 1) // BLOCK_SIZE] = BLK spin = "left" elif spin == "left": if (blocks[B_COLS * (ball_y) + (ball_x - 1) // BLOCK_SIZE] != BLK): blocks[B_COLS * (ball_y) + (ball_x - 1) // BLOCK_SIZE] = BLK spin = "right" except: pass # ball misses paddle and passes outside of map if ball_y == 20: if DEBUG: # reset ball ball_x, ball_y, ball_v = paddle_x + 5, 18, 0 spin = None launched = False else: running = False # ball spin from paddle if spin == "left": ball_x -= 1 elif spin == "right": ball_x += 1 # ball spin wall collision if ball_x == 0: spin = "right" if ball_x == 59: spin = "left" # ball moving up and down if ball_v: ball_y += ball_v ########### # display # ########### # refresh, delay (24FPS), clear screen stdscr.refresh() time.sleep(1 / 24.0) stdscr.clear()
def main(screen): global msgtrade1time, msgtrade1side, msgtrade1size, msgtrade1price global msgtrade2time, msgtrade2side, msgtrade2size, msgtrade2price global msgtrade3time, msgtrade3side, msgtrade3size, msgtrade3price global msgtrade4time, msgtrade4side, msgtrade4size, msgtrade4price global msgtrade5time, msgtrade5side, msgtrade5size, msgtrade5price global msgtrade6time, msgtrade6side, msgtrade6size, msgtrade6price global msgtrade7time, msgtrade7side, msgtrade7size, msgtrade7price global msgtrade8time, msgtrade8side, msgtrade8size, msgtrade8price global msgtrade9time, msgtrade9side, msgtrade9size, msgtrade9price global msgtrade10time, msgtrade10side, msgtrade10size, msgtrade10price global msgbookbid1size, msgbookbid1price, msgbookask1size, msgbookask1price global msgbookbid2size, msgbookbid2price, msgbookask2size, msgbookask2price global msgbookbid3size, msgbookbid3price, msgbookask3size, msgbookask3price global msgbookbid4size, msgbookbid4price, msgbookask4size, msgbookask4price global msgbookbid5size, msgbookbid5price, msgbookask5size, msgbookask5price global msgbookbid6size, msgbookbid6price, msgbookask6size, msgbookask6price global msgbookbid7size, msgbookbid7price, msgbookask7size, msgbookask7price global msgbookbid8size, msgbookbid8price, msgbookask8size, msgbookask8price global msgbookbid9size, msgbookbid9price, msgbookask9size, msgbookask9price global msgbookbid10size, msgbookbid10price, msgbookask10size, msgbookask10price global mvalor2, mbitmex, symbol, timeframe, limit, params mwin3count = 0 curses.start_color() # activate color usage curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_RED) # Sell color on Times & Trades curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_GREEN) # Buy color on Times&Trades # Screen definitions height, width = screen.getmaxyx() #previous value screen.addstr(0, int(width/2.7),"xxx...... if mvalor2 == "(1)": screen.addstr( 0, 0, " --- BITMEX PROD DATA Developed by Luciano Lima --- " ) elif mvalor2 == "(2)": screen.addstr( 0, 0, " --- BITMEX TEST DATA Developed by Luciano Lima --- " ) win1 = curses.newwin(18, 39, 2, 0) win2 = curses.newwin(18, 39, 2, 41) win3 = curses.newwin(5, 80, 20, 0) win1.box() win2.box() win3.box() height1, width1 = win1.getmaxyx() height2, width2 = win2.getmaxyx() win1.addstr(1, int(width1 / 3.2), "Book LII " + "%s" % mvalor1) win1.addstr(2, 1, "SIZE BID ") win1.addstr(2, 20, "ASK SIZE") win2.addstr(1, int(width2 / 3.3), "Times & Trades " + "%s" % mvalor1) win2.addstr(2, 1, "Timestamp") win2.addstr(2, 14, "Side") win2.addstr(2, 20, "Size") win2.addstr(2, 28, "Price") win3.addstr( 1, 1, "Chart Data |Amp|Frequency") #call_websocket() t = Thread(target=call_websocket) t.start() try: while True: # book win1.addstr(3, 1, msgbookbid1size + " ") win1.addstr(3, 10, msgbookbid1price + " ") win1.addstr(4, 1, msgbookbid2size + " ") win1.addstr(4, 10, msgbookbid2price + " ") win1.addstr(5, 1, msgbookbid3size + " ") win1.addstr(5, 10, msgbookbid3price + " ") win1.addstr(6, 1, msgbookbid4size + " ") win1.addstr(6, 10, msgbookbid4price + " ") win1.addstr(7, 1, msgbookbid5size + " ") win1.addstr(7, 10, msgbookbid5price + " ") win1.addstr(8, 1, msgbookbid6size + " ") win1.addstr(8, 10, msgbookbid6price + " ") win1.addstr(9, 1, msgbookbid7size + " ") win1.addstr(9, 10, msgbookbid7price + " ") win1.addstr(10, 1, msgbookbid8size + " ") win1.addstr(10, 10, msgbookbid8price + " ") win1.addstr(11, 1, msgbookbid9size + " ") win1.addstr(11, 10, msgbookbid9price + " ") win1.addstr(12, 1, msgbookbid10size + " ") win1.addstr(12, 10, msgbookbid10price + " ") win1.addstr(3, 30, msgbookask1size + " ") win1.addstr(3, 20, msgbookask1price + " ") win1.addstr(4, 30, msgbookask2size + " ") win1.addstr(4, 20, msgbookask2price + " ") win1.addstr(5, 30, msgbookask3size + " ") win1.addstr(5, 20, msgbookask3price + " ") win1.addstr(6, 30, msgbookask4size + " ") win1.addstr(6, 20, msgbookask4price + " ") win1.addstr(7, 30, msgbookask5size + " ") win1.addstr(7, 20, msgbookask5price + " ") win1.addstr(8, 30, msgbookask6size + " ") win1.addstr(8, 20, msgbookask6price + " ") win1.addstr(9, 30, msgbookask7size + " ") win1.addstr(9, 20, msgbookask7price + " ") win1.addstr(10, 30, msgbookask8size + " ") win1.addstr(10, 20, msgbookask8price + " ") win1.addstr(11, 30, msgbookask9size + " ") win1.addstr(11, 20, msgbookask9price + " ") win1.addstr(12, 30, msgbookask10size + " ") win1.addstr(12, 20, msgbookask10price + " ") # times and trades # 1st trade win2.addstr(3, 1, msgtrade1time) # timestamp if "Sell" in msgtrade1side: win2.addstr(3, 14, msgtrade1side, curses.color_pair(1)) # Sell side else: win2.addstr(3, 14, msgtrade1side, curses.color_pair(2)) # Buy side win2.addstr(3, 20, msgtrade1size + " ") # size win2.addstr(3, 28, msgtrade1price + " ") # price #2nd trade win2.addstr(4, 1, msgtrade2time) # timestamp if "Sell" in msgtrade2side: win2.addstr(4, 14, msgtrade2side, curses.color_pair(1)) # Sell side else: win2.addstr(4, 14, msgtrade2side, curses.color_pair(2)) # Buy side win2.addstr(4, 20, msgtrade2size + " ") # size win2.addstr(4, 28, msgtrade2price + " ") # price #3rd trade win2.addstr(5, 1, msgtrade3time) # timestamp if "Sell" in msgtrade3side: win2.addstr(5, 14, msgtrade3side, curses.color_pair(1)) # Sell side else: win2.addstr(5, 14, msgtrade3side, curses.color_pair(2)) # Buy side win2.addstr(5, 20, msgtrade3size + " ") # size win2.addstr(5, 28, msgtrade3price + " ") # price #4th trade win2.addstr(6, 1, msgtrade4time) # timestamp if "Sell" in msgtrade4side: win2.addstr(6, 14, msgtrade4side, curses.color_pair(1)) # Sell side else: win2.addstr(6, 14, msgtrade4side, curses.color_pair(2)) # Buy side win2.addstr(6, 20, msgtrade4size + " ") # size win2.addstr(6, 28, msgtrade4price + " ") # price #5th trade win2.addstr(7, 1, msgtrade5time) # timestamp if "Sell" in msgtrade5side: win2.addstr(7, 14, msgtrade5side, curses.color_pair(1)) # Sell side else: win2.addstr(7, 14, msgtrade5side, curses.color_pair(2)) # Buy side win2.addstr(7, 20, msgtrade5size + " ") # size win2.addstr(7, 28, msgtrade4price + " ") # price #6th trade win2.addstr(8, 1, msgtrade6time) # timestamp if "Sell" in msgtrade6side: win2.addstr(8, 14, msgtrade6side, curses.color_pair(1)) # Sell side else: win2.addstr(8, 14, msgtrade6side, curses.color_pair(2)) # Buy side win2.addstr(8, 20, msgtrade6size + " ") # size win2.addstr(8, 28, msgtrade6price + " ") # price #7th trade win2.addstr(9, 1, msgtrade7time) # timestamp if "Sell" in msgtrade7side: win2.addstr(8, 14, msgtrade7side, curses.color_pair(1)) # Sell side else: win2.addstr(9, 14, msgtrade7side, curses.color_pair(2)) # Buy side win2.addstr(9, 20, msgtrade7size + " ") # size win2.addstr(9, 28, msgtrade7price + " ") # price #8th trade win2.addstr(10, 1, msgtrade8time) # timestamp if "Sell" in msgtrade8side: win2.addstr(10, 14, msgtrade8side, curses.color_pair(1)) # Sell side else: win2.addstr(10, 14, msgtrade8side, curses.color_pair(2)) # Buy side win2.addstr(10, 20, msgtrade8size + " ") # size win2.addstr(10, 28, msgtrade8price + " ") # price #9th trade win2.addstr(11, 1, msgtrade9time) # timestamp if "Sell" in msgtrade9side: win2.addstr(11, 14, msgtrade9side, curses.color_pair(1)) # Sell side else: win2.addstr(11, 14, msgtrade9side, curses.color_pair(2)) # Buy side win2.addstr(11, 20, msgtrade9size + " ") # size win2.addstr(11, 28, msgtrade9price + " ") # price #10th trade win2.addstr(12, 1, msgtrade10time) # timestamp if "Sell" in msgtrade10side: win2.addstr(12, 14, msgtrade10side, curses.color_pair(1)) # Sell side else: win2.addstr(12, 14, msgtrade10side, curses.color_pair(2)) # Buy side win2.addstr(12, 20, msgtrade10size + " ") # size win2.addstr(12, 28, msgtrade10price + " ") # price if mwin3count == 360: # Isolating Win3 to avoid braking rate limit # Win3 Data --> Candle 3min/Chart Data # 3 min chart data since3min = mbitmex.milliseconds() - limit * 60 * 1000 # 1 day chart data since1day = mbitmex.milliseconds() - 1 * 86400 * 1000 # drawning 3 min data candles3min = mbitmex.fetch_ohlcv(symbol, timeframe, since3min, limit, params) num_candles3min = len(candles3min) ampl_candle3min = candles3min[ num_candles3min - 1][2] - candles3min[num_candles3min - 1][3] freq_candle3min = '{0:.3g}'.format(ampl_candle3min * 0.10) win3.addstr( 2, 1, "3m " + '{}: O:{} H:{} L:{} C:{}'.format( mbitmex.iso8601(candles3min[num_candles3min - 1][0]), candles3min[num_candles3min - 1][1], candles3min[num_candles3min - 1][2], candles3min[num_candles3min - 1][3], candles3min[num_candles3min - 1][4]) + "|" + str(ampl_candle3min) + "|" + str(freq_candle3min) + " ") # drawning 1 day data #candles1day = mbitmex.fetch_ohlcv(symbol, timeframe, since1day, limit, params) candles1day = mbitmex.fetch_ohlcv(symbol, '1d', since1day) num_candles1day = len(candles1day) ampl_candle1day = candles1day[ num_candles1day - 1][2] - candles1day[num_candles1day - 1][3] freq_candle1day = '{0:.3g}'.format(ampl_candle1day * 0.10) win3.addstr( 3, 1, "1d " + '{}: O: {} H: {} L:{} C:{}'.format( mbitmex.iso8601(candles1day[num_candles1day - 1][0]), candles1day[num_candles1day - 1][1], candles1day[num_candles1day - 1][2], candles1day[num_candles1day - 1][3], candles1day[num_candles1day - 1][4]) + "|" + str(ampl_candle1day) + "|" + str(freq_candle1day) + " ") # Sleep to avoid extra load and/or reaching rate limit mwin3count = 0 win3.refresh() time.sleep(0.5) screen.refresh() win1.refresh() win2.refresh() mwin3count = mwin3count + 1 except ccxt.NetworkError: time.sleep(2) curses.wrapper(main) pass except KeyboardInterrupt: #ws.close() curses.endwin() print("\n \n --- End of Program! Thank You !!! ---") time.sleep(1) sys.exit() # break first streaming sys.exit() # break ccxt requests sys.exit() pass
def __init__(self, refresh_time = 1): # Global information to display self.__version = __version__ # Init windows positions self.term_w = 80 ; self.term_h = 24 self.host_x = 0 ; self.host_y = 0 self.system_x = 0 ; self.system_y = 1 self.cpu_x = 0 ; self.cpu_y = 3 self.load_x = 20; self.load_y = 3 self.mem_x = 41; self.mem_y = 3 self.network_x = 0 ; self.network_y = 9 self.diskio_x = 0 ; self.diskio_y = -1 self.fs_x = 0 ; self.fs_y = -1 self.process_x = 30; self.process_y = 9 self.help_x = 30; self.help_y = 12 self.now_x = 79; self.now_y = 3 self.caption_x = 0 ; self.caption_y = 3 # Init the curses screen self.screen = curses.initscr() if not self.screen: print _("Error: Can not init the curses library.\n") curses.start_color() curses.use_default_colors() curses.noecho() ; curses.cbreak() ; curses.curs_set(0) # Init colors self.hascolors = False if curses.has_colors(): self.hascolors = True # Init FG color BG color curses.init_pair(1, curses.COLOR_WHITE, -1) curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_RED) curses.init_pair(3, curses.COLOR_WHITE, curses.COLOR_GREEN) curses.init_pair(4, curses.COLOR_WHITE, curses.COLOR_BLUE) curses.init_pair(5, curses.COLOR_WHITE, curses.COLOR_MAGENTA) curses.init_pair(6, curses.COLOR_WHITE, curses.COLOR_CYAN) curses.init_pair(7, curses.COLOR_BLACK, curses.COLOR_YELLOW) # Text colors/styles self.title_color = curses.A_BOLD|curses.A_UNDERLINE self.help_color = curses.A_BOLD self.no_color = curses.color_pair(1) self.default_color = curses.color_pair(3)|curses.A_BOLD self.if50pc_color = curses.color_pair(4)|curses.A_BOLD self.if70pc_color = curses.color_pair(5)|curses.A_BOLD self.if90pc_color = curses.color_pair(2)|curses.A_BOLD # By default all the stats are displayed self.network_tag = True self.diskio_tag = True self.fs_tag = True # Init main window self.term_window = self.screen.subwin(0, 0) # Init help panel term_help = self.screen.subwin(self.term_h-self.help_y-2, self.term_w-self.help_x, self.help_y, self.help_x) self.panel_help = curses.panel.new_panel(term_help) self.hideHelp() # Init refresh time self.__refresh_time = refresh_time # Catch key pressed with non blocking mode self.term_window.keypad(1) ; self.term_window.nodelay(1) ; self.pressedkey = -1
def main(argv = None): parser = argparse.ArgumentParser(description="A cross-platform script for creating and playing sound waves through mathematical expressions", prog="calcwave") parser.add_argument('expression', type = str, help = "The expression, in terms of x. When using the command line, it may help to surround it in single quotes. If --gui is specified, use 0 for this parimeter") parser.add_argument("-s", "--start", type = int, default = -100000, help = "The lower range of x to start from.") parser.add_argument("-e", "--end", type = int, default = 100000, help = "The upper range of x to end at.") parser.add_argument("-o", "--export", type = str, default = "", nargs = '?', help = "Export to specified file as wav. File extension is automatically added.") parser.add_argument("--channels", type = int, default = 1, help = "The number of audio channels to use") parser.add_argument("--rate", type = int, default = 44100, help = "The audio rate to use") parser.add_argument("--buffer", type = int, default = 1024, help = "The audio buffer frame size to use. This is the length of the list of floats, not the memory it will take.") parser.add_argument("--gui", default = False, action = "store_true", help = "Start with the GUI") if argv is None: argv = sys.argv # The class that is passed to other threads and holds # information about how to play sound and act tArgs = threadArgs() isGuiArgument = False isExportArgument = False isExpressionProvided = False args = None if len(sys.argv) > 1: args = parser.parse_args() #Parse arguments #Set variables tArgs.expression = args.expression tArgs.start = args.start tArgs.end = args.end tArgs.channels = args.channels tArgs.rate = args.rate tArgs.frameSize = args.buffer isExportArgument = args.export != "" isGuiArgument = args.gui isExpressionProvided = args.expression != "" # Initialize AudioPlayer audioClass = AudioPlayer(tArgs) window = None scr = None menu = None #The program may be started either in GUI mode or CLI mode. Test for GUI mode vvv if len(sys.argv) == 1 or isGuiArgument or not(isExportArgument or isExpressionProvided): #If no arguments are supplied - GUI if isExpressionProvided: tArgs.expression = args.expression sys.stderr.write("Starting GUI mode\n") tArgs.isGUI = True scr = curses.initscr() rows, cols = scr.getmaxyx() if curses.has_colors(): curses.start_color() curses.use_default_colors() # ySize, xSize, yStart, xStart menu = UIManager(2, cols, rows - 4, 0, tArgs, audioClass) #Start the GUI input thread window = WindowManager(tArgs, scr, menu) tArgs.expression = "0" # Default value else: tArgs.isGUI = False if len(sys.argv) >= 1 and isExportArgument: exportAudio(args.export, tArgs, None, None) else: # Keep in mind that menu will be None when it is not in GUI mode... audioClass.play() # When that exits tArgs.shutdown = True if window: window.thread.join()
def init(): global scr scr = curses.initscr() curses.start_color() scr.keypad(False) curses.noecho()
# NOTE: The screen goes away if an exception is raised, getting rid of potentially # useful information. Maybe we should "save" the screen and display it before # re-raising the exception. ALL_FG_COLORS = ('black', 'blue', 'green', 'cyan', 'red', 'magenta', 'yellow', 'white', 'light black', 'light blue', 'light green', 'light cyan', 'light red', 'light magenta', 'light yellow', 'light white') ALL_BG_COLORS = ('black', 'blue', 'green', 'cyan', 'red', 'magenta', 'yellow', 'white') _ALL_CURSES_COLORS = [curses.COLOR_BLACK, curses.COLOR_BLUE, curses.COLOR_GREEN, curses.COLOR_CYAN, curses.COLOR_RED, curses.COLOR_MAGENTA, curses.COLOR_YELLOW, curses.COLOR_WHITE] # Initialize the curses library _G_SCR = curses.initscr() # Initialize the screen. curses.start_color() # Initialize colors. # Initialize all the color pairs: ALL_COLOR_PAIRS = {} for fgi, fgc in enumerate(_ALL_CURSES_COLORS): for bgi, bgc in enumerate(_ALL_CURSES_COLORS): colorPairNum = 1 + (fgi + (bgi * 8)) ALL_COLOR_PAIRS[(ALL_FG_COLORS[fgi], ALL_BG_COLORS[bgi])] = colorPairNum curses.init_pair(colorPairNum, _ALL_CURSES_COLORS[fgc], _ALL_CURSES_COLORS[bgc]) _G_CURRENT_FG_COLOR = 'white' _G_CURRENT_BG_COLOR = 'black' _G_SCR.scrollok(True) # When stuff is printed on the last line, scroll the window. curses.noecho() # Don't echo key presses unless input() has been called. TODO - maybe not even then. _G_SCR.keypad(True) #
def __init__(self, screen, startLevel): self.length = 10 # Cannot be Modified Yet self.height = 20 # Cannot be Modified Yet self.board = None # Game Board Object self.threads = [] # Player and Computer Threads self.lock = threading.RLock() self.screen = screen curses.halfdelay(1) self.rowsToClear = [] # Used By Computer to Draw Row Clear Effects self.board = None # Game Board Object self.level = None self.blocksPlaced = None self.tetrises = None self.triples = None self.doubles = None self.singles = None self.lastCommandTime = None self.extraTime = False self.hasExtraTime = False self.isComplete = False self.isPaused = False self.didLose = False self.isSuspended = False self.startLevel = startLevel ## Calculate Coordinates ## self.spaceCoordinates = [] for x in range(10): for y in range(22): self.spaceCoordinates.append((x, y)) self.spaceCoordinatesReversed = [] for y in range(22): for x in range(10): self.spaceCoordinatesReversed.append((x, y)) self.nextCoordinates = [] self.afterCoordinates = [] for x in range(9): for y in range(2): self.nextCoordinates.append((x, y)) ## Set Up Curses Colors ## curses.curs_set(0) curses.start_color() ### BLOCKS ### curses.init_pair(1, 15, curses.COLOR_BLACK) # No Block / White Text curses.init_pair(2, 15, 39) # Blue Block curses.init_pair(3, 15, 11) # Yellow Block curses.init_pair(4, 15, 208) # Orange Block curses.init_pair(5, 15, 10) # Green Block curses.init_pair(6, 15, 13) # Purple Block curses.init_pair(7, 15, 9) # Red Block curses.init_pair(8, 15, 14) # Cyan Block curses.init_pair(16, 15, 199) # Dead Block curses.init_pair(17, 9, 15) ### TEXT ### curses.init_pair(9, 39, curses.COLOR_BLACK) # Blue Text curses.init_pair(10, 11, curses.COLOR_BLACK) # Yellow Text curses.init_pair(11, 208, curses.COLOR_BLACK) # Orange Text curses.init_pair(12, 10, curses.COLOR_BLACK) # Green Text curses.init_pair(13, 13, curses.COLOR_BLACK) # Purple Text curses.init_pair(14, 9, curses.COLOR_BLACK) # Red Text curses.init_pair(15, 14, curses.COLOR_BLACK) # Cyan Text self.CURSES_COLOR_DICT = { 'O': curses.color_pair(3), 'L': curses.color_pair(2), 'J': curses.color_pair(4), 'S': curses.color_pair(6), 'Z': curses.color_pair(5), 'T': curses.color_pair(8), 'I': curses.color_pair(7), }