Python Window.clear方法代码示例

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import clear [as 别名]
class Revisao:
    """Calsse que executa o programa criado na aula de revisão."""

    def setup(self, width, height, bg=color.BLACK):
        self.window = Window(width, height)
        self.objects = []
        self.background = bg

    def add_object(self, object):
        self.objects.append(object)

    def run(self):
        clock = pygame.time.Clock()
        running = True
        while running:
            # handle events
            for evt in pygame.event.get():
                if evt.type == pygame.QUIT:
                    running = False
                    continue
            # update objects
            for obj in self.objects:
                obj.update(self.window.size)
            # clear window.
            self.window.clear(self.background)
            # draw objects
            for obj in self.objects:
                self.window.draw(obj)
            # update window
            self.window.update()
            # ensure maximum speed
            clock.tick(240)

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import clear [as 别名]
def main(screen):

   # setup the basic syntax for text files
   text_syntax = SyntaxClass("basic")
   text_syntax.add("character", r".")
   text_syntax.add("word", r" ")
   text_syntax.add("sentance", r"\.")

   # make the main window 
   mainwin = Window(screen, FileBuffer(open("README.markdown")))
   mainwin.render()

   # the event loop
   while True: 
      event = screen.getch()
      if event == ord("q"): break 
      
      if event == ord("e"): mainwin.clear()
      if event == ord("r"): mainwin.render()
      if event == ord("f"): mainwin.addstr("X")
      if event == ord("w"): mainwin.rmove(0, -1)
      if event == ord("a"): mainwin.rmove(-1, 0)
      if event == ord("s"): mainwin.rmove(0, +1)
      if event == ord("d"): mainwin.rmove(+1, 0)
      if event == ord("x"): mainwin.here()

      
      def find(syntaxname):
         return lambda t, x, y: text_syntax.find(syntaxname, t, x, y)

      if event == ord("c"): mainwin.movef(find("character"))
      if event == ord("v"): mainwin.movef(find("word"))

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import clear [as 别名]
class GlutWindow(object):
    def __init__(self, width, height, title):
        super(GlutWindow, self).__init__()
        self.width = width
        self.height = height
        self.title = title

        self.texture_id = 0
        self.vertices = None

        self.pixels = np.zeros(self.width * self.height)
        self.window = Window(self.width, self.height, self.pixels)

        self.setup()

    def mouse_event(self, button, state, x, y):
        self.window.mouse_event(button, state, x, y)

    def key_event(self, key, key_is_down, x, y):
        key = ord(key)
        self.window.key_event(key, key_is_down)

    def key_down(self, key, x, y):
        self.key_event(key, True, x, y)

    def key_up(self, key, x, y):
        self.key_event(key, False, x, y)

    def setup(self):
        self.setup_glut()
        self.setup_gl()

    def setup_glut(self):
        # glutInit(sys.argv)
        glutInit()
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA)
        glutInitWindowSize(self.width, self.height)

        glutCreateWindow(self.title)
        glutDisplayFunc(self.show)

        glutMouseFunc(self.mouse_event)

        glutKeyboardFunc(self.key_down)
        glutKeyboardUpFunc(self.key_up)
        # glutSetKeyRepeat(GLUT_KEY_REPEAT_ON)

    def setup_gl(self):
        glEnable(GL_BLEND)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

        glClearColor(0, 0, 0, 1)
        glViewport(0, 0, self.width, self.height)

        self.texture_id = glGenTextures(1)
        glEnable(GL_TEXTURE_2D)
        glBindTexture(GL_TEXTURE_2D, self.texture_id)
        # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
        # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height,
                     0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, self.pixels)

        self.vertices = [
            # (u, v), (x, y, z)
            (0, 0), (-1, -1, 0),
            (1, 0), (1, -1, 0),
            (1, 1), (1, 1, 0),
            (0, 1), (-1, 1, 0),
        ]

    def update(self, dt=100):
        # clear
        self.clear()

        # update
        delta = dt / 1000.0
        self.window.update(delta)

        # draw
        self.window.draw()

        # show
        glutPostRedisplay()
        glutTimerFunc(dt, self.update, dt)

    def run(self):
        self.update()
        glutMainLoop()

    def clear(self):
        glClear(GL_COLOR_BUFFER_BIT)
        self.window.clear()

    def show(self):
        # update texture and render
        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, self.width, self.height,
                        GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, self.pixels)
#.........这里部分代码省略.........

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import clear [as 别名]
def start_client(sc, origin, pubkey, subkey, channel):
    global MSG_CURSOR
    global AUTO_PUBLISH

    # Set locale encoding
    import locale
    locale.setlocale(locale.LC_ALL, '')
    code = locale.getpreferredencoding()

    MAXY, MAXX = sc.getmaxyx()

    curses.use_default_colors()
    curses.init_pair(1, curses.COLOR_WHITE, COLOR_DEFAULT)
    curses.init_pair(2, curses.COLOR_CYAN, COLOR_DEFAULT)
    curses.init_pair(3, curses.COLOR_YELLOW, COLOR_DEFAULT)
    curses.init_pair(4, curses.COLOR_MAGENTA, COLOR_DEFAULT)

    # Check for min terminal height
    if MAXY < 46:
        sc.addstr(0, 0, "Your terminal window is too small. Please make it taller and try again. Press any key to continue...", curses.color_pair(3))
        sc.getch()
        return 1

    draw_header(sc, origin, pubkey, subkey, channel)

    # Draw winows
    sub_win = Window(sc, HEADER_LINES + 1, SUB_WINDOW_LINES, "Messages:")
    presence_win = Window(sc, HEADER_LINES + SUB_LINES + PUB_LINES + 1, PRESENCE_LINES, "Presence:")
    history_win = Window(sc, HISTORY_Y, HISTORY_LINES, "History:")

    # Draw Subscribe controls
    sc.addstr(SUB_Y, 22, "Scroll", curses.color_pair(1))
    sc.addch(SUB_Y, 29, curses.ACS_UARROW, curses.color_pair(2))
    sc.addch(SUB_Y, 31, curses.ACS_DARROW, curses.color_pair(2))

    # Draw history controls
    sc.addstr(HISTORY_Y, 10, "Refresh", curses.color_pair(1))
    sc.addstr(HISTORY_Y, 18, "(h)", curses.color_pair(2))
    sc.addstr(HISTORY_Y, 22, "Scroll", curses.color_pair(1))
    sc.addstr(HISTORY_Y, 29, "(j)", curses.color_pair(2))
    sc.addstr(HISTORY_Y, 33, "(k)", curses.color_pair(2))

    # Draw publish controls
    sc.addstr(PUB_Y, 0, "Publish:          Re-Publish last", curses.color_pair(1))
    sc.addstr(PUB_Y, 9, "(Ctrl-G)", curses.color_pair(2))
    sc.addstr(PUB_Y, 34, "(r)", curses.color_pair(2))
    auto_publish_state(sc, "info")

    pub_win, pub_text = draw_pubbox(sc)

    # Setup stdscr
    sc.refresh()
    sub_win.refresh()
    pub_win.refresh()
    presence_win.refresh()
    history_win.refresh()

    logger = threading.Thread(target=message_log, args=(sub_win,))
    logger.daemon=True
    logger.start()

    log_parser = threading.Thread(target=parse_logs, args=(sc,))
    log_parser.daemon = True
    log_parser.start()

    subscriber = threading.Thread(target=subscribe, args=(origin, subkey, channel))
    subscriber.daemon = True
    subscriber.start()

    presence_thread = threading.Thread(target=presence, args=(origin, subkey, channel, presence_win))
    presence_thread.daemon = True
    presence_thread.start()

    history(origin, subkey, channel, history_win)

    while True:
        cmd = sc.getch()

        if cmd == ord('q'):
            break

        # Clear windows
        elif cmd == ord('c'):
            sub_win.clear()
            history_win.clear()
            presence_win.clear()

        elif cmd == ord('p'):
            #TODO: redrawing all is overkill
            pub_win, pub_text = draw_pubbox(sc)
            publish(origin, pubkey, subkey, channel, pub_text.edit())

        # Re-publish
        elif cmd == ord('r'):
            publish(origin, pubkey, subkey, channel, pub_text.gather())

        # Subscribe pane scrolling
        elif cmd == curses.KEY_UP:
            sub_win.scroll(-1)
        elif cmd == curses.KEY_DOWN:
#.........这里部分代码省略.........

# 需要导入模块: from window import Window [as 别名]
# 或者: from window.Window import clear [as 别名]
class Pong(Game):
    """Implements the pong game."""

    def __init__(self, player1, player2):
        """Initialize the game."""
        Game.__init__(self)
        self.__ball = GameBall(400, 300, 10)
        self.__restart_ball()
        self.__paddles = [Paddle((20, 150), (5, 260), (200, 200, 200)),
                          Paddle((20, 150), (775, 260), (200, 200, 200))]
        self.window = Window(800, 600)
        self.window.set_title("Pong")
        self.add_object(self.__ball)
        for p in self.__paddles:
            self.add_object(p)
        self.__scores = [0, 0]
        self.digits = [Text(i, 48) for i in range(10)]

    def __restart_ball(self):
        self.__ball.position = (400, 300)
        self.__ball.movement = (choice([-0.5, 0.5]), choice([-0.5, 0.5]))

    def __ball_collision(self):
        c = collider.wall_circle_collision(self.window.bounds,
                                           self.__ball.bounds)
        dx, dy = self.__ball.movement
        dy *= -1 if {Wall.NORTH, Wall.SOUTH} & c else 1
        # paddles
        sx = -1 if dx < 0 else 1
        for p in self.__paddles:
            if collider.circle_rect_colision(self.__ball.bounds, p.bounds):
                dx = -1 * sx * (abs(dx) + 0.1)
        self.__ball.movement = (dx, dy)
        # walls
        if Wall.WEST in c:
            self.__scores[0] += 1
            self.__restart_ball()
        if Wall.EAST in c:
            self.__scores[1] += 1
            self.__restart_ball()

    def __paddle_collision(self):
        for p in self.__paddles:
            dx, dy = p.movement
            if collider.wall_rect_collision(self.window.bounds, p.bounds):
                dy *= -1
            p.movement = (dx, dy)

    def _update(self):
        """Update objects."""
        self.__ball_collision()
        self.__paddle_collision()
        Game._update(self)

    def _draw(self):
        self.window.clear()
        third = self.window.width // 3
        for i, s in enumerate(self.__scores):
            x = (2 - i)*third
            for c in str(s):
                d = self.digits[int(c)]
                d.position = (x, 5)
                x += d.rect.width + 2
                self.window.draw(d)
        Game._draw(self, False)