customwidgets.py

来自「bittorrent source by python. please enj」· Python 代码 · 共 519 行 · 第 1/2 页

            "line color"     : wx.NamedColour("blue"),
            "remaining color": wx.NamedColour("white"),
            "transferring color": wx.NamedColour("yellow"),
            "missing color": wx.Colour(255, 0, 0),
            "rare colors": [wx.Colour(185, 185, 185),
                            wx.Colour(195, 195, 195),
                            wx.Colour(205, 205, 205),
                            wx.Colour(215, 215, 215),
                            wx.Colour(225, 225, 225),
                            wx.Colour(235, 235, 235),
                            wx.Colour(245, 245, 245),
                            wx.Colour(255, 255, 255)]
            }

        self.gauge_theme = new_green

        wx.Window.__init__(self, parent, size=size, **k)
        #wx.Gauge.__init__(self, parent, 0, 10000, style=wx.GA_SMOOTH)
        ListCtrlPassThrough.__init__(self, parent)
        if border_color == None:
            border_color = self.gauge_theme["border color"]
        if completed_color == None:
            completed_color = self.gauge_theme["completed color"]
        if remaining_color == None:
            remaining_color = self.gauge_theme["remaining color"]
        self.completed_color = completed_color
        self.remaining_color = remaining_color
        self.border_color = border_color
        self.border = border
        self.line_color = self.gauge_theme["line color"]
        self.top_line = top_line
        self.smoother = wx.BitmapFromImage(
            wx.GetApp().theme_library.get(("progressbar",)))
        self.percent = None
        ScaledBufferMixin.__init__(self)

    def invalidate(self):
        pass

    def SetValue(self, value, state=None, data=None, redraw=True):
        #wx.Gauge.SetValue(self, value * 10000)
        if value != self.percent:
            self.percent = value
            self.redraw()

    def OnPaint(self, event):
        dc = wx.PaintDC(self)
        rect = self.GetClientRect()

        if self.border:
            dc.SetPen(wx.Pen(self.border_color))
            dc.SetBrush(wx.TRANSPARENT_BRUSH)
            dc.DrawRectangle(0, 0, rect.width, rect.height)
            rect = wx.Rect(rect.x + 1, rect.y + 1,
                           rect.width - 2, rect.height - 2)

        _ScaleBlit(self.buffer, dc, rect)

    def draw(self, dc, size):
        srect = wx.Rect(0, 0, size.width, size.height)
        self.draw_bar(dc, srect)

        # dear god, I hope it's smooth
        if self.gauge_theme["smooth"]:
            dc.SetClippingRegion(srect.x, srect.y, srect.width, srect.height)
            _ScaleBlit(self.smoother, dc,
                       wx.Rect(0, 0, srect.width, srect.height))

        # top-line
        if self.top_line and self.percent is not None:
            dc.SetBrush(wx.TRANSPARENT_BRUSH)
            dc.SetPen(wx.Pen(self.line_color))
            line_width = 1
            # top:
            line_position = 0
            # middle:
            #line_position = (srect.height) // 2
            # bottom:
            #line_position = srect.height - line_width
            dc.DrawRectangle(srect.x, line_position,
                             srect.width * self.percent, line_width)
            dc.SetPen(wx.Pen(self.border_color))
            dc.DrawRectangle(srect.x + srect.width * self.percent, line_position,
                             srect.width, line_width)

    def draw_bar(self, dc, rect):
        if self.percent == None:
            return 0
        dc.SetPen(wx.TRANSPARENT_PEN)
        dc.SetBrush(wx.Brush(self.remaining_color))
        dc.DrawRectangle(rect.x, rect.y,
                         rect.width, rect.height)
        dc.SetBrush(wx.Brush(self.completed_color))
        dc.DrawRectangle(rect.x, rect.y,
                         rect.width * self.percent, rect.height)
        return 0

REFRESH_MAX_SEC = 3

class FancyDownloadGauge(SimpleDownloadGauge):

    def __init__(self, *args, **kwargs):
        self.resolution = 1000
        self.grouped = DictWithLists()
        self.missing_known = False
        self.last_time = bttime()
        self.last_update = -1
        SimpleDownloadGauge.__init__(self, *args, **kwargs)
        self.transfering_color = self.gauge_theme["transferring color"]
        self.missing_color = self.gauge_theme["missing color"]
        self.SetValue(None, redraw=False)

    def gradient(self, v):
        if v == 0:
            if self.missing_known:
                c = self.missing_color
            else:
                c = self.gauge_theme["rare colors"][0]
        else:
            v = min(v, len(self.gauge_theme["rare colors"]))
            c = self.gauge_theme["rare colors"][v - 1]
        return c

    def invalidate(self):
        self.last_time = 0

    def SetValue(self, percent, state = None, data = None, redraw=True):
        # only draw if progress moved .01% or it's been REFRESH_MAX_SEC seconds
        if self.percent != None:
            if (percent < (self.percent + 0.0001) and
                bttime() < (self.last_time + REFRESH_MAX_SEC)):
                return
        self.last_time = bttime()

        if not redraw:
            return

        p_dirty = False
        if self.percent != percent:
            p_dirty = True
        self.percent = percent

        missing_known = state == "running"
        if self.missing_known != missing_known:
            p_dirty = True
        self.missing_known = missing_known

        if not data:
            # no data. allow future SetValues to continue passing
            # until we get something
            self.last_time = 0 - REFRESH_MAX_SEC
            # draw an empty bar
            data = (0, -1, {})

        length, update, piece_states = data

        self.resolution = length

        if p_dirty or update != self.last_update:
            self.grouped = piece_states
            self.redraw()
        self.last_update = update

    def draw_bar(self, dc, rect):
        # size events can catch this
        if self.percent is None:
            return

        y1 = rect.y
        w = rect.width
        h = rect.height

        if self.resolution <= 0:
            return

        # sort, so we get 0...N, h, t
        keys = self.grouped.keys()
        keys.sort()
        for k in keys:
            v = self.grouped[k]

            if k == 'h':
                c = self.completed_color
            elif k == 't':
                c = self.transfering_color
            else:
                c = self.gradient(k)

            dc.SetPen(wx.TRANSPARENT_PEN)
            dc.SetBrush(wx.Brush(c))

            for (b, e) in v.iterrange():
                b = float(b)
                e = float(e)
                r = float(self.resolution)
                x1 = (b / r) * w
                x2 = (e / r) * w
                # stupid floats
                x1 = int(rect.x + x1)
                x2 = int(rect.x + x2)
                dc.DrawRectangle(x1, y1,
                                 x2 - x1, h)



class ModerateDownloadGauge(FancyDownloadGauge):

    def __init__(self, parent,
                 completed_color=None,
                 remaining_color=None,
                 border_color=None,
                 border=True,
                 size=(0,0),
                 top_line=False,
                 *args, **kwargs):
        FancyDownloadGauge.__init__(self, parent,
                                    completed_color=completed_color,
                                    remaining_color=remaining_color,
                                    border_color=border_color,
                                    border=border,
                                    size=size,
                                    top_line=top_line,
                                    *args, **kwargs)
        self.resolution = 1000

    def sort(a,b):
        if   isinstance(a, str) and isinstance(b, str) : return cmp(a,b)
        elif isinstance(a, int) and isinstance(b, int) : return cmp(b,a)
        elif type(a) == type(''): return -1
        elif type(b) == type(''): return  1

    sort = staticmethod(sort)

    def SetValue(self, value, state=None, data=None, redraw=True):
        if data is not None:
            sorted_data = {}
            length, update, piece_states = data
            self.resolution = length
            keys = piece_states.keys()
            keys.sort(self.sort)
            pos = 0
            have_trans_sparse_set = piece_states.get('h', SparseSet()) + \
                                    piece_states.get('t', SparseSet())
            for k in keys:
                p = piece_states[k]
                if k in ('h','t'):
                    count = len(p)
                else:
                    count = len(p - have_trans_sparse_set)
                if not count:
                    continue
                newpos = pos+count
                s = SparseSet()
                s.add(pos, newpos)
                sorted_data[k] = s
                pos = newpos
            data = (length, update, sorted_data)
        FancyDownloadGauge.SetValue(self, value, state, data, redraw)