Console: internal changes

2 files changed, 137 insertions, 144 deletions

diff --git a/services/console/interface/xo/cpu.py b/services/console/interface/xo/cpu.py
index c0dfbfd..c64764b 100644
--- a/services/console/interface/xo/cpu.py
+++ b/services/console/interface/xo/cpu.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+##!/usr/bin/env python
 
 # Copyright (C) 2007, Eduardo Silva (edsiper@gmail.com).
 #
@@ -21,33 +21,32 @@ import sys
 import gtk
 import string
 import gobject
-import drwarea
 
 import procmem
 
 class CPU_Usage:
     
-    CPU_HZ = 0
-    last_jiffies = 0
-    times = 0
-    
+    _CPU_HZ = 0
+    _last_jiffies = 0
+    _times = 0
+
     def __init__(self):
-        self.CPU_hz = os.sysconf(2)
-        
+        self._CPU_HZ = os.sysconf(2)
+
     def _get_CPU_data(self):
         # Uptime info
         stat_file = "/proc/stat"
-        
+
         try:
             infile = file(stat_file, "r")
         except:
             print "Error trying uptime file"
             return -1
-            
+
         stat_line = infile.readline()
         cpu_info = string.split(stat_line, ' ')
         infile.close()
-                    
+
         return cpu_info
     
     def _get_CPU_usage(self):
@@ -56,13 +55,13 @@ class CPU_Usage:
         
         used_jiffies = (int(cpu_info[2]) + int(cpu_info[3]) + int(cpu_info[4]))
         
-        if self.times ==0:
-            self.last_jiffies = used_jiffies
-            self.times +=1
-            return True
-        
-        new_ujiffies = (used_jiffies - self.last_jiffies)
-        new_ajiffies = ((self.frequency/1000) * self.CPU_hz)
+        if self._times ==0:
+            self._last_jiffies = used_jiffies
+            self._times +=1
+            return 0
+
+        new_ujiffies = (used_jiffies - self._last_jiffies)
+        new_ajiffies = ((self.frequency/1000) * self._CPU_HZ)
 
         if new_ajiffies <= 0:
             pcpu = 0.0
@@ -71,186 +70,184 @@ class CPU_Usage:
 
         if pcpu >100:
             pcpu = 100
-            
-        self.times +=1
-        self.last_jiffies = used_jiffies
+
+        self._times +=1
+        self._last_jiffies = used_jiffies
         
         return pcpu
-        
+
 class XO_CPU(gtk.Frame):
-    
-    context = None
-    frequency_timer = 1
-    graph_offset = 7        
-        
+    _frequency_timer = 1
+
     def __init__(self):
         gtk.Frame.__init__(self, 'System CPU Usage')
         self.set_border_width(10)
 
         self._updated = False
-        self.drw_width = (gtk.gdk.screen_width() * 99 / 100) - 50
-        self.drw_height = (gtk.gdk.screen_height() * 15 / 100) - 20
+        width = (gtk.gdk.screen_width() * 99 / 100) - 50
+        height = (gtk.gdk.screen_height() * 15 / 100) - 20
 
-        self.y_cpu = self.drw_height - self.graph_offset
-        self._cpu = 0
-        self._cpu_buffer = [0]
+        self._graphic = HorizontalGraphic()
+        self._graphic.set_size_request(width, height)
 
-        self._drawingarea = gtk.DrawingArea()
-        self._drawingarea.set_size_request(self.drw_width, self.drw_height)
-        self._drawingarea.connect("expose-event", self.do_expose)
-
-        self.dat = drwarea.Drawing_Area_Tools(self._drawingarea)
-        
         fixed = gtk.Fixed()
         fixed.set_border_width(10)
-        fixed.add(self._drawingarea)
-        
+        fixed.add(self._graphic)
+
         self.add(fixed)
-        
+
         self._DRW_CPU = CPU_Usage()
         self._DRW_CPU.frequency = 1000 # 1 Second
 
         gobject.timeout_add(self._DRW_CPU.frequency, self._update_cpu_usage)
 
     def _update_cpu_usage(self):
-        
-        redraw_all = False
-        
-        # end of the drawing area
-        if ((self.frequency_timer + 1)*self.graph_offset) >= (self.drw_width - self.graph_offset):
-            self.frequency_timer = 1
-            self._cpu_buffer = [self._cpu_buffer[-1]]
-            redraw_all = True
-            length = 1
-        else:
-            length = len(self._cpu_buffer) - 1
-
         self._cpu = self._DRW_CPU._get_CPU_usage()
-        self._cpu_buffer.append(self._cpu)
-
         self._updated = True
 
-        if redraw_all:
-            area_x = 0
-            area_width = self.drw_width
-        else:
-            area_x = (length*self.graph_offset)
-            area_width = self.graph_offset*2
-
-        self._drawingarea.queue_draw_area(area_x, 0, area_width, self.drw_height - 5)
-        self.frequency_timer += 1
-
+        #print "Sending: " + str(self._cpu)
+        self.set_label('System CPU Usage: ' + str(self._cpu) + '%')
+        self._graphic.draw_value(self._cpu)
         return True
-    
-    def _get_y_cpu(self, pcpu):
 
-        height = (self.dat.range_y['to']) - (self.dat.range_y['from'])
-        
-        # Get percent of cpu usage
-        y_value	= (height - ((pcpu*height)/100) + 4)
+class HorizontalGraphic(gtk.DrawingArea):
+    _MARGIN = 5
+    _LINE_WIDTH = 2
+    _GRAPH_OFFSET = 7
+    _range_x = []
+    _range_y = []
+    _frequency_timer = 0
 
-        return int(y_value) 
+    def __init__(self):
+        gtk.DrawingArea.__init__(self)
+        self.connect('expose-event', self.do_expose)
+        self.connect('size-allocate', self._change_size_cb)
+
+        self._buffer = [0]
     
     def do_expose(self, widget, event):
-        context = widget.window.cairo_create()        
-
-        context.rectangle(0, 0, self.dat.width - 1, self.dat.height - 1)
+        context = widget.window.cairo_create()
+        context.rectangle(0, 0, self._width - 1, self._height - 1)
         context.set_source_rgb (0,0,0)
         context.fill_preserve()
+        context.set_line_width(self._LINE_WIDTH)
 
         if event.area.x == 0:
             draw_all = True
+
+            self._draw_border_lines(context)
+            context.stroke()            
         else:
             draw_all = False
+            context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)
+            context.clip()
 
-        context.rectangle(event.area.x, event.area.y, event.area.width, event.area.height)
-        context.clip()
-
-        # Drawing horizontal and vertical border lines
-        self.dat.draw_border_lines(context)
-            
-        # Drawing grid
-        line_margin = self.dat.margin
         context.set_source_rgb(1, 1, 1)
-        context.set_line_width(1)
-        #self.draw_grid(context, event, line_margin + 1, line_margin + 1, self.dat.width - line_margin - 2, self.dat.height - line_margin - 2)
-
         self._draw_buffer(event, widget, context, draw_all)
-
-        cpu_label = str(round(self._cpu, 4))
-        self.set_label('System CPU Usage: ' + cpu_label + ' %')
+        context.stroke()
 
         self._updated = False
         return False
 
-    # Draw a grid
-    def draw_grid(self, context, event, init_x, init_y, end_x, end_y):
-    
-        x_range = (end_x - init_x) + 5
-        y_range = (end_y - init_y) + 1
-        
-        current_y = init_y
-        context.set_line_width(0.3)
-        
-        #for y in range(y_range):
-        for y in range(0, y_range, 20):
-            if (y%20) == 0:
-                context.move_to(init_x, y)
-                context.line_to(end_x, y)
-
-        for x in range(0, x_range, 20):
-            if (x%20) == 0:
-                context.move_to(x, init_y)
-                context.line_to(x, end_y)
-        
-        context.stroke()
-    
-    def check_context(self, event, offset, length, freq):
-        print "CONTEXT ALLOWED - from: " + str(event.area.x) + " to: " + str(event.area.x+event.area.width)
-        
-        if event.area.x != (freq*self.graph_offset):
-            print "************************"
-            print " ERROR DRAWING CONTEXT"
-            print " ---> Area X: " + str(event.area.x) + " To X: " + str(freq*self.graph_offset)
-            print "************************"
-            
+    def draw_value(self, percent):
+        redraw_all = False
+
+        if (len(self._buffer) + 1) *self._GRAPH_OFFSET >= self._width:
+            redraw_all = True
+            self._buffer = [self._buffer[-1]]
+            length = 1
+        else:
+            length = len(self._buffer) - 1
+
+        self._buffer.append(percent)
+        self._updated = True
+
+        if redraw_all:
+            area_x = 0
+            area_y = 0
+            height = self._height
+            width = self._width
+        else:
+            area_x = (length*self._GRAPH_OFFSET)
+            area_y = self._graph_y
+            width = self._GRAPH_OFFSET * 2
+            height = self._graph_height
+
+        self.queue_draw_area(area_x, area_y, width, height)
+        self._frequency_timer += 1
+
+        return True
+
+    def _draw_border_lines(self, context):
+        context.set_source_rgb(1, 1, 1)
+        self._draw_line(context, self._MARGIN, self._MARGIN, self._MARGIN, self._height - self._MARGIN)
+        self._draw_line(context, self._MARGIN, self._height - self._MARGIN - 1, self._width - self._MARGIN, self._height - self._MARGIN - 1)
+
+    def _draw_line(self, context, from_x, from_y, to_x, to_y):               
+        #print ""
+        #print "DRAWING LINE"
+        #print "from: " + str(from_x) + "," + str(from_y) + "," + str(to_x) + "," + str(to_y)
+
+        context.move_to(from_x, from_y)
+        context.line_to(to_x, to_y)         
+
     def _draw_buffer(self, event, drwarea, context, draw_all=True):
         buffer_offset = 0
         freq = 1 # Frequency timer
 
-        length = len(self._cpu_buffer)
+        length = len(self._buffer)
         
         if length == 0:
             return
-        
+
         # Context properties
-        context.set_line_width(2)
+        context.set_line_width(self._LINE_WIDTH)
         context.set_source_rgb(0,1,0)
-        
+
         if draw_all == True:
             buffer_offset = 0
             freq = 0
         else:
-            freq = buffer_offset = (event.area.x/self.graph_offset)
+            freq = buffer_offset = (event.area.x/self._GRAPH_OFFSET)
 
-        for pcpu in self._cpu_buffer[buffer_offset:length]:
+        for percent in self._buffer[buffer_offset:length]:
             if buffer_offset == 0:
-                from_y = self.drw_height - self.graph_offset
-                from_x = self.graph_offset
+                from_y = self._height - self._GRAPH_OFFSET
+                from_x = self._GRAPH_OFFSET
             else:
-                from_y = self._get_y_cpu(self._cpu_buffer[buffer_offset-1])
-                from_x = (freq * self.graph_offset)
-            
-    
-            to_x = (freq+1) * self.graph_offset
-            to_y = self._get_y_cpu(pcpu)
-                
-            # Debug context, just for development
-            #self.check_context(event, buffer_offset, length, freq)
-            
-            self.dat.draw_line(context, from_x, from_y, to_x, to_y)
+                from_y = self._get_y(self._buffer[buffer_offset-1])
+                from_x = (freq * self._GRAPH_OFFSET)
+
+            to_x = (freq+1) * self._GRAPH_OFFSET
+            to_y = self._get_y(percent)
+
+            self._draw_line(context, from_x, from_y, to_x, to_y)
             buffer_offset+=1
             freq+=1
-        
+
         context.stroke()
 
+    def _get_y(self, percent):
+        y_value = self._GRAPH_OFFSET + (self._graph_height - ((percent*self._graph_height)/100))
+        return int(y_value) 
+
+    def _change_size_cb(self, widget, allocation):
+        self._width = allocation.width
+        self._height = allocation.height
+
+        self._graph_x = self._MARGIN + self._LINE_WIDTH
+        self._graph_y = self._MARGIN + self._LINE_WIDTH
+        self._graph_width = self._width - (self._MARGIN + self._LINE_WIDTH)
+        self._graph_height = self._height - ((self._MARGIN + self._LINE_WIDTH)*2)
+
+
+# Just for test >:)
+#graph = HorizontalGraphic()
+#graph.set_size_request(400,200)
+"""
+window = gtk.Window()
+window.set_size_request(500, 250)
+window.add(XO_CPU())
+window.show_all()
+gtk.main()
+"""
diff --git a/services/console/interface/xo/drwarea.py b/services/console/interface/xo/drwarea.py
index 996e686..e896b1f 100644
--- a/services/console/interface/xo/drwarea.py
+++ b/services/console/interface/xo/drwarea.py
@@ -39,9 +39,6 @@ class Drawing_Area_Tools:
         self.width	= drwarea_size[0]
         self.height	= drwarea_size[1]
 
-        # print "width %i" % self.width
-        # print "height %i" % self.height
-        
         self.range_x = {'from': self.margin+2, 'to': self.width - (self.margin+2)}
         self.range_y = {'from': self.margin+2, 'to': self.height - (self.margin+2)}
                 
@@ -54,4 +51,3 @@ class Drawing_Area_Tools:
         self.draw_line(context, self.margin, self.margin, self.margin, self.height - self.margin)
         self.draw_line(context, self.margin, self.height - self.margin - 1, self.width - self.margin, self.height - self.margin - 1)
         context.stroke()
-        
\ No newline at end of file