#!/usr/bin/python
#from PySide import QtCore, QtGui

from argparse import ArgumentParser

parser = ArgumentParser()

# Add more options if you like
parser.add_argument("-d", dest="DeviceNumber",
                    help="If you have connected multiple devices, choose a number from [1-n] that will represent the device you wish to use [in order of plugging in].", metavar="DEVICE_NUMBER")
args = parser.parse_args()


import Labtools.interface as interface
from PyQt4 import QtCore, QtGui
import time,sys
from Labtools.templates import template_scope

import sys,os,string
import time
import sys

import pyqtgraph as pg
import pyqtgraph.opengl as gl
from Labtools.customui_rc import *

import numpy as np
import scipy.optimize as optimize
import scipy.fftpack as fftpack


err_count=0
trial = 0
start_time = time.time()
fps = None
dacval=0
from Labtools.commands_proto import *




class MyMainWindow(QtGui.QMainWindow, template_scope.Ui_MainWindow):
	def __init__(self, parent=None):
		super(MyMainWindow, self).__init__(parent)
		self.setupUi(self)
		if not args.DeviceNumber: args.DeviceNumber=1
		dv=int(args.DeviceNumber)
		self.I = interface.Interface(devnum=dv)
		self.setWindowTitle('LabToolSuite : '+self.I.H.version_string)
		
		self.dacval=0

		self.yaxis = pg.AxisItem('left',showValues=False,maxTickLength=-4000)
		self.yaxis.setPen((0,45,45))
		#self.yaxis.setLabel(text='Voltage -->>', units='')
		self.yaxis.setTicks([[(a*5,'') for a in range(-6,6)],[(a,'') for a in range(-30,30)]])
		self.plot=pg.PlotWidget(axisItems={'left':self.yaxis})

		#cross hair
		self.vLine = pg.InfiniteLine(angle=90, movable=True)
		self.vLine.setPen(color=(135,44,64,150), width=3)
		self.plot.addItem(self.vLine, ignoreBounds=False)
		#self.proxy = pg.SignalProxy(self.plot.scene().sigMouseMoved, rateLimit=60, slot=self.mouseMoved)
		
		self.fps=0
		self.max_samples_per_channel=[0,self.I.MAX_SAMPLES/4,self.I.MAX_SAMPLES/4,self.I.MAX_SAMPLES/4,self.I.MAX_SAMPLES/4]
		self.liss_win=None
		self.liss_ready=False
		self.liss_animate_arrow1=None
		self.liss_animate_arrow2=None
		self.liss_animate_arrow3=None
		self.liss_anim1=None
		self.liss_anim2=None
		self.liss_anim3=None
		self.samples=self.I.MAX_SAMPLES/4#self.sample_slider.value()
		self.active_channels=1
		self.active_dchannels=1
		self.channel_states=np.array([1,0,0,0])
		self.channels_in_buffer=1
		self.chosa = 3
		self.chan1remap='CH1'
		self.ch123sa = 0
		self.dtrig=0
		self.dchan_modes=[1,1,1,1]
		self.dtime=0.001
		self.sqrDict={'SQ1':[0,0.5],'SQ2':[0,0.5],'OD1':[0,0.5],'OD2':[0,0.5]}
		g=1.75
		self.timebase = g
		self.datx=[]
		self.lastTime=time.time()
		self.plot.setLabel('bottom', 'Time -->>', units='S')
		self.plot.addLegend(offset=(-10,30))
		self.trace_colors=[(255,20,20),(255,255,0),(20,155,20),(10,255,255)]
		self.curve1 = self.plot.plot(name='CH1'); self.curve1.setPen(color=self.trace_colors[0], width=1)
		self.curve2 = self.plot.plot(name='CH2'); self.curve2.setPen(color=self.trace_colors[1], width=1)
		self.curve3 = self.plot.plot(name='CH3'); self.curve3.setPen(color=self.trace_colors[2], width=1)
		self.curve4 = self.plot.plot(name='CH4'); self.curve4.setPen(color=self.trace_colors[3], width=1)
		self.curve_lis = self.plot.plot(); self.curve_lis.setPen(color=(255,255,255), width=1)
		self.curve_fit = self.plot.plot(); self.curve_fit.setPen(color=(255,255,255), width=1)
		for a in range(4):
			names = ["CH1_controls","CH2_controls","CH3_controls","CH4_controls"]
			checkbox = self.channelBox.findChild(QtGui.QWidget, names[a])
			checkbox.setStyleSheet('background-color:rgba'+str(self.trace_colors[a])[:-1]+',3);color:(0,0,0);')
			self.trigger_select_box.setItemData(a, QtGui.QColor(*self.trace_colors[a]), QtCore.Qt.BackgroundRole);

		self.arrow = pg.ArrowItem(pos=(0, 0), angle=0)
		self.plot.addItem(self.arrow)
		#markings every 5 Volts
		self.artificial_gains=[1.0,1.6666,2.5,5,10,12.5,16.666,50] #5V/div,3V/div,2V/div,1V/div,0.5V/div,0.4V/div,.3V/div,.1V/div

		self.artificial_offset_list=[0,0,0,0]
		self.artificial_gain_list=['5V/div','5V/div','5V/div','5V/div']
		self.voltsperdiv = ['5V/div','3V/div','2V/div','1V/div','500mV/div','400mV/div','300mV/div','100mV/div']
		self.trigger_channel=0
		self.trigger_level = 0
		self.trigtext = pg.TextItem(html=self.trigger_text('CH1'), anchor=(1.2,0.5), border='w', fill=(0, 0, 255, 100),angle=0)
		self.plot.addItem(self.trigtext)
		self.plot.showGrid(True,False,0.4)
		self.showgrid()
		self.trigtext.setParentItem(self.arrow)
		self.I.configure_trigger(self.trigger_channel,0)
		#self.sqr4_continuous(10000,.5,0.1,.5,0.3,.3,0.5,.1)
		self.autoRange()
		#self.plot.setMouseEnabled(False,True)
		self.timer = QtCore.QTimer()
		self.timer.singleShot(500,self.start_capture)
		self.scope_type=0
		self.plot_area.addWidget(self.plot)
		
	def trigger_text(self,c):
		return '<div style="text-align: center"><span style="color: #FFF; font-size: 8pt;">'+c+'</span></div>'		




	def showgrid(self):
		return


	def set_scope_type(self,val):
		self.scope_type=val

		
	def setPVS1(self,val):
		val=self.I.DAC.__setRawVoltage__(3,val)
		self.PVS1_LABEL.setText('%.3f V'%(val))

	def setPVS2(self,val):
		val=self.I.DAC.__setRawVoltage__(2,val)
		self.PVS2_LABEL.setText('%.3f V'%(val))

	def setPVS3(self,val):
		val=self.I.DAC.__setRawVoltage__(1,val)
		self.PVS3_LABEL.setText('%.3f V'%(val))

	def setPCS(self,val):
		val=self.I.DAC.__setRawVoltage__(0,val)
		self.PCS_LABEL.setText('%.3f V'%(val))

	def setSINE1(self,val):
		self.I.set_sine1(val)

	def setSINE2(self,val):
		self.I.set_sine2(val)

	def setSINEPHASE(self,val):
		self.I.set_sine_phase(val)
		
	def start_capture(self):
		if(self.freezeButton.isChecked()):
			self.timer.singleShot(200,self.start_capture)
			return

		#print self.get_inductance()
		temperature=self.I.get_temperature()
		frq=0#self.I.get_high_freq(ID1)
		self.plot.setTitle('%0.2f fps, %d dac, %0.2fHz	%0.1f ^C' % (self.fps,self.dacval,frq,temperature ) )
		self.channels_in_buffer=self.active_channels
		#self.I.set_state(SQR1=0)
		if not self.scope_type:
			self.I.configure_trigger(self.trigger_channel,self.trigger_level,resolution=10)
			self.I.capture_traces(self.active_channels,self.samples,self.timebase,self.chan1remap,self.ch123sa)
			#self.I.capture_highres_traces(self.chan1remap,self.samples,self.timebase)
			
		else:
			if self.active_dchannels==4: self.I.start_four_channel_LA(1,self.dtime,self.dchan_modes,edge='rising',trigger_ID1=True)
			elif self.active_dchannels==1:#self.start_one_channel_LA_backup(self.dtrig,'ID1',edge='falling')
				aqchan = self.LA1_chan.currentText()
				aqmode = self.LA1_chanmode.currentIndex()
				trchan = self.LA1_trig.currentText()
				trmode = self.LA1_trigmode.currentIndex()
				if(trmode):trmode+=1
				#print aqchan,aqmode,trchan,trmode
				if trmode: self.I.start_one_channel_LA(channel=aqchan,channel_mode=aqmode,trigger_channel=trchan,trigger_mode=trmode)
				else : self.I.start_one_channel_LA(channel=aqchan,channel_mode=aqmode,trigger_mode=0)
			elif self.active_dchannels==3:
				trchan = self.LA1_trig.currentText()
				trmode = self.LA1_trigmode.currentIndex()
				if(trmode):trmode+=1
				if trmode: self.I.start_three_channel_LA(modes=self.dchan_modes,trigger_channel=trchan,trigger_mode=trmode)
				else : self.I.start_three_channel_LA(modes=self.dchan_modes,trigger_channel=trchan,trigger_mode=0)
			elif self.active_dchannels==2: self.I.start_two_channel_LA(1)
		
		#self.I.sqr1(1e5,80)

		self.timebase_label.setValue(self.I.timebase)
		if(self.scope_type):self.timer.singleShot(self.dtime*1e3+10,self.update)	#Logic analyzer mode
		else: self.timer.singleShot(self.samples*self.I.timebase*1e-3+10,self.update)     #oscilloscope mode

	def update(self):
		n=0
		while(not self.I.oscilloscope_progress()[0]):
			time.sleep(0.001)
			print self.timebase,'correction required',n
			n+=1
		if not self.scope_type:	#Analog mode
			if(self.channels_in_buffer>=1):self.I.__fetch_channel__(1)
			if(self.channels_in_buffer>=2):self.I.__fetch_channel__(2)
			if(self.channels_in_buffer>=3):self.I.__fetch_channel__(3)
			if(self.channels_in_buffer>=4):self.I.__fetch_channel__(4)
		else:			#Logic analyzer mode [digital mode]
			self.I.fetch_LA_channels()
			if len(self.I.dchans[0].timestamps)>2:
				offset = self.I.dchans[0].timestamps[0]
				txt = 'CH1: Offset:\t%.3euS\ttimestamps(uS):\t'%(offset/64.)
				txt += string.join(['%.2e'%(a/64.) for a in (self.I.dchans[0].timestamps[1:4]-offset)],'\t')
				self.message_label.setText(txt+'...')
			else:
				self.message_label.setText('CH1: too few points to display')

		self.curve1.clear()
		self.curve2.clear()
		self.curve3.clear()
		self.curve4.clear()
		self.curve_fit.clear()
		if self.scope_type:
			self.curve1.setData(self.I.dchans[0].get_xaxis(),self.I.dchans[0].get_yaxis() )
			if(self.active_dchannels>1):
				self.curve2.setData(self.I.dchans[1].get_xaxis(),self.I.dchans[1].get_yaxis() )
			else:	self.curve2.clear()
			
			if(self.active_dchannels>2):
				self.curve3.setData(self.I.dchans[2].get_xaxis(),self.I.dchans[2].get_yaxis() )
			else:	self.curve3.clear()
			
			if(self.active_dchannels>3):
				self.curve4.setData(self.I.dchans[3].get_xaxis(),self.I.dchans[3].get_yaxis() )
			else:	self.curve4.clear()
		else:
			msg='';pos=0
			for fitsel in [self.fit_select_box.currentIndex(),self.fit_select_box_2.currentIndex()]:
				if fitsel<4:
					if len(msg)>0:
						msg+='\n'
					if self.channel_states[fitsel]:
						msg+='FIT '+chr(pos+65)+': '+self.fitData(self.I.achans[fitsel].get_xaxis(),\
						self.I.achans[fitsel].get_yaxis(),self.artificial_gains[self.I.achans[fitsel].gain],self.artificial_offset_list[fitsel])
					else:
						msg+='FIT '+chr(pos+65)+': Channel Unavailable'

				pos+=1
			if len(msg):
				self.message_label.setText(msg)
			pos=0
			for a in [self.curve1,self.curve2,self.curve3,self.curve4]:
				gain=self.artificial_gains[self.I.achans[pos].gain]
				offset=self.artificial_offset_list[pos]/gain
				if self.channel_states[pos]: a.setData(self.I.achans[pos].get_xaxis()*1e-6,(self.I.achans[pos].get_yaxis()+offset)*gain)
				pos+=1

		if(self.Liss_show.isChecked() and self.scope_type==0):
			chans = ['CH1','CH2','CH3','CH4']
			lissx = self.Liss_x.currentText()
			lissy = self.Liss_y.currentText()
			self.liss_x = chans.index(lissx)
			self.liss_y = chans.index(lissy)
			xscale=1e6*16.5*2/(self.samples*self.timebase)
			xoffset=(self.samples*self.timebase)/2./1e6
			la=self.I.achans[self.liss_x].get_yaxis()
			lb=self.I.achans[self.liss_y].get_yaxis()
			if(self.liss_x<self.active_channels and self.liss_y<self.active_channels and len(la)==len(lb)):
				self.curve_lis.setData(self.I.achans[self.liss_x].get_yaxis()/xscale+xoffset,self.I.achans[self.liss_y].get_yaxis())
				self.liss_ready=True
			else:
				self.curve_lis.clear()
				self.liss_ready=False
				#print self.fps,'not available',self.active_channels,self.liss_x,self.liss_y
		else:
			self.curve_lis.clear()
			
		pos=self.vLine.getPos()
		index = int(pos[0]*1e6)/self.I.timebase
		if index > 0 and index < self.I.samples:
			coords="<span style='color: white'>%0.1f uS</span>: "%(self.I.achans[0].xaxis[index])
			for a in range(4):
				if self.channel_states[a]:
					c=self.trace_colors[a]
					coords+="<span style='color: rgb%s'>%0.3fV</span>," %(c, self.I.achans[a].yaxis[index])
			self.coord_label.setText(coords)
		else:
			self.coord_label.setText("")
			


		now = time.time()
		dt = now - self.lastTime
		self.lastTime = now
		if self.fps is None:
			self.fps = 1.0/dt
		else:
			s = np.clip(dt*3., 0, 1)
			self.fps = self.fps * (1-s) + (1.0/dt) * s
		
		self.timer.singleShot(100,self.start_capture)



	def fitData(self,xReal,yReal,artgain,artoff):
		def mysine(x, a1, a2, a3,a4):
		    return a4 + a1*np.sin(abs(a2)*x + a3)
		N=len(xReal)
		yhat = fftpack.rfft(yReal)
		idx = (yhat**2).argmax()
		freqs = fftpack.rfftfreq(N, d = (xReal[1]-xReal[0])/(2*np.pi))
		frequency = freqs[idx]

		amplitude = (yReal.max()-yReal.min())/2.0
		offset = yReal.max()-yReal.min()
		phase=0#.5*np.pi*((yReal[0]-offset)/amplitude)
		guess = [amplitude, frequency, phase,offset]
		try:
			(amplitude, frequency, phase,offset), pcov = optimize.curve_fit(mysine, xReal, yReal, guess)
			ph = ((phase)*180/(np.pi))
			if(frequency<0):
				#print 'negative frq'
				return 'fit failed'

			if(amplitude<0):
				ph-=180

			if(ph<0):ph = (ph+720)%360
			freq=1e6*abs(frequency)/(2*np.pi)
			amp=abs(amplitude)
			if(frequency):	period = 1./frequency
			else: period = 0
			pcov[0]*=1e6
			#return amp,freq,ph,offset,pcov
			if(abs(pcov[0][0])>500):
				self.curve_fit.clear()
				return 'fit failed. Bad convergence'
			if(self.overlay_fit_button.isChecked()):
				self.curve_fit.setData(xReal,(mysine(xReal,amp,frequency,ph*np.pi/180,offset)+artoff)*artgain)
			return 'Amp = %0.3fV\tFreq=%0.2fHz\tOffset=%0.3fV\tPhase=%0.1f%c'%(amp, freq, offset,ph,176)
		except:
			return 'fit failed'

	def setOffsetAndGainLabels(self):
		for cnum in range(4):
			g=self.artificial_gains[self.I.achans[cnum].gain]
			self.channelBox.setItemText(cnum,'CH'+str(cnum+1)+':  '+self.artificial_gain_list[cnum]+'   SHIFT=%0.2f V'%(self.artificial_offset_list[cnum]/g))
	
	def setGainCH1(self,g):
		self.I.set_gain(self.chan1remap,g)
		cnum=0
		self.artificial_gain_list[cnum] = self.voltsperdiv[g]
		self.CH1_gain_label.setText(self.artificial_gain_list[cnum])
		self.setOffsetAndGainLabels()
		
	def setGainCH2(self,g):
		self.I.set_gain('CH2',g)
		cnum=1
		self.artificial_gain_list[cnum] = self.voltsperdiv[g]
		self.CH2_gain_label.setText(self.artificial_gain_list[cnum])
		self.setOffsetAndGainLabels()

	def setGainCH3(self,g):
		self.I.set_gain('CH3',g)
		cnum=2
		self.artificial_gain_list[cnum] = self.voltsperdiv[g]
		self.CH3_gain_label.setText(self.artificial_gain_list[cnum])
		self.setOffsetAndGainLabels()

	def setGainCH4(self,g):
		self.I.set_gain('CH4',g)
		cnum=3
		self.artificial_gain_list[cnum] = self.voltsperdiv[g]
		self.CH4_gain_label.setText(self.artificial_gain_list[cnum])
		self.setOffsetAndGainLabels()

	def setOffsetCH1(self,g):
		cnum=0
		self.artificial_offset_list[cnum]=g*2.#/self.gain_values[self.analog_gains[cnum]]
		self.setOffsetAndGainLabels()

	def setOffsetCH2(self,g):
		cnum=1
		self.artificial_offset_list[cnum]=g*2.#/self.gain_values[self.analog_gains[cnum]]
		self.setOffsetAndGainLabels()

	def setOffsetCH3(self,g):
		cnum=2
		self.artificial_offset_list[cnum]=g*2.#/self.gain_values[self.analog_gains[cnum]]
		self.setOffsetAndGainLabels()

	def setOffsetCH4(self,g):
		cnum=3
		self.artificial_offset_list[cnum]=g*2.#/self.gain_values[self.analog_gains[cnum]]
		self.setOffsetAndGainLabels()


	def setGainCH5(self,g):
		self.I.set_gain('CH5',g)

	def setTimeBase(self,g):
		timebases = [1.75,2,4,8,16,32,128,256,512,1024,1024]
		samplescaling=[1,1,1,1,1,0.5,0.4,0.3,0.2,0.1,0.1]
		#print g,len(timebases),len(samplescaling)
		self.timebase=timebases[g]
		'''
		if(self.active_channels==1 and self.timebase<1.0):
			self.timebase=1.0
		elif(self.active_channels==2 and self.timebase<1.25):
			self.timebase=1.25
		elif((self.active_channels==3 or self.active_channels==4) and self.timebase<1.75):
			self.timebase=1.75
		'''
		self.timebase_label.setValue(self.timebase)
		self.autoSetSamples()
		self.samples = int(self.samples*samplescaling[g])
		self.autoRange()
		self.showgrid()

	def autoset(self):
		frq = 1./self.I.r2r_time('CH4',1.)
		if(frq>100000):
			self.timebase_dial.setValue(0)
			self.setTimeBase(0)
			if(frq>1e6):
				print 'Frequency too high :',frq
		elif frq>2:
			max_s = self.max_samples_per_channel[self.active_channels]
			expected_time = 4./frq	#accomodate four wavelengths
			if expected_time>1.:
				self.timebase = 1e6*expected_time/max_s
				self.samples = int(max_s/expected_time)
			else:
				self.timebase = 1e6*expected_time/max_s
				if self.timebase<1.75:self.timebase=1.75
				self.samples = max_s
			self.timebase_label.setValue(self.timebase)
		else:
			print 'frequency too low / autoset error'
		self.autoRange()
			
		print frq,self.timebase,self.samples

	def autoSetSamples(self):
		self.samples = self.max_samples_per_channel[self.active_channels]
		self.autoRange()

	def setTriggerLevel(self,val):
		scale = self.artificial_gains[self.I.achans[self.trigger_channel].gain]/2.0
		val = 16.5*(val/100.0-0.5)/scale
		self.trigger_level=val
		g=self.artificial_gains[self.I.achans[self.trigger_channel].gain]
		self.arrow.setPos(0,(val+self.artificial_offset_list[self.trigger_channel]/g)*g)
		self.trigger_level_box.setValue(val)

	def setTriggerChannel(self,val):
		self.trigtext.setHtml(self.trigger_text(self.I.achans[val].name))
		self.triggerChannel=val
		self.trigger_channel = val
		c=self.trace_colors[val]
		s='background-color:rgba'+str(c)[:-1]+',20);color:(0,0,0);'
		self.sender().parentWidget().setStyleSheet(s)

	def setActiveChannels(self,val):
		self.active_channels = int(val)
		self.autoSetSamples()
		

	def setActiveDigitalChannels(self,val):
		self.active_dchannels = int(val)
		self.samples=800
		self.autodRange()
		

	def remap_CH0(self,val):
		val = str(val)
		self.chosa = self.I.__calcCHOSA__(val)
		self.chan1remap=val
		print 'mapped to',val

	def autoRange(self):
		self.plot.setRange(QtCore.QRectF(0, -16.5, self.samples*self.timebase*1e-6, 2*16.5)) 

	def autodRange(self):
		self.plot.setRange(QtCore.QRectF(0, -2, self.dtime*1e6, 16)) 

	def enable_channel(self,state):
		button_names=['ch1','ch2','ch3','ch4']
		chan_num = button_names.index(self.sender().objectName())
		self.channel_states[chan_num] = state
		num_active = np.count_nonzero(self.channel_states)
		if num_active == 1:
			if self.channel_states[0] ==1:
				self.active_channels=1
			elif self.channel_states[1] ==1:
				self.active_chans = 2
			else: self.active_chans = 4
		elif num_active == 2 and self.channel_states[0] ==1 and self.channel_states[1] ==1:	#one channel active. the first one.
			self.active_channels=2
		else:	self.active_channels=4
		self.autoSetSamples()		
		
	def sqr_phase(self,val):
		self.sqrDict[str(self.SQR_NM.currentText())][0]=val/360.

	def sqr_dc(self,val):
		self.sqrDict[str(self.SQR_NM.currentText())][1]=val/100.

	def sqr_update(self):
		self.sqrDict[str(self.SQR_NM.currentText())][0]=self.SQR_PH.value()/360.
		self.sqrDict[str(self.SQR_NM.currentText())][1]=self.SQR_DC.value()/100.
		
		self.I.sqr4_continuous(self.SQR_FREQ.value(),self.sqrDict['SQ1'][1],self.sqrDict['SQ2'][0],self.sqrDict['SQ2'][1],
		self.sqrDict['OD1'][0],self.sqrDict['OD1'][1],self.sqrDict['OD2'][0],self.sqrDict['OD2'][1])

	def set_digital_trigger(self,a):
		self.dtrig = 1 if a else 0

	def set_digital_scope_time(self,val):
		scope_times=[0.001,0.005,0.01,0.05,.1,.2,.3,.4,.5,1]
		self.dtime = scope_times[val]
		self.digital_timescale.setValue(self.dtime*1000)
		self.autodRange()

	def set_dchan_mode_ch1(self,val):
		self.dchan_modes[0] = val
	def set_dchan_mode_ch2(self,val):
		self.dchan_modes[1] = val
	def set_dchan_mode_ch3(self,val):
		self.dchan_modes[2] = val
	def set_dchan_mode_ch4(self,val):
		self.dchan_modes[3] = val

	def change_scope_type(self,val):
		if(val<2):
			self.scope_type=val
			self.coord_label.setText("")
			if(val==0):self.autoRange()
			else: self.autodRange()
	
	def plot_liss(self):
		chans = ['CH1','CH2','CH3','CH4']
		lissx = self.Liss_x.currentText()
		lissy = self.Liss_y.currentText()
		self.liss_x = chans.index(lissx)
		self.liss_y = chans.index(lissy)
		self.liss_win = pg.GraphicsWindow(title="Basic plotting examples")
		self.liss_win.setWindowTitle('pyqtgraph example: Plotting')
		self.p1 = self.liss_win.addPlot(title="Lissajous: x:%s , y:%s"%(lissx,lissy), x=self.I.achans[self.liss_x].get_yaxis(),y=self.I.achans[self.liss_y].get_yaxis())
		if(self.liss_win.windowState() & QtCore.Qt.WindowActive):
			print 'opened'

	def liss_animate(self,val):
		if val and self.liss_ready and self.Liss_show.isChecked():
			self.freezeButton.setChecked(True)
			self.liss_animate_arrow1=pg.CurveArrow(self.curve_lis)
			if(self.liss_x==0):
				self.liss_animate_arrow2=pg.CurveArrow(self.curve1)
			elif(self.liss_x==1):
				self.liss_animate_arrow2=pg.CurveArrow(self.curve2)
			elif(self.liss_x==2):
				self.liss_animate_arrow2=pg.CurveArrow(self.curve3)
			elif(self.liss_x==3):
				self.liss_animate_arrow2=pg.CurveArrow(self.curve4)
			if(self.liss_y==0):
				self.liss_animate_arrow3=pg.CurveArrow(self.curve1)
			elif(self.liss_y==1):
				self.liss_animate_arrow3=pg.CurveArrow(self.curve2)
			elif(self.liss_y==2):
				self.liss_animate_arrow3=pg.CurveArrow(self.curve3)
			elif(self.liss_y==3):
				self.liss_animate_arrow3=pg.CurveArrow(self.curve4)
			self.plot.addItem(self.liss_animate_arrow1)
			self.plot.addItem(self.liss_animate_arrow2)
			self.plot.addItem(self.liss_animate_arrow3)
			self.liss_anim1 = self.liss_animate_arrow1.makeAnimation(loop=-1)
			self.liss_anim2 = self.liss_animate_arrow2.makeAnimation(loop=-1)
			self.liss_anim3 = self.liss_animate_arrow3.makeAnimation(loop=-1)
			self.liss_anim1.start();self.liss_anim2.start();self.liss_anim3.start()
		else:
			self.freezeButton.setChecked(False)
			try:
				self.liss_anim1.stop();self.liss_anim2.stop();self.liss_anim3.stop()
				self.plot.removeItem(self.liss_animate_arrow1)
				self.plot.removeItem(self.liss_animate_arrow2)
				self.plot.removeItem(self.liss_animate_arrow3)
			except:
				pass



	def measure_dcycle(self):
		inp = self.timing_input.currentText()
		v=self.I.DutyCycle(inp)
		if(v[0]!=-1):p=100*v[1]
		else: p=0
		self.timing_results.setText('Duty Cycle: %f %%'%(p))

	def measure_interval(self):
		t = self.I.MeasureInterval(self.edge1chan.currentText(),self.edge2chan.currentText(),self.edge1edge.currentText(),self.edge2edge.currentText())
		self.time_interval_label.setText('time: %.2e S'%(t))
	def setOpacity(self,val):
		self.setWindowOpacity(val/100.0)


	def __del__(self):
		print 'bye'
        		
if __name__ == "__main__":
	app = QtGui.QApplication(sys.argv)

	# Create and display the splash screen
	#splash_pix = QtGui.QPixmap('cat.png')
	#splash = QtGui.QSplashScreen(splash_pix, QtCore.Qt.WindowStaysOnTopHint)
	#progressBar = QtGui.QProgressBar(splash)
	#progressBar.setStyleSheet("""QProgressBar::chunk { width:100%;background: #112255; }""")
	#splash.setMask(splash_pix.mask())
	#splash.show()
	#for i in range(0, 100):
	#	progressBar.setValue(i)
	#	t = time.time()
	#	while time.time() < t + 0.001:
	#		app.processEvents()
	
	myapp = MyMainWindow()
	myapp.show()
	app.processEvents()
	#splash.finish(myapp)
	app.exec_()

