socket_console.py

python s60 1.4.5版本的源代码

            self.__write_code(self._el)
            y += 1

        self.__maybe_write_code(self._cnorm)
        
        #self.flushoutput()
        self.screen = screen
        self.move_cursor(cx, cy) # this does self.flushoutput()

    def write_changed_line(self, y, oldline, newline, px):
        # this is frustrating; there's no reason to test (say)
        # self.dch1 inside the loop -- but alternative ways of
        # structuring this function are equally painful (I'm trying to
        # avoid writing code generators these days...)
        x = 0
        minlen = min(len(oldline), len(newline))
        while x < minlen and oldline[x] == newline[x]:
            x += 1
        if oldline[x:] == newline[x+1:] and self.ich1:
            if ( y == self.__posxy[1] and x > self.__posxy[0]
                 and oldline[px:x] == newline[px+1:x+1] ):
                x = px
            self.__move(x, y)
            self.__write_code(self.ich1)
            self.__write(newline[x])
            self.__posxy = x + 1, y
        elif x < minlen and oldline[x + 1:] == newline[x + 1:]:
            self.__move(x, y)
            self.__write(newline[x])
            self.__posxy = x + 1, y
        elif (self.dch1 and self.ich1 and len(newline) == self.width
              and x < len(newline) - 2
              and newline[x+1:-1] == oldline[x:-2]):
            self.__move(self.width - 2, y)
            self.__posxy = self.width - 2, y
            self.__write_code(self.dch1)
            self.__move(x, y)
            self.__write_code(self.ich1)
            self.__write(newline[x])
            self.__posxy = x + 1, y
        else:
            self.__move(x, y)
            if len(oldline) > len(newline):
                self.__write_code(self._el)
            self.__write(newline[x:])
            self.__posxy = len(newline), y
        #self.flushoutput() # removed for efficiency

    def __write(self, text):
        self.__buffer.append((text, 0))

    def __write_code(self, fmt, *args):
        self.__buffer.append((curses.tparm(fmt, *args), 1))

    def __maybe_write_code(self, fmt, *args):
        if fmt:
            self.__write_code(fmt, *args)

    def __move_y_cuu1_cud1(self, y):
        dy = y - self.__posxy[1]
        if dy > 0:
            self.__write_code(dy*self._cud1)
        elif dy < 0:
            self.__write_code((-dy)*self._cuu1)

    def __move_y_cuu_cud(self, y):
        dy = y - self.__posxy[1]
        if dy > 0:
            self.__write_code(self._cud, dy)
        elif dy < 0:
            self.__write_code(self._cuu, -dy)

    def __move_x_hpa(self, x):
        if x != self.__posxy[0]:
            self.__write_code(self._hpa, x)

    def __move_x_cub1_cuf1(self, x):
        dx = x - self.__posxy[0]
        if dx > 0:
            self.__write_code(self._cuf1*dx)
        elif dx < 0:
            self.__write_code(self._cub1*(-dx))

    def __move_x_cub_cuf(self, x):
        dx = x - self.__posxy[0]
        if dx > 0:
            self.__write_code(self._cuf, dx)
        elif dx < 0:
            self.__write_code(self._cub, -dx)

    def __move_short(self, x, y):
        self.__move_x(x)
        self.__move_y(y)

    def __move_tall(self, x, y):
        assert 0 <= y - self.__offset < self.height, y - self.__offset
        self.__write_code(self._cup, y - self.__offset, x)

    def move_cursor(self, x, y):
        if y < self.__offset or y >= self.__offset + self.height:
            self.event_queue.insert(Event('scroll', None))
        else:
            self.__move(x, y)
            self.__posxy = x, y
            if not self.isbusy():
                self.flushoutput()

    def prepare(self):
        self.screen = []
        self.height, self.width = self.getheightwidth()

        self.__buffer = []
        
        self.__posxy = 0, 0
        self.__gone_tall = 0
        self.__move = self.__move_short
        self.__offset = 0

        self.__maybe_write_code(self._rmkx) # Turn off application cursor mode.

    def restore(self):
        # We never put the cursor keys in application mode, so this
        # is redundant now:
        #self.__maybe_write_code(self._rmkx) 
        self.flushoutput()

    def __sigwinch(self, signum, frame):
        self.height, self.width = self.getheightwidth()
        self.event_queue.insert(Event('resize', None))

    def isbusy(self):
        return self.busy

    def get_event(self, block=1):        
        while self.event_queue.empty():
            chars = self._osread(self.MAX_READ)
#            try:
#            except EOFError:
#                raise
#            except:
#                print >>sys.stderr,"Exception!"
#                import traceback
#                traceback.print_exc()
#                raise
            for c in chars:
                self.event_queue.push(c)
            if not block:
                break
        self.busy=len(self.event_queue.events)>1
        return self.event_queue.get()

    def wait(self):
        pass 
    #self.pollob.poll()

    def set_cursor_vis(self, vis):
        if vis:
            self.__maybe_write_code(self._cnorm)
        else:
            self.__maybe_write_code(self._civis)

    def repaint_prep(self):
        if not self.__gone_tall:
            self.__posxy = 0, self.__posxy[1]
            self.__write("\r")
            ns = len(self.screen)*['\000'*self.width]
            self.screen = ns
        else:
            self.__posxy = 0, self.__offset
            self.__move(0, self.__offset)
            ns = self.height*['\000'*self.width]
            self.screen = ns

    def getheightwidth(self):
        return 25, 80

    def forgetinput(self):
        pass

    def flushoutput(self):
        if not self.event_queue.empty():
            return
        if len(self.__buffer)==0:
            return 
        outbuf=[]
        for text, iscode in self.__buffer:
            if iscode:
                outbuf.append(text)
                # we don't use delays here, so we don't need tputs
                # processing.                
                # outbuf.append(self.__tputs(text))
            else:
                outbuf.append(text.encode(self.encoding))
 
        self._oswrite(''.join(outbuf))
        del self.__buffer[:]

    def finish(self):
        y = len(self.screen) - 1
        while y >= 0 and not self.screen[y]:
            y -= 1
        self.__move(0, min(y, self.height + self.__offset - 1))
        self.__write("\n\r")
        self.flushoutput()

    def beep(self):
        self.__maybe_write_code(self._bel)
        self.flushoutput()

    def getpending(self):
        e = Event('key', '', '')
        
        while not self.event_queue.empty():
            e2 = self.event_queue.get()
            e.data += e2.data
            e.raw += e2.raw

        amount = 1000
        raw = unicode(self._osread(amount), self.encoding, 'replace')
        e.data += raw
        e.raw += raw
        return e

    def clear(self):
        self.__write_code(self._clear)
        self.__gone_tall = 1
        self.__move = self.__move_tall
        self.__posxy = 0, 0
        self.screen = []