diff --git a/measure_devel/audiograb.py b/measure_devel/audiograb.py
diff --git a/measure_devel/config.py b/measure_devel/config.py
index e64c8cf..08bc557 100755
--- a/measure_devel/config.py
+++ b/measure_devel/config.py
@@ -40,9 +40,9 @@ QUIT_BIAS = True
 QUIT_PCM = 70
 
 #Which context is active on start
-# 0 - sound
-# 1 - sensors
-CONTEXT_ACTIVE_START = 0
+# 1 - sound
+# 2 - sensors
+CONTEXT = 1
 
 #How many maximum screenshots Measure will save while recording in Sound context
 SOUND_MAX_WAVE_LOGS = 10
diff --git a/measure_devel/drawwaveform.py b/measure_devel/drawwaveform.py
index 4604a12..2f7df92 100755
--- a/measure_devel/drawwaveform.py
+++ b/measure_devel/drawwaveform.py
@@ -22,377 +22,381 @@ import config  	#This has all the globals
 
 
 class DrawWaveform(gtk.DrawingArea):
-	def __init__(self):
-	
-		gtk.DrawingArea.__init__(self)
-	
-		self.buffers = []
-		self.str_buffer=''
-		self.buffers_temp=[]
-		self.integer_buffer=[]	
-		self.peaks = []
-		self.main_buffers = []
-		self.fftx = []
-
-		self.rms=''
-		self.avg=''
-		self.pp=''	
-		self.count=0
-
-		self.param1= config.WINDOW_H/65536.0
-		self.param2= config.WINDOW_H/2.0	
-		self.y_mag = 3.0
-		self.g = 1  #Gain (not in dB) introduced by Capture Gain and Mic Boost    
-		self._freq_range = 4	#See comment in sound_toolbar.py to see what different ranges are all about
-		self.draw_interval = 10
-		self.num_of_points = 115
-		self.details_iter = 50
-		self.c = 1180
-		self.m = 0.0238
-		self.k = 0.0238
-		self.c2 = 139240	#c squared
-		self.t_x = (int)(config.TEXT_X_M*config.WINDOW_W)
-		self.t_y = (int)(config.TEXT_Y_M*config.WINDOW_H)
-		self.rms = 0
-		self.avg = 0
-		self.Rv = 0
-		self.y_mag_bias_multiplier = 1	#constant to multiply with self.param2 while scaling values 
-		self.log_param1 = ""
-		self.log_param2 = ""
-		self.log_param3 = ""
-		self.log_param4 = ""
-		self.log_param5 = ""
-
-		self._BACKGROUND_LINE_THICKNESS =  0.8
-		self._FOREGROUND_LINE_THICKNESS = 6
-
-		self.logging_status = False
-		self.f = None
-		self.stop = False
-		self.fft_show = False
-		self.side_toolbar_copy = None
-
-		self.scaleX = str( 1.04167/self.draw_interval ) + " ms"
-		self.scaleY = ""
-	
-
-		self._line_gc = None
-		self._back_surf = None		
-		self.pango_context = self.create_pango_context()
-		#self.font_desc = pango.FontDescription('Serif 6')
-		self.expose_event_id = self.connect("expose_event", self._expose)
-	
-	
-	
-		self.pr_time = 0
-		self.MAX_GRAPHS = config.MAX_GRAPHS     #Maximum simultaneous graphs
-	
-		self.graph_show_state=[]
-		self.Xstart =[]
-		self.Ystart = []
-		self.Xend  = []
-		self.Yend  = []
-		self.type   = []
-		self.color  = []
-		self.source    = []
-		self.graph_id = []
-	
-		for x in range (0, self.MAX_GRAPHS):
-			self.graph_show_state.append(False)
-			self.Xstart.append(0)
-			self.Ystart.append(50)
-			self.Xend.append(1000)
-			self.Yend.append(500)
-			self.type .append(0)
-			self.color.append([65535,0,0])
-			self.source.append(0)
-			self.graph_id.append(x)
-	
-		self.graph_show_state[0]=True
-		self.Xstart[0] = 0
-		self.Ystart[0] = 0
-		self.Xend[0] = 1100
-		self.Yend[0] = 800
-		self.type[0]  = 0
-		self.color[0]  = [65535,0,65535]
-		self.source[0] = 0
-	
-		"""
-		self.graph_show_state[1]=True
-		self.Xstart[0] = 0
-		self.Ystart[1] = 0
-		self.Xend[0] = 800
-		self.Yend[1] = 600
-		self.type[1]  = 0
-		self.color[1]  = [0,65535,65535]
-		self.source[1] = 0
-	
-		self.graph_show_state[2]=True
-		self.Xstart[2] = 30
-		self.Ystart[2] = 0
-		self.Xend[2] = 300
-		self.Yend[2] = 300
-		self.type[2]  = 0
-		self.color[2]  = [0,65535,0]
-		self.source[2] = 0
-	
-		self.graph_show_state[3]=True
-		self.Xstart[3] = 0
-		self.Ystart[3] = 300
-		self.Xend[3] = 1000
-		self.Yend[3] = 700
-		self.type[3]  = 0
-		self.color[3]  = [65535,65535,0]
-		self.source[3] = 0
-		"""
-	
-		self.max_samples = 115
-	
-		self.debug_str="start"
-	
-		self.context = True
-	
-	def new_buffer(self, buf):
-		buf = str(buf)
-		self.str_buffer = buf
-		tmp_val = (self.max_samples - 1)
-		self.integer_buffer = list(unpack( str(int(len(buf))/2)+'h' , buf))		
-		if(len(self.main_buffers)>tmp_val):
-			del self.main_buffers[0:(len(self.main_buffers)-tmp_val)]
-		self.main_buffers += self.integer_buffer
-		return True
-
-	def set_context_on(self):
-		self.handler_unblock(self.expose_event_id)
-		self.context = True
-
-	def set_context_off(self):
-		self.context = False
-		self.handler_block(self.expose_event_id)
-
-
-	def get_drawing_interval(self):
-		"""Returns the pixel interval horizontally between plots of two consecutive points"""
-		return self.draw_interval
-
-
-	def _init_background(self):
-		if self._back_surf:
-			return
-
-		colmap = self.get_colormap()
-		clr = colmap.alloc_color(0, 65535, 0, False, False)
-		self._line_gc = self.window.new_gc(foreground = clr)
-		self._line_gc.set_line_attributes(self._FOREGROUND_LINE_THICKNESS, gdk.LINE_SOLID,\
-			gdk.CAP_ROUND, gdk.JOIN_BEVEL)   
-
-		self._back_surf = gdk.Pixmap(self.window, int(config.WINDOW_W), \
-			int(config.WINDOW_H))
-		cr = self._back_surf.cairo_create()
-			            
-		#background
-		cr.set_source_rgb(0, 0, 0)
-		cr.rectangle(0, 0, config.WINDOW_W, config.WINDOW_H)
-		cr.fill()
-
-		#grid
-		cr.set_line_width(self._BACKGROUND_LINE_THICKNESS)
-		cr.set_source_rgb(0.2, 0.2, 0.2)
-
-		x = 0
-		y = 0
-	
-		for j in range(1, 24):
-			cr.move_to(x, y)
-			cr.rel_line_to(0, config.WINDOW_H)
-			x = x + 50
-
-		cr.set_line_width(self._BACKGROUND_LINE_THICKNESS)
-		x = 0
-		y = 0
-
-		for j in range(1, 17):
-			cr.move_to(x, y)
-			cr.rel_line_to(config.WINDOW_W, 0)
-			y = y + 50
-
-		cr.stroke()	
 
+    def __init__(self):
+
+        gtk.DrawingArea.__init__(self)
+
+        self.buffers = []
+        self.str_buffer=''
+        self.buffers_temp=[]
+        self.integer_buffer=[]	
+        self.peaks = []
+        self.main_buffers = []
+        self.fftx = []
+
+        self.rms=''
+        self.avg=''
+        self.pp=''	
+        self.count=0
+
+        self.param1= config.WINDOW_H/65536.0
+        self.param2= config.WINDOW_H/2.0	
+        self.y_mag = 3.0
+        self.g = 1  #Gain (not in dB) introduced by Capture Gain and Mic Boost    
+        self._freq_range = 4	#See comment in sound_toolbar.py to see what different ranges are all about
+        self.draw_interval = 10
+        self.num_of_points = 115
+        self.details_iter = 50
+        self.c = 1180
+        self.m = 0.0238
+        self.k = 0.0238
+        self.c2 = 139240	#c squared
+        self.t_x = (int)(config.TEXT_X_M*config.WINDOW_W)
+        self.t_y = (int)(config.TEXT_Y_M*config.WINDOW_H)
+        self.rms = 0
+        self.avg = 0
+        self.Rv = 0
+        self.y_mag_bias_multiplier = 1	#constant to multiply with self.param2 while scaling values 
+        self.log_param1 = ""
+        self.log_param2 = ""
+        self.log_param3 = ""
+        self.log_param4 = ""
+        self.log_param5 = ""
+
+        self._BACKGROUND_LINE_THICKNESS =  0.8
+        self._FOREGROUND_LINE_THICKNESS = 6
+
+        self.logging_status = False
+        self.f = None
+        self.stop = False
+        self.fft_show = False
+        self.side_toolbar_copy = None
+
+        self.scaleX = str( 1.04167/self.draw_interval ) + " ms"
+        self.scaleY = ""
+
+
+        self._line_gc = None
+        self._back_surf = None		
+        self.pango_context = self.create_pango_context()
+        #self.font_desc = pango.FontDescription('Serif 6')
+        self.expose_event_id = self.connect("expose_event", self._expose)
+
+
+
+        self.pr_time = 0
+        self.MAX_GRAPHS = config.MAX_GRAPHS     #Maximum simultaneous graphs
+
+        self.graph_show_state=[]
+        self.Xstart =[]
+        self.Ystart = []
+        self.Xend  = []
+        self.Yend  = []
+        self.type   = []
+        self.color  = []
+        self.source    = []
+        self.graph_id = []
+
+        for x in range (0, self.MAX_GRAPHS):
+	        self.graph_show_state.append(False)
+	        self.Xstart.append(0)
+	        self.Ystart.append(50)
+	        self.Xend.append(1000)
+	        self.Yend.append(500)
+	        self.type .append(0)
+	        self.color.append([65535,0,0])
+	        self.source.append(0)
+	        self.graph_id.append(x)
+
+        self.graph_show_state[0]=True
+        self.Xstart[0] = 0
+        self.Ystart[0] = 0
+        self.Xend[0] = 1100
+        self.Yend[0] = 800
+        self.type[0]  = 0
+        self.color[0]  = [65535,0,65535]
+        self.source[0] = 0
+
+        """
+        self.graph_show_state[1]=True
+        self.Xstart[0] = 0
+        self.Ystart[1] = 0
+        self.Xend[0] = 800
+        self.Yend[1] = 600
+        self.type[1]  = 0
+        self.color[1]  = [0,65535,65535]
+        self.source[1] = 0
+
+        self.graph_show_state[2]=True
+        self.Xstart[2] = 30
+        self.Ystart[2] = 0
+        self.Xend[2] = 300
+        self.Yend[2] = 300
+        self.type[2]  = 0
+        self.color[2]  = [0,65535,0]
+        self.source[2] = 0
+
+        self.graph_show_state[3]=True
+        self.Xstart[3] = 0
+        self.Ystart[3] = 300
+        self.Xend[3] = 1000
+        self.Yend[3] = 700
+        self.type[3]  = 0
+        self.color[3]  = [65535,65535,0]
+        self.source[3] = 0
+        """
+
+        self.max_samples = 115
+
+        self.debug_str="start"
+
+        self.context = True
+
+    def new_buffer(self, buf):
+        buf = str(buf)
+        self.str_buffer = buf
+        tmp_val = (self.max_samples - 1)
+        self.integer_buffer = list(unpack( str(int(len(buf))/2)+'h' , buf))		
+        if(len(self.main_buffers)>tmp_val):
+	        del self.main_buffers[0:(len(self.main_buffers)-tmp_val)]
+        self.main_buffers += self.integer_buffer
+        return True
+
+    def set_context_on(self):
+        self.handler_unblock(self.expose_event_id)
+        self.context = True
+
+    def set_context_off(self):
+        self.context = False
+        self.handler_block(self.expose_event_id)
+
+
+    def get_drawing_interval(self):
+        """Returns the pixel interval horizontally between plots of two consecutive points"""
+        return self.draw_interval
+
+
+    def _init_background(self):
+        if self._back_surf:
+	        return
+
+        colmap = self.get_colormap()
+        clr = colmap.alloc_color(0, 65535, 0, False, False)
+        self._line_gc = self.window.new_gc(foreground = clr)
+        self._line_gc.set_line_attributes(self._FOREGROUND_LINE_THICKNESS, gdk.LINE_SOLID,\
+	        gdk.CAP_ROUND, gdk.JOIN_BEVEL)   
+
+        self._back_surf = gdk.Pixmap(self.window, int(config.WINDOW_W), \
+	        int(config.WINDOW_H))
+        cr = self._back_surf.cairo_create()
+	                    
+        #background
+        cr.set_source_rgb(0, 0, 0)
+        cr.rectangle(0, 0, config.WINDOW_W, config.WINDOW_H)
+        cr.fill()
+
+        #grid
+        cr.set_line_width(self._BACKGROUND_LINE_THICKNESS)
+        cr.set_source_rgb(0.2, 0.2, 0.2)
+
+        x = 0
+        y = 0
+
+        for j in range(1, 24):
+	        cr.move_to(x, y)
+	        cr.rel_line_to(0, config.WINDOW_H)
+	        x = x + 50
+
+        cr.set_line_width(self._BACKGROUND_LINE_THICKNESS)
+        x = 0
+        y = 0
+
+        for j in range(1, 17):
+	        cr.move_to(x, y)
+	        cr.rel_line_to(config.WINDOW_W, 0)
+	        y = y + 50
+
+        cr.stroke()	
+
+
+    def _expose(self, widget, event):
+        """This function is the "expose" event handler and does all the drawing"""
+
+        #######################Real time drawing###################################
+        if(self.context == True):
 	
-	def _expose(self, widget, event):
-		"""This function is the "expose" event handler and does all the drawing"""
-
-		#######################Real time drawing###################################
-		if(self.context == True):
-			
-			#Draw the background
-			#We could probably make this faster with another pixmap.
-			self._init_background()
-			self.window.draw_drawable(self.get_style().bg_gc[0], self._back_surf, 0, \
-		0,0, 0, config.WINDOW_W, \
-		config.WINDOW_H)									
-
-		#Iterate for each graph                                                            
-			for graph_id in self.graph_id:              							
-			    if self.graph_show_state[graph_id] == True:        
-					span = self.Xend[graph_id]-self.Xstart[graph_id]
-
-					if self._freq_range == 1:
-						self.draw_interval = 4
-						self.max_samples = span/self.draw_interval
-					else:
-						if span>=700:
-							self.draw_interval = 10
-						elif span<700 and span>=500:
-							self.draw_interval = 7
-						elif span<500 and span>=300:
-							self.draw_interval = 5
-						else:
-							self.draw_interval = 3
-						self.max_samples = span/self.draw_interval
-			        
-					if(self.fft_show==False):				
-						self.y_mag_bias_multiplier = 1					
-			            
-						#Depending upon the X span of the graph, deciding the total number of points to take
-						if(len(self.main_buffers)>=self.max_samples):
-							del self.main_buffers[0:(len(self.main_buffers)-(self.max_samples+1))]
-
-					else:
-						###############FFT################		
-						Fs = 48000
-						nfft = 65536
-						if self.integer_buffer:
-							self.integer_buffer = self.integer_buffer[0:256]
-							self.fftx = fft(self.integer_buffer, 256,-1)
-							self.fftx = self.fftx[0:self.max_samples]
-							self.main_buffers = [(abs(x) * 0.02) for x in self.fftx]
-							self.y_mag_bias_multiplier=0.1
-						##################################
-			                        
-										    
-					#################Getting data######################
-					if self.source[graph_id]==0:
-						self.buffers=self.main_buffers
-					else:
-						pass        #write code here that gets data from file
-					###############################################
-			        
-					################Scaling the values###################
-					self.param2= (self.Yend[graph_id]-self.Ystart[graph_id])/2.0
-					self.param1= self.param2/32768.0
-
-					val=[]
-					for i in self.buffers:
-						temp_val_float = (self.param1*i*self.y_mag) + (self.param2*self.y_mag_bias_multiplier)
-						if(temp_val_float>=self.Yend[graph_id]):
-							temp_val_float= self.Yend[graph_id]
-						if(temp_val_float<=self.Ystart[graph_id]):
-							temp_val_float= self.Ystart[graph_id]
-						val.append( config.WINDOW_H - temp_val_float  )
-
-					self.peaks=val
-					################################################
-
-			        
-			        
-					##########The actual drawing of the graph##################
-					#TODO: Improvement : The color setting shouldn't happen in every drawing loop, should happen only once
-					colmap = self.get_colormap()
-					r,g,b = self.get_stroke_color_from_sugar()
-					clr = colmap.alloc_color( r, g, b, False, False)					
-					self._line_gc.set_foreground(clr)
-
-					count = self.Xstart[graph_id]
-					lines = []
-					for peak in self.peaks:
-						lines.append((count, peak))
-						count = count + self.draw_interval
-
-					if self.type[graph_id] ==0:
-						self.window.draw_lines(self._line_gc, lines)
-					else:
-						self.window.draw_points(self._line_gc, lines)
-					############################################################
-
-			        
-		"""
-		## DISPLAYING FRAMERATE FOR DEBUGGGIN
-		fr = 1.0/( time.time()-self.pr_time)
-		self.pr_time=time.time()
-		layout = pango.Layout(self.pango_context)
-		layout.set_text(str(fr) +self.debug_str)
-		self.window.draw_layout(self.get_style().white_gc, self.t_x, self.t_y, layout)
-		"""
-		return True
-
-
-	def set_side_toolbar_reference(self, side_toolbar):
-		self.side_toolbar_copy = side_toolbar
-
-
-	def set_electrical_ui_reference(self, electrical_ui):
-		self.electrical_ui_copy = electrical_ui
-
-	def set_graph_source(self, graph_id, source=0):
-		"""Sets from where the graph will get data 
-		0 - uses from audiograb
-		1 - uses from file"""
-		self.source[graph_id] = source
-
-	def set_graph_params(self, graph_id, Xstart, Ystart, Xend, Yend, type, color):
-		"""Sets Xstart, Ystart --> the bottom left co-ordinates
-		Xend, Yend             --> the top right co-ordinates
-		type                   --> 0 for a connected graph, 1 for a dotted graph
-		color                  --> what color graph to draw"""
-		self.Xstart[graph_id] = Xstart
-		self.Ystart[graph_id] = Ystart
-		self.Xend[graph_id] = Xend
-		self.Yend[graph_id] = Yend
-		self.type[graph_id]  = type
-		self.color[graph_id]  = color
-
-
-	def get_fft_mode(self):
-		"""Returns if FFT is ON (True) or OFF (False)"""
-		return self.fft_show
-
-	def set_fft_mode(self, fft_mode=False):
-		"""Sets whether FFT mode is ON (True) or OFF (False)"""
-		self.fft_show = fft_mode
-
-	def set_freq_range(self, freq_range=4):
-		"""See sound_toolbar to see what all frequency ranges are"""
-		self._freq_range = freq_range
-
-
-	def get_stroke_color_from_sugar(self):
-		"""Returns in (r,g,b) format the stroke color set in the profile on the XO"""
-		color = profile.get_color()
-		stroke = color.get_stroke_color()
-		colorstring = stroke.strip()
-		if colorstring[0] == '#': 
-			colorstring = colorstring[1:]
-			r,g,b = colorstring[:2], colorstring[2:4], colorstring[4:]
-			r+="00"
-			g+="00"
-			b+="00"
-			r,g,b = [int(n, 16) for n in (r,g,b)]
-		return (r,g,b)
-
-
-	def get_fill_color_from_sugar(self):
-		"""Returns in (r,g,b) format the fill color set in the profile on the XO"""
-		color = profile.get_color()
-		fill = color.get_fill_color()
-		colorstring = fill.strip()
-		if colorstring[0] == '#': 
-			colorstring = colorstring[1:]
-			r,g,b = colorstring[:2], colorstring[2:4], colorstring[4:]
-			r+="00"
-			g+="00"
-			b+="00"
-			r,g,b = [int(n, 16) for n in (r,g,b)]
-		return (r,g,b)
+	        #Draw the background
+	        #We could probably make this faster with another pixmap.
+	        self._init_background()
+	        self.window.draw_drawable(self.get_style().bg_gc[0], self._back_surf, 0, 0, 0, \
+                0, config.WINDOW_W, config.WINDOW_H)									
+
+        #Iterate for each graph                                                            
+	        for graph_id in self.graph_id:              							
+	            if self.graph_show_state[graph_id] == True:        
+			        span = self.Xend[graph_id]-self.Xstart[graph_id]
+
+			        if self._freq_range == 1:
+				        self.draw_interval = 4
+				        self.max_samples = span/self.draw_interval
+			        else:
+				        if span>=700:
+					        self.draw_interval = 10
+				        elif span<700 and span>=500:
+					        self.draw_interval = 7
+				        elif span<500 and span>=300:
+					        self.draw_interval = 5
+				        else:
+					        self.draw_interval = 3
+				        self.max_samples = span/self.draw_interval
+	                
+			        #Depending upon the X span of the graph, deciding the total number of points to take
+			        if(len(self.main_buffers)>=self.max_samples):
+				        del self.main_buffers[0:(len(self.main_buffers)-(self.max_samples+1))]
+
+
+			        if(self.fft_show==False):				
+				        self.y_mag_bias_multiplier = 1					
+         
+			        else:
+				        ###############FFT################		
+				        Fs = 48000
+				        nfft = 65536
+				        if self.integer_buffer:
+					        self.integer_buffer = self.integer_buffer[0:256]
+					        self.fftx = fft(self.integer_buffer, 256,-1)
+					        self.fftx = self.fftx[0:self.max_samples]
+					        self.main_buffers = [(abs(x) * 0.02) for x in self.fftx]
+					        self.y_mag_bias_multiplier=0.1
+				        ##################################
+	                                
+								            
+                    #################Getting data######################
+                    if self.source[graph_id]==0:
+                        self.buffers=self.main_buffers
+                    else:
+                        pass        #write code here that gets data from file
+                    ###############################################
+
+                    ################Scaling the values###################
+                    #if config.CONTEXT == 2:
+                    #    self.y_mag = 1
+                    #    self.y_mag_bias_multiplier = 1
+                    self.param2= (self.Yend[graph_id]-self.Ystart[graph_id])/2.0
+                    self.param1= self.param2/32768.0
+
+                    val=[]
+                    for i in self.buffers:
+                        temp_val_float = (self.param1*i*self.y_mag) + (self.param2*self.y_mag_bias_multiplier)
+                        if(temp_val_float>=self.Yend[graph_id]):
+                            temp_val_float= self.Yend[graph_id]
+                        if(temp_val_float<=self.Ystart[graph_id]):
+                            temp_val_float= self.Ystart[graph_id]
+                        val.append( config.WINDOW_H - temp_val_float  )
+
+                    self.peaks=val
+                    ################################################
+
+	                
+	                
+			        ##########The actual drawing of the graph##################
+			        #TODO: Improvement : The color setting shouldn't happen in every drawing loop, should happen only once
+                    colmap = self.get_colormap()
+                    r,g,b = self.get_stroke_color_from_sugar()
+                    clr = colmap.alloc_color( r, g, b, False, False)					
+                    self._line_gc.set_foreground(clr)
+
+                    count = self.Xstart[graph_id]
+                    lines = []
+                    for peak in self.peaks:
+                        lines.append((count, peak))
+                        count = count + self.draw_interval
+
+                    if self.type[graph_id] ==0:
+                        self.window.draw_lines(self._line_gc, lines)
+                    else:
+                        self.window.draw_points(self._line_gc, lines)
+			        ############################################################
+
+	                
+        """
+        ## DISPLAYING FRAMERATE FOR DEBUGGGIN
+        fr = 1.0/( time.time()-self.pr_time)
+        self.pr_time=time.time()
+        layout = pango.Layout(self.pango_context)
+        layout.set_text(str(fr) +self.debug_str)
+        self.window.draw_layout(self.get_style().white_gc, self.t_x, self.t_y, layout)
+        """
+        return True
+
+
+    def set_side_toolbar_reference(self, side_toolbar):
+        self.side_toolbar_copy = side_toolbar
+
+
+    def set_electrical_ui_reference(self, electrical_ui):
+        self.electrical_ui_copy = electrical_ui
+
+    def set_graph_source(self, graph_id, source=0):
+        """Sets from where the graph will get data 
+        0 - uses from audiograb
+        1 - uses from file"""
+        self.source[graph_id] = source
+
+    def set_graph_params(self, graph_id, Xstart, Ystart, Xend, Yend, type, color):
+        """Sets Xstart, Ystart --> the bottom left co-ordinates
+        Xend, Yend             --> the top right co-ordinates
+        type                   --> 0 for a connected graph, 1 for a dotted graph
+        color                  --> what color graph to draw"""
+        self.Xstart[graph_id] = Xstart
+        self.Ystart[graph_id] = Ystart
+        self.Xend[graph_id] = Xend
+        self.Yend[graph_id] = Yend
+        self.type[graph_id]  = type
+        self.color[graph_id]  = color
+
+
+    def get_fft_mode(self):
+        """Returns if FFT is ON (True) or OFF (False)"""
+        return self.fft_show
+
+    def set_fft_mode(self, fft_mode=False):
+        """Sets whether FFT mode is ON (True) or OFF (False)"""
+        self.fft_show = fft_mode
+
+    def set_freq_range(self, freq_range=4):
+        """See sound_toolbar to see what all frequency ranges are"""
+        self._freq_range = freq_range
+
+
+    def get_stroke_color_from_sugar(self):
+        """Returns in (r,g,b) format the stroke color set in the profile on the XO"""
+        color = profile.get_color()
+        stroke = color.get_stroke_color()
+        colorstring = stroke.strip()
+        if colorstring[0] == '#': 
+	        colorstring = colorstring[1:]
+	        r,g,b = colorstring[:2], colorstring[2:4], colorstring[4:]
+	        r+="00"
+	        g+="00"
+	        b+="00"
+	        r,g,b = [int(n, 16) for n in (r,g,b)]
+        return (r,g,b)
+
+
+    def get_fill_color_from_sugar(self):
+        """Returns in (r,g,b) format the fill color set in the profile on the XO"""
+        color = profile.get_color()
+        fill = color.get_fill_color()
+        colorstring = fill.strip()
+        if colorstring[0] == '#': 
+	        colorstring = colorstring[1:]
+	        r,g,b = colorstring[:2], colorstring[2:4], colorstring[4:]
+	        r+="00"
+	        g+="00"
+	        b+="00"
+	        r,g,b = [int(n, 16) for n in (r,g,b)]
+        return (r,g,b)
 
 
diff --git a/measure_devel/measure.py b/measure_devel/measure.py
index c42b981..6d6d423 100755
--- a/measure_devel/measure.py
+++ b/measure_devel/measure.py
@@ -56,115 +56,116 @@ from sugar.datastore import datastore
 
 class MeasureActivity(activity.Activity):
 
-	def __init__(self, handle):
+    def __init__(self, handle):
 
-		activity.Activity.__init__(self, handle)
-		act_root = environ['SUGAR_ACTIVITY_ROOT'] 
-		tmp_dir = join(act_root, 'data')	   
+        activity.Activity.__init__(self, handle)
+        act_root = environ['SUGAR_ACTIVITY_ROOT'] 
+        tmp_dir = join(act_root, 'data')	   
 
+
+        self.active_status = True
+        self.ACTIVE = True
+        self.connect( "notify::active", self._activeCb )
+        self.connect("destroy", self.on_quit)	
+
+        if self._jobject.file_path:
+	        #logging.debug('1.0 Launched from journal')
+	        self.existing = True
+        else: 
+	        #logging.debug('1.1 Launched from frame or from Mesh View')
+	        self._jobject.file_path =str(tempfile.mkstemp(dir=tmp_dir)[1]) 
+	        os.chmod(self._jobject.file_path, 0777)
+	        self.existing = False	
+
+
+        self.ji = JournalInteraction(self._jobject.file_path, self.existing)
+        self.wave = DrawWaveform()
+        self.audiograb = AudioGrab(self.wave.new_buffer, self.ji)
+        self.side_toolbar = SideToolbar(self.wave)
+        self.text_box = TextBox()
+
+
+        self.box3 = gtk.HBox(False, 0)
+        self.box3.pack_start(self.wave,True,True,0)
+        self.box3.pack_start(self.side_toolbar.box1,False,True,0)	
+
+        self.box1 = gtk.VBox(False,0)
+        self.box1.pack_start(self.box3, True, True, 0)
+        self.box1.pack_start(self.text_box.box_main, False, True, 0)
+
+        self.set_canvas(self.box1)		
+
+        toolbox = Toolbar(self, self.wave, self.audiograb, self.ji, self.text_box)
+        self.set_toolbox(toolbox)
+        toolbox.show()
+
+        self.show_all()		
+
+        self.first = True
+
+        gobject.timeout_add(config.REFRESH_TIME, self.waveform_refresh)
+
+
+
+    def set_show_hide_windows(self, window_id=1):
+        """Shows the appropriate window identified by the window_id
+        1 --> sound
+        2 --> sensors
+        """
+        if window_id==1: 
+            #self.box3.pack_start(self.wave,True,True,0)
+            #self.box3.pack_start(self.side_toolbar.box1,False,True,0)	
+            #self.box3.show_all()
+            self.wave.set_context_on()
+            self.active_context_status = 1
+            return
 	
-		self.active_status = True
-		self.ACTIVE = True
-		self.connect( "notify::active", self._activeCb )
-		self.connect("destroy", self.on_quit)	
-
-		if self._jobject.file_path:
-			#logging.debug('1.0 Launched from journal')
-			self.existing = True
-		else: 
-			#logging.debug('1.1 Launched from frame or from Mesh View')
-			self._jobject.file_path =str(tempfile.mkstemp(dir=tmp_dir)[1]) 
-			os.chmod(self._jobject.file_path, 0777)
-			self.existing = False	
-
-
-		self.ji = JournalInteraction(self._jobject.file_path, self.existing)
-		self.wave = DrawWaveform()
-		self.audiograb = AudioGrab(self.wave.new_buffer, self.ji)
-		self.side_toolbar = SideToolbar(self.wave)
-		self.text_box = TextBox()
-
-
-		self.box3 = gtk.HBox(False, 0)
-		self.box3.pack_start(self.wave,True,True,0)
-		self.box3.pack_start(self.side_toolbar.box1,False,True,0)	
-
-		self.box1 = gtk.VBox(False,0)
-		self.box1.pack_start(self.box3, True, True, 0)
-		self.box1.pack_start(self.text_box.box_main, False, True, 0)
-
-		self.set_canvas(self.box1)		
-
-		toolbox = Toolbar(self, self.wave, self.audiograb, self.ji, self.text_box)
-		self.set_toolbox(toolbox)
-		toolbox.show()
-
-		self.show_all()		
-
-		self.first = True
-
-		gobject.timeout_add(config.REFRESH_TIME, self.waveform_refresh)
-
-		self.set_show_hide_windows(0)
-		self.active_context_status = config.CONTEXT_ACTIVE_START
-
-
-	def set_show_hide_windows(self, window_id=1):
-		"""Shows the appropriate window identified by the window_id
-		1 --> sound
-		2 --> sensors
-		"""
-		if window_id==1: 
-			self.box3.show_all()
-			self.active_context_status = 0
-			return
-			
-		elif window_id==2:
-			self.box3 = gtk.HBox(False, 0)
-			self.box3.pack_start(self.wave,True,True,0)
-			self.box3.show_all()
-			self.active_context_status = 1
-			return
-			
-
-	def get_show_hide_windows(self):
-		"""Gets which window is being shown
-		If 0 is returned means waveform window is being shown
-		If 1 is returned means camera context"""
-		return self.active_context_status
+        elif window_id==2:
+            #self.box3.pack_start(self.wave,True,True,0)
+            #self.box3.show_all()
+            self.active_context_status = 2
+            return
 	
 
+    def get_show_hide_windows(self):
+        """Gets which window is being shown
+        If 0 is returned means waveform window is being shown
+        If 1 is returned means camera context"""
+        return self.active_context_status
+
+
+
+    def waveform_refresh(self):
+        self.wave.queue_draw()
+        return self.active_status 						
+
+
+    def on_quit(self,data=None):	
+        self.audiograb.on_activity_quit()	
 
-	def waveform_refresh(self):
-		self.wave.queue_draw()
-		return self.active_status 						
 
+    def _activeCb( self, widget, pspec ):
+        if(self.first == True):
+	        self.audiograb.start_grabbing()
+	        self.first = False
+        if (not self.props.active and self.ACTIVE):
+	        self.audiograb.pause_grabbing()
+	        self.active_status = False 
+        elif (self.props.active and not self.ACTIVE):
+	        self.audiograb.resume_grabbing()
+	        self.active_status = True                
+	        gobject.timeout_add(config.REFRESH_TIME, \
+		        self.waveform_refresh)        
+        self.ACTIVE = self.props.active
 
-	def on_quit(self,data=None):	
-		self.audiograb.on_activity_quit()	
 
+    def write_file(self, file_path):
+        pass
 
-	def _activeCb( self, widget, pspec ):
-		if(self.first == True):
-			self.audiograb.start_grabbing()
-			self.first = False
-		if (not self.props.active and self.ACTIVE):
-			self.audiograb.pause_grabbing()
-			self.active_status = False 
-		elif (self.props.active and not self.ACTIVE):
-			self.audiograb.resume_grabbing()
-			self.active_status = True                
-			gobject.timeout_add(config.REFRESH_TIME, \
-				self.waveform_refresh)        
-		self.ACTIVE = self.props.active
+    def read_file(self, file_path):
+        pass
 
-		
-	def write_file(self, file_path):
-		pass
 
-	def read_file(self, file_path):
-		pass
-		
 gtk.gdk.threads_init()
 
 
diff --git a/measure_devel/sensor_toolbar.py b/measure_devel/sensor_toolbar.py
index efdcaf7..32664be 100644
--- a/measure_devel/sensor_toolbar.py
+++ b/measure_devel/sensor_toolbar.py
@@ -21,9 +21,12 @@ class SensorToolbar(gtk.Toolbar):
         self._STR1 = "Bias/Offset Enabled  "
         self._STR2 = "Bias/Offset Disabled "
 
+        self.gain_state = None
+        self.boost_state = None        
+
         self.string_for_textbox = ""
 
-        self._LOG_SEPARATOR_DIST = 12
+        self._LOG_SEPARATOR_DIST = 16
 
 
         self.ag = audiograb
@@ -62,19 +65,19 @@ class SensorToolbar(gtk.Toolbar):
 
         #######################Logging Interval#####################
         self._loginterval_combo = ComboBox()
-        self.interval = [_('Now'), _('1 second') , _('5 seconds'),  _('1 minute') , _('5 minutes'),  _('1 hour')]
+        self.interval = [_('1 second') , _('30 seconds'),  _('5 minutes'),  _('30 minutes')]
 
         self._interval_changed_id = self._loginterval_combo.connect("changed", self.loginterval_control)
 
         for i, s in enumerate(self.interval):
             self._loginterval_combo.append_item(i, s, None)
-            if s == 'Now':
+            if s == _('1 second'):
                 self._loginterval_combo.set_active(i)
 
         self._loginterval_tool = ToolComboBox(self._loginterval_combo)
         self.insert(self._loginterval_tool,-1)
         self._loginterval_tool.show()
-        self.logginginterval_status = 'picture'		
+        self.logginginterval_status = '1second'		
         ############################################################
 
         separator = gtk.SeparatorToolItem()
@@ -86,16 +89,13 @@ class SensorToolbar(gtk.Toolbar):
         self._record = ToolButton('media-record')
         self.insert(self._record, -1)
         self._record.show()
-        self._record.set_tooltip(_('Start Logging'))
+        self._record.set_tooltip(_('Start Recording'))
         self.record_state = False  	    #True means recording in progress, False means not recording
         self._record.connect('clicked', self.record_control)
         ######################################################################
 
 
     def record_control(self, data=None):
-        #######Experimental!################
-        self.ji.take_screenshot()
-        ####################################    
         """Depending upon the selected interval, does either
         a logging session, or just logs the current buffer"""
         if self.record_state == False:
@@ -108,12 +108,7 @@ class SensorToolbar(gtk.Toolbar):
             
             self._record.set_icon('media-playback-stop')
             self._record.show()
-            self._record.set_tooltip(_('Stop Logging'))
-            if interval==0:
-                self._record.set_icon('media-record')
-                self._record.show()
-                self._record.set_tooltip(_('Start Logging'))
-                self.record_state = False
+            self._record.set_tooltip(_('Stop Recording'))
         else:
             self.ji.stop_session()
             self.audiograb_copy.set_logging_params(False)
@@ -121,25 +116,21 @@ class SensorToolbar(gtk.Toolbar):
             
             self._record.set_icon('media-record')
             self._record.show()
-            self._record.set_tooltip(_('Start Logging'))
+            self._record.set_tooltip(_('Start Recording'))
 
 
     def interval_convert(self):
         """Converts picture/1second/5seconds/1minute/5minutes to an integer
         which denotes the number of times the audiograb buffer must be called before a value is written.
         When set to 0, the whole of current buffer will be written"""
-        if self.logginginterval_status == 'picture':
-            return 0
-        elif self.logginginterval_status == 'second':
-            return 50
-        elif self.logginginterval_status == '5second':
-            return 250
-        elif self.logginginterval_status == 'minute':
-            return 3000
+        if self.logginginterval_status == '1second':
+            return 89
+        elif self.logginginterval_status == '30second':
+            return 2667
         elif self.logginginterval_status == '5minute':
-            return 15000
-        elif self.logginginterval_status == 'hour':
-            return 180000
+            return 26667
+        elif self.logginginterval_status == '30minute':
+            return 160000
             
             
 
@@ -147,41 +138,13 @@ class SensorToolbar(gtk.Toolbar):
 
         if (self._loginterval_combo.get_active() != -1):
             if (self._loginterval_combo.get_active() == 0):
-                self.logginginterval_status = 'picture'		
+                self.logginginterval_status = '1second'		
             if (self._loginterval_combo.get_active() == 1):
-                self.logginginterval_status = 'second'		
+                self.logginginterval_status = '30second'		
             if (self._loginterval_combo.get_active() == 2):
-                self.logginginterval_status = '5second'		
-            if (self._loginterval_combo.get_active() == 3):
-                self.logginginterval_status = 'minute'		
-            if (self._loginterval_combo.get_active() == 3):
                 self.logginginterval_status = '5minute'		
             if (self._loginterval_combo.get_active() == 3):
-                self.logginginterval_status = 'hour'		
-
-
-
-
-    def _pauseplay_control_cb(self, data=None):
-
-        if self.audiograb_copy.get_freeze_the_display()==True:
-	        print "$$sound_toolbar:should unfreeze the display"
-	        self.audiograb_copy.set_freeze_the_display(False)
-	        self._pause.set_icon('media-playback-pause-insensitive')
-	        self._pause.set_tooltip(_('Unfreeze the display'))
-	        self._pause.show()
-	        return False
-
-        if self.audiograb_copy.get_freeze_the_display()==False:
-	        print "$$sound_toolbar:should freeze the display"
-	        self.audiograb_copy.set_freeze_the_display(True)
-	        self._pause.set_icon('media-playback-pause')
-	        self._pause.set_tooltip(_('Freeze the display'))
-	        self._pause.show()
-	        return False
-
-        return False
-
+                self.logginginterval_status = '30minute'		
 
 
 	
@@ -231,6 +194,10 @@ class SensorToolbar(gtk.Toolbar):
         self.ag.set_dc_mode(True)
         self.ag.set_bias(True)
         self._update_string_for_textbox()
+        #self.gain_state = self.ag.get_capture_gain()
+        #self.boost_state = self.ag.get_mic_boost()
+        self.ag.set_capture_gain(0)
+        self.ag.set_mic_boost(False)
 
 
     def _update_string_for_textbox(self):
diff --git a/measure_devel/sound_toolbar.py b/measure_devel/sound_toolbar.py
index ccaefce..217fd65 100644
--- a/measure_devel/sound_toolbar.py
+++ b/measure_devel/sound_toolbar.py
@@ -202,7 +202,7 @@ class SoundToolbar(gtk.Toolbar):
         elif self.logginginterval_status == '10minute':
             return 53340
         elif self.logginginterval_status == '30minute':
-            return 160020
+            return 160000
             
             
 
diff --git a/measure_devel/toolbar_side.py b/measure_devel/toolbar_side.py
index 288c7bf..2766158 100755
--- a/measure_devel/toolbar_side.py
+++ b/measure_devel/toolbar_side.py
@@ -8,48 +8,58 @@ import config  	#This has all the globals
 
 class SideToolbar(gtk.DrawingArea):
 
-	def __init__(self, wave):
-		gtk.DrawingArea.__init__(self)
-		
-		self.wave_copy = wave
-
-		self.adjustmenty = gtk.Adjustment(3.0, 0.0, 4.0 ,0.1, 0.1, 0.0)
-		self.adjustmenty.connect("value_changed", self.cb_page_sizey,\
-			self.adjustmenty)
-		self.yscrollbar = gtk.VScale(self.adjustmenty)
-		self.yscrollbar.set_draw_value(False)
-		self.yscrollbar.set_inverted(True)
-		self.yscrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS)
-				
-		self.img_amphigh = gtk.Image()
-		self.img_amplow =  gtk.Image()		
-
-		self.img_amphigh.set_from_file(config.ICONS_DIR + '/amp-high.svg')
-		self.img_amplow.set_from_file(config.ICONS_DIR + '/amp-low.svg')
+    def __init__(self, wave):
+        gtk.DrawingArea.__init__(self)
+
+        self.wave_copy = wave
+        self.show_toolbar = True
+
+        self.adjustmenty = gtk.Adjustment(3.0, 0.0, 4.0 ,0.1, 0.1, 0.0)
+        self.adjustmenty.connect("value_changed", self.cb_page_sizey,\
+	        self.adjustmenty)
+        self.yscrollbar = gtk.VScale(self.adjustmenty)
+        self.yscrollbar.set_draw_value(False)
+        self.yscrollbar.set_inverted(True)
+        self.yscrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS)
 		
-		self.box1 = gtk.VBox(False,0)
-		self.box1.pack_start(self.img_amphigh, False, True, 0)
-		self.box1.pack_start(self.yscrollbar, True, True, 0)
-		self.box1.pack_start(self.img_amplow, False, True, 0)
-
-
-	def cb_page_sizey(self, get, data=None):
-		if(get.value<=1.5):		
-			self.wave_copy.y_mag= get.value
-			os.system("amixer set 'Capture' 50%, 0% unmute captur")
-			self.wave_copy.g = 1            #0dB
-		if(get.value>1.5 and get.value<=2.5 ):
-			self.wave_copy.y_mag= (get.value*1.5)		
-			os.system("amixer set 'Capture' 50%, 25% unmute captur")
-			self.wave_copy.g = 1.9952       #6dB
-		if(get.value>2.5 and get.value<=3.5 ):
-			self.wave_copy.y_mag= (get.value*3)
-			os.system("amixer set 'Capture' 50%, 50% unmute captur")
-			self.wave_copy.g = 3.981        #12dB
-		if(get.value>3.5 and get.value<=4.0 ):
-			self.wave_copy.y_mag= (get.value*4)						
-			os.system("amixer set 'Capture' 50%, 100% unmute captur")
-			self.wave_copy.g = 13.335       #22.5dB
-		return True	
-
-	
+        self.img_amphigh = gtk.Image()
+        self.img_amplow =  gtk.Image()		
+
+        self.img_amphigh.set_from_file(config.ICONS_DIR + '/amp-high.svg')
+        self.img_amplow.set_from_file(config.ICONS_DIR + '/amp-low.svg')
+
+        self.box1 = gtk.VBox(False,0)
+        self.box1.pack_start(self.img_amphigh, False, True, 0)
+        self.box1.pack_start(self.yscrollbar, True, True, 0)
+        self.box1.pack_start(self.img_amplow, False, True, 0)
+
+        ##test  
+        self.set_show_hide(False)
+
+
+    def cb_page_sizey(self, get, data=None):
+        if(get.value<=1.5):		
+            self.wave_copy.y_mag= get.value
+            os.system("amixer set 'Capture' 50%, 0% unmute captur")
+            self.wave_copy.g = 1            #0dB
+        if(get.value>1.5 and get.value<=2.5 ):
+            self.wave_copy.y_mag= (get.value*1.5)		
+            os.system("amixer set 'Capture' 50%, 25% unmute captur")
+            self.wave_copy.g = 1.9952       #6dB
+        if(get.value>2.5 and get.value<=3.5 ):
+            self.wave_copy.y_mag= (get.value*3)
+            os.system("amixer set 'Capture' 50%, 50% unmute captur")
+            self.wave_copy.g = 3.981        #12dB
+        if(get.value>3.5 and get.value<=4.0 ):
+            self.wave_copy.y_mag= (get.value*4)						
+            os.system("amixer set 'Capture' 50%, 100% unmute captur")
+            self.wave_copy.g = 13.335       #22.5dB
+        return True	
+
+
+    def set_show_hide(self, show=True):
+        self.show_toolbar = show
+        #self.yscrollbar.show(self.show_toolbar)
+
+    def get_show_hide(self):
+        return self.show_toolbar
diff --git a/measure_devel/toolbar_top.py b/measure_devel/toolbar_top.py
index dd2be49..4b1e051 100755
--- a/measure_devel/toolbar_top.py
+++ b/measure_devel/toolbar_top.py
@@ -2,6 +2,8 @@ import pygtk
 import gtk
 import time
 
+import config
+
 from sugar.activity.activity import ActivityToolbox
 
 from sound_toolbar import SoundToolbar
@@ -11,87 +13,89 @@ from logging_ui import LogToolbar
 
 class Toolbar(ActivityToolbox):
 
-	def __init__(self, activity, wave, audiograb, journal, textbox):
-
-		ActivityToolbox.__init__(self, activity)
-
-		self._SOUND_TOOLBAR = 1
-		self._SENSOR_TOOLBAR = 2
-
-		self._sound_toolbar = SoundToolbar(wave, audiograb, textbox, journal, activity)
-		self.add_toolbar('Sound', self._sound_toolbar)
-		self._sound_toolbar.show()
-
-		self._sensors_toolbar = SensorToolbar(audiograb, textbox)
-		self.add_toolbar('Sensors', self._sensors_toolbar)
-		self._sensors_toolbar.show()
-
-		"""
-		self._camera_toolbar = CameraToolbar(activity, camera_ui)
-		self.add_toolbar('Camera', self._camera_toolbar)
-		self._camera_toolbar.show()
-
-		self._wifi_toolbar = MeasureToolbar(wave, audiograb)
-		self.add_toolbar('Wireless', self._wifi_toolbar)
-		self._wifi_toolbar.show()
-
-		self._log_toolbar = LogToolbar(audiograb, journal, activity)
-		self.add_toolbar('Log View', self._log_toolbar)
-		self._log_toolbar.show()
-		"""
-
-		self.connect("current-toolbar-changed", self._toolbar_changed_cb)
-		self.wave = wave
-		self.activity = activity
-		self.toolbar_active_id = 1
-		self.set_current_toolbar(self._SOUND_TOOLBAR)
-
-
-	def _toolbar_changed_cb(self, tbox, num):
-		if num==0:                              #Activity
-			pass
-		elif num==self._SOUND_TOOLBAR:                           #Sound
-			self.activity.set_show_hide_windows(self._SOUND_TOOLBAR)
-			self._sensors_toolbar.context_off()
-			time.sleep(0.5)
-			self._sound_toolbar.context_on()
-			self.wave.set_context_on()
-		elif num==self._SENSOR_TOOLBAR:                            #Sensor
-			self.activity.set_show_hide_windows(self._SENSOR_TOOLBAR)
-			self._sound_toolbar.context_off()
-			time.sleep(0.5)
-			self._sensors_toolbar.context_on()
-			self.wave.set_context_on()
-
-		self.toolbar_active_id = num
-		"""
-		elif num==3:                            #Camera
-			self.activity.set_show_hide_windows(1)
-			self._sound_toolbar.context_off()
-			self.wave.set_context_off()
-			time.sleep(0.5)
-			self._camera_toolbar.set_context_on()
-		elif num==4:        
-			self.wave.set_context_off()
-			self._sound_toolbar.context_off()
-			self._camera_toolbar.set_context_off()
-			time.sleep(0.5)
-		elif num==5:
-			self.wave.set_context_off() 
-			self._sound_toolbar.context_off()
-			self._camera_toolbar.set_context_off()
-			time.sleep(0.5)
-		"""
-		return True
-		
-
-	def get_which_toolbar_active(self):
-		"""Returns which toolbar is active
-		Activity toolbar - 1
-		Sound toolbar 	 - 2
-		Sensors toolbar  - 3
-		"""
-		return self.toolbar_active_id
+    def __init__(self, activity, wave, audiograb, journal, textbox):
+
+        ActivityToolbox.__init__(self, activity)
+
+        self._SOUND_TOOLBAR = 1
+        self._SENSOR_TOOLBAR = 2
+
+        self._sound_toolbar = SoundToolbar(wave, audiograb, textbox, journal, activity)
+        self.add_toolbar('Sound', self._sound_toolbar)
+        self._sound_toolbar.show()
+
+        self._sensors_toolbar = SensorToolbar(audiograb, textbox)
+        self.add_toolbar('Sensors', self._sensors_toolbar)
+        self._sensors_toolbar.show()
+
+        """
+        self._camera_toolbar = CameraToolbar(activity, camera_ui)
+        self.add_toolbar('Camera', self._camera_toolbar)
+        self._camera_toolbar.show()
+
+        self._wifi_toolbar = MeasureToolbar(wave, audiograb)
+        self.add_toolbar('Wireless', self._wifi_toolbar)
+        self._wifi_toolbar.show()
+
+        self._log_toolbar = LogToolbar(audiograb, journal, activity)
+        self.add_toolbar('Log View', self._log_toolbar)
+        self._log_toolbar.show()
+        """
+
+        self.connect("current-toolbar-changed", self._toolbar_changed_cb)
+        self.wave = wave
+        self.activity = activity
+        self.toolbar_active_id = 1
+        self.set_current_toolbar(self._SOUND_TOOLBAR)
+
+
+    def _toolbar_changed_cb(self, tbox, num):
+        if num==0:                              #Activity
+	        pass
+
+        elif num==self._SOUND_TOOLBAR:                           #Sound
+            self.activity.set_show_hide_windows(self._SOUND_TOOLBAR)
+            self._sensors_toolbar.context_off()
+            time.sleep(0.5)
+            self._sound_toolbar.context_on()
+            config.CONTEXT = self._SOUND_TOOLBAR
+
+        elif num==self._SENSOR_TOOLBAR:                            #Sensor
+            self._sound_toolbar.context_off()
+            time.sleep(0.5)
+            self._sensors_toolbar.context_on()
+            self.activity.set_show_hide_windows(self._SENSOR_TOOLBAR)
+            config.CONTEXT = self._SENSOR_TOOLBAR
+
+        self.toolbar_active_id = num
+        """
+        elif num==3:                            #Camera
+	        self.activity.set_show_hide_windows(1)
+	        self._sound_toolbar.context_off()
+	        self.wave.set_context_off()
+	        time.sleep(0.5)
+	        self._camera_toolbar.set_context_on()
+        elif num==4:        
+	        self.wave.set_context_off()
+	        self._sound_toolbar.context_off()
+	        self._camera_toolbar.set_context_off()
+	        time.sleep(0.5)
+        elif num==5:
+	        self.wave.set_context_off() 
+	        self._sound_toolbar.context_off()
+	        self._camera_toolbar.set_context_off()
+	        time.sleep(0.5)
+        """
+        return True
+
+
+    def get_which_toolbar_active(self):
+        """Returns which toolbar is active
+        Activity toolbar - 1
+        Sound toolbar 	 - 2
+        Sensors toolbar  - 3
+        """
+        return self.toolbar_active_id
 
 
 
