network graph fix

plugins/NetworkGraph/tab_graph.py

@@ -0,0 +1,117 @@
+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()