118 lines
4.8 KiB
Python
118 lines
4.8 KiB
Python
import gtk
|
|
import pango
|
|
|
|
class GraphTabManager:
|
|
def __init__(self, scrolledWindow, image, pangoLayout, manager):
|
|
self.scrolledWindow = scrolledWindow
|
|
self.image = image
|
|
self.pangoLayout = pangoLayout
|
|
self.manager = manager
|
|
self.length = 60
|
|
|
|
self.width = -1
|
|
self.height = -1
|
|
|
|
self.savedUpSpeeds = []
|
|
self.savedDownSpeeds = []
|
|
|
|
def update_graph_store(self):
|
|
session_info = self.manager.get_state()
|
|
self.savedUpSpeeds.insert(0, session_info['upload_rate'])
|
|
if len(self.savedUpSpeeds) > self.length:
|
|
self.savedUpSpeeds.pop()
|
|
self.savedDownSpeeds.insert(0, session_info['download_rate'])
|
|
if len(self.savedDownSpeeds) > self.length:
|
|
self.savedDownSpeeds.pop()
|
|
|
|
def update_graph_view(self):
|
|
|
|
extraWidth = self.scrolledWindow.get_vscrollbar().get_allocation().width * 1.5
|
|
extraHeight = self.scrolledWindow.get_hscrollbar().get_allocation().height * 1.5
|
|
allocation = self.scrolledWindow.get_allocation()
|
|
allocation.width = int(allocation.width) - extraWidth
|
|
allocation.height = int(allocation.height) - extraHeight
|
|
# Don't try to allocate a size too small, or you might crash
|
|
if allocation.width < 2 or allocation.height < 2:
|
|
return
|
|
|
|
# savedDownSpeeds = [1,2,3,2,1]
|
|
# savedUpSpeeds = [5,8,0,0,1,2]
|
|
|
|
# allocation = self.image.get_allocation()
|
|
# allocation.width = 300
|
|
# allocation.height = 200
|
|
|
|
if not allocation.width == self.width or not allocation.height == self.height:
|
|
# print "New Pixmap!"
|
|
self.width = allocation.width
|
|
self.height = allocation.height
|
|
|
|
self.networkPixmap = gtk.gdk.Pixmap(None, self.width,
|
|
self.height, gtk.gdk.visual_get_system().depth)
|
|
self.image.set_from_pixmap(self.networkPixmap, None)
|
|
self.ctx = self.networkPixmap.cairo_create()
|
|
|
|
self.networkPixmap.draw_rectangle(self.image.get_style().white_gc,True, 0, 0, self.width, self.height)
|
|
|
|
maxSpeed = max(max(self.savedDownSpeeds),max(self.savedUpSpeeds))
|
|
|
|
if maxSpeed == 0:
|
|
return
|
|
|
|
maxSpeed = maxSpeed*1.1 # Give some extra room on top
|
|
|
|
self.drawSpeedPoly(self.savedDownSpeeds, (0.5,1, 0.5, 1.0), maxSpeed, True)
|
|
self.drawSpeedPoly(self.savedDownSpeeds, (0, 0.75,0, 1.0), maxSpeed, False)
|
|
|
|
self.drawSpeedPoly(self.savedUpSpeeds, (0.33,0.33,1.0, 0.5), maxSpeed, True)
|
|
self.drawSpeedPoly(self.savedUpSpeeds, (0, 0, 1.0, 0.75), maxSpeed, False)
|
|
|
|
meanUpSpeed = sum(self.savedUpSpeeds) /len(self.savedUpSpeeds)
|
|
meanDownSpeed = sum(self.savedDownSpeeds)/len(self.savedDownSpeeds)
|
|
shownSpeed = max(meanUpSpeed, meanDownSpeed)
|
|
|
|
import deluge.common
|
|
|
|
self.pangoLayout.set_text(deluge.common.fspeed(shownSpeed))
|
|
self.networkPixmap.draw_layout(self.image.get_style().black_gc,
|
|
4,
|
|
int(self.height - 1 - (self.height*shownSpeed/maxSpeed)),
|
|
self.pangoLayout)
|
|
|
|
self.networkPixmap.draw_line(self.image.get_style().black_gc,
|
|
0,
|
|
int(self.height - (self.height*shownSpeed/maxSpeed)),
|
|
self.width,
|
|
int(self.height - (self.height*shownSpeed/maxSpeed)))
|
|
|
|
self.networkPixmap.draw_rectangle(self.image.get_style().black_gc,False, 0, 0, self.width-1, self.height-1)
|
|
|
|
self.image.queue_draw()
|
|
|
|
def tracePath(self, speeds, maxSpeed):
|
|
lineWidth = 4
|
|
|
|
self.ctx.set_line_width(lineWidth)
|
|
|
|
self.ctx.move_to(self.width + lineWidth,self.height + lineWidth)
|
|
self.ctx.line_to(self.width + lineWidth,int(self.height-(self.height*speeds[0]/maxSpeed)))
|
|
|
|
for i in range(len(speeds)):
|
|
self.ctx.line_to(int(self.width-1-((i*self.width)/(self.length-1))),
|
|
int(self.height-1-(self.height*speeds[i]/maxSpeed)))
|
|
|
|
self.ctx.line_to(int(self.width-1-(((len(speeds)-1)*self.width)/(self.length-1))),
|
|
int(self.height)-1 + lineWidth)
|
|
|
|
self.ctx.close_path()
|
|
|
|
def drawSpeedPoly(self, speeds, color, maxSpeed, fill):
|
|
|
|
self.tracePath(speeds, maxSpeed)
|
|
self.ctx.set_source_rgba(color[0],color[1],color[2], color[3])
|
|
|
|
if fill:
|
|
self.ctx.fill()
|
|
else:
|
|
self.ctx.stroke()
|