def wait_for_event(self, event):

		"""See pygaze._eyetracker.baseeyetracker.BaseEyeTracker"""

		if not self.recording:
			raise Exception( \
				"Error in libeyelink.libeyelink.wait_for_event(): Recording was not started before collecting eyelink data!")

		if self.eye_used == None:
			self.set_eye_used()
		if self.eventdetection == 'native':
			d = 0
			while d != event:
				d = pylink.getEYELINK().getNextData()
			return pylink.getEYELINK().getFloatData()

		if event == 5:
			outcome = self.wait_for_saccade_start()
		elif event == 6:
			outcome = self.wait_for_saccade_end()
		elif event == 7:
			outcome = self.wait_for_fixation_start()
		elif event == 8:
			outcome = self.wait_for_fixation_end()
		elif event == 3:
			outcome = self.wait_for_blink_start()
		elif event == 4:
			outcome = self.wait_for_blink_end()
		else:
			raise Exception( \
				"Error in libeyelink.libeyelink.wait_for_event: eventcode %s is not supported" \
				% event)
		return outcome

	def wait_for_event(self, event):

		"""<DOC>
		Waits until an event has occurred.

		Arguments:
		event	-- An EyeLink event, such as pylink.STARTSACC.

		Returns:
		A tuple (timestamp, event). The event is in float_data format. The #
		timestamp is in experiment time.

		Exceptions:
		Raises an exceptions.runtime_error on failure.
		</DOC>"""

		if not self.recording:
			raise exceptions.runtime_error( \
				u'Please start recording before collecting eyelink data')
		if self.eye_used == None:
			self.set_eye_used()
		t_0 = self.experiment.time()
		while True:
			d = 0
			while d != event:
				d = pylink.getEYELINK().getNextData()
			# ignore d if its event occured before t_0:
			float_data = pylink.getEYELINK().getFloatData()
			if float_data.getTime() - self.get_eyelink_clock_async() > t_0:
				break
		return float_data.getTime() - self.get_eyelink_clock_async(), float_data

	def start_recording(self):

		"""See pygaze._eyetracker.baseeyetracker.BaseEyeTracker"""

		self.recording = True
		i = 0
		while True:
			# params: write samples, write event, send samples, send events
			error = pylink.getEYELINK().startRecording(1, 1, 1, 1)
			
			if not error:
				break
			if i > self.MAX_TRY:
				raise Exception( \
					"Error in libeyelink.libeyelink.start_recording(): Failed to start recording!")
				self.close()
				clock.expend()
			i += 1
			print( \
				"WARNING libeyelink.libeyelink.start_recording(): Failed to start recording (attempt %d of %d)" \
				% (i, self.MAX_TRY))
			pylink.msecDelay(100)
		# don't know what this is
		pylink.pylink.beginRealTimeMode(100)
		# wait a bit until samples start coming in
		if not pylink.getEYELINK().waitForBlockStart(100, 1, 0):
			raise Exception( \
				"Error in libeyelink.libeyelink.start_recording(): Failed to start recording (waitForBlockStart error)!")

	def calibrate(self, beep=True, target_size=16):

		"""<DOC>
		Starts eyelink calibration.

		Keyword arguments:
		beep			--	Indicates whether or not the calibration target #
							should beep when jumping. (default=True)
		target_size		--	The size of the calibration target. (default=16)

		Exceptions:
		Raises an exceptions.runtime_error on failure.
		</DOC>"""

		if self.recording:
			raise exceptions.runtime_error( \
				u'Trying to calibrate after recording has started')

		self.cal_beep = beep
		self.cal_target_size = target_size

		# attempt calibrate; confirm abort when esc pressed
		while True:
			pylink.getEYELINK().doTrackerSetup()
			if not self.experiment.eyelink_esc_pressed: 
				break
			else:
				self.confirm_abort_experiment()
				self.experiment.eyelink_esc_pressed = False

    def start_recording(self):
        """See pygaze._eyetracker.baseeyetracker.BaseEyeTracker"""

        self.recording = True
        i = 0
        while True:
            # params: write samples, write event, send samples, send events
            print(u'starting recording ...')
            error = pylink.getEYELINK().startRecording(1, 1, 1, 1)
            print(u'returned %s' % error)
            if not error:
                break
            if i > self.MAX_TRY:
                raise Exception(
                    "Error in libeyelink.libeyelink.start_recording(): Failed "
                    "to start recording!")
                self.close()
                clock.expend()
            i += 1
            print(
                ("WARNING libeyelink.libeyelink.start_recording(): Failed to "
                 "start recording (attempt %d of %d)") % (i, self.MAX_TRY))
            pylink.msecDelay(100)
        # don't know what this is
        print(u'Start realtime mode ...')
        pylink.msecDelay(100)
        pylink.beginRealTimeMode(100)
        # wait a bit until samples start coming in
        print(u'Wait for block start ...')
        pylink.msecDelay(100)
        if not pylink.getEYELINK().waitForBlockStart(100, 1, 0):
            raise Exception(
                "Error in libeyelink.libeyelink.start_recording(): Failed to "
                "start recording (waitForBlockStart error)!")
        print(u'done ...')

	def set_backdrop(self, canvas, prepped_backdrop_image=None):
	
		"""<DOC>
		Set backdrop image of Eyelink computer. For performance, it can be
		useful sometimes to already prepare the image to send to the eyelink in
		the prepare phase. This prepared image can be optionally supplied in
		prepped_backdrop_image (a  3 dimensional list with hor-lines x ver-lines
		x pixels) Otherwise, supplying the canvas is enough and this function
		will take care of the conversion
		
		Arguments:
		canvas -- an openexp canvas
		
		Keyword arguments:
		prepped_backdrop_image -- an image in the (list x list x tuple) format
								  required by pylink
		</DOC>"""
		
		if self.experiment.canvas_backend != 'legacy':
			raise exceptions.runtime_error( \
				'prepare_backdrop requires the legacy back-end')
						
		if not prepped_backdrop_image is None: 
			if	type(prepped_backdrop_image) == list:
				width = len(prepped_backdrop_image[0])
				height = len(prepped_backdrop_image)
				pylink.getEYELINK().bitmapBackdrop(width,height,prepped_backdrop_image,0,0,width,height,0,0,pylink.BX_MAXCONTRAST)
			else:
				raise exceptions.runtime_error("Backdrop image has invalid format")
		else:
			backdrop = prepare_backdrop(canvas)
			width = canvas.surface.get_width()
			height = canvas.surface.get_height()		
			pylink.getEYELINK().bitmapBackdrop(width,height,backdrop,0,0,width,height,0,0,pylink.BX_MAXCONTRAST)

	def start_recording(self):

		"""<DOC>
		Starts recording of gaze samples.

		Exceptions:
		Raises an exceptions.runtime_error on failure.
		</DOC>"""

		self.recording = True
		i = 0
		while True:
			# Params: write  samples, write event, send samples, send events
			error = pylink.getEYELINK().startRecording(1, 1, 1, 1)
			if not error:
				break
			if i > self.MAX_TRY:
				raise exceptions.runtime_error( \
					u'Failed to start recording (startRecording error)')
			i += 1
			print u'libeyelink.start_recording(): failed to start recording (attempt %d of %d)' \
				% (i, self.MAX_TRY)
			pylink.msecDelay(100)
		# Don't know what this is
		pylink.pylink.beginRealTimeMode(100)
		# Wait for a bit until samples start coming in (I think?)
		if not pylink.getEYELINK().waitForBlockStart(100, 1, 0):
			raise exceptions.runtime_error( \
				u'Failed to start recording (waitForBlockStart error)')

	def stop_recording(self):

		"""See pygaze._eyetracker.baseeyetracker.BaseEyeTracker"""

		self.recording = False
		pylink.endRealTimeMode()
		pylink.getEYELINK().setOfflineMode()
		pylink.msecDelay(500)

	def stop_recording(self):

		"""<DOC>
		Stops recording of gaze samples.
		</DOC>"""

		self.recording = False
		pylink.endRealTimeMode()
		pylink.getEYELINK().setOfflineMode()
		pylink.msecDelay(500)

	def send_command(self, cmd):

		"""<DOC>
		Sends a command to the eyelink.

		Arguments:
		cmd		--	The eyelink command to be executed.
		</DOC>"""

		pylink.getEYELINK().sendCommand(cmd)

	def log(self, msg):

		"""
		Writes a message to the eyelink data file
	
		In:
		msg: the message to be logged
		"""

		pylink.getEYELINK().sendMessage(msg)

	def send_command(self, cmd):

		"""
		Writes a message to the eyelink
	
		In:
		cmd: the eyelink command to be executed
		"""
	
		pylink.getEYELINK().sendCommand(cmd)

	def log(self, msg):

		"""<DOC>
		Writes a message to the eyelink data file
	
		Arguments:
		msg -- the message to be logged
		</DOC>"""

		pylink.getEYELINK().sendMessage(msg)

	def stop_recording(self):

		"""
		Stop recording of gaze samples
		"""
	
		self.recording = False	

		pylink.endRealTimeMode();
		pylink.getEYELINK().setOfflineMode();                          
		pylink.msecDelay(500);                 

	def status_msg(self, msg):

		"""
		Sets the eyelink status message, which is displayed on the 
		eyelink pc
	
		In:
		msg: the status message
		"""
	
		pylink.getEYELINK().sendCommand("record_status_message '%s'" % msg)

	def status_msg(self, msg):

		"""<DOC>
		Sets the eyelink status message, which is displayed on the eyelink #
		experimenter pc.

		Arguments:
		msg		--	The status message.
		</DOC>"""

		pylink.getEYELINK().sendCommand("record_status_message '%s'" % msg)

	def log_var(self, var, val):

		"""
		Writes a variable to the eyelink data file
	
		In:
		var: the variable name
		val: the value
		"""

		pylink.getEYELINK().sendMessage("var %s %s" % (var, val))

	def log_var(self, var, val):

		"""<DOC>
		Writes a variable to the eyelink data file. This is a shortcut for #
		eyelink.log("var %s %s" % (var, val)).

		Arguments:
		var		-- The variable name.
		val		-- The value.
		</DOC>"""

		pylink.getEYELINK().sendMessage("var %s %s" % (var, val))

	def calibrate(self):

		"""
		Starts eyelink calibration
	
		Exceptions:
		Raises an exceptions.runtime_error on failure		
		"""
	
		if self.recording:
			raise exceptions.runtime_error("Trying to calibrate after recording has started")	
	
		pylink.getEYELINK().doTrackerSetup()

    def pupil_size(self):
        """See pygaze._eyetracker.baseeyetracker.BaseEyeTracker"""

        if not self.recording:
            raise Exception(
                "Error in libeyelink.libeyelink.pupil_size(): Recording was "
                "not started before collecting eyelink data!")
        if self.eye_used == None:
            self.set_eye_used()
        # get newest sample
        s = pylink.getEYELINK().getNewestSample()
        # check if sample is new
        if s != None:
            # right eye
            if self.eye_used == self.right_eye and s.isRightSample():
                ps = s.getRightEye().getPupilSize()
            # left eye
            elif self.eye_used == self.left_eye and s.isLeftSample():
                ps = s.getLeftEye().getPupilSize()
            # invalid
            else:
                ps = -1
            # set new pupil size as previous pupil size
            self.prevps = ps
        # if no new sample is available, use old data
        else:
            ps = self.prevps
        return ps