[Pycodeocr-main] SF.net SVN: pycodeocr:[42] branches/laserb/PyCodeOCR.py

[<la...@us...>]

Revision: 42
          http://pycodeocr.svn.sourceforge.net/pycodeocr/?rev=42&view=rev
Author:   laserb
Date:     2011-03-16 21:07:35 +0000 (Wed, 16 Mar 2011)

Log Message:
-----------
split files / make RunSane threaded

Modified Paths:
--------------
    branches/laserb/PyCodeOCR.py

Modified: branches/laserb/PyCodeOCR.py
===================================================================
--- branches/laserb/PyCodeOCR.py	2011-03-16 21:07:17 UTC (rev 41)
+++ branches/laserb/PyCodeOCR.py	2011-03-16 21:07:35 UTC (rev 42)
@@ -15,11 +15,12 @@
 pygtk.require('2.0')
 import gtk, gtk.glade
 import gobject
+import threading
 
 # import Modules
 from Modules.checksum import modulo10
-#from Modules.blacklist_manager import blacklist_manager
-#from Modules.RunSane import RunSANE
+from Modules.blacklist_manager import blacklist_manager
+from Modules.RunSane import RunSANE
 from Modules.RunExternal import RunExternal
 #from Modules.RunMagickWand import RunMagickWand
 #from Modules.RunLibdmtx import RunLibdmtx
@@ -27,7 +28,7 @@
 # PIL image library and it's SANE bindings
 import Image, ImageDraw
 #from PIL import Image
-import sane		# f12: 'python-imaging-sane'
+#import sane		# f12: 'python-imaging-sane'
 from time import gmtime, strftime
 
 
@@ -223,9 +224,10 @@
 		
 		
 		# init sane when idle, hopefully this is right after GUI is loaded
-		gobject.idle_add(self.init_sane)
+#		gobject.idle_add(self.init_sane)
 		
 		
+		
 		# display window
 		self.main_window.show()
 
@@ -233,46 +235,23 @@
 	
 	## Run gtk mainloop and with it THIS APP.
 	def run(self):
-		gtk.main()
-	
-	
-	
-	## initialize sane
-	#
-	def init_sane(self, source=None):
-		# lock window
-		self.main_window.set_sensitive(False)
-		# init sane
-		self.run_sane = RunSANE()
+		gtk.gdk.threads_init()
 		
-		# select device if more than one is found
-		if self.run_sane.found_scanner == None:
-			# set default row to first
-			self.device_treeview.set_cursor(0)
-			
-			# show tab with device list
-			# choose device and press ok to initialize scanner
-			self.notebook.set_current_page(2)
-			# unlock window
-			self.main_window.set_sensitive(True)
-		else:
-			# unlock window
-			self.main_window.set_sensitive(True)
-			# set sensitivity
-			self.init_sensitivity()
+		self.device_chooser_event = threading.Event()
 		
-		# return false, otherwise gobject runs it again
-		return False
+		## initialize sane
+		self.run_sane = RunSANE(self.notebook, self.progress, self.device_chooser_button, BlacklistMgr,self.device_chooser_event)
+		self.run_sane.start()
 		
+		gtk.main()
+	
+		
 	def on_device_chooser_button_clicked(self, source=None):
 		self.device_chooser_button.set_visible(False)
-		# get selection from treeview
-		devnr = self.device_treeview.get_cursor()[0][0]
-		# init scanner
-		self.run_sane.init_scanner(devnr)
-		# set sensitivity
-		self.init_sensitivity()
+		self.device_chooser_event.set()
 			
+			
+			
 	## set sensitivity of buttons the first time
 	def init_sensitivity(self):
 		# set sensitivity
@@ -424,12 +403,8 @@
 
 	## exit and restart
 	def on_retry_button_clicked(self, source=None, event=None):
-		try:
-			self.run_sane.scanner.close()
-		except:
-			pass
-		sane.exit()
-		self.init_sane()
+		self.device_chooser_event.clear()
+		self.run_sane.retry()
 #		os.execv(sys.argv[0],sys.argv)
 #		self.on_main_window_destroy()
 
@@ -836,240 +811,12 @@
 			if not (data == olddata): print 'subst: "%s" => "%s"' % (item[0], item[1])
 
 		return data
-
-## sSANE/PIL interface python wrapper/bindings.
-class RunSANE:
-	#                "scanimage --format=tif --resolution 300 --mode Gray > %s.tif"
-	#                "scanimage --format=tif --resolution 600 --mode Gray  -t 82 -y 20 -l 60 -x 155.9 > %s.tif"
-	#cmd_scan       = "scanimage --format=tif --resolution 600 --mode Gray  -t %d -l %d -y %d -x %d > %s.tif"
-
-	resolution = 600
-
-	## Init of sane interface -> device. 
-	def __init__(self):
-		print "init sane python interface ..."
-
-		# Get the path set up properly
-		#sys.path.append('.')
 		
-		# get blacklist
-		self.blacklist = BlacklistMgr.read_blacklist()
 
-		# init SANE
-		self.n = 4.
-		main.progress(0.,"init sane python interface ...")
-		try:
-			self.version = sane.init()
-			main.progress(1./self.n,"init sane python interface ... search devices")
-			# get sane devices
-			self.devices = sane.get_devices()
 
-			# filter blacklisted devices
-			self.devices = BlacklistMgr.filter_devices(self.devices)
-			# check how many devices we found
-			if len(self.devices) == 0:
-				main.progress(0./self.n,"No device found.")
-				main.device_chooser_button.set_visible(False)
-				self.found_scanner = False
-			elif len(self.devices) > 1:
-				# simply continue and select device in GUI ( see init_sane )
-				main.progress(2./self.n,"More than one device found.")
-				main.device_chooser_button.set_visible(True)
-				self.found_scanner = None
-				
-			else:
-				# only one device found, continue
-				main.progress(2./self.n,"Device: %s" % self.devices[0][1]+" "+self.devices[0][2])
-				main.device_chooser_button.set_visible(False)
-				# continue to init scanner
-				self.init_scanner(0)
-		
-		except:
-			# No device found at all
-			self.found_scanner = False
-			main.device_chooser_button.set_visible(False)
-			print "No sane device found. Retry again."
-			main.progress(0./self.n,"No sane device found. Retry again.")
-
-	## iInit of sane interface -> scanner
-	def init_scanner(self, devnr):
-		print "Use device number: "+str(devnr)
-		try:	
-			# finish init device
-			self.dev     = self.devices[devnr][0]	# choose device
-			print "%s" % self.dev
-			main.progress(3./self.n,"Device initialized. Open scanner...")
-	
-			# open scanner device
-			self.scanner = sane.open(self.dev)
-			self.params  = self.scanner.get_parameters()
-			self.opts    = self.scanner.get_options()
-			self.found_scanner = True
-
-			main.progress(4./self.n,"Ready: %s" % self.devices[devnr][1]+" "+self.devices[devnr][2])
-			self.info()
-			
-			main.notebook.set_current_page(0)
-			main.device_chooser_button.set_visible(False)
-			print "done."
-	
-		except:
-			# init scanner failed. maybe device has no scanner
-			self.found_scanner = False
-			print "Loading sane device failed. Retry again."
-			main.progress(0./self.n,"Loading sane device failed. Retry again.")
-		
-		
-
-	## Not init of sane and scanner, but of scan operation.
-	def post_init(self, coords, out_filename):
-		self.coords       = coords
-		self.out_filename = out_filename
-
-	## call
-	def __call__(self):
-		(self.error, self.stdout, self.stderr) = self._run()
-		return self.error
-
-	## Scan and save the PIL image object to file.
-	# @see http://mail.python.org/pipermail/image-sig/1997-June/000307.html
-	# @see http://sane-pygtk.sourceforge.net/)
-	def _run(self):
-		try:
-			# Set scan parameters (also with higher resolution!)
-			(t, l, y, x) = self.coords
-			self.scanner.tl_y = float(t)
-			self.scanner.tl_x = float(l)
-			self.scanner.br_y = (float(y) + self.scanner.tl_y)
-			self.scanner.br_x = (float(x) + self.scanner.tl_x)
-			self.scanner.resolution = self.resolution
-			self.scanner.mode       = "Gray"
-
-			# Initiate the scan
-			self.scanner.start()
-
-			# Get an Image object containing the scanned image
-			im = self.scanner.snap()
-			
-			# Write the image out as a TIFF file (or whatever)
-			im.save(self.out_filename)
-
-			#self.scanner.stop()
-		except:
-			return (True, "error", sys.exc_info()[1])
-
-		return (False, "ok", "")
-
-	## Show some info about the scanner and SANE.
-	def info(self):
-#		print self.entry3.get_text()
-		entrybuffer = main.entry3.get_buffer()
-		entrybuffer.delete(entrybuffer.get_start_iter(),entrybuffer.get_end_iter())
-		# redirect print to device textbuffer
-		logdev = logging(entrybuffer)
-		#sys.stdout = logdev
-#		print """SANE version: %s
-#Selected device= %s
-#SaneDev object= %s
-#""" % ( self.version ,self.dev,self.scanner )
-#		enditer = entrybuffer.get_end_iter()
-#		entrybuffer.insert(enditer,"test")
-		print 'SANE version: %s' % repr(self.version).replace('array',' ')
-		print 'Available devices= %s' % repr(self.devices).replace('array',' ')
-		print 'Selected device= %s' % self.dev 
-
-		print 'SaneDev object= %s' % self.scanner
-		print 'Device parameters: %s' % repr(self.params).replace('array',' ')
-		print 'Device options:', "\n",self.opts
-		
-		# redirect print again to old textbuffer
-		#sys.stdout = main.logging
-
-class blacklist_manager:
-	def __init__(self):
-		pass
-	
-	def post_init(self, device_treeview, blacklist_treeview, local_path):
-		self.device_treeview = device_treeview
-		self.blacklist_treeview = blacklist_treeview
-		self.local_path = local_path
-		
-		# create self.treeview things
-		self.list_store = gtk.ListStore(gobject.TYPE_STRING)
-		self.device_treeview.set_model(self.list_store)
-		col = gtk.TreeViewColumn("Select Device to use:", gtk.CellRendererText(),text=0)
-		self.device_treeview.append_column(col)
-		
-		# create self.treeview things
-		self.blacklist_store = gtk.ListStore(gobject.TYPE_STRING)
-		self.blacklist_treeview.set_model(self.blacklist_store)
-		blackcol = gtk.TreeViewColumn("Blacklisted Devices:", gtk.CellRendererText(),text=0)
-		self.blacklist_treeview.append_column(blackcol)
-		return
-		
-	def filter_devices(self, devices1):
-		# init filtered list
-		devices = []
-			
-		print "\n"
-		# add found devices to self.treeview
-		self.list_store.clear()
-		for i in range(len(devices1)):
-			# filter devices: remove blacklisted devices
-			if not devices1[i][1]+" "+devices1[i][2] in self.blacklist:
-				devices.append(devices1[i])
-				print str(i)+": "+devices1[i][1]+" "+devices1[i][2]
-				self.list_store.append([devices1[i][1]+" "+devices1[i][2]])
-				
-		return devices
-		
-	## get blacklisted devices
-	def read_blacklist(self):
-		self.blacklist_store.clear()
-			
-		bl = open('%s/blacklist' % self.local_path, 'r' )
-		temp = bl.readlines()
-		bl.close	
-		self.blacklist = []
-		for line in temp:
-			self.blacklist.append(line.strip())
-			self.blacklist_store.append([line.strip()])
-		return self.blacklist
-
-	## write blacklisted devices
-	# @todo add UI way to blacklist device
-	def write_blacklist(self):
-		bl = open('%s/blacklist' % self.local_path, 'w' )
-		
-		model= self.blacklist_treeview.get_model()
-		iter = model.get_iter_first()
-		while( iter != None):
-			data = model.get_value(iter, 0)
-			bl.write(data+"\n")
-			iter = model.iter_next(iter)
-		bl.close()
-		
-	## add device to blacklist
-	def blacklist_add(self, widget=None):
-		treeselection = self.device_treeview.get_selection()
-		model, iter = treeselection.get_selected()
-		data = model.get_value(iter, 0)
-		self.blacklist_store.append([data])
-		self.list_store.remove(iter)
-		self.write_blacklist()
-	
-	## remove device from blacklist
-	def blacklist_remove(self, widget=None):
-		treeselection = self.blacklist_treeview.get_selection()
-		model, iter =treeselection.get_selected()
-		data = model.get_value(iter, 0)
-		self.list_store.append([data])
-		self.blacklist_store.remove(iter)
-		self.write_blacklist()
-		
-
-
 if __name__ == '__main__':
+	global BlacklistMgr
+	global main
 	## initialize Blacklist Manager
 	BlacklistMgr = blacklist_manager()
 	## run main application


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.