Changed all tabs to 4 spaces for python style

shell/console/console.py

@@ -27,7 +27,7 @@ logviewer_widget = logviewer.Interface().widget
 logviewer_widget.show()
 
 # Terminal interface
-terminal_widget	= terminal.Interface().widget
+terminal_widget    = terminal.Interface().widget
 terminal_widget.show()
 
 # Notebook

shell/console/logviewer.py

@@ -26,76 +26,76 @@ import gobject
 from sugar import env
 
 class LogBuffer(gtk.TextBuffer):
-	def __init__(self, logfile):
-		gtk.TextBuffer.__init__(self)
+    def __init__(self, logfile):
+        gtk.TextBuffer.__init__(self)
 
-		self._logfile = logfile
-		self._pos = 0
+        self._logfile = logfile
+        self._pos = 0
 
-		self.update()
+        self.update()
 
-	def update(self):
-		f = open(self._logfile, 'r')
+    def update(self):
+        f = open(self._logfile, 'r')
 
-		f.seek(self._pos)
-		self.insert(self.get_end_iter(), f.read())
-		self._pos = f.tell()
+        f.seek(self._pos)
+        self.insert(self.get_end_iter(), f.read())
+        self._pos = f.tell()
 
-		f.close()
+        f.close()
 
-		return True
+        return True
 
 class LogView(gtk.ScrolledWindow):
-	def __init__(self, model):
-		gtk.ScrolledWindow.__init__(self)
+    def __init__(self, model):
+        gtk.ScrolledWindow.__init__(self)
 
-		self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
-		textview = gtk.TextView(model)
-		textview.set_wrap_mode(gtk.WRAP_WORD)
-		textview.set_editable(False)
+        textview = gtk.TextView(model)
+        textview.set_wrap_mode(gtk.WRAP_WORD)
+        textview.set_editable(False)
 
-		self.add(textview)
-		textview.show()
+        self.add(textview)
+        textview.show()
 
 class MultiLogView(gtk.Notebook):
-	def __init__(self, path):
-		gtk.Notebook.__init__(self)
+    def __init__(self, path):
+        gtk.Notebook.__init__(self)
 
-		self._logs_path = path
-		self._pages = {}
+        self._logs_path = path
+        self._pages = {}
 
-		self._update()
+        self._update()
 
-		gobject.timeout_add(1000, self._update)
+        gobject.timeout_add(1000, self._update)
 
-	def _add_page(self, logfile):
-		full_log_path = os.path.join(self._logs_path, logfile)
-		model = LogBuffer(full_log_path)
+    def _add_page(self, logfile):
+        full_log_path = os.path.join(self._logs_path, logfile)
+        model = LogBuffer(full_log_path)
 
-		view = LogView(model)
-		self.append_page(view, gtk.Label(logfile))
-		view.show()
+        view = LogView(model)
+        self.append_page(view, gtk.Label(logfile))
+        view.show()
 
-		self._pages[logfile] = model
+        self._pages[logfile] = model
 
-	def _update(self):
-		if not os.path.isdir(self._logs_path):
-			return True
+    def _update(self):
+        if not os.path.isdir(self._logs_path):
+            return True
 
-		for logfile in os.listdir(self._logs_path):
-			if self._pages.has_key(logfile):
-				self._pages[logfile].update()
-			else:
-				self._add_page(logfile)
+        for logfile in os.listdir(self._logs_path):
+            if self._pages.has_key(logfile):
+                self._pages[logfile].update()
+            else:
+                self._add_page(logfile)
 
-		return True
+        return True
 
 class Interface:
 
-	def __init__(self):
-		path = os.path.join(env.get_profile_path(), 'logs')
-		viewer = MultiLogView(path)
-		viewer.show()
-		self.widget = viewer
-		
+    def __init__(self):
+        path = os.path.join(env.get_profile_path(), 'logs')
+        viewer = MultiLogView(path)
+        viewer.show()
+        self.widget = viewer
+        

shell/console/memphis.py

@@ -8,175 +8,175 @@ import plugin
 from procmem import proc
 
 try:
-	import gtk
-	import gtk.gdk
-	import gobject
+    import gtk
+    import gtk.gdk
+    import gobject
 except:
-	sys.exit(1)
+    sys.exit(1)
 
 class Interface:
-	
-	store_data_types = []
-	store_data_types_details = []
-	
-	def __init__(self):	
-		
-		# Our GtkTree (Treeview)
-		self.treeview = gtk.TreeView()
-		self.widget = self.treeview
-		
-		# Loading plugins
-		self.plg = plugin.Plugin()
-				
-		# TOP data types (columns)
-		self.store_data_types = []
-		
-		for plg in self.plg.list:
-			plg_data = plg.INTERNALS
-			
-			# Give plugin object to plugin
-			plg.INTERNALS['Plg'] = self.plg
+    
+    store_data_types = []
+    store_data_types_details = []
+    
+    def __init__(self):    
+        
+        # Our GtkTree (Treeview)
+        self.treeview = gtk.TreeView()
+        self.widget = self.treeview
+        
+        # Loading plugins
+        self.plg = plugin.Plugin()
+                
+        # TOP data types (columns)
+        self.store_data_types = []
+        
+        for plg in self.plg.list:
+            plg_data = plg.INTERNALS
+            
+            # Give plugin object to plugin
+            plg.INTERNALS['Plg'] = self.plg
 
-		# Creating a store model and loading process data to Treeview
-		# self.store_data_types, ex [int, str, str, str, int,...]
-		#self.store = gtk.TreeStore(*self.store_data_types)
-		self.data = Data(self.treeview, self.plg.list)
-	
+        # Creating a store model and loading process data to Treeview
+        # self.store_data_types, ex [int, str, str, str, int,...]
+        #self.store = gtk.TreeStore(*self.store_data_types)
+        self.data = Data(self.treeview, self.plg.list)
+    
 class Data:
 
-	treeview = None
-	last_col_index = 0
+    treeview = None
+    last_col_index = 0
 
-	store_data_cols = []
-	store_data_types = []
-	store_data_types_details = []
-	
-	def __init__(self, treeview, plg_list):
-		
-		# Top data types
-		self.plg_list = plg_list
-		
-		for plg in self.plg_list:
+    store_data_cols = []
+    store_data_types = []
+    store_data_types_details = []
+    
+    def __init__(self, treeview, plg_list):
+        
+        # Top data types
+        self.plg_list = plg_list
+        
+        for plg in self.plg_list:
 
-			if plg.INTERNALS['top_data'] != None:
-				last_dt = len(self.store_data_types)
-	
-				if last_dt > 0:
-					last_dt -= 1
-	
-				len_dt = len(plg.INTERNALS['top_data'])
-	
-				self.store_data_types_details.append({"plugin": plg, "init": last_dt, "end": last_dt + len_dt})
-				
-				for dt in plg.INTERNALS['top_data']:
-					self.store_data_types.append(dt)
+            if plg.INTERNALS['top_data'] != None:
+                last_dt = len(self.store_data_types)
+    
+                if last_dt > 0:
+                    last_dt -= 1
+    
+                len_dt = len(plg.INTERNALS['top_data'])
+    
+                self.store_data_types_details.append({"plugin": plg, "init": last_dt, "end": last_dt + len_dt})
+                
+                for dt in plg.INTERNALS['top_data']:
+                    self.store_data_types.append(dt)
 
-				for col in plg.INTERNALS['top_cols']:
-					self.store_data_cols.append(col)
-		
-		# Set global treeview
-		self.treeview = treeview
-		
-		# Basic columns 
-		index = 0
-		for column_name in self.store_data_cols:
-			self.add_column(column_name, index)
-			index += 1
-		
-		self.store = gtk.TreeStore(*self.store_data_types)
-		treeview.set_model(self.store)
+                for col in plg.INTERNALS['top_cols']:
+                    self.store_data_cols.append(col)
+        
+        # Set global treeview
+        self.treeview = treeview
+        
+        # Basic columns 
+        index = 0
+        for column_name in self.store_data_cols:
+            self.add_column(column_name, index)
+            index += 1
+        
+        self.store = gtk.TreeStore(*self.store_data_types)
+        treeview.set_model(self.store)
 
-		# Update information every 1 second
-		gobject.timeout_add(500, self.load_data, treeview)
+        # Update information every 1 second
+        gobject.timeout_add(500, self.load_data, treeview)
 
-	# Add a new column to the main treeview 
-	def add_column(self, column_name, index):
-		cell = gtk.CellRendererText()
-		col_tv = gtk.TreeViewColumn(column_name, cell, text=index)
-		col_tv.set_resizable(True)
-		col_tv.connect('clicked', self.sort_column_clicked)
-		col_tv.set_property('clickable', True)
-		
-		self.treeview.append_column(col_tv)
-		
-		# Set the last column index added
-		self.last_col_index = index
+    # Add a new column to the main treeview 
+    def add_column(self, column_name, index):
+        cell = gtk.CellRendererText()
+        col_tv = gtk.TreeViewColumn(column_name, cell, text=index)
+        col_tv.set_resizable(True)
+        col_tv.connect('clicked', self.sort_column_clicked)
+        col_tv.set_property('clickable', True)
+        
+        self.treeview.append_column(col_tv)
+        
+        # Set the last column index added
+        self.last_col_index = index
 
-	# Sorting 
-	def sort_column_clicked(self, TreeViewColumn):
-		cols = self.treeview.get_columns()
+    # Sorting 
+    def sort_column_clicked(self, TreeViewColumn):
+        cols = self.treeview.get_columns()
 
-		# Searching column index
-		index = 0
-		for col in cols:
-			if col == TreeViewColumn:
-				break
-			
-			index += 1
+        # Searching column index
+        index = 0
+        for col in cols:
+            if col == TreeViewColumn:
+                break
+            
+            index += 1
 
-		self.store.set_sort_column_id(index, gtk.SORT_DESCENDING)
-		
-	def load_data(self, treeview):
-		self.store.clear()
-		
-		# Getting procfs data
-		self.procdata = proc.ProcInfo()
-		self.process_list = []
+        self.store.set_sort_column_id(index, gtk.SORT_DESCENDING)
+        
+    def load_data(self, treeview):
+        self.store.clear()
+        
+        # Getting procfs data
+        self.procdata = proc.ProcInfo()
+        self.process_list = []
 
-		pids = []
-		screen = wnck.screen_get_default()
-		windows =  screen.get_windows()
-	
-		current_pid = os.getpid()
-		
-		for win in windows:
-			pid = int(win.get_pid())
-			if current_pid != pid:
-				pids.append(pid)
-	
-		self.process_list = set(pids)
-		
-		# Sort rows using pid
-		#self.process_list.sort(key=operator.itemgetter('pid'))
-		self.process_iter = []
-	
-		for pid in self.process_list:
-			pi = self.build_row(self.store, None, self.procdata, pid)
-			self.process_iter.append(pi)
-	
-		treeview.set_rules_hint(True)
-		treeview.expand_all()
+        pids = []
+        screen = wnck.screen_get_default()
+        windows =  screen.get_windows()
+    
+        current_pid = os.getpid()
+        
+        for win in windows:
+            pid = int(win.get_pid())
+            if current_pid != pid:
+                pids.append(pid)
+    
+        self.process_list = set(pids)
+        
+        # Sort rows using pid
+        #self.process_list.sort(key=operator.itemgetter('pid'))
+        self.process_iter = []
+    
+        for pid in self.process_list:
+            pi = self.build_row(self.store, None, self.procdata, pid)
+            self.process_iter.append(pi)
+    
+        treeview.set_rules_hint(True)
+        treeview.expand_all()
 
-		return True
-	
-	def build_row(self, store, parent_iter, proc_data, pid):
-		data = []
-	
-		pinfo = proc_data.MemoryInfo(pid)
-			
-		# Look for plugins that need to update the top data treeview
-		for plg in self.plg_list:
-			plg_data = []
-			
-			if plg.INTERNALS['top_data'] != None:
-				# data = [xxx, yyy,zzz,...]
-				plg_data = plg.info.plg_on_top_data_refresh(plg, pinfo)
-								
-			for field in plg_data:
-				data.append(field)
-										
-		pi = self.insert_row(store, parent_iter, data)
-	
-		return pi
-		
-	# Insert a Row in our TreeView
-	def insert_row(self, store, parent, row_data):
-		iter = store.insert_after(parent, None)
+        return True
+    
+    def build_row(self, store, parent_iter, proc_data, pid):
+        data = []
+    
+        pinfo = proc_data.MemoryInfo(pid)
+            
+        # Look for plugins that need to update the top data treeview
+        for plg in self.plg_list:
+            plg_data = []
+            
+            if plg.INTERNALS['top_data'] != None:
+                # data = [xxx, yyy,zzz,...]
+                plg_data = plg.info.plg_on_top_data_refresh(plg, pinfo)
+                                
+            for field in plg_data:
+                data.append(field)
+                                        
+        pi = self.insert_row(store, parent_iter, data)
+    
+        return pi
+        
+    # Insert a Row in our TreeView
+    def insert_row(self, store, parent, row_data):
+        iter = store.insert_after(parent, None)
 
-		index = 0
-		
-		for data in row_data:
-			store.set_value(iter, index , data)
-			index += 1
-			
-		return iter
+        index = 0
+        
+        for data in row_data:
+            store.set_value(iter, index , data)
+            index += 1
+            
+        return iter

shell/console/plugin.py

@@ -9,42 +9,42 @@ from procmem import proc, proc_smaps, analysis
 
 class Plugin:
 
-	# Plugin list
-	list = []
-	proc = proc.ProcInfo()
-	
-	internal_plugin = "memphis_init"
-	plg_path = os.path.dirname(os.path.abspath(__file__)) + "/plugins"
-	
-	# Frequency timer, managed by main program
-	freq_timer = 0
-	
-	def __init__(self):
-		
-		sys.path.insert(0, self.plg_path)
-		
-		# Including memphis plugin
-		self.list.append(__import__(self.internal_plugin))
-		
-		if os.path.isdir(self.plg_path):
-			# around dir entries
-			for plg in os.listdir(self.plg_path):
-				
-				if plg == self.internal_plugin:
-					continue
-				
-				if os.path.isdir(self.plg_path + "/" + plg):
-					p = __import__(plg)
-					self.list.append(__import__(plg))
-			
-	# Parse /proc/PID/smaps information
-	def proc_get_smaps(self, pid):
-		return proc_smaps.ProcSmaps(pid)
-	
-	# Parse /proc/PID/maps information
-	def proc_get_maps(self, pid):
-		return proc_smaps.ProcMaps(pid)
+    # Plugin list
+    list = []
+    proc = proc.ProcInfo()
+    
+    internal_plugin = "memphis_init"
+    plg_path = os.path.dirname(os.path.abspath(__file__)) + "/plugins"
+    
+    # Frequency timer, managed by main program
+    freq_timer = 0
+    
+    def __init__(self):
+        
+        sys.path.insert(0, self.plg_path)
+        
+        # Including memphis plugin
+        self.list.append(__import__(self.internal_plugin))
+        
+        if os.path.isdir(self.plg_path):
+            # around dir entries
+            for plg in os.listdir(self.plg_path):
+                
+                if plg == self.internal_plugin:
+                    continue
+                
+                if os.path.isdir(self.plg_path + "/" + plg):
+                    p = __import__(plg)
+                    self.list.append(__import__(plg))
+            
+    # Parse /proc/PID/smaps information
+    def proc_get_smaps(self, pid):
+        return proc_smaps.ProcSmaps(pid)
+    
+    # Parse /proc/PID/maps information
+    def proc_get_maps(self, pid):
+        return proc_smaps.ProcMaps(pid)
 
-	def proc_analysis(self, pid):
-		return analysis.Analysis(pid)
-	
+    def proc_analysis(self, pid):
+        return analysis.Analysis(pid)
+    

shell/console/plugins/clean_size/__init__.py

@@ -2,15 +2,15 @@
 import info
 
 INTERNALS = {
-			# Basic information
-			'PLGNAME': "Clean Size",
-			'TABNAME': None,
-			'AUTHOR': "Eduardo Silva",
-			'DESC': "Print the approx real memory usage",
+            # Basic information
+            'PLGNAME': "Clean Size",
+            'TABNAME': None,
+            'AUTHOR': "Eduardo Silva",
+            'DESC': "Print the approx real memory usage",
 
-			# Plugin API
-			'Plg': None, # Plugin object
+            # Plugin API
+            'Plg': None, # Plugin object
 
-			'top_data': [int], # Top data types needed by memphis core plugin
-			'top_cols': ["Approx Real Usage (kb)"]
-		}
+            'top_data': [int], # Top data types needed by memphis core plugin
+            'top_cols': ["Approx Real Usage (kb)"]
+        }

shell/console/plugins/clean_size/info.py

@@ -7,9 +7,9 @@
 ############################################################
 
 def plg_on_top_data_refresh(self, pinfo):
-		
-	# Get clean size
-	maps = self.INTERNALS['Plg'].proc_get_maps(pinfo['pid'])
+        
+    # Get clean size
+    maps = self.INTERNALS['Plg'].proc_get_maps(pinfo['pid'])
 
-	size = (maps.clean_size/1024)
-	return [size]
+    size = (maps.clean_size/1024)
+    return [size]

shell/console/plugins/cpu/__init__.py

@@ -2,20 +2,20 @@ import os
 import info
 
 INTERNALS = {
-			'PLGNAME': "cpu",
-			'TABNAME': None,
-			'AUTHOR': "Eduardo Silva",
-			'DESC': "Print CPU usage",
+            'PLGNAME': "cpu",
+            'TABNAME': None,
+            'AUTHOR': "Eduardo Silva",
+            'DESC': "Print CPU usage",
 
-			# Plugin API
-			'Plg': None, # Plugin object
-			'current_plg': None, # Current plugin object
-			'current_page': None, # Current page number
+            # Plugin API
+            'Plg': None, # Plugin object
+            'current_plg': None, # Current plugin object
+            'current_page': None, # Current page number
 
-			# Top process view requirements
-			'top_data': [int], # Top data types needed by memphis core plugin
-			'top_cols': ["%CPU "] # Column names
-		}
+            # Top process view requirements
+            'top_data': [int], # Top data types needed by memphis core plugin
+            'top_cols': ["%CPU "] # Column names
+        }
 
 # Get CPU frequency 
 cpu_hz = os.sysconf(2)

shell/console/plugins/cpu/info.py

@@ -7,42 +7,42 @@
 ############################################################
 
 def plg_on_top_data_refresh(self, pinfo):
-	PI = self.INTERNALS['Plg'].proc
-	
-	pid = pinfo['pid']
-	
-	# Get JIFFIES CPU usage
-	used_jiffies = pinfo['utime'] + pinfo['stime']
-	last_ujiffies = get_pid_ujiffies(self, pid)
-	
-	cpu_usage = PI.get_CPU_usage(self.cpu_hz, used_jiffies, pinfo['start_time'])
+    PI = self.INTERNALS['Plg'].proc
+    
+    pid = pinfo['pid']
+    
+    # Get JIFFIES CPU usage
+    used_jiffies = pinfo['utime'] + pinfo['stime']
+    last_ujiffies = get_pid_ujiffies(self, pid)
+    
+    cpu_usage = PI.get_CPU_usage(self.cpu_hz, used_jiffies, pinfo['start_time'])
 
-	# Get PERCENT CPU usage
-	if last_ujiffies == 0.0:
-		pcpu = 0.0
-		set_pid_ujiffies(self, pid, cpu_usage['used_jiffies'])
-		data = [int(pcpu)]
-		return data
-				
-	used_jiffies  = cpu_usage['used_jiffies'] - last_ujiffies
+    # Get PERCENT CPU usage
+    if last_ujiffies == 0.0:
+        pcpu = 0.0
+        set_pid_ujiffies(self, pid, cpu_usage['used_jiffies'])
+        data = [int(pcpu)]
+        return data
+                
+    used_jiffies  = cpu_usage['used_jiffies'] - last_ujiffies
 
-	# Available jiffies are
-	avail_jiffies = (500/1000.0)*self.cpu_hz # 500 = 0.5 second
-	pcpu = ((used_jiffies*100)/avail_jiffies)
-	
-	set_pid_ujiffies(self, pid, cpu_usage['used_jiffies'])
-		
-	data = [int(pcpu)]
-	return data
+    # Available jiffies are
+    avail_jiffies = (500/1000.0)*self.cpu_hz # 500 = 0.5 second
+    pcpu = ((used_jiffies*100)/avail_jiffies)
+    
+    set_pid_ujiffies(self, pid, cpu_usage['used_jiffies'])
+        
+    data = [int(pcpu)]
+    return data
 
 def get_pid_ujiffies(self, pid):
-	
-	if pid in self.pids_ujiffies:
-		return self.pids_ujiffies[pid]
-	else:
-		set_pid_ujiffies(self, pid, 0)
-		return self.pids_ujiffies[pid]
+    
+    if pid in self.pids_ujiffies:
+        return self.pids_ujiffies[pid]
+    else:
+        set_pid_ujiffies(self, pid, 0)
+        return self.pids_ujiffies[pid]
 
 def set_pid_ujiffies(self, pid, ujiffies):
-	self.pids_ujiffies[pid] = ujiffies
+    self.pids_ujiffies[pid] = ujiffies
 

shell/console/plugins/dirty_size/__init__.py

@@ -3,15 +3,15 @@ import info
 
 
 INTERNALS = {
-			# Basic information
-			'PLGNAME': "Dirty Size",
-			'TABNAME': None, # No tabbed plugin
-			'AUTHOR': "Eduardo Silva",
-			'DESC': "Get dirty size memory usage",
+            # Basic information
+            'PLGNAME': "Dirty Size",
+            'TABNAME': None, # No tabbed plugin
+            'AUTHOR': "Eduardo Silva",
+            'DESC': "Get dirty size memory usage",
 
-			# Plugin API
-			'Plg': None, # Plugin object
+            # Plugin API
+            'Plg': None, # Plugin object
 
-			'top_data': [int], # Top data types needed by memphis core plugin
-			'top_cols': ["PDRSS (kb)"]
-		}
+            'top_data': [int], # Top data types needed by memphis core plugin
+            'top_cols': ["PDRSS (kb)"]
+        }

shell/console/plugins/dirty_size/info.py

@@ -9,12 +9,12 @@
 
 def plg_on_top_data_refresh(self, ppinfo):
 
-	dirty_sizes = get_dirty(self, ppinfo['pid'])
-	
-	# memhis need an array 
-	return [dirty_sizes['private']]
+    dirty_sizes = get_dirty(self, ppinfo['pid'])
+    
+    # memhis need an array 
+    return [dirty_sizes['private']]
 
 def get_dirty(pself, pid):
-	ProcAnalysis = pself.INTERNALS['Plg'].proc_analysis(pid)
+    ProcAnalysis = pself.INTERNALS['Plg'].proc_analysis(pid)
 
-	return ProcAnalysis.DirtyRSS()
+    return ProcAnalysis.DirtyRSS()

shell/console/plugins/memphis_init/__init__.py

@@ -1,15 +1,15 @@
 import info
 
 INTERNALS = {
-			'PLGNAME': "memphis",
-			'TABNAME': None,
-			'AUTHOR': "Eduardo Silva",
-			'DESC': "Print basic process information",
+            'PLGNAME': "memphis",
+            'TABNAME': None,
+            'AUTHOR': "Eduardo Silva",
+            'DESC': "Print basic process information",
 
-			# Plugin API
-			'Plg': None, # Plugin object
+            # Plugin API
+            'Plg': None, # Plugin object
 
-			# Top process view requirements
-			'top_data': [int, str, str], # Top data types needed by memphis core plugin
-			'top_cols': ["PID", "Process Name", "Status"] # Column names
-		}
+            # Top process view requirements
+            'top_data': [int, str, str], # Top data types needed by memphis core plugin
+            'top_cols': ["PID", "Process Name", "Status"] # Column names
+        }

shell/console/plugins/memphis_init/info.py

@@ -8,6 +8,6 @@
 
 def plg_on_top_data_refresh(self, ppinfo):
 
-	data = [ppinfo['pid'], ppinfo['name'], ppinfo['state_name']]
-		
-	return data
+    data = [ppinfo['pid'], ppinfo['name'], ppinfo['state_name']]
+        
+    return data

shell/console/procmem/analysis.py

@@ -1,30 +1,30 @@
 import proc, proc_smaps
 
 class Analysis:
-	
-	pid = 0
-	
-	def __init__(self, pid):
-		self.pid = pid
-	
-	def DirtyRSS(self):
-		smaps =	proc_smaps.ProcSmaps(self.pid)
-		dirty = []
+    
+    pid = 0
+    
+    def __init__(self, pid):
+        self.pid = pid
+    
+    def DirtyRSS(self):
+        smaps =    proc_smaps.ProcSmaps(self.pid)
+        dirty = []
 
-		private = 0
-		shared = 0
-		
-		for map in smaps.mappings:
-			private += map.private_dirty
-			shared  += map.shared_dirty
+        private = 0
+        shared = 0
+        
+        for map in smaps.mappings:
+            private += map.private_dirty
+            shared  += map.shared_dirty
 
-		dirty = {"private": int(private), "shared": int(shared)}
+        dirty = {"private": int(private), "shared": int(shared)}
 
-		return dirty
-	
-	def ApproxRealMemoryUsage(self):
-		maps = proc_smaps.ProcMaps(self.pid)
-		size = (maps.clean_size/1024)
+        return dirty
+    
+    def ApproxRealMemoryUsage(self):
+        maps = proc_smaps.ProcMaps(self.pid)
+        size = (maps.clean_size/1024)
 
-		return size
-	
+        return size
+    

shell/console/procmem/proc.py

@@ -5,96 +5,96 @@ import string
 
 class ProcInfo:
 
-	dir_path	= "/proc/"	# Our cute Proc File System
-	status_file = "status"
-	stat_file	= "stat"
-	
-	proc_list = [] # Our PID list :D
-	proc_info = [] # 
-	
-	def __init__(self):
-		self.proc_list = self.Get_PID_List()
-		
-	# Returns Process List
-	def Get_PID_List(self):
-		list = []
-		
-		# Exists our procfs ?
-		if os.path.isdir(self.dir_path):
-			# around dir entries
-			for f in os.listdir(self.dir_path):
-				if os.path.isdir(self.dir_path+f) & str.isdigit(f):
-						list.append(int(f))
+    dir_path    = "/proc/"    # Our cute Proc File System
+    status_file = "status"
+    stat_file    = "stat"
+    
+    proc_list = [] # Our PID list :D
+    proc_info = [] # 
+    
+    def __init__(self):
+        self.proc_list = self.Get_PID_List()
+        
+    # Returns Process List
+    def Get_PID_List(self):
+        list = []
+        
+        # Exists our procfs ?
+        if os.path.isdir(self.dir_path):
+            # around dir entries
+            for f in os.listdir(self.dir_path):
+                if os.path.isdir(self.dir_path+f) & str.isdigit(f):
+                        list.append(int(f))
 
-		return list
-	
-	def MemoryInfo(self, pid):
-		# Path
-		pidfile = self.dir_path + str(pid) + "/stat"
-		try:
-			infile = open(pidfile, "r")
-		except:
-			print "Error trying " + pidfile
-			return None
+        return list
+    
+    def MemoryInfo(self, pid):
+        # Path
+        pidfile = self.dir_path + str(pid) + "/stat"
+        try:
+            infile = open(pidfile, "r")
+        except:
+            print "Error trying " + pidfile
+            return None
 
-		# Parsing data , check 'man 5 proc' for details
-		data = infile.read().split()
+        # Parsing data , check 'man 5 proc' for details
+        data = infile.read().split()
 
-		infile.close()
-		
-		state_dic = {
-					'R': 'Running',
-					'S': 'Sleeping', 
-					'D': 'Disk sleep',
-					'Z': 'Zombie', 
-					'T': 'Traced/Stopped', 
-					'W': 'Paging'
-					}
+        infile.close()
+        
+        state_dic = {
+                    'R': 'Running',
+                    'S': 'Sleeping', 
+                    'D': 'Disk sleep',
+                    'Z': 'Zombie', 
+                    'T': 'Traced/Stopped', 
+                    'W': 'Paging'
+                    }
 
-		# user and group owners
-		pidstat = os.stat(pidfile)
-		
-		info = {
-			'pid':		int(data[0]), # Process ID
-			'name':		data[1].strip('()'), # Process name
-			'state':	data[2], # Process State, ex: R|S|D|Z|T|W
-			'state_name':	state_dic[data[2]], # Process State name, ex: Running, sleeping, Zombie, etc
-			'ppid':		int(data[3]), # Parent process ID
-			'utime':	int(data[13]), # Used jiffies in user mode
-			'stime':	int(data[14]), # Used jiffies in kernel mode
-			'start_time':	int(data[21]), # Process time from system boot (jiffies)
-			'vsize':	int(data[22]), # Virtual memory size used (bytes)
-			'rss':		int(data[23])*4,	# Resident Set Size (bytes)
-			'user_id': pidstat.st_uid, # process owner
-			'group_id': pidstat.st_gid # owner group
-		}
-		
-		return info
-		
+        # user and group owners
+        pidstat = os.stat(pidfile)
+        
+        info = {
+            'pid':        int(data[0]), # Process ID
+            'name':        data[1].strip('()'), # Process name
+            'state':    data[2], # Process State, ex: R|S|D|Z|T|W
+            'state_name':    state_dic[data[2]], # Process State name, ex: Running, sleeping, Zombie, etc
+            'ppid':        int(data[3]), # Parent process ID
+            'utime':    int(data[13]), # Used jiffies in user mode
+            'stime':    int(data[14]), # Used jiffies in kernel mode
+            'start_time':    int(data[21]), # Process time from system boot (jiffies)
+            'vsize':    int(data[22]), # Virtual memory size used (bytes)
+            'rss':        int(data[23])*4,    # Resident Set Size (bytes)
+            'user_id': pidstat.st_uid, # process owner
+            'group_id': pidstat.st_gid # owner group
+        }
+        
+        return info
+        
 
-	# Returns the CPU usage expressed in Jiffies
-	def get_CPU_usage(self, cpu_hz, used_jiffies, start_time):
-		
-		# Uptime info
-		uptime_file = self.dir_path + "/uptime"
-		try:
-			infile = file(uptime_file, "r")
-		except:
-			print "Error trying uptime file"
-			return None
-		
-		uptime_line = infile.readline()
-		uptime = string.split(uptime_line, " ",2)
-		
-		infile.close()
-				
-		# System uptime, from /proc/uptime
-		uptime = float(uptime[0])
-		
-		# Jiffies
-		avail_jiffies = (uptime * cpu_hz) - start_time
-		
-		cpu_usage = {'used_jiffies': used_jiffies, 'avail_jiffies': avail_jiffies}
+    # Returns the CPU usage expressed in Jiffies
+    def get_CPU_usage(self, cpu_hz, used_jiffies, start_time):
+        
+        # Uptime info
+        uptime_file = self.dir_path + "/uptime"
+        try:
+            infile = file(uptime_file, "r")
+        except:
+            print "Error trying uptime file"
+            return None
+        
+        uptime_line = infile.readline()
+        uptime = string.split(uptime_line, " ",2)
+        
+        infile.close()
+                
+        # System uptime, from /proc/uptime
+        uptime = float(uptime[0])
+        
+        # Jiffies
+        avail_jiffies = (uptime * cpu_hz) - start_time
+        
+        cpu_usage = {'used_jiffies': used_jiffies, 'avail_jiffies': avail_jiffies}
 
-		return cpu_usage
+        return cpu_usage
 

shell/console/procmem/proc_smaps.py

@@ -9,121 +9,121 @@ import os
 # Parse the /proc/PID/smaps file
 class ProcSmaps:
 
-	mappings = [] # Devices information
-	
-	def __init__(self, pid):
-		
-		smapfile = "/proc/%s/smaps" % pid
-		self.mappings = []
-		
-		# Coded by Federico Mena (script)
-		try:
-			infile = open(smapfile, "r")
-			input = infile.read()
-			infile.close()
-		except:
-			print "Error trying " + smapfile
-			return
-		
-		lines = input.splitlines()
+    mappings = [] # Devices information
+    
+    def __init__(self, pid):
+        
+        smapfile = "/proc/%s/smaps" % pid
+        self.mappings = []
+        
+        # Coded by Federico Mena (script)
+        try:
+            infile = open(smapfile, "r")
+            input = infile.read()
+            infile.close()
+        except:
+            print "Error trying " + smapfile
+            return
+        
+        lines = input.splitlines()
 
-		num_lines = len (lines)
-		line_idx = 0
-	
-		# 08065000-08067000 rw-p 0001c000 03:01 147613     /opt/gnome/bin/evolution-2.6
-		# Size:                 8 kB
-		# Rss:                  8 kB
-		# Shared_Clean:         0 kB
-		# Shared_Dirty:         0 kB
-		# Private_Clean:        8 kB
-		# Private_Dirty:        0 kB
-	
-		while num_lines > 0:
-			fields = lines[line_idx].split (" ", 5)
-			if len (fields) == 6:
-				(offsets, permissions, bin_permissions, device, inode, name) = fields
-			else:
-				(offsets, permissions, bin_permissions, device, inode) = fields
-				name = ""
-	
-			size          = self.parse_smaps_size_line (lines[line_idx + 1])
-			rss           = self.parse_smaps_size_line (lines[line_idx + 2])
-			shared_clean  = self.parse_smaps_size_line (lines[line_idx + 3])
-			shared_dirty  = self.parse_smaps_size_line (lines[line_idx + 4])
-			private_clean = self.parse_smaps_size_line (lines[line_idx + 5])
-			private_dirty = self.parse_smaps_size_line (lines[line_idx + 6])
-			name = name.strip ()
+        num_lines = len (lines)
+        line_idx = 0
+    
+        # 08065000-08067000 rw-p 0001c000 03:01 147613     /opt/gnome/bin/evolution-2.6
+        # Size:                 8 kB
+        # Rss:                  8 kB
+        # Shared_Clean:         0 kB
+        # Shared_Dirty:         0 kB
+        # Private_Clean:        8 kB
+        # Private_Dirty:        0 kB
+    
+        while num_lines > 0:
+            fields = lines[line_idx].split (" ", 5)
+            if len (fields) == 6:
+                (offsets, permissions, bin_permissions, device, inode, name) = fields
+            else:
+                (offsets, permissions, bin_permissions, device, inode) = fields
+                name = ""
+    
+            size          = self.parse_smaps_size_line (lines[line_idx + 1])
+            rss           = self.parse_smaps_size_line (lines[line_idx + 2])
+            shared_clean  = self.parse_smaps_size_line (lines[line_idx + 3])
+            shared_dirty  = self.parse_smaps_size_line (lines[line_idx + 4])
+            private_clean = self.parse_smaps_size_line (lines[line_idx + 5])
+            private_dirty = self.parse_smaps_size_line (lines[line_idx + 6])
+            name = name.strip ()
 
-			mapping = Mapping (size, rss, shared_clean, shared_dirty, private_clean, private_dirty, permissions, name)
-			self.mappings.append (mapping)
+            mapping = Mapping (size, rss, shared_clean, shared_dirty, private_clean, private_dirty, permissions, name)
+            self.mappings.append (mapping)
 
-			num_lines -= 7
-			line_idx += 7
+            num_lines -= 7
+            line_idx += 7
 
-	# Parses a line of the form "foo: 42 kB" and returns an integer for the "42" field
-	def parse_smaps_size_line (self, line):
-		# Rss:                  8 kB
-		fields = line.split ()
-		return int(fields[1])
+    # Parses a line of the form "foo: 42 kB" and returns an integer for the "42" field
+    def parse_smaps_size_line (self, line):
+        # Rss:                  8 kB
+        fields = line.split ()
+        return int(fields[1])
 
 class Mapping:
-	def __init__ (self, size, rss, shared_clean, shared_dirty, private_clean, private_dirty, permissions, name):
-		self.size = size
-		self.rss = rss
-		self.shared_clean = shared_clean
-		self.shared_dirty = shared_dirty
-		self.private_clean = private_clean
-		self.private_dirty = private_dirty
-		self.permissions = permissions
-		self.name = name
+    def __init__ (self, size, rss, shared_clean, shared_dirty, private_clean, private_dirty, permissions, name):
+        self.size = size
+        self.rss = rss
+        self.shared_clean = shared_clean
+        self.shared_dirty = shared_dirty
+        self.private_clean = private_clean
+        self.private_dirty = private_dirty
+        self.permissions = permissions
+        self.name = name
 
 # Parse /proc/PID/maps file to get the clean memory usage by process,
 # we avoid lines with backed-files
 class ProcMaps:
-	
-	clean_size = 0
-	
-	def __init__(self, pid):
-		mapfile = "/proc/%s/maps" % pid
+    
+    clean_size = 0
+    
+    def __init__(self, pid):
+        mapfile = "/proc/%s/maps" % pid
 
-		try:
-			infile = open(mapfile, "r")
-		except:
-			print "Error trying " + mapfile
-			return None
-			
-		sum = 0
-		to_data_do = {
-			"[anon]": self.parse_size_line,
-			"[heap]": self.parse_size_line
-		}
-		
-		for line in infile:
-			arr = line.split()
-			
-			# Just parse writable mapped areas
-			if arr[1][1] != "w":
-				continue
-			
-			if len(arr) == 6:				
-				# if we got a backed-file we skip this info
-				if os.path.isfile(arr[5]):
-					continue
-				else:
-					line_size = to_data_do.get(arr[5], self.skip)(line)
-					sum += line_size
-			else:
-				line_size = self.parse_size_line(line)
-				sum += line_size
-					
-		infile.close()
-		self.clean_size = sum
-		
-	def skip(self, line):
-		return 0
-	
-	# Parse a maps line and return the mapped size
-	def parse_size_line(self, line):
-		start, end = line.split()[0].split('-')
-		size = int(end, 16) - int(start, 16)			
-		return size
+        try:
+            infile = open(mapfile, "r")
+        except:
+            print "Error trying " + mapfile
+            return None
+            
+        sum = 0
+        to_data_do = {
+            "[anon]": self.parse_size_line,
+            "[heap]": self.parse_size_line
+        }
+        
+        for line in infile:
+            arr = line.split()
+            
+            # Just parse writable mapped areas
+            if arr[1][1] != "w":
+                continue
+            
+            if len(arr) == 6:                
+                # if we got a backed-file we skip this info
+                if os.path.isfile(arr[5]):
+                    continue
+                else:
+                    line_size = to_data_do.get(arr[5], self.skip)(line)
+                    sum += line_size
+            else:
+                line_size = self.parse_size_line(line)
+                sum += line_size
+                    
+        infile.close()
+        self.clean_size = sum
+        
+    def skip(self, line):
+        return 0
+    
+    # Parse a maps line and return the mapped size
+    def parse_size_line(self, line):
+        start, end = line.split()[0].split('-')
+        size = int(end, 16) - int(start, 16)            
+        return size

shell/console/terminal.py

@@ -3,141 +3,141 @@ import vte
 import pango
 
 class Terminal(gtk.HBox):
-	def __init__(self):
-		gtk.HBox.__init__(self, False, 4)
+    def __init__(self):
+        gtk.HBox.__init__(self, False, 4)
 
-		self._vte = vte.Terminal()
-		self._configure_vte()
-		self._vte.set_size(30, 5)
-		self._vte.set_size_request(200, 450)
-		self._vte.show()
-		self.pack_start(self._vte)
-		
-		self._scrollbar = gtk.VScrollbar(self._vte.get_adjustment())
-		self._scrollbar.show()
-		self.pack_start(self._scrollbar, False, False, 0)
-		
-		self._vte.connect("child-exited", lambda term: term.fork_command())
+        self._vte = vte.Terminal()
+        self._configure_vte()
+        self._vte.set_size(30, 5)
+        self._vte.set_size_request(200, 450)
+        self._vte.show()
+        self.pack_start(self._vte)
+        
+        self._scrollbar = gtk.VScrollbar(self._vte.get_adjustment())
+        self._scrollbar.show()
+        self.pack_start(self._scrollbar, False, False, 0)
+        
+        self._vte.connect("child-exited", lambda term: term.fork_command())
 
-		self._vte.fork_command()
+        self._vte.fork_command()
 
-	def _configure_vte(self):
-		self._vte.set_font(pango.FontDescription('Monospace 10'))
-		self._vte.set_colors(gtk.gdk.color_parse ('#AAAAAA'),
-							gtk.gdk.color_parse ('#000000'),
-							[])
-		self._vte.set_cursor_blinks(False)
-		self._vte.set_audible_bell(False)
-		self._vte.set_scrollback_lines(100)
-		self._vte.set_allow_bold(True)
-		self._vte.set_scroll_on_keystroke(False)
-		self._vte.set_scroll_on_output(False)
-		self._vte.set_emulation('xterm')
-		self._vte.set_visible_bell(False)
+    def _configure_vte(self):
+        self._vte.set_font(pango.FontDescription('Monospace 10'))
+        self._vte.set_colors(gtk.gdk.color_parse ('#AAAAAA'),
+                            gtk.gdk.color_parse ('#000000'),
+                            [])
+        self._vte.set_cursor_blinks(False)
+        self._vte.set_audible_bell(False)
+        self._vte.set_scrollback_lines(100)
+        self._vte.set_allow_bold(True)
+        self._vte.set_scroll_on_keystroke(False)
+        self._vte.set_scroll_on_output(False)
+        self._vte.set_emulation('xterm')
+        self._vte.set_visible_bell(False)
 
-	def on_gconf_notification(self, client, cnxn_id, entry, what):
-		self.reconfigure_vte()
+    def on_gconf_notification(self, client, cnxn_id, entry, what):
+        self.reconfigure_vte()
 
-	def on_vte_button_press(self, term, event):
-		if event.button == 3:
-			self.do_popup(event)
-			return True
+    def on_vte_button_press(self, term, event):
+        if event.button == 3:
+            self.do_popup(event)
+            return True
 
-	def on_vte_popup_menu(self, term):
-		pass
+    def on_vte_popup_menu(self, term):
+        pass
 
 class Multiple:
-	
-	page_number = 0
-	
-	def __init__(self):
-		self.notebook = gtk.Notebook()
-		self.add_new_terminal()
-		
-		open_terminal = gtk.Button('Open a new terminal')
-		open_terminal.connect("clicked", self.add_new_terminal)
-		open_terminal.show()
-				
-		self.notebook.show()
-		
-		self.main_vbox = gtk.VBox(False, 3)
-		self.main_vbox.pack_start(open_terminal, True, True, 2)
-		self.main_vbox.pack_start(self.notebook, True, True, 2)
+    
+    page_number = 0
+    
+    def __init__(self):
+        self.notebook = gtk.Notebook()
+        self.add_new_terminal()
+        
+        open_terminal = gtk.Button('Open a new terminal')
+        open_terminal.connect("clicked", self.add_new_terminal)
+        open_terminal.show()
+                
+        self.notebook.show()
+        
+        self.main_vbox = gtk.VBox(False, 3)
+        self.main_vbox.pack_start(open_terminal, True, True, 2)
+        self.main_vbox.pack_start(self.notebook, True, True, 2)
 
-		self.main_vbox.show_all()
-	
-	# Remove a page from the notebook
-	def close_terminal(self, button, child):
-		page = self.notebook.page_num(child)
+        self.main_vbox.show_all()
+    
+    # Remove a page from the notebook
+    def close_terminal(self, button, child):
+        page = self.notebook.page_num(child)
 
-		if page != -1:
-			self.notebook.remove_page(page)
-		
-		
-		pages = self.notebook.get_n_pages()
-		if pages <= 0:
-			self.page_number = 0
-			self.add_new_terminal()
-			
-		# Need to refresh the widget --
-		# This forces the widget to redraw itself.
-		self.notebook.queue_draw_area(0, 0, -1, -1)
+        if page != -1:
+            self.notebook.remove_page(page)
+        
+        
+        pages = self.notebook.get_n_pages()
+        if pages <= 0:
+            self.page_number = 0
+            self.add_new_terminal()
+            
+        # Need to refresh the widget --
+        # This forces the widget to redraw itself.
+        self.notebook.queue_draw_area(0, 0, -1, -1)
 
-	def add_icon_to_button(self, button):
-		iconBox = gtk.HBox(False, 0)
-		image = gtk.Image()
-		image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
-		gtk.Button.set_relief(button, gtk.RELIEF_NONE)
+    def add_icon_to_button(self, button):
+        iconBox = gtk.HBox(False, 0)
+        image = gtk.Image()
+        image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
+        gtk.Button.set_relief(button, gtk.RELIEF_NONE)
 
-		settings = gtk.Widget.get_settings (button)
-		(w,h) = gtk.icon_size_lookup_for_settings (settings, gtk.ICON_SIZE_MENU)
-		gtk.Widget.set_size_request (button, w + 4, h + 4)
-		image.show()
-		iconBox.pack_start(image, True, False, 0)
-		button.add(iconBox)
-		iconBox.show()
+        settings = gtk.Widget.get_settings (button)
+        (w,h) = gtk.icon_size_lookup_for_settings (settings, gtk.ICON_SIZE_MENU)
+        gtk.Widget.set_size_request (button, w + 4, h + 4)
+        image.show()
+        iconBox.pack_start(image, True, False, 0)
+        button.add(iconBox)
+        iconBox.show()
 
-	def add_new_terminal(self, *arguments, **keywords):
-		self.page_number += 1
+    def add_new_terminal(self, *arguments, **keywords):
+        self.page_number += 1
 
-		terminal = Terminal()
-		terminal.show()
+        terminal = Terminal()
+        terminal.show()
 
-		eventBox = self.create_custom_tab("Term %d" % self.page_number, terminal)
-		self.notebook.append_page(terminal, eventBox)
+        eventBox = self.create_custom_tab("Term %d" % self.page_number, terminal)
+        self.notebook.append_page(terminal, eventBox)
 
-		# Set the new page
-		pages = gtk.Notebook.get_n_pages(self.notebook)
-		self.notebook.set_current_page(pages - 1)
-		return True
+        # Set the new page
+        pages = gtk.Notebook.get_n_pages(self.notebook)
+        self.notebook.set_current_page(pages - 1)
+        return True
 
-	def create_custom_tab(self, text, child):
-		eventBox = gtk.EventBox()
-		tabBox = gtk.HBox(False, 2)
-		tabLabel = gtk.Label(text)
+    def create_custom_tab(self, text, child):
+        eventBox = gtk.EventBox()
+        tabBox = gtk.HBox(False, 2)
+        tabLabel = gtk.Label(text)
 
-		tabButton = gtk.Button()
-		tabButton.connect('clicked', self.close_terminal, child)
+        tabButton = gtk.Button()
+        tabButton.connect('clicked', self.close_terminal, child)
 
-		# Add a picture on a button
-		self.add_icon_to_button(tabButton)
-		iconBox = gtk.HBox(False, 0)
+        # Add a picture on a button
+        self.add_icon_to_button(tabButton)
+        iconBox = gtk.HBox(False, 0)
 
-		eventBox.show()
-		tabButton.show()
-		tabLabel.show()
+        eventBox.show()
+        tabButton.show()
+        tabLabel.show()
 
-		tabBox.pack_start(tabLabel, False)
-		tabBox.pack_start(tabButton, False)
+        tabBox.pack_start(tabLabel, False)
+        tabBox.pack_start(tabButton, False)
 
-		tabBox.show_all()
-		eventBox.add(tabBox)
-		
-		return eventBox
+        tabBox.show_all()
+        eventBox.add(tabBox)
+        
+        return eventBox
 
 class Interface:
 
-	def __init__(self):
-		multiple = Multiple()
-		self.widget = multiple.main_vbox
-		
+    def __init__(self):
+        multiple = Multiple()
+        self.widget = multiple.main_vbox
+        

shell/model/BuddyModel.py

@@ -21,122 +21,122 @@ import gobject
 _NOT_PRESENT_COLOR = "#888888,#BBBBBB"
 
 class BuddyModel(gobject.GObject):
-	__gsignals__ = {
-		'appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
-		'disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
-		'color-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'icon-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([])),
-		'current-activity-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-									([gobject.TYPE_PYOBJECT]))
-	}
+    __gsignals__ = {
+        'appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
+        'disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
+        'color-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'icon-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([])),
+        'current-activity-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                                    ([gobject.TYPE_PYOBJECT]))
+    }
 
-	def __init__(self, name=None, buddy=None):
-		if name and buddy:
-			raise RuntimeError("Must specify only _one_ of name or buddy.")
+    def __init__(self, name=None, buddy=None):
+        if name and buddy:
+            raise RuntimeError("Must specify only _one_ of name or buddy.")
 
-		gobject.GObject.__init__(self)
+        gobject.GObject.__init__(self)
 
-		self._ba_handler = None
-		self._pc_handler = None
-		self._dis_handler = None
-		self._bic_handler = None
-		self._cac_handler = None
+        self._ba_handler = None
+        self._pc_handler = None
+        self._dis_handler = None
+        self._bic_handler = None
+        self._cac_handler = None
 
-		self._pservice = PresenceService.get_instance()
+        self._pservice = PresenceService.get_instance()
 
-		self._buddy = None
+        self._buddy = None
 
-		# If given just a name, try to get the buddy from the PS first
-		if not buddy:
-			self._name = name
-			# FIXME: use public key, not name
-			buddy = self._pservice.get_buddy_by_name(self._name)
+        # If given just a name, try to get the buddy from the PS first
+        if not buddy:
+            self._name = name
+            # FIXME: use public key, not name
+            buddy = self._pservice.get_buddy_by_name(self._name)
 
-		# If successful, copy properties from the PS buddy object
-		if buddy:
-			self.__update_buddy(buddy)
-		else:
-			# Otherwise, connect to the PS's buddy-appeared signal and
-			# wait for the buddy to appear
-			self._ba_handler = self._pservice.connect('buddy-appeared',
-					self.__buddy_appeared_cb)
-			self._name = name
-			# Set color to 'inactive'/'disconnected'
-			self.__set_color_from_string(_NOT_PRESENT_COLOR)
+        # If successful, copy properties from the PS buddy object
+        if buddy:
+            self.__update_buddy(buddy)
+        else:
+            # Otherwise, connect to the PS's buddy-appeared signal and
+            # wait for the buddy to appear
+            self._ba_handler = self._pservice.connect('buddy-appeared',
+                    self.__buddy_appeared_cb)
+            self._name = name
+            # Set color to 'inactive'/'disconnected'
+            self.__set_color_from_string(_NOT_PRESENT_COLOR)
 
-	def __set_color_from_string(self, color_string):
-		self._color = IconColor(color_string)
+    def __set_color_from_string(self, color_string):
+        self._color = IconColor(color_string)
 
-	def get_name(self):
-		return self._name
+    def get_name(self):
+        return self._name
 
-	def get_color(self):
-		return self._color
+    def get_color(self):
+        return self._color
 
-	def get_buddy(self):
-		return self._buddy
+    def get_buddy(self):
+        return self._buddy
 
-	def is_present(self):
-		if self._buddy:
-			return True
-		return False
+    def is_present(self):
+        if self._buddy:
+            return True
+        return False
 
-	def get_current_activity(self):
-		if self._buddy:
-			return self._buddy.get_current_activity()
-		return None
+    def get_current_activity(self):
+        if self._buddy:
+            return self._buddy.get_current_activity()
+        return None
 
-	def __update_buddy(self, buddy):
-		if not buddy:
-			raise ValueError("Buddy cannot be None.")
+    def __update_buddy(self, buddy):
+        if not buddy:
+            raise ValueError("Buddy cannot be None.")
 
-		self._buddy = buddy
-		self._name = self._buddy.get_name()
-		self.__set_color_from_string(self._buddy.get_color())
+        self._buddy = buddy
+        self._name = self._buddy.get_name()
+        self.__set_color_from_string(self._buddy.get_color())
 
-		self._pc_handler = self._buddy.connect('property-changed', self.__buddy_property_changed_cb)
-		self._dis_handler = self._buddy.connect('disappeared', self.__buddy_disappeared_cb)
-		self._bic_handler = self._buddy.connect('icon-changed', self.__buddy_icon_changed_cb)
-		self._cac_handler = self._buddy.connect('current-activity-changed', self.__buddy_current_activity_changed_cb)
+        self._pc_handler = self._buddy.connect('property-changed', self.__buddy_property_changed_cb)
+        self._dis_handler = self._buddy.connect('disappeared', self.__buddy_disappeared_cb)
+        self._bic_handler = self._buddy.connect('icon-changed', self.__buddy_icon_changed_cb)
+        self._cac_handler = self._buddy.connect('current-activity-changed', self.__buddy_current_activity_changed_cb)
 
-	def __buddy_appeared_cb(self, pservice, buddy):
-		# FIXME: use public key rather than buddy name
-		if self._buddy or buddy.get_name() != self._name:
-			return
+    def __buddy_appeared_cb(self, pservice, buddy):
+        # FIXME: use public key rather than buddy name
+        if self._buddy or buddy.get_name() != self._name:
+            return
 
-		if self._ba_handler:
-			# Once we have the buddy, we no longer need to
-			# monitor buddy-appeared events
-			self._pservice.disconnect(self._ba_handler)
-			self._ba_handler = None
+        if self._ba_handler:
+            # Once we have the buddy, we no longer need to
+            # monitor buddy-appeared events
+            self._pservice.disconnect(self._ba_handler)
+            self._ba_handler = None
 
-		self.__update_buddy(buddy)
-		self.emit('appeared')
+        self.__update_buddy(buddy)
+        self.emit('appeared')
 
-	def __buddy_property_changed_cb(self, buddy, keys):
-		if not self._buddy:
-			return
-		if 'color' in keys:
-			self.__set_color_from_string(self._buddy.get_color())
-			self.emit('color-changed', self.get_color())
+    def __buddy_property_changed_cb(self, buddy, keys):
+        if not self._buddy:
+            return
+        if 'color' in keys:
+            self.__set_color_from_string(self._buddy.get_color())
+            self.emit('color-changed', self.get_color())
 
-	def __buddy_disappeared_cb(self, buddy):
-		if buddy != self._buddy:
-			return
-		self._buddy.disconnect(self._pc_handler)
-		self._buddy.disconnect(self._dis_handler)
-		self._buddy.disconnect(self._bic_handler)
-		self._buddy.disconnect(self._cac_handler)
-		self.__set_color_from_string(_NOT_PRESENT_COLOR)
-		self.emit('disappeared')
-		self._buddy = None
+    def __buddy_disappeared_cb(self, buddy):
+        if buddy != self._buddy:
+            return
+        self._buddy.disconnect(self._pc_handler)
+        self._buddy.disconnect(self._dis_handler)
+        self._buddy.disconnect(self._bic_handler)
+        self._buddy.disconnect(self._cac_handler)
+        self.__set_color_from_string(_NOT_PRESENT_COLOR)
+        self.emit('disappeared')
+        self._buddy = None
 
-	def __buddy_icon_changed_cb(self, buddy):
-		self.emit('icon-changed')
+    def __buddy_icon_changed_cb(self, buddy):
+        self.emit('icon-changed')
 
-	def __buddy_current_activity_changed_cb(self, buddy, activity=None):
-		if not self._buddy:
-			return
-		self.emit('current-activity-changed', activity)
+    def __buddy_current_activity_changed_cb(self, buddy, activity=None):
+        if not self._buddy:
+            return
+        self.emit('current-activity-changed', activity)

shell/model/Friends.py

@@ -24,61 +24,61 @@ from sugar import env
 import logging
 
 class Friends(gobject.GObject):
-	__gsignals__ = {
-		'friend-added':   (gobject.SIGNAL_RUN_FIRST,
-						   gobject.TYPE_NONE, ([object])),
-		'friend-removed': (gobject.SIGNAL_RUN_FIRST,
-						   gobject.TYPE_NONE, ([str])),
-	}
+    __gsignals__ = {
+        'friend-added':   (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE, ([object])),
+        'friend-removed': (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE, ([str])),
+    }
 
-	def __init__(self):
-		gobject.GObject.__init__(self)
+    def __init__(self):
+        gobject.GObject.__init__(self)
 
-		self._friends = {}
-		self._path = os.path.join(env.get_profile_path(), 'friends')
+        self._friends = {}
+        self._path = os.path.join(env.get_profile_path(), 'friends')
 
-		self.load()
+        self.load()
 
-	def has_buddy(self, buddy):
-		return self._friends.has_key(buddy.get_name())
+    def has_buddy(self, buddy):
+        return self._friends.has_key(buddy.get_name())
 
-	def add_friend(self, buddy_info):
-		self._friends[buddy_info.get_name()] = buddy_info
-		self.emit('friend-added', buddy_info)
+    def add_friend(self, buddy_info):
+        self._friends[buddy_info.get_name()] = buddy_info
+        self.emit('friend-added', buddy_info)
 
-	def make_friend(self, buddy):
-		if not self.has_buddy(buddy):	
-			self.add_friend(BuddyModel(buddy=buddy))
-			self.save()
+    def make_friend(self, buddy):
+        if not self.has_buddy(buddy):    
+            self.add_friend(BuddyModel(buddy=buddy))
+            self.save()
 
-	def remove(self, buddy_info):
-		del self._friends[buddy_info.get_name()]
-		self.save()
-		self.emit('friend-removed', buddy_info.get_name())
+    def remove(self, buddy_info):
+        del self._friends[buddy_info.get_name()]
+        self.save()
+        self.emit('friend-removed', buddy_info.get_name())
 
-	def __iter__(self):
-		return self._friends.values().__iter__()
+    def __iter__(self):
+        return self._friends.values().__iter__()
 
-	def load(self):
-		cp = ConfigParser()
+    def load(self):
+        cp = ConfigParser()
 
-		try:
-			success = cp.read([self._path])
-			if success:
-				for name in cp.sections():
-					buddy = BuddyModel(name)
-					self.add_friend(buddy)
-		except Exception, exc:
-			logging.error("Error parsing friends file: %s" % exc)
+        try:
+            success = cp.read([self._path])
+            if success:
+                for name in cp.sections():
+                    buddy = BuddyModel(name)
+                    self.add_friend(buddy)
+        except Exception, exc:
+            logging.error("Error parsing friends file: %s" % exc)
 
-	def save(self):
-		cp = ConfigParser()
+    def save(self):
+        cp = ConfigParser()
 
-		for friend in self:
-			section = friend.get_name()
-			cp.add_section(section)
-			cp.set(section, 'color', friend.get_color().to_string())
+        for friend in self:
+            section = friend.get_name()
+            cp.add_section(section)
+            cp.set(section, 'color', friend.get_color().to_string())
 
-		fileobject = open(self._path, 'w')
-		cp.write(fileobject)
-		fileobject.close()
+        fileobject = open(self._path, 'w')
+        cp.write(fileobject)
+        fileobject.close()

shell/model/Invites.py

@@ -17,38 +17,38 @@
 import gobject
 
 class Invite:
-	def __init__(self, issuer, bundle_id, activity_id):
-		self._issuer = issuer
-		self._activity_id = activity_id
-		self._bundle_id = bundle_id
+    def __init__(self, issuer, bundle_id, activity_id):
+        self._issuer = issuer
+        self._activity_id = activity_id
+        self._bundle_id = bundle_id
 
-	def get_activity_id(self):
-		return self._activity_id
+    def get_activity_id(self):
+        return self._activity_id
 
-	def get_bundle_id(self):
-		return self._bundle_id
+    def get_bundle_id(self):
+        return self._bundle_id
 
 class Invites(gobject.GObject):
-	__gsignals__ = {
-		'invite-added':   (gobject.SIGNAL_RUN_FIRST,
-						   gobject.TYPE_NONE, ([object])),
-		'invite-removed': (gobject.SIGNAL_RUN_FIRST,
-						   gobject.TYPE_NONE, ([object])),
-	}
+    __gsignals__ = {
+        'invite-added':   (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE, ([object])),
+        'invite-removed': (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE, ([object])),
+    }
 
-	def __init__(self):
-		gobject.GObject.__init__(self)
+    def __init__(self):
+        gobject.GObject.__init__(self)
 
-		self._list = []
+        self._list = []
 
-	def add_invite(self, issuer, bundle_id, activity_id):
-		invite = Invite(issuer, bundle_id, activity_id)
-		self._list.append(invite)
-		self.emit('invite-added', invite)
+    def add_invite(self, issuer, bundle_id, activity_id):
+        invite = Invite(issuer, bundle_id, activity_id)
+        self._list.append(invite)
+        self.emit('invite-added', invite)
 
-	def remove_invite(self, invite):
-		self._list.remove(invite)
-		self.emit('invite-removed', invite)
+    def remove_invite(self, invite):
+        self._list.remove(invite)
+        self.emit('invite-removed', invite)
 
-	def __iter__(self):
-		return self._list.__iter__()
+    def __iter__(self):
+        return self._list.__iter__()

shell/model/MeshModel.py

@@ -21,137 +21,137 @@ from sugar.presence import PresenceService
 from model.BuddyModel import BuddyModel
 
 class ActivityModel:
-	def __init__(self, activity, bundle, service):
-		self._service = service
-		self._activity = activity
+    def __init__(self, activity, bundle, service):
+        self._service = service
+        self._activity = activity
 
-	def get_id(self):
-		return self._activity.get_id()
-		
-	def get_icon_name(self):
-		return bundle.get_icon()
-	
-	def get_color(self):
-		return IconColor(self._activity.get_color())
+    def get_id(self):
+        return self._activity.get_id()
+        
+    def get_icon_name(self):
+        return bundle.get_icon()
+    
+    def get_color(self):
+        return IconColor(self._activity.get_color())
 
-	def get_service(self):
-		return self._service
+    def get_service(self):
+        return self._service
 
 class MeshModel(gobject.GObject):
-	__gsignals__ = {
-		'activity-added':   (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
-		'activity-removed': (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
-		'buddy-added':      (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
-		'buddy-moved':      (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT,
-												  gobject.TYPE_PYOBJECT])),
-		'buddy-removed':    (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT]))
-	}
+    __gsignals__ = {
+        'activity-added':   (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
+        'activity-removed': (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
+        'buddy-added':      (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
+        'buddy-moved':      (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT,
+                                                  gobject.TYPE_PYOBJECT])),
+        'buddy-removed':    (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT]))
+    }
 
-	def __init__(self, bundle_registry):
-		gobject.GObject.__init__(self)
+    def __init__(self, bundle_registry):
+        gobject.GObject.__init__(self)
 
-		self._activities = {}
-		self._buddies = {}
-		self._bundle_registry = bundle_registry
+        self._activities = {}
+        self._buddies = {}
+        self._bundle_registry = bundle_registry
 
-		self._pservice = PresenceService.get_instance()
-		self._pservice.connect("service-appeared",
-							   self._service_appeared_cb)
-		self._pservice.connect('activity-disappeared',
-							   self._activity_disappeared_cb)
-		self._pservice.connect("buddy-appeared",
-							   self._buddy_appeared_cb)
-		self._pservice.connect("buddy-disappeared",
-							   self._buddy_disappeared_cb)
+        self._pservice = PresenceService.get_instance()
+        self._pservice.connect("service-appeared",
+                               self._service_appeared_cb)
+        self._pservice.connect('activity-disappeared',
+                               self._activity_disappeared_cb)
+        self._pservice.connect("buddy-appeared",
+                               self._buddy_appeared_cb)
+        self._pservice.connect("buddy-disappeared",
+                               self._buddy_disappeared_cb)
 
-		# Add any buddies the PS knows about already
-		for buddy in self._pservice.get_buddies():
-			self._buddy_appeared_cb(self._pservice, buddy)
+        # Add any buddies the PS knows about already
+        for buddy in self._pservice.get_buddies():
+            self._buddy_appeared_cb(self._pservice, buddy)
 
-		for service in self._pservice.get_services():
-			self._check_service(service)
+        for service in self._pservice.get_services():
+            self._check_service(service)
 
-	def get_activities(self):
-		return self._activities.values()
+    def get_activities(self):
+        return self._activities.values()
 
-	def get_buddies(self):
-		return self._buddies.values()
+    def get_buddies(self):
+        return self._buddies.values()
 
-	def _buddy_activity_changed_cb(self, buddy, cur_activity):
-		if not self._buddies.has_key(buddy.get_name()):
-			return
-		buddy_model = self._buddies[buddy.get_name()]
-		if cur_activity == None:
-			self.emit('buddy-moved', buddy_model, None)
-		else:
-			self._notify_buddy_change(buddy_model, cur_activity)
+    def _buddy_activity_changed_cb(self, buddy, cur_activity):
+        if not self._buddies.has_key(buddy.get_name()):
+            return
+        buddy_model = self._buddies[buddy.get_name()]
+        if cur_activity == None:
+            self.emit('buddy-moved', buddy_model, None)
+        else:
+            self._notify_buddy_change(buddy_model, cur_activity)
 
-	def _notify_buddy_change(self, buddy_model, cur_activity):
-		if self._activities.has_key(cur_activity.get_id()):
-			activity_model = self._activities[cur_activity.get_id()]
-			self.emit('buddy-moved', buddy_model, activity_model)
+    def _notify_buddy_change(self, buddy_model, cur_activity):
+        if self._activities.has_key(cur_activity.get_id()):
+            activity_model = self._activities[cur_activity.get_id()]
+            self.emit('buddy-moved', buddy_model, activity_model)
 
-	def _buddy_appeared_cb(self, pservice, buddy):
-		model = BuddyModel(buddy=buddy)
-		if self._buddies.has_key(model.get_name()):
-			del model
-			return
+    def _buddy_appeared_cb(self, pservice, buddy):
+        model = BuddyModel(buddy=buddy)
+        if self._buddies.has_key(model.get_name()):
+            del model
+            return
 
-		model.connect('current-activity-changed',
-					  self._buddy_activity_changed_cb)
-		self._buddies[model.get_name()] = model
-		self.emit('buddy-added', model)
+        model.connect('current-activity-changed',
+                      self._buddy_activity_changed_cb)
+        self._buddies[model.get_name()] = model
+        self.emit('buddy-added', model)
 
-		cur_activity = buddy.get_current_activity()
-		if cur_activity:
-			self._notify_buddy_change(model, cur_activity)
+        cur_activity = buddy.get_current_activity()
+        if cur_activity:
+            self._notify_buddy_change(model, cur_activity)
 
-	def _buddy_disappeared_cb(self, pservice, buddy):
-		if not self._buddies.has_key(buddy.get_name()):
-			return
-		self.emit('buddy-removed', buddy)
-		del self._buddies[buddy.get_name()]
+    def _buddy_disappeared_cb(self, pservice, buddy):
+        if not self._buddies.has_key(buddy.get_name()):
+            return
+        self.emit('buddy-removed', buddy)
+        del self._buddies[buddy.get_name()]
 
-	def _service_appeared_cb(self, pservice, service):
-		self._check_service(service)
+    def _service_appeared_cb(self, pservice, service):
+        self._check_service(service)
 
-	def _check_service(self, service):
-		if self._bundle_registry.get_bundle(service.get_type()) != None:
-			activity_id = service.get_activity_id()
-			if not self.has_activity(activity_id):
-				activity = self._pservice.get_activity(activity_id)
-				if activity != None:
-					self.add_activity(activity, service)
+    def _check_service(self, service):
+        if self._bundle_registry.get_bundle(service.get_type()) != None:
+            activity_id = service.get_activity_id()
+            if not self.has_activity(activity_id):
+                activity = self._pservice.get_activity(activity_id)
+                if activity != None:
+                    self.add_activity(activity, service)
 
-	def has_activity(self, activity_id):
-		return self._activities.has_key(activity_id)
+    def has_activity(self, activity_id):
+        return self._activities.has_key(activity_id)
 
-	def get_activity(self, activity_id):
-		if self.has_activity(activity_id):
-			return self._activities[activity_id]
-		else:
-			return None
+    def get_activity(self, activity_id):
+        if self.has_activity(activity_id):
+            return self._activities[activity_id]
+        else:
+            return None
 
-	def add_activity(self, activity, service):
-		bundle = self._bundle_registry.get_bundle(service.get_type())
-		model = ActivityModel(activity, bundle, service)
-		self._activities[model.get_id()] = model
-		self.emit('activity-added', model)
+    def add_activity(self, activity, service):
+        bundle = self._bundle_registry.get_bundle(service.get_type())
+        model = ActivityModel(activity, bundle, service)
+        self._activities[model.get_id()] = model
+        self.emit('activity-added', model)
 
-		for buddy in self._pservice.get_buddies():
-			cur_activity = buddy.get_current_activity()
-			name = buddy.get_name()
-			if cur_activity == activity and self._buddies.has_key(name):
-				buddy_model = self._buddies[name]
-				self.emit('buddy-moved', buddy_model, model)
+        for buddy in self._pservice.get_buddies():
+            cur_activity = buddy.get_current_activity()
+            name = buddy.get_name()
+            if cur_activity == activity and self._buddies.has_key(name):
+                buddy_model = self._buddies[name]
+                self.emit('buddy-moved', buddy_model, model)
 
-	def _activity_disappeared_cb(self, pservice, activity):
-		if self._activities.has_key(activity.get_id()):
-			activity_model = self._activities[activity.get_id()]
-			self.emit('activity-removed', activity_model)
-			del self._activities[activity.get_id()]
+    def _activity_disappeared_cb(self, pservice, activity):
+        if self._activities.has_key(activity.get_id()):
+            activity_model = self._activities[activity.get_id()]
+            self.emit('activity-removed', activity_model)
+            del self._activities[activity.get_id()]

shell/model/Owner.py

@@ -31,90 +31,90 @@ from model.Invites import Invites
 PRESENCE_SERVICE_TYPE = "_presence_olpc._tcp"
 
 class ShellOwner(object):
-	"""Class representing the owner of this machine/instance.  This class
-	runs in the shell and serves up the buddy icon and other stuff.  It's the
-	server portion of the Owner, paired with the client portion in Buddy.py."""
-	def __init__(self):
-		self._nick = profile.get_nick_name()
-		user_dir = env.get_profile_path()
+    """Class representing the owner of this machine/instance.  This class
+    runs in the shell and serves up the buddy icon and other stuff.  It's the
+    server portion of the Owner, paired with the client portion in Buddy.py."""
+    def __init__(self):
+        self._nick = profile.get_nick_name()
+        user_dir = env.get_profile_path()
 
-		self._icon = None
-		self._icon_hash = ""
-		for fname in os.listdir(user_dir):
-			if not fname.startswith("buddy-icon."):
-				continue
-			fd = open(os.path.join(user_dir, fname), "r")
-			self._icon = fd.read()
-			if self._icon:
-				# Get the icon's hash
-				import md5, binascii
-				digest = md5.new(self._icon).digest()
-				self._icon_hash = util.printable_hash(digest)
-			fd.close()
-			break
+        self._icon = None
+        self._icon_hash = ""
+        for fname in os.listdir(user_dir):
+            if not fname.startswith("buddy-icon."):
+                continue
+            fd = open(os.path.join(user_dir, fname), "r")
+            self._icon = fd.read()
+            if self._icon:
+                # Get the icon's hash
+                import md5, binascii
+                digest = md5.new(self._icon).digest()
+                self._icon_hash = util.printable_hash(digest)
+            fd.close()
+            break
 
-		self._pservice = PresenceService.get_instance()
+        self._pservice = PresenceService.get_instance()
 
-		self._invites = Invites()
+        self._invites = Invites()
 
-		self._last_activity_update = time.time()
-		self._pending_activity_update_timer = None
-		self._pending_activity_update = None
+        self._last_activity_update = time.time()
+        self._pending_activity_update_timer = None
+        self._pending_activity_update = None
 
-	def get_invites(self):
-		return self._invites
+    def get_invites(self):
+        return self._invites
 
-	def get_name(self):
-		return self._nick
+    def get_name(self):
+        return self._nick
 
-	def announce(self):
-		# Create and announce our presence
-		color = profile.get_color()
-		props = {'color': color.to_string(), 'icon-hash': self._icon_hash}
-		self._service = self._pservice.register_service(self._nick,
-				PRESENCE_SERVICE_TYPE, properties=props)
-		logging.debug("Owner '%s' using port %d" % (self._nick, self._service.get_port()))
-		self._icon_stream = Stream.Stream.new_from_service(self._service)
-		self._icon_stream.register_reader_handler(self._handle_buddy_icon_request, "get_buddy_icon")
-		self._icon_stream.register_reader_handler(self._handle_invite, "invite")
+    def announce(self):
+        # Create and announce our presence
+        color = profile.get_color()
+        props = {'color': color.to_string(), 'icon-hash': self._icon_hash}
+        self._service = self._pservice.register_service(self._nick,
+                PRESENCE_SERVICE_TYPE, properties=props)
+        logging.debug("Owner '%s' using port %d" % (self._nick, self._service.get_port()))
+        self._icon_stream = Stream.Stream.new_from_service(self._service)
+        self._icon_stream.register_reader_handler(self._handle_buddy_icon_request, "get_buddy_icon")
+        self._icon_stream.register_reader_handler(self._handle_invite, "invite")
 
-	def _handle_buddy_icon_request(self):
-		"""XMLRPC method, return the owner's icon encoded with base64."""
-		if self._icon:
-			return base64.b64encode(self._icon)
-		return ""
+    def _handle_buddy_icon_request(self):
+        """XMLRPC method, return the owner's icon encoded with base64."""
+        if self._icon:
+            return base64.b64encode(self._icon)
+        return ""
 
-	def _handle_invite(self, issuer, bundle_id, activity_id):
-		"""XMLRPC method, called when the owner is invited to an activity."""
-		self._invites.add_invite(issuer, bundle_id, activity_id)
-		return ''
+    def _handle_invite(self, issuer, bundle_id, activity_id):
+        """XMLRPC method, called when the owner is invited to an activity."""
+        self._invites.add_invite(issuer, bundle_id, activity_id)
+        return ''
 
-	def __update_advertised_current_activity_cb(self):
-		self._last_activity_update = time.time()
-		self._pending_activity_update_timer = None
-		if self._pending_activity_update:
-			logging.debug("*** Updating current activity to %s" % self._pending_activity_update)
-			self._service.set_published_value('curact', dbus.String(self._pending_activity_update))
-		return False
+    def __update_advertised_current_activity_cb(self):
+        self._last_activity_update = time.time()
+        self._pending_activity_update_timer = None
+        if self._pending_activity_update:
+            logging.debug("*** Updating current activity to %s" % self._pending_activity_update)
+            self._service.set_published_value('curact', dbus.String(self._pending_activity_update))
+        return False
 
-	def set_current_activity(self, activity_id):
-		"""Update our presence service with the latest activity, but no
-		more frequently than every 30 seconds"""
-		self._pending_activity_update = activity_id
-		# If there's no pending update, we must not have updated it in the
-		# last 30 seconds (except for the initial update, hence we also check
-		# for the last update)
-		if not self._pending_activity_update_timer or time.time() - self._last_activity_update > 30:
-			self.__update_advertised_current_activity_cb()
-			return
+    def set_current_activity(self, activity_id):
+        """Update our presence service with the latest activity, but no
+        more frequently than every 30 seconds"""
+        self._pending_activity_update = activity_id
+        # If there's no pending update, we must not have updated it in the
+        # last 30 seconds (except for the initial update, hence we also check
+        # for the last update)
+        if not self._pending_activity_update_timer or time.time() - self._last_activity_update > 30:
+            self.__update_advertised_current_activity_cb()
+            return
 
-		# If we have a pending update already, we have nothing left to do
-		if self._pending_activity_update_timer:
-			return
+        # If we have a pending update already, we have nothing left to do
+        if self._pending_activity_update_timer:
+            return
 
-		# Otherwise, we start a timer to update the activity at the next
-		# interval, which should be 30 seconds from the last update, or if that
-		# is in the past already, then now
-		next = 30 - max(30, time.time() - self._last_activity_update)
-		self._pending_activity_update_timer = gobject.timeout_add(next * 1000,
-				self.__update_advertised_current_activity_cb)
+        # Otherwise, we start a timer to update the activity at the next
+        # interval, which should be 30 seconds from the last update, or if that
+        # is in the past already, then now
+        next = 30 - max(30, time.time() - self._last_activity_update)
+        self._pending_activity_update_timer = gobject.timeout_add(next * 1000,
+                self.__update_advertised_current_activity_cb)

shell/model/ShellModel.py

@@ -24,45 +24,45 @@ from model.Owner import ShellOwner
 from sugar import env
 
 class ShellModel:
-	def __init__(self):
-		self._current_activity = None
+    def __init__(self):
+        self._current_activity = None
 
-		self._bundle_registry = BundleRegistry()
+        self._bundle_registry = BundleRegistry()
 
-		PresenceService.start()
-		self._pservice = PresenceService.get_instance()
+        PresenceService.start()
+        self._pservice = PresenceService.get_instance()
 
-		self._owner = ShellOwner()
-		self._owner.announce()
+        self._owner = ShellOwner()
+        self._owner.announce()
 
-		self._friends = Friends()
-		self._mesh = MeshModel(self._bundle_registry)
+        self._friends = Friends()
+        self._mesh = MeshModel(self._bundle_registry)
 
-		path = os.path.expanduser('~/Activities')
-		self._bundle_registry.add_search_path(path)
+        path = os.path.expanduser('~/Activities')
+        self._bundle_registry.add_search_path(path)
 
-		for path in env.get_data_dirs():
-			bundles_path = os.path.join(path, 'activities')
-			self._bundle_registry.add_search_path(bundles_path)
+        for path in env.get_data_dirs():
+            bundles_path = os.path.join(path, 'activities')
+            self._bundle_registry.add_search_path(bundles_path)
 
-	def get_bundle_registry(self):
-		return self._bundle_registry
+    def get_bundle_registry(self):
+        return self._bundle_registry
 
-	def get_mesh(self):
-		return self._mesh
+    def get_mesh(self):
+        return self._mesh
 
-	def get_friends(self):
-		return self._friends
+    def get_friends(self):
+        return self._friends
 
-	def get_invites(self):
-		return self._owner.get_invites()
+    def get_invites(self):
+        return self._owner.get_invites()
 
-	def get_owner(self):
-		return self._owner
+    def get_owner(self):
+        return self._owner
 
-	def set_current_activity(self, activity_id):
-		self._current_activity = activity_id
-		self._owner.set_current_activity(activity_id)
+    def set_current_activity(self, activity_id):
+        self._current_activity = activity_id
+        self._owner.set_current_activity(activity_id)
 
-	def get_current_activity(self):
-		return self._current_activity
+    def get_current_activity(self):
+        return self._current_activity

shell/view/ActivityHost.py

@@ -27,122 +27,122 @@ from sugar.chat import ActivityChat
 import OverlayWindow
 
 class ActivityChatWindow(gtk.Window):
-	def __init__(self, gdk_window, chat_widget):
-		gtk.Window.__init__(self)
+    def __init__(self, gdk_window, chat_widget):
+        gtk.Window.__init__(self)
 
-		self.realize()
-		self.set_decorated(False)
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
-		self.window.set_accept_focus(True)		
-		self.window.set_transient_for(gdk_window)
-		self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
-		self.set_default_size(600, 450)
+        self.realize()
+        self.set_decorated(False)
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+        self.window.set_accept_focus(True)        
+        self.window.set_transient_for(gdk_window)
+        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
+        self.set_default_size(600, 450)
 
-		self.add(chat_widget)
+        self.add(chat_widget)
 
 class ActivityHost:
-	def __init__(self, shell_model, window):
-		self._window = window
-		self._xid = window.get_xid()
-		self._pservice = PresenceService.get_instance()
+    def __init__(self, shell_model, window):
+        self._window = window
+        self._xid = window.get_xid()
+        self._pservice = PresenceService.get_instance()
 
-		bus = dbus.SessionBus()
-		proxy_obj = bus.get_object(Activity.get_service_name(self._xid),
-								   Activity.get_object_path(self._xid))
+        bus = dbus.SessionBus()
+        proxy_obj = bus.get_object(Activity.get_service_name(self._xid),
+                                   Activity.get_object_path(self._xid))
 
-		self._activity = dbus.Interface(proxy_obj, Activity.ACTIVITY_INTERFACE)
-		self._id = self._activity.get_id()
-		self._type = self._activity.get_type()
-		self._gdk_window = gtk.gdk.window_foreign_new(self._xid)
+        self._activity = dbus.Interface(proxy_obj, Activity.ACTIVITY_INTERFACE)
+        self._id = self._activity.get_id()
+        self._type = self._activity.get_type()
+        self._gdk_window = gtk.gdk.window_foreign_new(self._xid)
 
-		registry = shell_model.get_bundle_registry()
-		info = registry.get_bundle(self._type)
-		self._icon_name = info.get_icon()
+        registry = shell_model.get_bundle_registry()
+        info = registry.get_bundle(self._type)
+        self._icon_name = info.get_icon()
 
-		try:
-			self._overlay_window = OverlayWindow.OverlayWindow(self._gdk_window)
-			win = self._overlay_window.window
-		except RuntimeError:
-			self._overlay_window = None
-			win = self._gdk_window
+        try:
+            self._overlay_window = OverlayWindow.OverlayWindow(self._gdk_window)
+            win = self._overlay_window.window
+        except RuntimeError:
+            self._overlay_window = None
+            win = self._gdk_window
 
-		self._chat_widget = ActivityChat.ActivityChat(self)
-		self._chat_window = ActivityChatWindow(win, self._chat_widget)
+        self._chat_widget = ActivityChat.ActivityChat(self)
+        self._chat_window = ActivityChatWindow(win, self._chat_widget)
 
-		self._frame_was_visible = False
+        self._frame_was_visible = False
 
-	def get_id(self):
-		return self._id
+    def get_id(self):
+        return self._id
 
-	def get_title(self):
-		return self._window.get_name()
+    def get_title(self):
+        return self._window.get_name()
 
-	def get_xid(self):
-		return self._xid
+    def get_xid(self):
+        return self._xid
 
-	def get_icon_name(self):
-		return self._icon_name
+    def get_icon_name(self):
+        return self._icon_name
 
-	def get_icon_color(self):
-		activity = self._pservice.get_activity(self._id)
-		if activity != None:
-			return IconColor(activity.get_color())
-		else:
-			return profile.get_color()
+    def get_icon_color(self):
+        activity = self._pservice.get_activity(self._id)
+        if activity != None:
+            return IconColor(activity.get_color())
+        else:
+            return profile.get_color()
 
-	def share(self):
-		self._activity.share()
-		self._chat_widget.share()
+    def share(self):
+        self._activity.share()
+        self._chat_widget.share()
 
-	def invite(self, buddy):
-		if not self.get_shared():
-			self.share()
+    def invite(self, buddy):
+        if not self.get_shared():
+            self.share()
 
-		issuer = self._pservice.get_owner().get_name()
-		service = buddy.get_service_of_type("_presence_olpc._tcp")
-		stream = Stream.Stream.new_from_service(service, start_reader=False)
-		writer = stream.new_writer(service)
-		writer.custom_request("invite", None, None, issuer,
-							  self._type, self._id)
+        issuer = self._pservice.get_owner().get_name()
+        service = buddy.get_service_of_type("_presence_olpc._tcp")
+        stream = Stream.Stream.new_from_service(service, start_reader=False)
+        writer = stream.new_writer(service)
+        writer.custom_request("invite", None, None, issuer,
+                              self._type, self._id)
 
-	def get_shared(self):
-		return self._activity.get_shared()
+    def get_shared(self):
+        return self._activity.get_shared()
 
-	def get_type(self):
-		return self._type
+    def get_type(self):
+        return self._type
 
-	def present(self):
-		self._window.activate(gtk.get_current_event_time())
+    def present(self):
+        self._window.activate(gtk.get_current_event_time())
 
-	def close(self):
-		self._window.close(gtk.get_current_event_time())
+    def close(self):
+        self._window.close(gtk.get_current_event_time())
 
-	def show_dialog(self, dialog):
-		dialog.show()
-		dialog.window.set_transient_for(self._gdk_window)
+    def show_dialog(self, dialog):
+        dialog.show()
+        dialog.window.set_transient_for(self._gdk_window)
 
-	def chat_show(self, frame_was_visible):
-		if self._overlay_window:
-			self._overlay_window.show_all()
-		self._chat_window.show_all()
-		self._frame_was_visible = frame_was_visible
+    def chat_show(self, frame_was_visible):
+        if self._overlay_window:
+            self._overlay_window.show_all()
+        self._chat_window.show_all()
+        self._frame_was_visible = frame_was_visible
 
-	def chat_hide(self):
-		self._chat_window.hide()
-		if self._overlay_window:
-			self._overlay_window.hide()
-		wasvis = self._frame_was_visible
-		self._frame_was_visible = False
-		return wasvis
+    def chat_hide(self):
+        self._chat_window.hide()
+        if self._overlay_window:
+            self._overlay_window.hide()
+        wasvis = self._frame_was_visible
+        self._frame_was_visible = False
+        return wasvis
 
-	def is_chat_visible(self):
-		return self._chat_window.get_property('visible')
+    def is_chat_visible(self):
+        return self._chat_window.get_property('visible')
 
-	def set_active(self, active):
-		if not active:
-			self.chat_hide()
-			self._frame_was_visible = False
+    def set_active(self, active):
+        if not active:
+            self.chat_hide()
+            self._frame_was_visible = False
 
-	def destroy(self):
-		self._chat_window.destroy()
-		self._frame_was_visible = False
+    def destroy(self):
+        self._chat_window.destroy()
+        self._frame_was_visible = False

shell/view/BuddyIcon.py

@@ -18,41 +18,41 @@ from sugar.graphics.menuicon import MenuIcon
 from view.BuddyMenu import BuddyMenu
 
 class BuddyIcon(MenuIcon):
-	def __init__(self, shell, menu_shell, buddy):
-		MenuIcon.__init__(self, menu_shell, icon_name='stock-buddy',
-						  color=buddy.get_color())
+    def __init__(self, shell, menu_shell, buddy):
+        MenuIcon.__init__(self, menu_shell, icon_name='stock-buddy',
+                          color=buddy.get_color())
 
-		self._shell = shell
-		self._buddy = buddy
-		self._buddy.connect('appeared', self._buddy_presence_change_cb)
-		self._buddy.connect('disappeared', self._buddy_presence_change_cb)
-		self._buddy.connect('color-changed', self._buddy_presence_change_cb)
+        self._shell = shell
+        self._buddy = buddy
+        self._buddy.connect('appeared', self._buddy_presence_change_cb)
+        self._buddy.connect('disappeared', self._buddy_presence_change_cb)
+        self._buddy.connect('color-changed', self._buddy_presence_change_cb)
 
-	def _buddy_presence_change_cb(self, buddy, color=None):
-		# Update the icon's color when the buddy comes and goes
-		self.set_property('color', buddy.get_color())
+    def _buddy_presence_change_cb(self, buddy, color=None):
+        # Update the icon's color when the buddy comes and goes
+        self.set_property('color', buddy.get_color())
 
-	def set_popup_distance(self, distance):
-		self._popup_distance = distance
+    def set_popup_distance(self, distance):
+        self._popup_distance = distance
 
-	def create_menu(self):
-		menu = BuddyMenu(self._shell, self._buddy)
-		menu.connect('action', self._popup_action_cb)
-		return menu
+    def create_menu(self):
+        menu = BuddyMenu(self._shell, self._buddy)
+        menu.connect('action', self._popup_action_cb)
+        return menu
 
-	def _popup_action_cb(self, popup, action):
-		self.popdown()
+    def _popup_action_cb(self, popup, action):
+        self.popdown()
 
-		friends = self._shell.get_model().get_friends()
-		if action == BuddyMenu.ACTION_REMOVE_FRIEND:
-			friends.remove(self._buddy)
+        friends = self._shell.get_model().get_friends()
+        if action == BuddyMenu.ACTION_REMOVE_FRIEND:
+            friends.remove(self._buddy)
 
-		ps_buddy = self._buddy.get_buddy()
-		if ps_buddy == None:
-			return
+        ps_buddy = self._buddy.get_buddy()
+        if ps_buddy == None:
+            return
 
-		if action == BuddyMenu.ACTION_INVITE:
-			activity = self._shell.get_current_activity()
-			activity.invite(ps_buddy)
-		elif action == BuddyMenu.ACTION_MAKE_FRIEND:
-			friends.make_friend(ps_buddy)
+        if action == BuddyMenu.ACTION_INVITE:
+            activity = self._shell.get_current_activity()
+            activity.invite(ps_buddy)
+        elif action == BuddyMenu.ACTION_MAKE_FRIEND:
+            friends.make_friend(ps_buddy)

shell/view/BuddyMenu.py

@@ -25,73 +25,73 @@ from sugar.presence import PresenceService
 _ICON_SIZE = 75
 
 class BuddyMenu(Menu):
-	ACTION_MAKE_FRIEND = 0
-	ACTION_INVITE = 1
-	ACTION_REMOVE_FRIEND = 2
+    ACTION_MAKE_FRIEND = 0
+    ACTION_INVITE = 1
+    ACTION_REMOVE_FRIEND = 2
 
-	def __init__(self, shell, buddy):
-		self._buddy = buddy
-		self._shell = shell
+    def __init__(self, shell, buddy):
+        self._buddy = buddy
+        self._shell = shell
 
-		icon_item = None
-		pixbuf = self._get_buddy_icon_pixbuf()
-		if pixbuf:
-			scaled_pixbuf = pixbuf.scale_simple(_ICON_SIZE, _ICON_SIZE,
-												gtk.gdk.INTERP_BILINEAR)
-			del pixbuf
-			icon_item = hippo.CanvasImage(pixbuf=scaled_pixbuf)
+        icon_item = None
+        pixbuf = self._get_buddy_icon_pixbuf()
+        if pixbuf:
+            scaled_pixbuf = pixbuf.scale_simple(_ICON_SIZE, _ICON_SIZE,
+                                                gtk.gdk.INTERP_BILINEAR)
+            del pixbuf
+            icon_item = hippo.CanvasImage(pixbuf=scaled_pixbuf)
 
-		Menu.__init__(self, buddy.get_name(), icon_item)
+        Menu.__init__(self, buddy.get_name(), icon_item)
 
-		self._buddy.connect('icon-changed', self.__buddy_icon_changed_cb)
+        self._buddy.connect('icon-changed', self.__buddy_icon_changed_cb)
 
-		owner = shell.get_model().get_owner()
-		if buddy.get_name() != owner.get_name():
-			self._add_actions()
+        owner = shell.get_model().get_owner()
+        if buddy.get_name() != owner.get_name():
+            self._add_actions()
 
-	def _get_buddy_icon_pixbuf(self):
-		buddy_object = self._buddy.get_buddy()
-		if not buddy_object:
-			return None
+    def _get_buddy_icon_pixbuf(self):
+        buddy_object = self._buddy.get_buddy()
+        if not buddy_object:
+            return None
 
-		pixbuf = None
-		icon_data = buddy_object.get_icon()
-		icon_data_string = ""
-		for item in icon_data:
-			if item < 0:
-				item = item + 128
-			icon_data_string += chr(item)
-		pbl = gtk.gdk.PixbufLoader()
-		pbl.write(icon_data_string)
-		try:
-			pbl.close()
-			pixbuf = pbl.get_pixbuf()
-		except gobject.GError:
-			pass
-		del pbl
-		return pixbuf
+        pixbuf = None
+        icon_data = buddy_object.get_icon()
+        icon_data_string = ""
+        for item in icon_data:
+            if item < 0:
+                item = item + 128
+            icon_data_string += chr(item)
+        pbl = gtk.gdk.PixbufLoader()
+        pbl.write(icon_data_string)
+        try:
+            pbl.close()
+            pixbuf = pbl.get_pixbuf()
+        except gobject.GError:
+            pass
+        del pbl
+        return pixbuf
 
-	def _add_actions(self):
-		shell_model = self._shell.get_model()
-		pservice = PresenceService.get_instance()
+    def _add_actions(self):
+        shell_model = self._shell.get_model()
+        pservice = PresenceService.get_instance()
 
-		friends = shell_model.get_friends()
-		if friends.has_buddy(self._buddy):
-			icon = CanvasIcon(icon_name='stock-remove')
-			self.add_action(icon, BuddyMenu.ACTION_REMOVE_FRIEND) 
-		else:
-			icon = CanvasIcon(icon_name='stock-add')
-			self.add_action(icon, BuddyMenu.ACTION_MAKE_FRIEND)
+        friends = shell_model.get_friends()
+        if friends.has_buddy(self._buddy):
+            icon = CanvasIcon(icon_name='stock-remove')
+            self.add_action(icon, BuddyMenu.ACTION_REMOVE_FRIEND) 
+        else:
+            icon = CanvasIcon(icon_name='stock-add')
+            self.add_action(icon, BuddyMenu.ACTION_MAKE_FRIEND)
 
-		activity_id = shell_model.get_current_activity()
-		if activity_id != None:
-			activity_ps = pservice.get_activity(activity_id)
+        activity_id = shell_model.get_current_activity()
+        if activity_id != None:
+            activity_ps = pservice.get_activity(activity_id)
 
-			# FIXME check that the buddy is not in the activity already
+            # FIXME check that the buddy is not in the activity already
 
-			icon = CanvasIcon(icon_name='stock-invite')
-			self.add_action(icon, BuddyMenu.ACTION_INVITE)
+            icon = CanvasIcon(icon_name='stock-invite')
+            self.add_action(icon, BuddyMenu.ACTION_INVITE)
 
-	def __buddy_icon_changed_cb(self, buddy):
-		pass
+    def __buddy_icon_changed_cb(self, buddy):
+        pass
 

shell/view/ClipboardIcon.py

@@ -5,34 +5,34 @@ from sugar.clipboard import ClipboardService
 
 class ClipboardIcon(MenuIcon):
 
-	def __init__(self, menu_shell, name, file_name):
-		MenuIcon.__init__(self, menu_shell, icon_name='activity-xbook')
-		self._name = name
-		self._file_name = file_name
-		self._percent = 0
-		self.connect('activated', self._icon_activated_cb)
-		self._menu = None
-		
-	def create_menu(self):
-		self._menu = ClipboardMenu(self._name, self._percent)
-		self._menu.connect('action', self._popup_action_cb)
-		return self._menu
+    def __init__(self, menu_shell, name, file_name):
+        MenuIcon.__init__(self, menu_shell, icon_name='activity-xbook')
+        self._name = name
+        self._file_name = file_name
+        self._percent = 0
+        self.connect('activated', self._icon_activated_cb)
+        self._menu = None
+        
+    def create_menu(self):
+        self._menu = ClipboardMenu(self._name, self._percent)
+        self._menu.connect('action', self._popup_action_cb)
+        return self._menu
 
-	def set_percent(self, percent):
-		self._percent = percent
-		if self._menu:
-			self._menu.set_percent(percent)
+    def set_percent(self, percent):
+        self._percent = percent
+        if self._menu:
+            self._menu.set_percent(percent)
 
-	def _icon_activated_cb(self, icon):
-		if self._percent == 100:
-			activity = ActivityFactory.create("org.laptop.sugar.Xbook")
-			activity.execute("open_document", [self._file_name])
+    def _icon_activated_cb(self, icon):
+        if self._percent == 100:
+            activity = ActivityFactory.create("org.laptop.sugar.Xbook")
+            activity.execute("open_document", [self._file_name])
 
-	def _popup_action_cb(self, popup, action):
-		self.popdown()
-		
-		if action == ClipboardMenu.ACTION_STOP_DOWNLOAD:
-			raise "Stopping downloads still not implemented."
-		elif action == ClipboardMenu.ACTION_DELETE:
-			cb_service = ClipboardService.get_instance()
-			cb_service.delete_object(self._file_name)
+    def _popup_action_cb(self, popup, action):
+        self.popdown()
+        
+        if action == ClipboardMenu.ACTION_STOP_DOWNLOAD:
+            raise "Stopping downloads still not implemented."
+        elif action == ClipboardMenu.ACTION_DELETE:
+            cb_service = ClipboardService.get_instance()
+            cb_service.delete_object(self._file_name)

shell/view/ClipboardMenu.py

@@ -9,48 +9,48 @@ from sugar.graphics import style
 
 class ClipboardMenuItem(ClipboardBubble):
 
-	def __init__(self, percent = 0, stylesheet="clipboard.Bubble"):
-		ClipboardBubble.__init__(self, percent = percent)
-		style.apply_stylesheet(self, stylesheet)
+    def __init__(self, percent = 0, stylesheet="clipboard.Bubble"):
+        ClipboardBubble.__init__(self, percent = percent)
+        style.apply_stylesheet(self, stylesheet)
 
 class ClipboardMenu(Menu):
 
-	ACTION_DELETE = 0
-	ACTION_SHARE = 1
-	ACTION_STOP_DOWNLOAD = 2
-	
-	def __init__(self, name, percent):
-		Menu.__init__(self, name)
-		
-		self._progress_bar = ClipboardMenuItem(percent)
-		self._root.append(self._progress_bar)
-				
-		#icon = CanvasIcon(icon_name='stock-share-mesh')
-		#self.add_action(icon, ClipboardMenu.ACTION_SHARE)
-		
-		self._remove_icon = None
-		self._stop_icon = None
-		
-		self._create_icons(percent)
-		
-	def _create_icons(self, percent):			
-		if percent == 100:
-			if not self._remove_icon:
-				self._remove_icon = CanvasIcon(icon_name='stock-remove')
-				self.add_action(self._remove_icon, ClipboardMenu.ACTION_DELETE)
-			
-			if self._stop_icon:
-				self.remove_action(self._stop_icon)
-				self._stop_icon = None
-		else:
-			if not self._stop_icon:
-				self._stop_icon = CanvasIcon(icon_name='stock-close')
-				self.add_action(self._stop_icon, ClipboardMenu.ACTION_STOP_DOWNLOAD)
+    ACTION_DELETE = 0
+    ACTION_SHARE = 1
+    ACTION_STOP_DOWNLOAD = 2
+    
+    def __init__(self, name, percent):
+        Menu.__init__(self, name)
+        
+        self._progress_bar = ClipboardMenuItem(percent)
+        self._root.append(self._progress_bar)
+                
+        #icon = CanvasIcon(icon_name='stock-share-mesh')
+        #self.add_action(icon, ClipboardMenu.ACTION_SHARE)
+        
+        self._remove_icon = None
+        self._stop_icon = None
+        
+        self._create_icons(percent)
+        
+    def _create_icons(self, percent):            
+        if percent == 100:
+            if not self._remove_icon:
+                self._remove_icon = CanvasIcon(icon_name='stock-remove')
+                self.add_action(self._remove_icon, ClipboardMenu.ACTION_DELETE)
+            
+            if self._stop_icon:
+                self.remove_action(self._stop_icon)
+                self._stop_icon = None
+        else:
+            if not self._stop_icon:
+                self._stop_icon = CanvasIcon(icon_name='stock-close')
+                self.add_action(self._stop_icon, ClipboardMenu.ACTION_STOP_DOWNLOAD)
 
-			if self._remove_icon:
-				self.remove_action(self._remove_icon)
-				self._remove_icon = None
-	
-	def set_percent(self, percent):
-		self._progress_bar.set_property('percent', percent)
-		self._create_icons(percent)
+            if self._remove_icon:
+                self.remove_action(self._remove_icon)
+                self._remove_icon = None
+    
+    def set_percent(self, percent):
+        self._progress_bar.set_property('percent', percent)
+        self._create_icons(percent)

shell/view/FirstTimeDialog.py

@@ -24,47 +24,47 @@ from sugar.graphics.iconcolor import IconColor
 from sugar import env
 
 class FirstTimeDialog(gtk.Dialog):
-	def __init__(self):
-		gtk.Dialog.__init__(self)
+    def __init__(self):
+        gtk.Dialog.__init__(self)
 
-		label = gtk.Label(_('Nick Name:'))
-		label.set_alignment(0.0, 0.5)
-		self.vbox.pack_start(label)
-		label.show()
+        label = gtk.Label(_('Nick Name:'))
+        label.set_alignment(0.0, 0.5)
+        self.vbox.pack_start(label)
+        label.show()
 
-		self._entry = gtk.Entry()
-		self._entry.connect('changed', self._entry_changed_cb)
-		self._entry.connect('activate', self._entry_activated_cb)
-		self.vbox.pack_start(self._entry)
-		self._entry.show()
+        self._entry = gtk.Entry()
+        self._entry.connect('changed', self._entry_changed_cb)
+        self._entry.connect('activate', self._entry_activated_cb)
+        self.vbox.pack_start(self._entry)
+        self._entry.show()
 
-		self._ok = gtk.Button(None, gtk.STOCK_OK)
-		self._ok.set_sensitive(False)
-		self.vbox.pack_start(self._ok)
-		self._ok.connect('clicked', self._ok_button_clicked_cb)
-		self._ok.show()
+        self._ok = gtk.Button(None, gtk.STOCK_OK)
+        self._ok.set_sensitive(False)
+        self.vbox.pack_start(self._ok)
+        self._ok.connect('clicked', self._ok_button_clicked_cb)
+        self._ok.show()
 
-	def _entry_changed_cb(self, entry):
-		valid = (len(entry.get_text()) > 0)
-		self._ok.set_sensitive(valid)
+    def _entry_changed_cb(self, entry):
+        valid = (len(entry.get_text()) > 0)
+        self._ok.set_sensitive(valid)
 
-	def _entry_activated_cb(self, entry):
-		self._create_buddy_section()
-		
-	def _ok_button_clicked_cb(self, button):
-		self._create_buddy_section()
-		
-	def _create_buddy_section(self):
-		cp = ConfigParser()
+    def _entry_activated_cb(self, entry):
+        self._create_buddy_section()
+        
+    def _ok_button_clicked_cb(self, button):
+        self._create_buddy_section()
+        
+    def _create_buddy_section(self):
+        cp = ConfigParser()
 
-		section = 'Buddy'	
-		cp.add_section(section)
-		cp.set(section, 'NickName', self._entry.get_text())
-		cp.set(section, 'Color', IconColor().to_string())
+        section = 'Buddy'    
+        cp.add_section(section)
+        cp.set(section, 'NickName', self._entry.get_text())
+        cp.set(section, 'Color', IconColor().to_string())
 
-		config_path = os.path.join(env.get_profile_path(), 'config')
-		fileobject = open(config_path, 'w')
-		cp.write(fileobject)
-		fileobject.close()
+        config_path = os.path.join(env.get_profile_path(), 'config')
+        fileobject = open(config_path, 'w')
+        cp.write(fileobject)
+        fileobject.close()
 
-		self.destroy()
+        self.destroy()

shell/view/OverlayWindow.py

@@ -19,32 +19,32 @@ import cairo
 
 
 class OverlayWindow(gtk.Window):
-	def __init__(self, lower_window):
-		gtk.Window.__init__(self)
+    def __init__(self, lower_window):
+        gtk.Window.__init__(self)
 
-		colormap = self.get_screen().get_rgba_colormap()
-		colormap=None
-		if not colormap:
-			raise RuntimeError("The window manager doesn't support compositing.")
-		self.set_colormap(colormap)
+        colormap = self.get_screen().get_rgba_colormap()
+        colormap=None
+        if not colormap:
+            raise RuntimeError("The window manager doesn't support compositing.")
+        self.set_colormap(colormap)
 
-		self.realize()
+        self.realize()
 
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
-		self.window.set_accept_focus(False)
-		self.window.set_transient_for(lower_window)
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+        self.window.set_accept_focus(False)
+        self.window.set_transient_for(lower_window)
 
-		self.set_decorated(False)
-		self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
-		self.set_default_size(gtk.gdk.screen_width(), gtk.gdk.screen_height())
-		self.set_app_paintable(True)
+        self.set_decorated(False)
+        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
+        self.set_default_size(gtk.gdk.screen_width(), gtk.gdk.screen_height())
+        self.set_app_paintable(True)
 
-		self.connect('expose-event', self._expose_cb)
+        self.connect('expose-event', self._expose_cb)
 
-	def _expose_cb(self, widget, event):
-		cr = widget.window.cairo_create()
-		cr.set_source_rgba(0.0, 0.0, 0.0, 0.4) # Transparent
-		cr.set_operator(cairo.OPERATOR_SOURCE)
-		cr.paint()
-		return False
+    def _expose_cb(self, widget, event):
+        cr = widget.window.cairo_create()
+        cr.set_source_rgba(0.0, 0.0, 0.0, 0.4) # Transparent
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.paint()
+        return False
 

shell/view/Shell.py

@@ -31,206 +31,206 @@ from _sugar import KeyGrabber
 import sugar
 
 class Shell(gobject.GObject):
-	__gsignals__ = {
-		'activity-opened':  (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
-		'activity-changed': (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
-		'activity-closed':  (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT]))
-	}
+    __gsignals__ = {
+        'activity-opened':  (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
+        'activity-changed': (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
+        'activity-closed':  (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT]))
+    }
 
-	def __init__(self, model):
-		gobject.GObject.__init__(self)
+    def __init__(self, model):
+        gobject.GObject.__init__(self)
 
-		self._model = model
-		self._hosts = {}
-		self._screen = wnck.screen_get_default()
-		self._current_host = None
+        self._model = model
+        self._hosts = {}
+        self._screen = wnck.screen_get_default()
+        self._current_host = None
 
-		style.load_stylesheet(view.stylesheet)
+        style.load_stylesheet(view.stylesheet)
 
-		self._dcon_manager = DCONManager()
+        self._dcon_manager = DCONManager()
 
-		self._key_grabber = KeyGrabber()
-		self._key_grabber.connect('key-pressed',
-								  self.__global_key_pressed_cb)
-		self._key_grabber.connect('key-released',
-								  self.__global_key_released_cb)
-		self._key_grabber.grab('F1')
-		self._key_grabber.grab('F2')
-		self._key_grabber.grab('F3')
-		self._key_grabber.grab('F4')
-		self._key_grabber.grab('F5')
-		self._key_grabber.grab('F6')
-		self._key_grabber.grab('F7')
-		self._key_grabber.grab('F8')
-		self._key_grabber.grab('0xDC') # Camera key
-		self._key_grabber.grab('0xE0') # Overlay key
-		self._key_grabber.grab('0x93') # Frame key
+        self._key_grabber = KeyGrabber()
+        self._key_grabber.connect('key-pressed',
+                                  self.__global_key_pressed_cb)
+        self._key_grabber.connect('key-released',
+                                  self.__global_key_released_cb)
+        self._key_grabber.grab('F1')
+        self._key_grabber.grab('F2')
+        self._key_grabber.grab('F3')
+        self._key_grabber.grab('F4')
+        self._key_grabber.grab('F5')
+        self._key_grabber.grab('F6')
+        self._key_grabber.grab('F7')
+        self._key_grabber.grab('F8')
+        self._key_grabber.grab('0xDC') # Camera key
+        self._key_grabber.grab('0xE0') # Overlay key
+        self._key_grabber.grab('0x93') # Frame key
 
-		# For non-OLPC machines
-		self._key_grabber.grab('<shft><alt>F9')
-		self._key_grabber.grab('<shft><alt>F10')
-		self._key_grabber.grab('<shft><alt>F11')
+        # For non-OLPC machines
+        self._key_grabber.grab('<shft><alt>F9')
+        self._key_grabber.grab('<shft><alt>F10')
+        self._key_grabber.grab('<shft><alt>F11')
 
-		self._home_window = HomeWindow(self)
-		self._home_window.show()
-		self.set_zoom_level(sugar.ZOOM_HOME)
+        self._home_window = HomeWindow(self)
+        self._home_window.show()
+        self.set_zoom_level(sugar.ZOOM_HOME)
 
-		self._screen.connect('window-opened', self.__window_opened_cb)
-		self._screen.connect('window-closed', self.__window_closed_cb)
-		self._screen.connect('active-window-changed',
-							 self.__active_window_changed_cb)
+        self._screen.connect('window-opened', self.__window_opened_cb)
+        self._screen.connect('window-closed', self.__window_closed_cb)
+        self._screen.connect('active-window-changed',
+                             self.__active_window_changed_cb)
 
-		self._frame = Frame(self)
-		self._frame.show_and_hide(3)
+        self._frame = Frame(self)
+        self._frame.show_and_hide(3)
 
-	def _open_terminal_cb(self):
-		self.start_activity('org.sugar.Terminal')
-		return False
+    def _open_terminal_cb(self):
+        self.start_activity('org.sugar.Terminal')
+        return False
 
-	def __global_key_pressed_cb(self, grabber, key):
-		if key == 'F1':
-			self.set_zoom_level(sugar.ZOOM_MESH)
-		elif key == 'F2':
-			self.set_zoom_level(sugar.ZOOM_FRIENDS)
-		elif key == 'F3':
-			self.set_zoom_level(sugar.ZOOM_HOME)
-		elif key == 'F4':
-			self.set_zoom_level(sugar.ZOOM_ACTIVITY)
-		elif key == 'F5':
-			self._dcon_manager.decrease_brightness()
-		elif key == 'F6':
-			self._dcon_manager.increase_brightness()
-		elif key == 'F7':
-			self._dcon_manager.set_mode(DCONManager.COLOR_MODE)
-		elif key == 'F8':
-			self._dcon_manager.set_mode(DCONManager.BLACK_AND_WHITE_MODE)
-		elif key == '<shft><alt>F9':
-			self._frame.notify_key_press()
-		elif key == '<shft><alt>F10':
-			self.toggle_chat_visibility()
-		elif key == '<shft><alt>F11':
-			gobject.idle_add(self._open_terminal_cb)
-		elif key == '0xDC': # Camera key
-			pass
-		elif key == '0xE0': # Overlay key
-			self.toggle_chat_visibility()
-		elif key == '0x93': # Frame key
-			self._frame.notify_key_press()
+    def __global_key_pressed_cb(self, grabber, key):
+        if key == 'F1':
+            self.set_zoom_level(sugar.ZOOM_MESH)
+        elif key == 'F2':
+            self.set_zoom_level(sugar.ZOOM_FRIENDS)
+        elif key == 'F3':
+            self.set_zoom_level(sugar.ZOOM_HOME)
+        elif key == 'F4':
+            self.set_zoom_level(sugar.ZOOM_ACTIVITY)
+        elif key == 'F5':
+            self._dcon_manager.decrease_brightness()
+        elif key == 'F6':
+            self._dcon_manager.increase_brightness()
+        elif key == 'F7':
+            self._dcon_manager.set_mode(DCONManager.COLOR_MODE)
+        elif key == 'F8':
+            self._dcon_manager.set_mode(DCONManager.BLACK_AND_WHITE_MODE)
+        elif key == '<shft><alt>F9':
+            self._frame.notify_key_press()
+        elif key == '<shft><alt>F10':
+            self.toggle_chat_visibility()
+        elif key == '<shft><alt>F11':
+            gobject.idle_add(self._open_terminal_cb)
+        elif key == '0xDC': # Camera key
+            pass
+        elif key == '0xE0': # Overlay key
+            self.toggle_chat_visibility()
+        elif key == '0x93': # Frame key
+            self._frame.notify_key_press()
 
-	def __global_key_released_cb(self, grabber, key):
-		if key == '<shft><alt>F9':
-			self._frame.notify_key_release()
-		elif key == '0x93':
-			self._frame.notify_key_release()
+    def __global_key_released_cb(self, grabber, key):
+        if key == '<shft><alt>F9':
+            self._frame.notify_key_release()
+        elif key == '0x93':
+            self._frame.notify_key_release()
 
-	def __window_opened_cb(self, screen, window):
-		if window.get_window_type() == wnck.WINDOW_NORMAL:
-			activity_host = ActivityHost(self.get_model(), window)
-			self._hosts[activity_host.get_xid()] = activity_host
-			self.emit('activity-opened', activity_host)
+    def __window_opened_cb(self, screen, window):
+        if window.get_window_type() == wnck.WINDOW_NORMAL:
+            activity_host = ActivityHost(self.get_model(), window)
+            self._hosts[activity_host.get_xid()] = activity_host
+            self.emit('activity-opened', activity_host)
 
-	def __active_window_changed_cb(self, screen):
-		window = screen.get_active_window()
-		if not window or window.get_window_type() != wnck.WINDOW_NORMAL:
-			return
-		if not self._hosts.has_key(window.get_xid()):
-			return
+    def __active_window_changed_cb(self, screen):
+        window = screen.get_active_window()
+        if not window or window.get_window_type() != wnck.WINDOW_NORMAL:
+            return
+        if not self._hosts.has_key(window.get_xid()):
+            return
 
-		activity_host = self._hosts[window.get_xid()]
-		current = self._model.get_current_activity()
-		if activity_host.get_id() == current:
-			return
+        activity_host = self._hosts[window.get_xid()]
+        current = self._model.get_current_activity()
+        if activity_host.get_id() == current:
+            return
 
-		self._set_current_activity(activity_host)
+        self._set_current_activity(activity_host)
 
-	def __window_closed_cb(self, screen, window):
-		if window.get_window_type() != wnck.WINDOW_NORMAL:
-			return
+    def __window_closed_cb(self, screen, window):
+        if window.get_window_type() != wnck.WINDOW_NORMAL:
+            return
 
-		if not self._hosts.has_key(window.get_xid()):
-			return
+        if not self._hosts.has_key(window.get_xid()):
+            return
 
-		host = self._hosts[window.get_xid()]
-		host.destroy()
+        host = self._hosts[window.get_xid()]
+        host.destroy()
 
-		self.emit('activity-closed', host)
-		del self._hosts[window.get_xid()]
+        self.emit('activity-closed', host)
+        del self._hosts[window.get_xid()]
 
-		if len(self._hosts) == 0:
-			self._set_current_activity(None)
+        if len(self._hosts) == 0:
+            self._set_current_activity(None)
 
-	def _set_current_activity(self, host):
-		if host:
-			self._model.set_current_activity(host.get_id())
-		else:
-			self._model.set_current_activity(None)
+    def _set_current_activity(self, host):
+        if host:
+            self._model.set_current_activity(host.get_id())
+        else:
+            self._model.set_current_activity(None)
 
-		if self._current_host:
-			self._current_host.set_active(False)
+        if self._current_host:
+            self._current_host.set_active(False)
 
-		self._current_host = host
+        self._current_host = host
 
-		if self._current_host:
-			self._current_host.set_active(True)
+        if self._current_host:
+            self._current_host.set_active(True)
 
-		self.emit('activity-changed', host)
+        self.emit('activity-changed', host)
 
-	def get_model(self):
-		return self._model
+    def get_model(self):
+        return self._model
 
-	def join_activity(self, bundle_id, activity_id):
-		pservice = PresenceService.get_instance()
+    def join_activity(self, bundle_id, activity_id):
+        pservice = PresenceService.get_instance()
 
-		activity = self._get_activity(activity_id)
-		if activity:
-			activity.present()
-		else:
-			activity_ps = pservice.get_activity(activity_id)
+        activity = self._get_activity(activity_id)
+        if activity:
+            activity.present()
+        else:
+            activity_ps = pservice.get_activity(activity_id)
 
-			if activity_ps:
-				activity = ActivityFactory.create(bundle_id)
-				activity.join(activity_ps.object_path())
-			else:
-				logging.error('Cannot start activity.')
+            if activity_ps:
+                activity = ActivityFactory.create(bundle_id)
+                activity.join(activity_ps.object_path())
+            else:
+                logging.error('Cannot start activity.')
 
-	def start_activity(self, activity_type):
-		activity = ActivityFactory.create(activity_type)
-		activity.execute('test', [])
-		return activity
+    def start_activity(self, activity_type):
+        activity = ActivityFactory.create(activity_type)
+        activity.execute('test', [])
+        return activity
 
-	def set_zoom_level(self, level):
-		if level == sugar.ZOOM_ACTIVITY:
-			self._screen.toggle_showing_desktop(False)
-		else:
-			self._screen.toggle_showing_desktop(True)
-			self._home_window.set_zoom_level(level)
+    def set_zoom_level(self, level):
+        if level == sugar.ZOOM_ACTIVITY:
+            self._screen.toggle_showing_desktop(False)
+        else:
+            self._screen.toggle_showing_desktop(True)
+            self._home_window.set_zoom_level(level)
 
-	def get_current_activity(self):
-		activity_id = self._model.get_current_activity()
-		if activity_id:
-			return self._get_activity(activity_id)
-		else:
-			return None
+    def get_current_activity(self):
+        activity_id = self._model.get_current_activity()
+        if activity_id:
+            return self._get_activity(activity_id)
+        else:
+            return None
 
-	def _get_activity(self, activity_id):
-		for host in self._hosts.values():
-			if host.get_id() == activity_id:
-				return host
-		return None
+    def _get_activity(self, activity_id):
+        for host in self._hosts.values():
+            if host.get_id() == activity_id:
+                return host
+        return None
 
-	def toggle_chat_visibility(self):
-		act = self.get_current_activity()
-		if not act:
-			return
-		is_visible = self._frame.is_visible()
-		if act.is_chat_visible():
-			frame_was_visible = act.chat_hide()
-			if not frame_was_visible:
-				self._frame.do_slide_out()
-		else:
-			if not is_visible:
-				self._frame.do_slide_in()
-			act.chat_show(is_visible)
+    def toggle_chat_visibility(self):
+        act = self.get_current_activity()
+        if not act:
+            return
+        is_visible = self._frame.is_visible()
+        if act.is_chat_visible():
+            frame_was_visible = act.chat_hide()
+            if not frame_was_visible:
+                self._frame.do_slide_out()
+        else:
+            if not is_visible:
+                self._frame.do_slide_in()
+            act.chat_show(is_visible)

shell/view/dconmanager.py

@@ -21,23 +21,23 @@ DCON_MANAGER_SERVICE = 'org.laptop.DCONManager'
 DCON_MANAGER_OBJECT_PATH = '/org/laptop/DCONManager'
 
 class DCONManager(object):
-	COLOR_MODE = 0
-	BLACK_AND_WHITE_MODE = 1
+    COLOR_MODE = 0
+    BLACK_AND_WHITE_MODE = 1
 
-	def __init__(self):
-		bus = dbus.SystemBus()
-		proxy = bus.get_object(DCON_MANAGER_SERVICE, DCON_MANAGER_OBJECT_PATH)
-		self._service = dbus.Interface(proxy, DCON_MANAGER_INTERFACE)
+    def __init__(self):
+        bus = dbus.SystemBus()
+        proxy = bus.get_object(DCON_MANAGER_SERVICE, DCON_MANAGER_OBJECT_PATH)
+        self._service = dbus.Interface(proxy, DCON_MANAGER_INTERFACE)
 
-	def set_mode(self, mode):
-		self._service.set_mode(mode)
+    def set_mode(self, mode):
+        self._service.set_mode(mode)
 
-	def increase_brightness(self):
-		level = self._service.get_backlight_level()
-		if level >= 0:
-			self._service.set_backlight_level(level + 1)
+    def increase_brightness(self):
+        level = self._service.get_backlight_level()
+        if level >= 0:
+            self._service.set_backlight_level(level + 1)
 
-	def decrease_brightness(self):
-		level = self._service.get_backlight_level()
-		if level >= 0:
-			self._service.set_backlight_level(level - 1)
+    def decrease_brightness(self):
+        level = self._service.get_backlight_level()
+        if level >= 0:
+            self._service.set_backlight_level(level - 1)

shell/view/frame/ActivitiesBox.py

@@ -22,80 +22,80 @@ from sugar.presence import PresenceService
 from sugar.graphics import style
 
 class ActivityItem(CanvasIcon):
-	def __init__(self, activity):
-		icon_name = activity.get_icon()
-		CanvasIcon.__init__(self, icon_name=icon_name)
-		style.apply_stylesheet(self, 'frame.ActivityIcon')
-		self._activity = activity
+    def __init__(self, activity):
+        icon_name = activity.get_icon()
+        CanvasIcon.__init__(self, icon_name=icon_name)
+        style.apply_stylesheet(self, 'frame.ActivityIcon')
+        self._activity = activity
 
-	def get_bundle_id(self):
-		return self._activity.get_service_name()
+    def get_bundle_id(self):
+        return self._activity.get_service_name()
 
 class InviteItem(CanvasIcon):
-	def __init__(self, activity, invite):
-		CanvasIcon.__init__(self, icon_name=activity.get_icon())
+    def __init__(self, activity, invite):
+        CanvasIcon.__init__(self, icon_name=activity.get_icon())
 
-		style.apply_stylesheet(self, 'frame.ActivityIcon')
-		self.props.color = activity.get_color()
+        style.apply_stylesheet(self, 'frame.ActivityIcon')
+        self.props.color = activity.get_color()
 
-		self._invite = invite
+        self._invite = invite
 
-	def get_activity_id(self):
-		return self._invite.get_activity_id()
+    def get_activity_id(self):
+        return self._invite.get_activity_id()
 
-	def get_bundle_id(self):
-		return self._invite.get_bundle_id()
+    def get_bundle_id(self):
+        return self._invite.get_bundle_id()
 
-	def get_invite(self):
-		return self._invite
+    def get_invite(self):
+        return self._invite
 
 class ActivitiesBox(hippo.CanvasBox):
-	def __init__(self, shell):
-		hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
+    def __init__(self, shell):
+        hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
 
-		self._shell = shell
-		self._shell_model = self._shell.get_model() 
-		self._invite_to_item = {}
-		self._invites = self._shell_model.get_invites()
+        self._shell = shell
+        self._shell_model = self._shell.get_model() 
+        self._invite_to_item = {}
+        self._invites = self._shell_model.get_invites()
 
-		for bundle in self._shell_model.get_bundle_registry():
-			if bundle.get_show_launcher():
-				self.add_activity(bundle)
+        for bundle in self._shell_model.get_bundle_registry():
+            if bundle.get_show_launcher():
+                self.add_activity(bundle)
 
-		for invite in self._invites:
-			self.add_invite(invite)
-		self._invites.connect('invite-added', self._invite_added_cb)
-		self._invites.connect('invite-removed', self._invite_removed_cb)
+        for invite in self._invites:
+            self.add_invite(invite)
+        self._invites.connect('invite-added', self._invite_added_cb)
+        self._invites.connect('invite-removed', self._invite_removed_cb)
 
-	def _activity_clicked_cb(self, icon):
-		self._shell.start_activity(icon.get_bundle_id())
+    def _activity_clicked_cb(self, icon):
+        self._shell.start_activity(icon.get_bundle_id())
 
-	def _invite_clicked_cb(self, icon):
-		self._invites.remove_invite(icon.get_invite())
-		self._shell.join_activity(icon.get_bundle_id(),
-								  icon.get_activity_id())
-	
-	def _invite_added_cb(self, invites, invite):
-		self.add_invite(invite)
+    def _invite_clicked_cb(self, icon):
+        self._invites.remove_invite(icon.get_invite())
+        self._shell.join_activity(icon.get_bundle_id(),
+                                  icon.get_activity_id())
+    
+    def _invite_added_cb(self, invites, invite):
+        self.add_invite(invite)
 
-	def _invite_removed_cb(self, invites, invite):
-		self.remove_invite(invite)
+    def _invite_removed_cb(self, invites, invite):
+        self.remove_invite(invite)
 
-	def add_activity(self, activity):
-		item = ActivityItem(activity)
-		item.connect('activated', self._activity_clicked_cb)
-		self.append(item, 0)
+    def add_activity(self, activity):
+        item = ActivityItem(activity)
+        item.connect('activated', self._activity_clicked_cb)
+        self.append(item, 0)
 
-	def add_invite(self, invite):
-		mesh = self._shell_model.get_mesh()
-		activity = mesh.get_activity(invite.get_activity_id())
-		if activity:
-			item = InviteItem(activity, invite)
-			item.connect('activated', self._invite_clicked_cb)
-			self.append(item, 0)
+    def add_invite(self, invite):
+        mesh = self._shell_model.get_mesh()
+        activity = mesh.get_activity(invite.get_activity_id())
+        if activity:
+            item = InviteItem(activity, invite)
+            item.connect('activated', self._invite_clicked_cb)
+            self.append(item, 0)
 
-			self._invite_to_item[invite] = item
+            self._invite_to_item[invite] = item
 
-	def remove_invite(self, invite):
-		self.remove(self._invite_to_item[invite])
-		del self._invite_to_item[invite]
+    def remove_invite(self, invite):
+        self.remove(self._invite_to_item[invite])
+        del self._invite_to_item[invite]

shell/view/frame/ClipboardBox.py

@@ -7,36 +7,36 @@ from view.ClipboardIcon import ClipboardIcon
 from sugar.clipboard import ClipboardService
 
 class ClipboardBox(hippo.CanvasBox):
-	
-	def __init__(self, frame, menu_shell):
-		hippo.CanvasBox.__init__(self)
-		self._frame = frame
-		self._menu_shell = menu_shell
-		self._icons = {}
-		
-		cb_service = ClipboardService.get_instance()
-		cb_service.connect('object-added', self._object_added_cb)
-		cb_service.connect('object-deleted', self._object_deleted_cb)
-		cb_service.connect('object-state-changed', self._object_state_changed_cb)
+    
+    def __init__(self, frame, menu_shell):
+        hippo.CanvasBox.__init__(self)
+        self._frame = frame
+        self._menu_shell = menu_shell
+        self._icons = {}
+        
+        cb_service = ClipboardService.get_instance()
+        cb_service.connect('object-added', self._object_added_cb)
+        cb_service.connect('object-deleted', self._object_deleted_cb)
+        cb_service.connect('object-state-changed', self._object_state_changed_cb)
 
-	def _object_added_cb(self, cb_service, name, mimeType, fileName):
-		icon = ClipboardIcon(self._menu_shell, name, fileName)
-		style.apply_stylesheet(icon, 'frame.BuddyIcon')
-		self.append(icon)
-		self._icons[fileName] = icon
-		
-		if not self._frame.is_visible():
-			self._frame.show_and_hide(0.1)
-		
-		logging.debug('ClipboardBox: ' + fileName + ' was added.')
+    def _object_added_cb(self, cb_service, name, mimeType, fileName):
+        icon = ClipboardIcon(self._menu_shell, name, fileName)
+        style.apply_stylesheet(icon, 'frame.BuddyIcon')
+        self.append(icon)
+        self._icons[fileName] = icon
+        
+        if not self._frame.is_visible():
+            self._frame.show_and_hide(0.1)
+        
+        logging.debug('ClipboardBox: ' + fileName + ' was added.')
 
-	def _object_deleted_cb(self, cb_service, fileName):
-		icon = self._icons[fileName]
-		self.remove(icon)
-		del self._icons[fileName]
-		logging.debug('ClipboardBox: ' + fileName + ' was deleted.')
+    def _object_deleted_cb(self, cb_service, fileName):
+        icon = self._icons[fileName]
+        self.remove(icon)
+        del self._icons[fileName]
+        logging.debug('ClipboardBox: ' + fileName + ' was deleted.')
 
-	def _object_state_changed_cb(self, cb_service, fileName, percent):
-		icon = self._icons[fileName]
-		icon.set_percent(percent)
-		logging.debug('ClipboardBox: ' + fileName + ' state was changed.')
+    def _object_state_changed_cb(self, cb_service, fileName, percent):
+        icon = self._icons[fileName]
+        icon.set_percent(percent)
+        logging.debug('ClipboardBox: ' + fileName + ' state was changed.')

shell/view/frame/Frame.py

@@ -32,268 +32,268 @@ from sugar.graphics.grid import Grid
 from sugar.graphics.menushell import MenuShell
 
 class EventFrame(gobject.GObject):
-	__gsignals__ = {
-		'enter-edge':    (gobject.SIGNAL_RUN_FIRST,
-				          gobject.TYPE_NONE, ([])),
-		'enter-corner':  (gobject.SIGNAL_RUN_FIRST,
-				          gobject.TYPE_NONE, ([])),
-		'leave':		 (gobject.SIGNAL_RUN_FIRST,
-				          gobject.TYPE_NONE, ([]))
-	}
+    __gsignals__ = {
+        'enter-edge':    (gobject.SIGNAL_RUN_FIRST,
+                          gobject.TYPE_NONE, ([])),
+        'enter-corner':  (gobject.SIGNAL_RUN_FIRST,
+                          gobject.TYPE_NONE, ([])),
+        'leave':         (gobject.SIGNAL_RUN_FIRST,
+                          gobject.TYPE_NONE, ([]))
+    }
 
-	HOVER_NONE = 0
-	HOVER_CORNER = 1
-	HOVER_EDGE = 2
+    HOVER_NONE = 0
+    HOVER_CORNER = 1
+    HOVER_EDGE = 2
 
-	def __init__(self):
-		gobject.GObject.__init__(self)
+    def __init__(self):
+        gobject.GObject.__init__(self)
 
-		self._windows = []
-		self._hover = EventFrame.HOVER_NONE
-		self._active = False
+        self._windows = []
+        self._hover = EventFrame.HOVER_NONE
+        self._active = False
 
-		invisible = self._create_invisible(0, 0, gtk.gdk.screen_width(), 1)
-		self._windows.append(invisible)
+        invisible = self._create_invisible(0, 0, gtk.gdk.screen_width(), 1)
+        self._windows.append(invisible)
 
-		invisible = self._create_invisible(0, 0, 1, gtk.gdk.screen_height())
-		self._windows.append(invisible)
+        invisible = self._create_invisible(0, 0, 1, gtk.gdk.screen_height())
+        self._windows.append(invisible)
 
-		invisible = self._create_invisible(gtk.gdk.screen_width() - 1, 0,
-										   gtk.gdk.screen_width(),
-										   gtk.gdk.screen_height())
-		self._windows.append(invisible)
+        invisible = self._create_invisible(gtk.gdk.screen_width() - 1, 0,
+                                           gtk.gdk.screen_width(),
+                                           gtk.gdk.screen_height())
+        self._windows.append(invisible)
 
-		invisible = self._create_invisible(0, gtk.gdk.screen_height() - 1,
-										   gtk.gdk.screen_width(),
-										   gtk.gdk.screen_height())
-		self._windows.append(invisible)
+        invisible = self._create_invisible(0, gtk.gdk.screen_height() - 1,
+                                           gtk.gdk.screen_width(),
+                                           gtk.gdk.screen_height())
+        self._windows.append(invisible)
 
-		screen = wnck.screen_get_default()
-		screen.connect('active-window-changed',
-					   self._active_window_changed_cb)
+        screen = wnck.screen_get_default()
+        screen.connect('active-window-changed',
+                       self._active_window_changed_cb)
 
-	def _create_invisible(self, x, y, width, height):
-		invisible = gtk.Invisible()
-		invisible.connect('motion-notify-event', self._motion_notify_cb)
-		invisible.connect('enter-notify-event', self._enter_notify_cb)
-		invisible.connect('leave-notify-event', self._leave_notify_cb)
+    def _create_invisible(self, x, y, width, height):
+        invisible = gtk.Invisible()
+        invisible.connect('motion-notify-event', self._motion_notify_cb)
+        invisible.connect('enter-notify-event', self._enter_notify_cb)
+        invisible.connect('leave-notify-event', self._leave_notify_cb)
 
-		invisible.realize()
-		invisible.window.set_events(gtk.gdk.POINTER_MOTION_MASK |
-									gtk.gdk.ENTER_NOTIFY_MASK |
-									gtk.gdk.LEAVE_NOTIFY_MASK)
-		invisible.window.move_resize(x, y, width, height)
+        invisible.realize()
+        invisible.window.set_events(gtk.gdk.POINTER_MOTION_MASK |
+                                    gtk.gdk.ENTER_NOTIFY_MASK |
+                                    gtk.gdk.LEAVE_NOTIFY_MASK)
+        invisible.window.move_resize(x, y, width, height)
 
-		return invisible
+        return invisible
 
-	def _enter_notify_cb(self, widget, event):
-		self._notify_enter(event.x, event.y)
+    def _enter_notify_cb(self, widget, event):
+        self._notify_enter(event.x, event.y)
 
-	def _motion_notify_cb(self, widget, event):
-		self._notify_enter(event.x, event.y)
+    def _motion_notify_cb(self, widget, event):
+        self._notify_enter(event.x, event.y)
 
-	def _notify_enter(self, x, y):
-		screen_w = gtk.gdk.screen_width()
-		screen_h = gtk.gdk.screen_height()
+    def _notify_enter(self, x, y):
+        screen_w = gtk.gdk.screen_width()
+        screen_h = gtk.gdk.screen_height()
 
-		if (x == 0 and y == 0) or \
-		   (x == 0 and y == screen_h - 1) or \
-		   (x == screen_w - 1 and y == 0) or \
-		   (x == screen_w - 1 and y == screen_h - 1):
-			if self._hover != EventFrame.HOVER_CORNER:
-				self._hover = EventFrame.HOVER_CORNER
-				self.emit('enter-corner')
-		else:
-			if self._hover != EventFrame.HOVER_EDGE:
-				self._hover = EventFrame.HOVER_EDGE
-				self.emit('enter-edge')
+        if (x == 0 and y == 0) or \
+           (x == 0 and y == screen_h - 1) or \
+           (x == screen_w - 1 and y == 0) or \
+           (x == screen_w - 1 and y == screen_h - 1):
+            if self._hover != EventFrame.HOVER_CORNER:
+                self._hover = EventFrame.HOVER_CORNER
+                self.emit('enter-corner')
+        else:
+            if self._hover != EventFrame.HOVER_EDGE:
+                self._hover = EventFrame.HOVER_EDGE
+                self.emit('enter-edge')
 
-	def _leave_notify_cb(self, widget, event):
-		self._hover = EventFrame.HOVER_NONE
-		if self._active:
-			self.emit('leave')
+    def _leave_notify_cb(self, widget, event):
+        self._hover = EventFrame.HOVER_NONE
+        if self._active:
+            self.emit('leave')
 
-	def show(self):
-		self._active = True
-		for window in self._windows:
-			window.show()
+    def show(self):
+        self._active = True
+        for window in self._windows:
+            window.show()
 
-	def hide(self):
-		self._active = False
-		for window in self._windows:
-			window.hide()
+    def hide(self):
+        self._active = False
+        for window in self._windows:
+            window.hide()
 
-	def _active_window_changed_cb(self, screen):
-		for window in self._windows:
-			window.window.raise_()
+    def _active_window_changed_cb(self, screen):
+        for window in self._windows:
+            window.window.raise_()
 
 class Frame:
-	INACTIVE = 0
-	TEMPORARY = 1
-	STICKY = 2
-	HIDE_ON_LEAVE = 3
-	AUTOMATIC = 4
+    INACTIVE = 0
+    TEMPORARY = 1
+    STICKY = 2
+    HIDE_ON_LEAVE = 3
+    AUTOMATIC = 4
 
-	def __init__(self, shell):
-		self._windows = []
-		self._active_menus = 0
-		self._shell = shell
-		self._mode = Frame.INACTIVE
+    def __init__(self, shell):
+        self._windows = []
+        self._active_menus = 0
+        self._shell = shell
+        self._mode = Frame.INACTIVE
 
-		self._timeline = Timeline(self)
-		self._timeline.add_tag('slide_in', 6, 12)
-		self._timeline.add_tag('before_slide_out', 36, 36)
-		self._timeline.add_tag('slide_out', 37, 42)
+        self._timeline = Timeline(self)
+        self._timeline.add_tag('slide_in', 6, 12)
+        self._timeline.add_tag('before_slide_out', 36, 36)
+        self._timeline.add_tag('slide_out', 37, 42)
 
-		self._event_frame = EventFrame()
-		self._event_frame.connect('enter-edge', self._enter_edge_cb)
-		self._event_frame.connect('enter-corner', self._enter_corner_cb)
-		self._event_frame.connect('leave', self._event_frame_leave_cb)
-		self._event_frame.show()
+        self._event_frame = EventFrame()
+        self._event_frame.connect('enter-edge', self._enter_edge_cb)
+        self._event_frame.connect('enter-corner', self._enter_corner_cb)
+        self._event_frame.connect('leave', self._event_frame_leave_cb)
+        self._event_frame.show()
 
-		grid = Grid()
+        grid = Grid()
 
-		# Top panel
-		[menu_shell, root] = self._create_panel(grid, 0, 0, 16, 1)
-		menu_shell.set_position(MenuShell.BOTTOM)
+        # Top panel
+        [menu_shell, root] = self._create_panel(grid, 0, 0, 16, 1)
+        menu_shell.set_position(MenuShell.BOTTOM)
 
-		box = ZoomBox(self._shell, menu_shell)
+        box = ZoomBox(self._shell, menu_shell)
 
-		[x, y] = grid.point(1, 0)
-		root.append(box, hippo.PACK_FIXED)
-		root.move(box, x, y)
+        [x, y] = grid.point(1, 0)
+        root.append(box, hippo.PACK_FIXED)
+        root.move(box, x, y)
 
-		tray = NotificationTray()
-		tray_box = hippo.CanvasBox(box_width=grid.dimension(1),
-								   box_height=grid.dimension(1),
-								   xalign=hippo.ALIGNMENT_END)
+        tray = NotificationTray()
+        tray_box = hippo.CanvasBox(box_width=grid.dimension(1),
+                                   box_height=grid.dimension(1),
+                                   xalign=hippo.ALIGNMENT_END)
 
-		tray_widget = hippo.CanvasWidget()
-		tray_widget.props.widget = tray
-		tray_box.append(tray_widget, gtk.EXPAND)
+        tray_widget = hippo.CanvasWidget()
+        tray_widget.props.widget = tray
+        tray_box.append(tray_widget, gtk.EXPAND)
 
-		[x, y] = grid.point(13, 0)
-		root.append(tray_box, hippo.PACK_FIXED)
-		root.move(tray_box, x, y)
+        [x, y] = grid.point(13, 0)
+        root.append(tray_box, hippo.PACK_FIXED)
+        root.move(tray_box, x, y)
 
-		box = OverlayBox(self._shell)
+        box = OverlayBox(self._shell)
 
-		[x, y] = grid.point(14, 0)
-		root.append(box, hippo.PACK_FIXED)
-		root.move(box, x, y)
+        [x, y] = grid.point(14, 0)
+        root.append(box, hippo.PACK_FIXED)
+        root.move(box, x, y)
 
-		shutdown_icon = ShutdownIcon(menu_shell)
+        shutdown_icon = ShutdownIcon(menu_shell)
 
-		[x, y] = grid.point(12, 0)
-		root.append(shutdown_icon, hippo.PACK_FIXED)
-		root.move(shutdown_icon, x, y)
+        [x, y] = grid.point(12, 0)
+        root.append(shutdown_icon, hippo.PACK_FIXED)
+        root.move(shutdown_icon, x, y)
 
-		# Bottom panel
-		[menu_shell, root] = self._create_panel(grid, 0, 11, 16, 1)
-		menu_shell.set_position(MenuShell.TOP)
+        # Bottom panel
+        [menu_shell, root] = self._create_panel(grid, 0, 11, 16, 1)
+        menu_shell.set_position(MenuShell.TOP)
 
-		box = ActivitiesBox(self._shell)
-		root.append(box, hippo.PACK_FIXED)
+        box = ActivitiesBox(self._shell)
+        root.append(box, hippo.PACK_FIXED)
 
-		[x, y] = grid.point(1, 0)
-		root.move(box, x, y)
+        [x, y] = grid.point(1, 0)
+        root.move(box, x, y)
 
-		# Right panel
-		[menu_shell, root] = self._create_panel(grid, 15, 1, 1, 10)
-		menu_shell.set_position(MenuShell.LEFT)
+        # Right panel
+        [menu_shell, root] = self._create_panel(grid, 15, 1, 1, 10)
+        menu_shell.set_position(MenuShell.LEFT)
 
-		box = FriendsBox(self._shell, menu_shell)
-		root.append(box)
+        box = FriendsBox(self._shell, menu_shell)
+        root.append(box)
 
-		# Left panel
-		[menu_shell, root] = self._create_panel(grid, 0, 1, 1, 10)
+        # Left panel
+        [menu_shell, root] = self._create_panel(grid, 0, 1, 1, 10)
 
-		box = ClipboardBox(self, menu_shell)
-		root.append(box)
+        box = ClipboardBox(self, menu_shell)
+        root.append(box)
 
-	def _create_panel(self, grid, x, y, width, height):
-		panel = PanelWindow()
+    def _create_panel(self, grid, x, y, width, height):
+        panel = PanelWindow()
 
-		panel.connect('enter-notify-event', self._enter_notify_cb)
-		panel.connect('leave-notify-event', self._leave_notify_cb)
+        panel.connect('enter-notify-event', self._enter_notify_cb)
+        panel.connect('leave-notify-event', self._leave_notify_cb)
 
-		menu_shell = panel.get_menu_shell()
-		menu_shell.connect('activated', self._menu_shell_activated_cb)
-		menu_shell.connect('deactivated', self._menu_shell_deactivated_cb)
+        menu_shell = panel.get_menu_shell()
+        menu_shell.connect('activated', self._menu_shell_activated_cb)
+        menu_shell.connect('deactivated', self._menu_shell_deactivated_cb)
 
-		[x, y, width, height] = grid.rectangle(x, y, width, height)
+        [x, y, width, height] = grid.rectangle(x, y, width, height)
 
-		panel.move(x, y)
-		panel.resize(width, height)
+        panel.move(x, y)
+        panel.resize(width, height)
 
-		self._windows.append(panel)
+        self._windows.append(panel)
 
-		return [panel.get_menu_shell(), panel.get_root()]
+        return [panel.get_menu_shell(), panel.get_root()]
 
-	def _menu_shell_activated_cb(self, menu_shell):
-		self._active_menus += 1
-		self._timeline.goto('slide_in', True)
+    def _menu_shell_activated_cb(self, menu_shell):
+        self._active_menus += 1
+        self._timeline.goto('slide_in', True)
 
-	def _menu_shell_deactivated_cb(self, menu_shell):
-		self._active_menus -= 1
-		if self._mode != Frame.STICKY:
-			self._timeline.play('before_slide_out', 'slide_out')
+    def _menu_shell_deactivated_cb(self, menu_shell):
+        self._active_menus -= 1
+        if self._mode != Frame.STICKY:
+            self._timeline.play('before_slide_out', 'slide_out')
 
-	def _enter_notify_cb(self, window, event):
-		self._timeline.goto('slide_in', True)
+    def _enter_notify_cb(self, window, event):
+        self._timeline.goto('slide_in', True)
 
-	def _leave_notify_cb(self, window, event):
-		# FIXME for some reason every click cause also a leave-notify
-		if event.state == gtk.gdk.BUTTON1_MASK:
-			return
+    def _leave_notify_cb(self, window, event):
+        # FIXME for some reason every click cause also a leave-notify
+        if event.state == gtk.gdk.BUTTON1_MASK:
+            return
 
-		if self._active_menus == 0 and \
-		   (self._mode == Frame.HIDE_ON_LEAVE or \
-		    self._mode == Frame.AUTOMATIC):
-			self._timeline.play('before_slide_out', 'slide_out')
+        if self._active_menus == 0 and \
+           (self._mode == Frame.HIDE_ON_LEAVE or \
+            self._mode == Frame.AUTOMATIC):
+            self._timeline.play('before_slide_out', 'slide_out')
 
-	def _enter_edge_cb(self, event_frame):
-		self._mode = Frame.HIDE_ON_LEAVE
-		self._timeline.play(None, 'slide_in')
+    def _enter_edge_cb(self, event_frame):
+        self._mode = Frame.HIDE_ON_LEAVE
+        self._timeline.play(None, 'slide_in')
 
-	def _enter_corner_cb(self, event_frame):
-		self._mode = Frame.HIDE_ON_LEAVE
-		self._timeline.play('slide_in', 'slide_in')
+    def _enter_corner_cb(self, event_frame):
+        self._mode = Frame.HIDE_ON_LEAVE
+        self._timeline.play('slide_in', 'slide_in')
 
-	def _event_frame_leave_cb(self, event_frame):
-		if self._mode != Frame.STICKY:
-			self._timeline.goto('slide_out', True)
+    def _event_frame_leave_cb(self, event_frame):
+        if self._mode != Frame.STICKY:
+            self._timeline.goto('slide_out', True)
 
-	def show_and_hide(self, seconds):
-		self._mode = Frame.AUTOMATIC
-		self._timeline.play()
+    def show_and_hide(self, seconds):
+        self._mode = Frame.AUTOMATIC
+        self._timeline.play()
 
-	def notify_key_press(self):
-		if self._timeline.on_tag('slide_in'):
-			self._timeline.play('before_slide_out', 'slide_out')
-		elif self._timeline.on_tag('before_slide_out'):
-			self._mode = Frame.TEMPORARY
-		else:
-			self._mode = Frame.STICKY
-			self._timeline.play('slide_in', 'slide_in')
+    def notify_key_press(self):
+        if self._timeline.on_tag('slide_in'):
+            self._timeline.play('before_slide_out', 'slide_out')
+        elif self._timeline.on_tag('before_slide_out'):
+            self._mode = Frame.TEMPORARY
+        else:
+            self._mode = Frame.STICKY
+            self._timeline.play('slide_in', 'slide_in')
 
-	def notify_key_release(self):
-		if self._mode == Frame.TEMPORARY:
-			self._timeline.play('before_slide_out', 'slide_out')
+    def notify_key_release(self):
+        if self._mode == Frame.TEMPORARY:
+            self._timeline.play('before_slide_out', 'slide_out')
 
-	def do_slide_in(self, current=0, n_frames=0):
-		if not self._windows[0].props.visible:
-			for panel in self._windows:
-				panel.show()
-			self._event_frame.hide()
+    def do_slide_in(self, current=0, n_frames=0):
+        if not self._windows[0].props.visible:
+            for panel in self._windows:
+                panel.show()
+            self._event_frame.hide()
 
-	def do_slide_out(self, current=0, n_frames=0):
-		if self._windows[0].props.visible:
-			for panel in self._windows:
-				panel.hide()
-			self._event_frame.show()
+    def do_slide_out(self, current=0, n_frames=0):
+        if self._windows[0].props.visible:
+            for panel in self._windows:
+                panel.hide()
+            self._event_frame.show()
 
-	def is_visible(self):
-		if self._windows[0].props.visible:
-			return True
-		return False
+    def is_visible(self):
+        if self._windows[0].props.visible:
+            return True
+        return False

shell/view/frame/FriendsBox.py

@@ -24,85 +24,85 @@ from view.BuddyIcon import BuddyIcon
 from model.BuddyModel import BuddyModel
 
 class FriendsBox(hippo.CanvasBox):
-	def __init__(self, shell, menu_shell):
-		hippo.CanvasBox.__init__(self)
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._activity_ps = None
-		self._joined_hid = -1
-		self._left_hid = -1
-		self._buddies = {}
+    def __init__(self, shell, menu_shell):
+        hippo.CanvasBox.__init__(self)
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._activity_ps = None
+        self._joined_hid = -1
+        self._left_hid = -1
+        self._buddies = {}
 
-		self._pservice = PresenceService.get_instance()
-		self._pservice.connect('activity-appeared',
-							   self.__activity_appeared_cb)
+        self._pservice = PresenceService.get_instance()
+        self._pservice.connect('activity-appeared',
+                               self.__activity_appeared_cb)
 
-		# Add initial activities the PS knows about
-		for activity in self._pservice.get_activities():
-			self.__activity_appeared_cb(self._pservice, activity)
+        # Add initial activities the PS knows about
+        for activity in self._pservice.get_activities():
+            self.__activity_appeared_cb(self._pservice, activity)
 
-		shell.connect('activity-changed', self.__activity_changed_cb)
+        shell.connect('activity-changed', self.__activity_changed_cb)
 
-	def add_buddy(self, buddy):
-		if self._buddies.has_key(buddy.get_name()):
-			return
+    def add_buddy(self, buddy):
+        if self._buddies.has_key(buddy.get_name()):
+            return
 
-		model = BuddyModel(buddy=buddy)
-		icon = BuddyIcon(self._shell, self._menu_shell, model)
-		style.apply_stylesheet(icon, 'frame.BuddyIcon')
-		self.append(icon)
+        model = BuddyModel(buddy=buddy)
+        icon = BuddyIcon(self._shell, self._menu_shell, model)
+        style.apply_stylesheet(icon, 'frame.BuddyIcon')
+        self.append(icon)
 
-		self._buddies[buddy.get_name()] = icon
+        self._buddies[buddy.get_name()] = icon
 
-	def remove_buddy(self, buddy):
-		if not self._buddies.has_key(buddy.get_name()):
-			return
+    def remove_buddy(self, buddy):
+        if not self._buddies.has_key(buddy.get_name()):
+            return
 
-		self.remove(self._buddies[buddy.get_name()])
+        self.remove(self._buddies[buddy.get_name()])
 
-	def clear(self):
-		for item in self.get_children():
-			self.remove(item)
-		self._buddies = {}
+    def clear(self):
+        for item in self.get_children():
+            self.remove(item)
+        self._buddies = {}
 
-	def __activity_appeared_cb(self, pservice, activity_ps):
-		activity = self._shell.get_current_activity()
-		if activity and activity_ps.get_id() == activity.get_id():
-			self._set_activity_ps(activity_ps)
+    def __activity_appeared_cb(self, pservice, activity_ps):
+        activity = self._shell.get_current_activity()
+        if activity and activity_ps.get_id() == activity.get_id():
+            self._set_activity_ps(activity_ps)
 
-	def _set_activity_ps(self, activity_ps):
-		if self._activity_ps == activity_ps:
-			return
+    def _set_activity_ps(self, activity_ps):
+        if self._activity_ps == activity_ps:
+            return
 
-		if self._joined_hid > 0:
-			self._activity_ps.disconnect(self._joined_hid)
-			self._joined_hid = -1
-		if self._left_hid > 0:
-			self._activity_ps.disconnect(self._left_hid)
-			self._left_hid = -1
+        if self._joined_hid > 0:
+            self._activity_ps.disconnect(self._joined_hid)
+            self._joined_hid = -1
+        if self._left_hid > 0:
+            self._activity_ps.disconnect(self._left_hid)
+            self._left_hid = -1
 
-		self._activity_ps = activity_ps
+        self._activity_ps = activity_ps
 
-		self.clear()
+        self.clear()
 
-		if activity_ps != None:
-			for buddy in activity_ps.get_joined_buddies():
-				self.add_buddy(buddy)
+        if activity_ps != None:
+            for buddy in activity_ps.get_joined_buddies():
+                self.add_buddy(buddy)
 
-			self._joined_hid = activity_ps.connect(
-							'buddy-joined', self.__buddy_joined_cb)
-			self._left_hid = activity_ps.connect(
-							'buddy-left', self.__buddy_left_cb)
+            self._joined_hid = activity_ps.connect(
+                            'buddy-joined', self.__buddy_joined_cb)
+            self._left_hid = activity_ps.connect(
+                            'buddy-left', self.__buddy_left_cb)
 
-	def __activity_changed_cb(self, group, activity):
-		if activity:
-			ps = self._pservice.get_activity(activity.get_id())
-			self._set_activity_ps(ps)
-		else:
-			self._set_activity_ps(None)
+    def __activity_changed_cb(self, group, activity):
+        if activity:
+            ps = self._pservice.get_activity(activity.get_id())
+            self._set_activity_ps(ps)
+        else:
+            self._set_activity_ps(None)
 
-	def __buddy_joined_cb(self, activity, buddy):
-		self.add_buddy(buddy)
+    def __buddy_joined_cb(self, activity, buddy):
+        self.add_buddy(buddy)
 
-	def __buddy_left_cb(self, activity, buddy):
-		self.remove_buddy(buddy)
+    def __buddy_left_cb(self, activity, buddy):
+        self.remove_buddy(buddy)

shell/view/frame/PanelWindow.py

@@ -20,28 +20,28 @@ import hippo
 from sugar.graphics.menushell import MenuShell
 
 class PanelWindow(gtk.Window):
-	def __init__(self):
-		gtk.Window.__init__(self)
+    def __init__(self):
+        gtk.Window.__init__(self)
 
-		self.set_decorated(False)
-		self.connect('realize', self._realize_cb)
+        self.set_decorated(False)
+        self.connect('realize', self._realize_cb)
 
-		canvas = hippo.Canvas()
+        canvas = hippo.Canvas()
 
-		self._bg = hippo.CanvasBox(background_color=0x414141ff)
-		canvas.set_root(self._bg)
+        self._bg = hippo.CanvasBox(background_color=0x414141ff)
+        canvas.set_root(self._bg)
 
-		self.add(canvas)
-		canvas.show()
+        self.add(canvas)
+        canvas.show()
 
-		self._menu_shell = MenuShell(canvas)
+        self._menu_shell = MenuShell(canvas)
 
-	def get_menu_shell(self):
-		return self._menu_shell
+    def get_menu_shell(self):
+        return self._menu_shell
 
-	def get_root(self):
-		return self._bg
+    def get_root(self):
+        return self._bg
 
-	def _realize_cb(self, widget):
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
-		self.window.set_accept_focus(False)
+    def _realize_cb(self, widget):
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+        self.window.set_accept_focus(False)

shell/view/frame/ZoomBox.py

@@ -23,98 +23,98 @@ from sugar.graphics import style
 import sugar
 
 class ActivityMenu(Menu):
-	ACTION_SHARE = 1
-	ACTION_CLOSE = 2
+    ACTION_SHARE = 1
+    ACTION_CLOSE = 2
 
-	def __init__(self, activity_host):
-		Menu.__init__(self, activity_host.get_title())
+    def __init__(self, activity_host):
+        Menu.__init__(self, activity_host.get_title())
 
-		if not activity_host.get_shared():
-			self._add_mesh_action()
+        if not activity_host.get_shared():
+            self._add_mesh_action()
 
-		self._add_close_action()
+        self._add_close_action()
 
-	def _add_mesh_action(self):
-		icon = CanvasIcon(icon_name='stock-share-mesh')
-		self.add_action(icon, ActivityMenu.ACTION_SHARE) 
+    def _add_mesh_action(self):
+        icon = CanvasIcon(icon_name='stock-share-mesh')
+        self.add_action(icon, ActivityMenu.ACTION_SHARE) 
 
-	def _add_close_action(self):
-		icon = CanvasIcon(icon_name='stock-close')
-		self.add_action(icon, ActivityMenu.ACTION_CLOSE) 
+    def _add_close_action(self):
+        icon = CanvasIcon(icon_name='stock-close')
+        self.add_action(icon, ActivityMenu.ACTION_CLOSE) 
 
 class ActivityIcon(MenuIcon):
-	def __init__(self, shell, menu_shell, activity_host):
-		self._shell = shell
-		self._activity_host = activity_host
+    def __init__(self, shell, menu_shell, activity_host):
+        self._shell = shell
+        self._activity_host = activity_host
 
-		icon_name = activity_host.get_icon_name()
-		icon_color = activity_host.get_icon_color()
+        icon_name = activity_host.get_icon_name()
+        icon_color = activity_host.get_icon_color()
 
-		MenuIcon.__init__(self, menu_shell, icon_name=icon_name,
-						  color=icon_color)
+        MenuIcon.__init__(self, menu_shell, icon_name=icon_name,
+                          color=icon_color)
 
-	def create_menu(self):
-		menu = ActivityMenu(self._activity_host)
-		menu.connect('action', self._action_cb)
-		return menu
+    def create_menu(self):
+        menu = ActivityMenu(self._activity_host)
+        menu.connect('action', self._action_cb)
+        return menu
 
-	def _action_cb(self, menu, action):
-		self.popdown()
+    def _action_cb(self, menu, action):
+        self.popdown()
 
-		activity = self._shell.get_current_activity()
-		if activity == None:
-			return
+        activity = self._shell.get_current_activity()
+        if activity == None:
+            return
 
-		if action == ActivityMenu.ACTION_SHARE:
-			activity.share()
-		if action == ActivityMenu.ACTION_CLOSE:
-			activity.close()
+        if action == ActivityMenu.ACTION_SHARE:
+            activity.share()
+        if action == ActivityMenu.ACTION_CLOSE:
+            activity.close()
 
 class ZoomBox(hippo.CanvasBox):
-	def __init__(self, shell, menu_shell):
-		hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
+    def __init__(self, shell, menu_shell):
+        hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
 
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._activity_icon = None
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._activity_icon = None
 
-		icon = CanvasIcon(icon_name='stock-zoom-mesh')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_MESH)
-		self.append(icon)
+        icon = CanvasIcon(icon_name='stock-zoom-mesh')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_MESH)
+        self.append(icon)
 
-		icon = CanvasIcon(icon_name='stock-zoom-friends')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_FRIENDS)
-		self.append(icon)
+        icon = CanvasIcon(icon_name='stock-zoom-friends')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_FRIENDS)
+        self.append(icon)
 
-		icon = CanvasIcon(icon_name='stock-zoom-home')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_HOME)
-		self.append(icon)
+        icon = CanvasIcon(icon_name='stock-zoom-home')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_HOME)
+        self.append(icon)
 
-		icon = CanvasIcon(icon_name='stock-zoom-activity')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_ACTIVITY)
-		self.append(icon)
+        icon = CanvasIcon(icon_name='stock-zoom-activity')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_ACTIVITY)
+        self.append(icon)
 
-		shell.connect('activity-changed', self._activity_changed_cb)
-		self._set_current_activity(shell.get_current_activity())
+        shell.connect('activity-changed', self._activity_changed_cb)
+        self._set_current_activity(shell.get_current_activity())
 
-	def _set_current_activity(self, activity):
-		if self._activity_icon:
-			self.remove(self._activity_icon)
+    def _set_current_activity(self, activity):
+        if self._activity_icon:
+            self.remove(self._activity_icon)
 
-		if activity:
-			icon = ActivityIcon(self._shell, self._menu_shell, activity)
-			style.apply_stylesheet(icon, 'frame.ZoomIcon')
-			self.append(icon, 0)
-			self._activity_icon = icon
-		else:
-			self._activity_icon = None
+        if activity:
+            icon = ActivityIcon(self._shell, self._menu_shell, activity)
+            style.apply_stylesheet(icon, 'frame.ZoomIcon')
+            self.append(icon, 0)
+            self._activity_icon = icon
+        else:
+            self._activity_icon = None
 
-	def _activity_changed_cb(self, shell_model, activity):
-		self._set_current_activity(activity)
+    def _activity_changed_cb(self, shell_model, activity):
+        self._set_current_activity(activity)
 
-	def _level_clicked_cb(self, item, level):
-		self._shell.set_zoom_level(level)
+    def _level_clicked_cb(self, item, level):
+        self._shell.set_zoom_level(level)

shell/view/frame/notificationtray.py

@@ -3,16 +3,16 @@ import gtk
 from _sugar import TrayManager
 
 class NotificationTray(gtk.HBox):
-	def __init__(self):
-		gtk.HBox.__init__(self)
+    def __init__(self):
+        gtk.HBox.__init__(self)
 
-		self._manager = TrayManager()
-		self._manager.connect('tray-icon-added', self._icon_added_cb)
-		self._manager.connect('tray-icon-removed', self._icon_removed_cb)
-		self._manager.manage_screen(gtk.gdk.screen_get_default())
+        self._manager = TrayManager()
+        self._manager.connect('tray-icon-added', self._icon_added_cb)
+        self._manager.connect('tray-icon-removed', self._icon_removed_cb)
+        self._manager.manage_screen(gtk.gdk.screen_get_default())
 
-	def _icon_added_cb(self, manager, icon):
-		self.pack_start(icon, False)
+    def _icon_added_cb(self, manager, icon):
+        self.pack_start(icon, False)
 
-	def _icon_removed_cb(self, manager, icon):
-		icon.destroy()
+    def _icon_removed_cb(self, manager, icon):
+        icon.destroy()

shell/view/frame/overlaybox.py

@@ -4,15 +4,15 @@ from sugar.graphics import style
 from sugar.graphics.canvasicon import CanvasIcon
 
 class OverlayBox(hippo.CanvasBox):
-	def __init__(self, shell):
-		hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
+    def __init__(self, shell):
+        hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
 
-		self._shell = shell
+        self._shell = shell
 
-		icon = CanvasIcon(icon_name='stock-chat')
-		style.apply_stylesheet(icon, 'frame.OverlayIcon')
-		icon.connect('activated', self._overlay_clicked_cb)
-		self.append(icon)
+        icon = CanvasIcon(icon_name='stock-chat')
+        style.apply_stylesheet(icon, 'frame.OverlayIcon')
+        icon.connect('activated', self._overlay_clicked_cb)
+        self.append(icon)
 
-	def _overlay_clicked_cb(self, item):
-		self._shell.toggle_chat_visibility()
+    def _overlay_clicked_cb(self, item):
+        self._shell.toggle_chat_visibility()

shell/view/frame/shutdownicon.py

@@ -21,24 +21,24 @@ from sugar.graphics.menu import Menu
 from sugar.graphics import style
 
 class ShutdownIcon(MenuIcon):
-	ACTION_SHUTDOWN = 2
+    ACTION_SHUTDOWN = 2
 
-	def __init__(self, menu_shell):
-		MenuIcon.__init__(self, menu_shell, icon_name='stock-close')
-		style.apply_stylesheet(self, 'menu.ActionIcon')
+    def __init__(self, menu_shell):
+        MenuIcon.__init__(self, menu_shell, icon_name='stock-close')
+        style.apply_stylesheet(self, 'menu.ActionIcon')
 
-	def create_menu(self):
-		menu = Menu()
-		menu.add_item('Shut Down', ShutdownIcon.ACTION_SHUTDOWN)
-		menu.connect('action', self._action_cb)
-		return menu
+    def create_menu(self):
+        menu = Menu()
+        menu.add_item('Shut Down', ShutdownIcon.ACTION_SHUTDOWN)
+        menu.connect('action', self._action_cb)
+        return menu
 
-	def _action_cb(self, menu, action):
-		self.popdown()
+    def _action_cb(self, menu, action):
+        self.popdown()
 
-		if action == ShutdownIcon.ACTION_SHUTDOWN:
-			bus = dbus.SystemBus()
-			proxy = bus.get_object('org.freedesktop.Hal',
-								   '/org/freedesktop/Hal/devices/computer')
-			mgr = dbus.Interface(proxy, 'org.freedesktop.Hal.Device.SystemPowerManagement')
-			mgr.Shutdown()
+        if action == ShutdownIcon.ACTION_SHUTDOWN:
+            bus = dbus.SystemBus()
+            proxy = bus.get_object('org.freedesktop.Hal',
+                                   '/org/freedesktop/Hal/devices/computer')
+            mgr = dbus.Interface(proxy, 'org.freedesktop.Hal.Device.SystemPowerManagement')
+            mgr.Shutdown()

shell/view/home/FriendView.py

@@ -23,67 +23,67 @@ from sugar.graphics import style
 from sugar.presence import PresenceService
 
 class FriendView(hippo.CanvasBox):
-	def __init__(self, shell, menu_shell, buddy, **kwargs):
-		hippo.CanvasBox.__init__(self, **kwargs)
+    def __init__(self, shell, menu_shell, buddy, **kwargs):
+        hippo.CanvasBox.__init__(self, **kwargs)
 
-		self._pservice = PresenceService.get_instance()
+        self._pservice = PresenceService.get_instance()
 
-		self._buddy = buddy
-		self._buddy_icon = BuddyIcon(shell, menu_shell, buddy)
-		style.apply_stylesheet(self._buddy_icon, 'friends.FriendIcon')
-		self.append(self._buddy_icon)
+        self._buddy = buddy
+        self._buddy_icon = BuddyIcon(shell, menu_shell, buddy)
+        style.apply_stylesheet(self._buddy_icon, 'friends.FriendIcon')
+        self.append(self._buddy_icon)
 
-		self._activity_icon = CanvasIcon()
-		style.apply_stylesheet(self._activity_icon, 'friends.ActivityIcon')
-		self._activity_icon_visible = False
+        self._activity_icon = CanvasIcon()
+        style.apply_stylesheet(self._activity_icon, 'friends.ActivityIcon')
+        self._activity_icon_visible = False
 
-		if self._buddy.is_present():
-			self._buddy_appeared_cb(buddy)
+        if self._buddy.is_present():
+            self._buddy_appeared_cb(buddy)
 
-		self._buddy.connect('current-activity-changed', self._buddy_activity_changed_cb)
-		self._buddy.connect('appeared', self._buddy_appeared_cb)
-		self._buddy.connect('disappeared', self._buddy_disappeared_cb)
-		self._buddy.connect('color-changed', self._buddy_color_changed_cb)
+        self._buddy.connect('current-activity-changed', self._buddy_activity_changed_cb)
+        self._buddy.connect('appeared', self._buddy_appeared_cb)
+        self._buddy.connect('disappeared', self._buddy_disappeared_cb)
+        self._buddy.connect('color-changed', self._buddy_color_changed_cb)
 
-	def _get_new_icon_name(self, activity):
-		# FIXME: do something better here; we probably need to use "flagship"
-		# services like mDNS where activities default services are marked
-		# somehow.
-		activity_registry = shell.get_model().get_bundle_registry()
-		for serv in activity.get_services():
-			bundle = activity_registry.get_bundle(serv.get_type())
-			if bundle:
-				return bundle.get_icon()
-		return None
+    def _get_new_icon_name(self, activity):
+        # FIXME: do something better here; we probably need to use "flagship"
+        # services like mDNS where activities default services are marked
+        # somehow.
+        activity_registry = shell.get_model().get_bundle_registry()
+        for serv in activity.get_services():
+            bundle = activity_registry.get_bundle(serv.get_type())
+            if bundle:
+                return bundle.get_icon()
+        return None
 
-	def _remove_activity_icon(self):
-		if self._activity_icon_visible:
-			self.remove(self._activity_icon)
-			self._activity_icon_visible = False
+    def _remove_activity_icon(self):
+        if self._activity_icon_visible:
+            self.remove(self._activity_icon)
+            self._activity_icon_visible = False
 
-	def _buddy_activity_changed_cb(self, buddy, activity=None):
-		if not activity:
-			self._remove_activity_icon()
-			return
+    def _buddy_activity_changed_cb(self, buddy, activity=None):
+        if not activity:
+            self._remove_activity_icon()
+            return
 
-		# FIXME: use some sort of "unknown activity" icon rather
-		# than hiding the icon?
-		name = self._get_new_icon_name(activity)
-		if name:
-			self._activity_icon.props.icon_name = name
-			self._activity_icon.props.color = buddy.get_color()
-			if not self._activity_icon_visible:
-				self.append(self._activity_icon, hippo.PACK_EXPAND)
-				self._activity_icon_visible = True
-		else:
-			self._remove_activity_icon()
+        # FIXME: use some sort of "unknown activity" icon rather
+        # than hiding the icon?
+        name = self._get_new_icon_name(activity)
+        if name:
+            self._activity_icon.props.icon_name = name
+            self._activity_icon.props.color = buddy.get_color()
+            if not self._activity_icon_visible:
+                self.append(self._activity_icon, hippo.PACK_EXPAND)
+                self._activity_icon_visible = True
+        else:
+            self._remove_activity_icon()
 
-	def _buddy_appeared_cb(self, buddy):
-		activity = self._buddy.get_current_activity()
-		self._buddy_activity_changed_cb(buddy, activity)
+    def _buddy_appeared_cb(self, buddy):
+        activity = self._buddy.get_current_activity()
+        self._buddy_activity_changed_cb(buddy, activity)
 
-	def _buddy_disappeared_cb(self, buddy):
-		self._buddy_activity_changed_cb(buddy, None)
+    def _buddy_disappeared_cb(self, buddy):
+        self._buddy_activity_changed_cb(buddy, None)
 
-	def _buddy_color_changed_cb(self, buddy, color):
-		self._activity_icon.props.color = buddy.get_color()
+    def _buddy_color_changed_cb(self, buddy, color):
+        self._activity_icon.props.color = buddy.get_color()

shell/view/home/FriendsBox.py

@@ -25,42 +25,42 @@ from view.home.MyIcon import MyIcon
 from view.home.FriendView import FriendView
 
 class FriendsBox(SpreadBox, hippo.CanvasItem):
-	__gtype_name__ = 'SugarFriendsBox'
-	def __init__(self, shell, menu_shell):
-		SpreadBox.__init__(self, background_color=0xe2e2e2ff)
+    __gtype_name__ = 'SugarFriendsBox'
+    def __init__(self, shell, menu_shell):
+        SpreadBox.__init__(self, background_color=0xe2e2e2ff)
 
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._friends = {}
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._friends = {}
 
-		self._my_icon = MyIcon()
-		style.apply_stylesheet(self._my_icon, 'friends.MyIcon')
-		self.append(self._my_icon, hippo.PACK_FIXED)
+        self._my_icon = MyIcon()
+        style.apply_stylesheet(self._my_icon, 'friends.MyIcon')
+        self.append(self._my_icon, hippo.PACK_FIXED)
 
-		friends = self._shell.get_model().get_friends()
+        friends = self._shell.get_model().get_friends()
 
-		for friend in friends:
-			self.add_friend(friend)
+        for friend in friends:
+            self.add_friend(friend)
 
-		friends.connect('friend-added', self._friend_added_cb)
-		friends.connect('friend-removed', self._friend_removed_cb)
+        friends.connect('friend-added', self._friend_added_cb)
+        friends.connect('friend-removed', self._friend_removed_cb)
 
-	def add_friend(self, buddy_info):
-		icon = FriendView(self._shell, self._menu_shell, buddy_info)
-		self.add_item(icon)
+    def add_friend(self, buddy_info):
+        icon = FriendView(self._shell, self._menu_shell, buddy_info)
+        self.add_item(icon)
 
-		self._friends[buddy_info.get_name()] = icon
+        self._friends[buddy_info.get_name()] = icon
 
-	def _friend_added_cb(self, data_model, buddy_info):
-		self.add_friend(buddy_info)
+    def _friend_added_cb(self, data_model, buddy_info):
+        self.add_friend(buddy_info)
 
-	def _friend_removed_cb(self, data_model, name):
-		self.remove_item(self._friends[name])
-		del self._friends[name]
+    def _friend_removed_cb(self, data_model, name):
+        self.remove_item(self._friends[name])
+        del self._friends[name]
 
-	def do_allocate(self, width, height):
-		SpreadBox.do_allocate(self, width, height)
+    def do_allocate(self, width, height):
+        SpreadBox.do_allocate(self, width, height)
 
-		[icon_width, icon_height] = self._my_icon.get_allocation()
-		self.move(self._my_icon, (width - icon_width) / 2,
-				  (height - icon_height) / 2)
+        [icon_width, icon_height] = self._my_icon.get_allocation()
+        self.move(self._my_icon, (width - icon_width) / 2,
+                  (height - icon_height) / 2)

shell/view/home/HomeBox.py

@@ -22,24 +22,24 @@ from sugar.graphics.grid import Grid
 from sugar.graphics import style
 
 class HomeBox(hippo.CanvasBox, hippo.CanvasItem):
-	__gtype_name__ = 'SugarHomeBox'
+    __gtype_name__ = 'SugarHomeBox'
 
-	def __init__(self, shell):
-		hippo.CanvasBox.__init__(self, background_color=0xe2e2e2ff,
-								 yalign=2)
+    def __init__(self, shell):
+        hippo.CanvasBox.__init__(self, background_color=0xe2e2e2ff,
+                                 yalign=2)
 
-		grid = Grid()
-		donut = ActivitiesDonut(shell, box_width=grid.dimension(7),
-								box_height=grid.dimension(7))
-		self.append(donut)
+        grid = Grid()
+        donut = ActivitiesDonut(shell, box_width=grid.dimension(7),
+                                box_height=grid.dimension(7))
+        self.append(donut)
 
-		self._my_icon = MyIcon()
-		style.apply_stylesheet(self._my_icon, 'home.MyIcon')
-		self.append(self._my_icon, hippo.PACK_FIXED)
+        self._my_icon = MyIcon()
+        style.apply_stylesheet(self._my_icon, 'home.MyIcon')
+        self.append(self._my_icon, hippo.PACK_FIXED)
 
-	def do_allocate(self, width, height):
-		hippo.CanvasBox.do_allocate(self, width, height)
+    def do_allocate(self, width, height):
+        hippo.CanvasBox.do_allocate(self, width, height)
 
-		[icon_width, icon_height] = self._my_icon.get_allocation()
-		self.move(self._my_icon, (width - icon_width) / 2,
-				  (height - icon_height) / 2)
+        [icon_width, icon_height] = self._my_icon.get_allocation()
+        self.move(self._my_icon, (width - icon_width) / 2,
+                  (height - icon_height) / 2)

shell/view/home/HomeWindow.py

@@ -25,45 +25,45 @@ from view.home.HomeBox import HomeBox
 from view.home.FriendsBox import FriendsBox
 
 class HomeWindow(gtk.Window):
-	def __init__(self, shell):
-		gtk.Window.__init__(self)
-		self._shell = shell
+    def __init__(self, shell):
+        gtk.Window.__init__(self)
+        self._shell = shell
 
-		self.set_default_size(gtk.gdk.screen_width(),
-							  gtk.gdk.screen_height())
+        self.set_default_size(gtk.gdk.screen_width(),
+                              gtk.gdk.screen_height())
 
-		self.realize()
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DESKTOP)
+        self.realize()
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DESKTOP)
 
-		self._nb = gtk.Notebook()
-		self._nb.set_show_border(False)
-		self._nb.set_show_tabs(False)
+        self._nb = gtk.Notebook()
+        self._nb.set_show_border(False)
+        self._nb.set_show_tabs(False)
 
-		self.add(self._nb)
-		self._nb.show()
+        self.add(self._nb)
+        self._nb.show()
 
-		canvas = hippo.Canvas()
-		box = HomeBox(shell)
-		canvas.set_root(box)
-		self._nb.append_page(canvas)
-		canvas.show()
+        canvas = hippo.Canvas()
+        box = HomeBox(shell)
+        canvas.set_root(box)
+        self._nb.append_page(canvas)
+        canvas.show()
 
-		canvas = hippo.Canvas()
-		box = FriendsBox(shell, MenuShell(canvas))
-		canvas.set_root(box)
-		self._nb.append_page(canvas)
-		canvas.show()
+        canvas = hippo.Canvas()
+        box = FriendsBox(shell, MenuShell(canvas))
+        canvas.set_root(box)
+        self._nb.append_page(canvas)
+        canvas.show()
 
-		canvas = hippo.Canvas()
-		box = MeshBox(shell, MenuShell(canvas))
-		canvas.set_root(box)
-		self._nb.append_page(canvas)
-		canvas.show()
+        canvas = hippo.Canvas()
+        box = MeshBox(shell, MenuShell(canvas))
+        canvas.set_root(box)
+        self._nb.append_page(canvas)
+        canvas.show()
 
-	def set_zoom_level(self, level):
-		if level == sugar.ZOOM_HOME:
-			self._nb.set_current_page(0)
-		elif level == sugar.ZOOM_FRIENDS:
-			self._nb.set_current_page(1)
-		elif level == sugar.ZOOM_MESH:
-			self._nb.set_current_page(2)
+    def set_zoom_level(self, level):
+        if level == sugar.ZOOM_HOME:
+            self._nb.set_current_page(0)
+        elif level == sugar.ZOOM_FRIENDS:
+            self._nb.set_current_page(1)
+        elif level == sugar.ZOOM_MESH:
+            self._nb.set_current_page(2)

shell/view/home/MeshBox.py

@@ -25,116 +25,116 @@ from sugar.graphics.canvasicon import CanvasIcon
 from view.BuddyIcon import BuddyIcon
 
 class ActivityView(SnowflakeBox):
-	def __init__(self, shell, menu_shell, model):
-		SnowflakeBox.__init__(self)
+    def __init__(self, shell, menu_shell, model):
+        SnowflakeBox.__init__(self)
 
-		self._shell = shell
-		self._model = model
-		self._icons = {}
+        self._shell = shell
+        self._model = model
+        self._icons = {}
 
-		icon = CanvasIcon(icon_name=model.get_icon_name(),
-						  color=model.get_color(), size=80)
-		icon.connect('activated', self._clicked_cb)
-		self.append(icon, hippo.PACK_FIXED)
-		self.set_root(icon)
+        icon = CanvasIcon(icon_name=model.get_icon_name(),
+                          color=model.get_color(), size=80)
+        icon.connect('activated', self._clicked_cb)
+        self.append(icon, hippo.PACK_FIXED)
+        self.set_root(icon)
 
-	def has_buddy_icon(self, name):
-		return self._icons.has_key(name)
+    def has_buddy_icon(self, name):
+        return self._icons.has_key(name)
 
-	def add_buddy_icon(self, name, icon):
-		self._icons[name] = icon
-		self.append(icon, hippo.PACK_FIXED)
+    def add_buddy_icon(self, name, icon):
+        self._icons[name] = icon
+        self.append(icon, hippo.PACK_FIXED)
 
-	def remove_buddy_icon(self, name):
-		icon = self._icons[name]
-		self.remove(icon)
-		del self._icons[name]
+    def remove_buddy_icon(self, name):
+        icon = self._icons[name]
+        self.remove(icon)
+        del self._icons[name]
 
-	def _clicked_cb(self, item):
-		bundle_id = self._model.get_service().get_type()
-		self._shell.join_activity(bundle_id, self._model.get_id())
+    def _clicked_cb(self, item):
+        bundle_id = self._model.get_service().get_type()
+        self._shell.join_activity(bundle_id, self._model.get_id())
 
 class MeshBox(SpreadBox):
-	def __init__(self, shell, menu_shell):
-		SpreadBox.__init__(self, background_color=0xe2e2e2ff)
+    def __init__(self, shell, menu_shell):
+        SpreadBox.__init__(self, background_color=0xe2e2e2ff)
 
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._model = shell.get_model().get_mesh()
-		self._buddies = {}
-		self._activities = {}
-		self._buddy_to_activity = {}
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._model = shell.get_model().get_mesh()
+        self._buddies = {}
+        self._activities = {}
+        self._buddy_to_activity = {}
 
-		for buddy_model in self._model.get_buddies():
-			self._add_alone_buddy(buddy_model)
+        for buddy_model in self._model.get_buddies():
+            self._add_alone_buddy(buddy_model)
 
-		self._model.connect('buddy-added', self._buddy_added_cb)
-		self._model.connect('buddy-removed', self._buddy_removed_cb)
-		self._model.connect('buddy-moved', self._buddy_moved_cb)
+        self._model.connect('buddy-added', self._buddy_added_cb)
+        self._model.connect('buddy-removed', self._buddy_removed_cb)
+        self._model.connect('buddy-moved', self._buddy_moved_cb)
 
-		for activity_model in self._model.get_activities():
-			self._add_activity(activity_model)
+        for activity_model in self._model.get_activities():
+            self._add_activity(activity_model)
 
-		self._model.connect('activity-added', self._activity_added_cb)
-		self._model.connect('activity-removed', self._activity_removed_cb)
+        self._model.connect('activity-added', self._activity_added_cb)
+        self._model.connect('activity-removed', self._activity_removed_cb)
 
-	def _buddy_added_cb(self, model, buddy_model):
-		self._add_alone_buddy(buddy_model)
+    def _buddy_added_cb(self, model, buddy_model):
+        self._add_alone_buddy(buddy_model)
 
-	def _buddy_removed_cb(self, model, buddy_model):
-		self._remove_buddy(buddy_model) 
+    def _buddy_removed_cb(self, model, buddy_model):
+        self._remove_buddy(buddy_model) 
 
-	def _buddy_moved_cb(self, model, buddy_model, activity_model):
-		self._move_buddy(buddy_model, activity_model)
+    def _buddy_moved_cb(self, model, buddy_model, activity_model):
+        self._move_buddy(buddy_model, activity_model)
 
-	def _activity_added_cb(self, model, activity_model):
-		self._add_activity(activity_model)
+    def _activity_added_cb(self, model, activity_model):
+        self._add_activity(activity_model)
 
-	def _activity_removed_cb(self, model, activity_model):
-		self._remove_activity(activity_model) 
+    def _activity_removed_cb(self, model, activity_model):
+        self._remove_activity(activity_model) 
 
-	def _add_alone_buddy(self, buddy_model):
-		icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
-		icon.props.size = 80
-		self.add_item(icon)
+    def _add_alone_buddy(self, buddy_model):
+        icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
+        icon.props.size = 80
+        self.add_item(icon)
 
-		self._buddies[buddy_model.get_name()] = icon
+        self._buddies[buddy_model.get_name()] = icon
 
-	def _remove_alone_buddy(self, buddy_model):
-		icon = self._buddies[buddy_model.get_name()]
-		self.remove_item(icon)
-		del self._buddies[buddy_model.get_name()]
+    def _remove_alone_buddy(self, buddy_model):
+        icon = self._buddies[buddy_model.get_name()]
+        self.remove_item(icon)
+        del self._buddies[buddy_model.get_name()]
 
-	def _remove_buddy(self, buddy_model):
-		name = buddy_model.get_name()
-		if self._buddies.has_key(name):
-			self._remove_alone_buddy(buddy_model)
-		else:
-			for activity in self._activities.values():
-				if activity.has_buddy_icon(name):
-					activity.remove_buddy_icon(name)
+    def _remove_buddy(self, buddy_model):
+        name = buddy_model.get_name()
+        if self._buddies.has_key(name):
+            self._remove_alone_buddy(buddy_model)
+        else:
+            for activity in self._activities.values():
+                if activity.has_buddy_icon(name):
+                    activity.remove_buddy_icon(name)
 
-	def _move_buddy(self, buddy_model, activity_model):
-		name = buddy_model.get_name()
+    def _move_buddy(self, buddy_model, activity_model):
+        name = buddy_model.get_name()
 
-		self._remove_buddy(buddy_model)
+        self._remove_buddy(buddy_model)
 
-		if activity_model == None:
-			self._add_alone_buddy(buddy_model)
-		else:
-			activity = self._activities[activity_model.get_id()]
+        if activity_model == None:
+            self._add_alone_buddy(buddy_model)
+        else:
+            activity = self._activities[activity_model.get_id()]
 
-			icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
-			icon.props.size = 60
-			activity.add_buddy_icon(buddy_model.get_name(), icon)
+            icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
+            icon.props.size = 60
+            activity.add_buddy_icon(buddy_model.get_name(), icon)
 
-	def _add_activity(self, activity_model):
-		icon = ActivityView(self._shell, self._menu_shell, activity_model)
-		self.add_item(icon)
+    def _add_activity(self, activity_model):
+        icon = ActivityView(self._shell, self._menu_shell, activity_model)
+        self.add_item(icon)
 
-		self._activities[activity_model.get_id()] = icon
+        self._activities[activity_model.get_id()] = icon
 
-	def _remove_activity(self, activity_model):
-		icon = self._activities[activity_model.get_id()]
-		self.remove_item(icon)
-		del self._activities[activity_model.get_id()]
+    def _remove_activity(self, activity_model):
+        icon = self._activities[activity_model.get_id()]
+        self.remove_item(icon)
+        del self._activities[activity_model.get_id()]

shell/view/home/MyIcon.py

@@ -18,6 +18,6 @@ from sugar.graphics.canvasicon import CanvasIcon
 from sugar import profile
 
 class MyIcon(CanvasIcon):
-	def __init__(self):
-		CanvasIcon.__init__(self, icon_name='stock-buddy',
-					  	    color=profile.get_color())
+    def __init__(self):
+        CanvasIcon.__init__(self, icon_name='stock-buddy',
+                              color=profile.get_color())

shell/view/home/activitiesdonut.py

@@ -21,100 +21,100 @@ from sugar.graphics.canvasicon import CanvasIcon
 from sugar.graphics import style
 
 class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
-	__gtype_name__ = 'SugarActivitiesDonut'
-	def __init__(self, shell, **kwargs):
-		hippo.CanvasBox.__init__(self, **kwargs)
+    __gtype_name__ = 'SugarActivitiesDonut'
+    def __init__(self, shell, **kwargs):
+        hippo.CanvasBox.__init__(self, **kwargs)
 
-		self._activities = {}
+        self._activities = {}
 
-		shell.connect('activity_opened', self.__activity_opened_cb)
-		shell.connect('activity_closed', self.__activity_closed_cb)
+        shell.connect('activity_opened', self.__activity_opened_cb)
+        shell.connect('activity_closed', self.__activity_closed_cb)
 
-	def __activity_opened_cb(self, model, activity):
-		self._add_activity(activity)
+    def __activity_opened_cb(self, model, activity):
+        self._add_activity(activity)
 
-	def __activity_closed_cb(self, model, activity):
-		self._remove_activity(activity)
-	
-	def _remove_activity(self, activity):
-		icon = self._activities[activity.get_id()]
-		self.remove(icon)
-		del self._activities[activity.get_id()]
+    def __activity_closed_cb(self, model, activity):
+        self._remove_activity(activity)
+    
+    def _remove_activity(self, activity):
+        icon = self._activities[activity.get_id()]
+        self.remove(icon)
+        del self._activities[activity.get_id()]
 
-	def _add_activity(self, activity):
-		icon_name = activity.get_icon_name()
-		icon_color = activity.get_icon_color()
+    def _add_activity(self, activity):
+        icon_name = activity.get_icon_name()
+        icon_color = activity.get_icon_color()
 
-		icon = CanvasIcon(icon_name=icon_name, color=icon_color)
-		style.apply_stylesheet(icon, 'ring.ActivityIcon')
-		icon.connect('activated', self.__activity_icon_clicked_cb, activity)
-		self.append(icon, hippo.PACK_FIXED)
+        icon = CanvasIcon(icon_name=icon_name, color=icon_color)
+        style.apply_stylesheet(icon, 'ring.ActivityIcon')
+        icon.connect('activated', self.__activity_icon_clicked_cb, activity)
+        self.append(icon, hippo.PACK_FIXED)
 
-		self._activities[activity.get_id()] = icon
+        self._activities[activity.get_id()] = icon
 
-		self.emit_paint_needed(0, 0, -1, -1)
+        self.emit_paint_needed(0, 0, -1, -1)
 
-	def __activity_icon_clicked_cb(self, item, activity):
-		activity.present()
+    def __activity_icon_clicked_cb(self, item, activity):
+        activity.present()
 
-	def _get_angles(self, index):
-		angle = 2 * math.pi / 8
-		return [index * angle, (index + 1) * angle]
+    def _get_angles(self, index):
+        angle = 2 * math.pi / 8
+        return [index * angle, (index + 1) * angle]
 
-	def _get_radius(self):
-		[width, height] = self.get_allocation()
-		return min(width, height) / 2
+    def _get_radius(self):
+        [width, height] = self.get_allocation()
+        return min(width, height) / 2
 
-	def _get_inner_radius(self):
-		return self._get_radius() * 0.5
+    def _get_inner_radius(self):
+        return self._get_radius() * 0.5
 
-	def do_paint_below_children(self, cr, damaged_box):
-		[width, height] = self.get_allocation()
+    def do_paint_below_children(self, cr, damaged_box):
+        [width, height] = self.get_allocation()
 
-		cr.translate(width / 2, height / 2)
+        cr.translate(width / 2, height / 2)
 
-		radius = self._get_radius()
+        radius = self._get_radius()
 
-		cr.set_source_rgb(0xf1 / 255.0, 0xf1 / 255.0, 0xf1 / 255.0)
-		cr.arc(0, 0, radius, 0, 2 * math.pi)
-		cr.fill()
+        cr.set_source_rgb(0xf1 / 255.0, 0xf1 / 255.0, 0xf1 / 255.0)
+        cr.arc(0, 0, radius, 0, 2 * math.pi)
+        cr.fill()
 
-		angle_end = 0
-		for i in range(0, len(self._activities)):
-			[angle_start, angle_end] = self._get_angles(i)
+        angle_end = 0
+        for i in range(0, len(self._activities)):
+            [angle_start, angle_end] = self._get_angles(i)
 
-			cr.new_path()
-			cr.move_to(0, 0)
-			cr.line_to(radius * math.cos(angle_start),
-					   radius * math.sin(angle_start))
-			cr.arc(0, 0, radius, angle_start, angle_end)
-			cr.line_to(0, 0)
+            cr.new_path()
+            cr.move_to(0, 0)
+            cr.line_to(radius * math.cos(angle_start),
+                       radius * math.sin(angle_start))
+            cr.arc(0, 0, radius, angle_start, angle_end)
+            cr.line_to(0, 0)
 
-			cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
-			cr.set_line_width(4)
-			cr.stroke_preserve()
+            cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
+            cr.set_line_width(4)
+            cr.stroke_preserve()
 
-			cr.set_source_rgb(1, 1, 1)
-			cr.fill()
+            cr.set_source_rgb(1, 1, 1)
+            cr.fill()
 
-		cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
-		cr.arc(0, 0, self._get_inner_radius(), 0, 2 * math.pi)
-		cr.fill()
+        cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
+        cr.arc(0, 0, self._get_inner_radius(), 0, 2 * math.pi)
+        cr.fill()
 
-	def do_allocate(self, width, height):
-		hippo.CanvasBox.do_allocate(self, width, height)
+    def do_allocate(self, width, height):
+        hippo.CanvasBox.do_allocate(self, width, height)
 
-		radius = (self._get_inner_radius() + self._get_radius()) / 2
+        radius = (self._get_inner_radius() + self._get_radius()) / 2
 
-		i = 0
-		for icon in self._activities.values():
-			[angle_start, angle_end] = self._get_angles(i)
-			angle = angle_start + (angle_end - angle_start) / 2
+        i = 0
+        for icon in self._activities.values():
+            [angle_start, angle_end] = self._get_angles(i)
+            angle = angle_start + (angle_end - angle_start) / 2
 
-			[icon_width, icon_height] = icon.get_allocation()
+            [icon_width, icon_height] = icon.get_allocation()
 
-			x = int(radius * math.cos(angle)) - icon_width / 2
-			y = int(radius * math.sin(angle)) - icon_height / 2
-			self.move(icon, x + width / 2, y + height / 2)
+            x = int(radius * math.cos(angle)) - icon_width / 2
+            y = int(radius * math.sin(angle)) - icon_height / 2
+            self.move(icon, x + width / 2, y + height / 2)
 
-			i += 1
+            i += 1

shell/view/stylesheet.py

@@ -21,59 +21,59 @@ from sugar.graphics.iconcolor import IconColor
 from sugar.graphics import style
 
 frame_ActivityIcon = {
-	'color' : IconColor('white'),
-	'size'  : style.standard_icon_size
+    'color' : IconColor('white'),
+    'size'  : style.standard_icon_size
 }
 
 frame_ShutdownIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 frame_OverlayIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 frame_ZoomIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 frame_BuddyIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 home_MyIcon = {
-	'size' : style.xlarge_icon_size
+    'size' : style.xlarge_icon_size
 }
 
 ring_ActivityIcon = {
-	'size'  : style.medium_icon_size
+    'size'  : style.medium_icon_size
 }
 
 friends_MyIcon = {
-	'size' : style.large_icon_size
+    'size' : style.large_icon_size
 }
 
 friends_FriendIcon = {
-	'size' : style.large_icon_size
+    'size' : style.large_icon_size
 }
 
 friends_ActivityIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 clipboard_bubble = {
-	'fill-color'	: 0x646464FF,
-	'stroke-color'	: 0x646464FF,
-	'progress-color': 0x333333FF,
-	'spacing'		: style.space_unit,
-	'padding'		: style.space_unit * 1.5
+    'fill-color'    : 0x646464FF,
+    'stroke-color'    : 0x646464FF,
+    'progress-color': 0x333333FF,
+    'spacing'        : style.space_unit,
+    'padding'        : style.space_unit * 1.5
 }
 
 clipboard_menu_item_title = {
-	'xalign': hippo.ALIGNMENT_START,
-	'padding-left': 5,
-	'color'	 : 0xFFFFFFFF,
-	'font'	 : style.get_font_description('Bold', 1.2)
+    'xalign': hippo.ALIGNMENT_START,
+    'padding-left': 5,
+    'color'     : 0xFFFFFFFF,
+    'font'     : style.get_font_description('Bold', 1.2)
 }
 
 style.register_stylesheet("clipboard.Bubble", clipboard_bubble)