#! /usr/bin/env mpscript
#

import wxversion
wxversion.ensureMinimal("2.8")

import numpy
import wx
import MpNum
import MpWx
import time

try:
	import Image
except:
	from PIL import Image

#
# Have we been requested to start a C debugger?
#

try:
	test = os.environ["MPAD_DEBUGGER"]
	Mp.c_wait_for_debugger()
except:
	pass

#
# Create an object to hold attributes used by the example script.
#

class _Example:
	pass

_example = _Example()

_example.mxdir = mxdir

_example.callback_list = []

_example.gui_ready = False

_example.fetch_image_frame = False

#------

lib_dir = os.path.join( mxdir, "lib", "mpad" )

lib_dir = os.path.normpath( lib_dir )

sys.path.append( lib_dir )

#---

from MpadImage import *
import MpadTools

#--------------------------------------------------------------------------

class MpadImageApp(wx.App):

	def OnInit( self ):
		#
		# _example.is_busy is used to remember whether the area
		# detector was busy the last time we checked, so we can
		# compare it to the current busy status.
		#

		_example.is_busy = False

		self.frame = MpadImageMainFrame()

		self.frame.Show()

		self.SetTopWindow( self.frame )

		self.timer = MpadTimer( self, _example.mx_database )

		_example.timer = self.timer

		self.timer.Start( 1000 )

		return True

#--------------------------------------------------------------------------

def main( mx_database, args ):
	_example.mx_database = mx_database

	_example.mx_database.set_program_name('mpad_image')

	## _example.mx_database.set_network_debug(True)

	#
	# Find the area detector record.
	#

	_example.ad_record = MpadTools.find_area_detector( mx_database, args )

	#-------------------------------------------------------------------
	#
	# What type of area detector record is this?
	#

	( _example.mx_type, _example.server_record,
		_example.remote_ad_name, _example.remote_mx_type ) \
    = MpadTools.get_area_detector_type( _example.ad_record, mx_database )

	_example.mx_type = _example.ad_record.get_field("mx_type")

	#
	# If this is a network area detector record, find out what type
	# of record is being used by the server.
	#

	if ( _example.mx_type != "network_area_detector" ):
		_example.server_record = None
		_example.remote_ad_name = None
		_example.remote_mx_type = None
	else:
		server_record_name = \
			_example.ad_record.get_field("server_record")

		_example.server_record = \
			_example.mx_database.get_record( server_record_name )

		_example.remote_ad_name = \
			_example.ad_record.get_field("remote_record_name")

		mx_type_nf_name = "%s.mx_type" % ( _example.remote_ad_name )

		mx_type_nf = \
			Mp.Net( _example.server_record, mx_type_nf_name )

		_example.remote_mx_type = mx_type_nf.get()


	print "_example.remote_mx_type =", _example.remote_mx_type

	#
	# Initialize the saved correction flags to 0, so that the Status
	# callback will ignore it (to begin with).
	#

	_example.saved_correction_flags = 0

	#
	#-------------------------------------------------------------------

	#
	# Create the ImageFrame object that will be used to contain frames
	# read from the area detector.
	#

	maximum_framesize = _example.ad_record.get_maximum_framesize()
	bytes_per_pixel   = _example.ad_record.get_bytes_per_pixel()

	_example.max_framesize = maximum_framesize

	num_pixels = int(maximum_framesize[0]) * int(maximum_framesize[1])

	image_length = bytes_per_pixel * num_pixels

	image_length = int(image_length)

	image_frame = Mp.ImageFrame( maximum_framesize, \
				_example.ad_record.get_image_format(), \
				Mp.native_byteorder(), \
				bytes_per_pixel, \
				0, \
				image_length )

	_example.image_frame = image_frame

	_example.ad_record.setup_frame( _example.image_frame )

	_example.file_number = 0

	#
	# Create the WxPython GUI.
	#

	app = MpadImageApp(redirect=False)

	_example.gui_ready = True

	#
	# Create a callback to monitor the value of 'total_num_frames'.
	# When we are notified that 'total_num_frames' changes, then that
	# is the time that we ask the server for a new image.
	#

	nf_name = "%s.total_num_frames" % ( _example.ad_record.name )

	total_num_frames_nf = Mp.Net( _example.server_record, nf_name )

	args = ( total_num_frames_nf,
		_example.ad_record,
		app.frame.image_panel )

	callback = total_num_frames_nf.add_callback( Mp.MXCBT_VALUE_CHANGED,
					mpad_image_monitor_callback, args )

	_example.callback_list.append( callback )

	del callback

	_example.total_num_frames_nf = total_num_frames_nf

	#
	# Load the initial image into the image display.
	#

	try:
		mpad_image_monitor_callback( None, args )
	except:
		pass

	#
	# Start the WxPython event loop.
	#

	app.MainLoop()

#=============================================================================

#
# mpad_image_monitor_callback() is invoked each time that we are notified
# that new frames have been taken by the area detector.
#

def mpad_image_monitor_callback( callback, args ):

	( total_num_frames_nf, ad_record, image_panel ) = args

	# Get the frame from the server

	ad_record.setup_frame( _example.image_frame )
	ad_record.readout_frame( -1 )
	ad_record.correct_frame()
	ad_record.transfer_frame( 0, _example.image_frame )

	# Display the new frame

	image_panel.SetData( _example.image_frame )
	image_panel.Display()

#=============================================================================

#
# The MpadImageMainFrame class is used to implement the top level window
# of mpad_image.
#

#
#----------------------------------------------------------------------------
#

class MpadImageMainFrame(wx.Frame):

	def __init__( self ):
		wx.Frame.__init__( self, None, \
				title="MX Area Detector Control" )

		_example.frame = self

		#
		# Load the image panel.
		#

		self.image_panel = MpadImagePanel( self )

		#
		# Exit when the top level window is closed.
		#

		self.Bind( wx.EVT_CLOSE, self.OnCloseWindow )

		self.Bind( wx.EVT_SIZE, self.OnSize )

		#
		# Expand the size of the top level window to make sure
		# that all windows are visible.
		#

		self.image_panel.Fit()
		self.Fit()

	def OnCloseWindow( self, event ):
		self.Destroy()

	def OnSize( self, event ):
		# print "MpadImageMainFrame: OnSize(): size =", self.GetSize()

		event.Skip()

#=============================================================================