//////////////////////////////////////////////////////////////////////
//
// HSI.cpp : Implementation of the MicroVu HSI supporting:
//           - MicroVu based systems
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"

#include "..\include\resource.h"

#include "HAL.h"
#include "HSI.h"

#include "FGLoad.h"

#include "HAL_EventHandler.H"
#include "HAL_Fixture.H"
#include "HAL_Illumination.H"
#include "HAL_LaserProbe.H"
#include "HAL_Motion.H"
#include "HAL_Optics.H"
#include "HAL_Pendant.H"
#include "HAL_ToolChanger.H"
#include "HAL_TouchProbe.H"
#include "HAL_VideoProbe.H"

#include "Logger.h"

// #define _TEST_MOTION_ONLY

#ifdef _MERGE_PROXYSTUB
extern "C" HINSTANCE hProxyDll;
#endif

extern TCHAR SectionHeader[];

//extern CMachineInterface *m_pMachine;
//HANDLE hEventEStop = NULL;

//////////////////////////////////////////////////////////////////////////////
// Interface version used in GetVersion()
//
#define VERSION   _T("1.0")
//CMachineInterface *m_pMachine = NULL;
//CPCDpart_program *m_pPartProgram = NULL;
CWnd *pMessageBox;
CHAL           *g_pHSI = NULL;
HINSTANCE VPlib = NULL;
HINSTANCE FGlib = NULL;
CHALMicroVuExt  g_HSIExt;  // basic configuration data
CMv_Proto      *g_pMv_Proto = NULL;
CLogger        *pLogger;

long            g_lFramegrabberType						= -1l;

//////////////////////////////////////////////////////////////////////////////

#define MACHINE_ID_STRING (m_pMachine ? m_pMachine->m_id : _T("<undefined>"))
static AFX_EXTENSION_MODULE HSIDLL = { NULL, NULL };

//////////////////////////////////////////////////////////////////////
extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
{
	if (dwReason == DLL_PROCESS_ATTACH)
	{
		TRACE0("Hsi_MicroVu.DLL Initializing!\n");

		// Extension DLL one-time initialization
		AfxInitExtensionModule(HSIDLL, hInstance);

		// Insert this DLL into the resource chain
		new CDynLinkLibrary(HSIDLL);
	}
	else if (dwReason == DLL_PROCESS_DETACH)
	{
		TRACE0("Hsi_MicroVu.DLL Terminating!\n");
	}
	return 1;
}

//////////////////////////////////////////////////////////////////////////
// All required hardware objects
extern "C" __declspec(dllexport) HAL_STATUS HAL_GetVersion(TCHAR *Version)
{
	HAL_STATUS Status = HAL_STATUS_NORMAL;
	CString VersionStr;
#ifdef _DEBUG

	VersionStr= _T("HSI_MicroVu.dll ") _T(__DATE__) _T(" debug version ") VERSION;
#else
	VersionStr= _T("HSI_MicroVu.dll ") _T(__DATE__) _T(" release version ") VERSION;
#endif

	wcsncpy_s(Version, HAL_MaxStringLength+1, VersionStr, HAL_MaxStringLength);
	HAL_SendDebug(_T("HAL_GetVersion %s\n"), VersionStr);
	return Status;
}

//////////////////////////////////////////////////////////////////////
//extern "C" __declspec(dllexport) HSI_STATUS HAL_Shutdown()
HAL_STATUS HAL_Shutdown()
{
  if (g_pMv_Proto)
  {
    g_pMv_Proto->Exit_MvUsb();
    delete g_pMv_Proto;
    g_pMv_Proto = NULL;
  };

	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
extern "C" __declspec(dllexport) HAL_STATUS HAL_GetInterfaceVersion(long &APIVersionMajor, long &APIVersionMinor)
{
	APIVersionMajor=HAL_APIVersionMajor;
	APIVersionMinor=HAL_APIVersionMinor;
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
// Start up checks if the m_TestMotion is ON.  We will load the needed only.
//
extern "C" __declspec(dllexport) HAL_STATUS HAL_Startup(HWND hWnd, CHAL *pHAL, bool bOfflineOnly, long lFrameGrabberType)
{
	HAL_STATUS Status = HAL_STATUS_NORMAL;
	g_HSIExt.g_bOfflineOnly = bOfflineOnly;

//  m_pMachine = global_machine_active;
//	m_pPartProgram = m_pMachine->m_pPartProgram;

	// If no HAL then quit
	if(!pHAL)
		return HAL_STATUS_FAILED;

	// Set global HAL object
	g_pHSI = pHAL;

	if(!g_HSIExt.g_bOfflineOnly)
	{
    g_HSIExt.m_bIsInitialised = false;

    g_pMv_Proto = new CMv_Proto(); // Create the MicroVu object 
    SSI_STATUS Status = g_pMv_Proto->Init_MvUsb();
    if (Status != SSI_STATUS_NORMAL)
    {
#pragma message("Add USB specific HAL event message here")
      return HAL_STATUS_FAILED;
    }

    Status = g_pMv_Proto->mv_motion_startup(g_HSIExt.m_ScaleResolutionX, g_HSIExt.m_ScaleResolutionY, g_HSIExt.m_ScaleResolutionZ);
    if (Status != SSI_STATUS_NORMAL)
    {
#pragma message("Add USB specific HAL event message here")
      return HAL_STATUS_FAILED;
    }

    g_HSIExt.m_bIsInitialised = true;
  }

	// Initialise the HAL function addresses
	if(g_pHSI)
	{
		// Set exported HAL function addresses
		g_pHSI->Shutdown = (HAL_SHUTDOWN) HAL_Shutdown;
		g_pHSI->GetVersion = (HAL_GET_VERSION) ((HAL_GET_VERSION) HAL_GetVersion);
		g_pHSI->GetInterfaceVersion = (HAL_GET_INTERFACE_VERSION) HAL_GetInterfaceVersion;
		g_pHSI->GetMachineCount = (HAL_GET_MACHINE_COUNT) HAL_GetMachineCount;
		g_pHSI->GetMachineInfo = (HAL_GET_MACHINE_INFO) HAL_GetMachineInfo;
		g_pHSI->SetActiveMachine = (HAL_SET_ACTIVE_MACHINE) HAL_SetActiveMachine;
		g_pHSI->GetActiveMachine = (HAL_GET_ACTIVE_MACHINE) HAL_GetActiveMachine;
		g_pHSI->SetLocale = (HAL_SET_LOCALE) HAL_SetLocale;
		g_pHSI->SetRegistryRootKey = (HAL_SET_REGISTRY_ROOT_KEY) HAL_SetRegistryRootKey;
		g_pHSI->PreSetupDialog = (HAL_PRE_SETUP_DIALOG) HAL_PreSetupDialog;
		g_pHSI->PostSetupDialog = (HAL_POST_SETUP_DIALOG) HAL_PostSetupDialog;
		g_pHSI->EventResponse = (HAL_EVENT_RESPONSE) HAL_EventResponse;
		g_pHSI->GetCustomMessage = (HAL_GET_CUSTOM_MESSAGE) HAL_GetCustomMessage;
		//g_pHSI->GetTemperatureSensor = (HAL_GET_TEMPERATURE_SENSOR) HAL_GetTemperatureSensor;
		//g_pHSI->GetTemperatureSensorCount = (HAL_GET_TEMPERATURE_SENSOR_COUNT) HAL_GetTemperatureSensorCount;

		if(!g_HSIExt.g_bOfflineOnly)
		{
			g_pHSI->Calibrate = (HAL_CALIBRATE) HAL_Calibrate;
			g_pHSI->Notify    = (HAL_NOTIFY)    HAL_Notify;
			g_pHSI->GetCustomCalibrationTypeInfo = (HAL_GET_CUSTOM_CALIBRATION_TYPE_INFO) HAL_GetCustomCalibrationTypeInfo;
		}

		// Map the supported function addresses for the MSI
    HAL_MapSupportedFunctions(pHAL, hWnd, bOfflineOnly);

// #ifndef _TEST_MOTION_ONLY

		HAL_SendDebug(_T("Load VideoProbe library\n"));
		VPlib = ::AfxLoadLibrary(_T("WAI_VideoProbe.dll"));
		if(VPlib)
		{
			g_pHSI->VideoProbe.IsSupported = (HAL_VP_IS_SUPPORTED) ::GetProcAddress(VPlib, "HAL_VP_IsSupported");
			g_pHSI->VideoProbe.IsToolSupported = (HAL_VP_IS_TOOL_SUPPORTED) ::GetProcAddress(VPlib, "HAL_VP_IsToolSupported");
			g_pHSI->VideoProbe.GetProbeCount = (HAL_VP_GET_PROBE_COUNT) ::GetProcAddress(VPlib, "HAL_VP_GetProbeCount");

			g_pHSI->VideoProbe.GetActiveProbe = (HAL_VP_GET_ACTIVE_PROBE) HAL_VP_GetActiveProbe;
			g_pHSI->VideoProbe.SetActiveProbe = (HAL_VP_SET_ACTIVE_PROBE) HAL_VP_SetActiveProbe;

			if(g_pHSI->VideoProbe.IsActive())
			{
				if(!bOfflineOnly)
				{
					g_pHSI->VideoProbe.DoMeasure = (HAL_VP_DO_MEASURE) ::GetProcAddress(VPlib, "HAL_VP_DoMeasure");
					g_pHSI->VideoProbe.Enable = (HAL_VP_ENABLE) ::GetProcAddress(VPlib, "HAL_VP_Enable");
					g_pHSI->VideoProbe.IsEnabled = (HAL_VP_IS_ENABLED) ::GetProcAddress(VPlib, "HAL_VP_IsEnabled");
					g_pHSI->VideoProbe.GetToolCustomTypeInfo = (HAL_VP_GET_TOOL_CUSTOM_TYPE_INFO) ::GetProcAddress(VPlib, "HAL_VP_GetToolCustomTypeInfo");
					g_pHSI->VideoProbe.GetMeasureData = (HAL_VP_GET_MEASURE_DATA) ::GetProcAddress(VPlib, "HAL_VP_GetMeasureData");
					g_pHSI->VideoProbe.GetParameterCount = (HAL_VP_GET_PARAMETER_COUNT) ::GetProcAddress(VPlib, "HAL_VP_GetParameterCount");
					g_pHSI->VideoProbe.GetParameterInfo = (HAL_VP_GET_PARAMETER_INFO) ::GetProcAddress(VPlib, "HAL_VP_GetParameterInfo");
					g_pHSI->VideoProbe.GetTipOffset = (HAL_VP_GET_TIP_OFFSET) ::GetProcAddress(VPlib, "HAL_VP_GetTipOffset");
					g_pHSI->VideoProbe.IsMeasuring = (HAL_VP_IS_MEASURING) ::GetProcAddress(VPlib, "HAL_VP_IsMeasuring");
					g_pHSI->VideoProbe.SetTipOffset = (HAL_VP_SET_TIP_OFFSET) ::GetProcAddress(VPlib, "HAL_VP_SetTipOffset");
					g_pHSI->VideoProbe.SetupMeasureEdgeArc = (HAL_VP_SETUP_MEASURE_EDGE_ARC) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeArc");
					g_pHSI->VideoProbe.SetupMeasureEdgeBlob = (HAL_VP_SETUP_MEASURE_EDGE_BLOB) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeBlob");
					g_pHSI->VideoProbe.SetupMeasureEdgeLine = (HAL_VP_SETUP_MEASURE_EDGE_LINE) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeLine");
					g_pHSI->VideoProbe.SetupMeasureEdgePoint = (HAL_VP_SETUP_MEASURE_EDGE_POINT) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgePoint");
					g_pHSI->VideoProbe.SetupMeasureEdgeTracer = (HAL_VP_SETUP_MEASURE_EDGE_TRACER) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeTrace");
					g_pHSI->VideoProbe.SetupMeasureSurfacePoint = (HAL_VP_SETUP_MEASURE_SURFACE_POINT) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureSurfacePoint");
					g_pHSI->VideoProbe.SetupImage = (HAL_VP_SETUP_IMAGE) ::GetProcAddress(VPlib, "HAL_VP_SetupImage");        //Task104403-- 501919 - 2 - Measure features and pass back points, putting them in the appropriate auto feature—Subtask: MSI grabs the image and pass it to the videoprobe
					g_pHSI->VideoProbe.Shutdown = (HAL_VP_SHUTDOWN) ::GetProcAddress(VPlib, "HAL_VP_ShutDown");
					g_pHSI->VideoProbe.Startup = (HAL_VP_STARTUP) ::GetProcAddress(VPlib, "HAL_VP_Startup");

          //PVD-29: Remove MSIGlobal from the VideoProbe.dll.
          g_pHSI->VideoProbe.HelperSetupFocusData = (HAL_VP_HELPER_SETUP_FOCUS_DATA) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupFocusData");
          g_pHSI->VideoProbe.HelperSetupOpticsSupports = (HAL_VP_HELPER_SETUP_OPTICS_SUPPORTS) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupOpticsSupports");
          g_pHSI->VideoProbe.HelperSetupFrameGrabberData = (HAL_VP_HELPER_SETUP_FRAME_GRABBER_DATA) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupFrameGrabberData");
          g_pHSI->VideoProbe.HelperSetupProbeData = (HAL_VP_HELPER_SETUP_PROBE_DATA) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupProbeData");
          g_pHSI->VideoProbe.HelperSetCameraRotationalAngle = (HAL_VP_HELPER_SET_CAMERA_ROTATIONAL_ANGLE) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetCameraRotationalAngle");
          g_pHSI->VideoProbe.HelperSetOpticalFocalCenter = (HAL_VP_HELPER_SET_OPTICAL_FOCAL_CENTER) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetOpticalFocalCenter");
          g_pHSI->VideoProbe.HelperSetOpticsCurrPixelSize = (HAL_VP_HELPER_SET_OPTICS_CURR_PIXEL_SIZE) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetOpticsCurrPixelSize");
          g_pHSI->VideoProbe.HelperSetGlobalUnitInMM = (HAL_VP_HELPER_SET_GLOBAL_UNIT_IN_MM) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetGlobalUnitInMM");
				}
			}
		}
		else
		{
			HAL_SendDebug(_T("Load VideoProbe library failed\n"));
			CString Message;
			Message.LoadString(IDS_NC_FILE_NOT_FOUND);
			Message = _T("WAI_VideoProbe.dll - ") + Message;
			TCHAR Msg[HAL_MaxStringLength+1];
			wcsncpy_s(Msg, HAL_MaxStringLength+1, Message, HAL_MaxStringLength);
			UINT EventCallbackID = 0;
			g_pHSI->Event(HAL_EVENT_ERROR, 0, Msg, EventCallbackID);
			return HAL_STATUS_FILE_NOT_FOUND;
		}

		// Set exported HAL FRAME GRABBER function addresses
		if(g_pHSI->FrameGrabber.m_bEnabled)
		{
			// Load FrameGrabber library
			HAL_SendDebug(_T("Load FrameGrabber library\n"));
      CString DLLsFoundWithFailedLoad;
      CString DefFileName;
      BOOL bDefWAIFGFileFound=FALSE;
      BOOL bWAIVenderFGFileFound=FALSE;
      CString LoadingStatus;
      bool bLoadedAndProbed = LoadFramegrabberDLL(lFrameGrabberType, FGlib, DLLsFoundWithFailedLoad, bDefWAIFGFileFound, bWAIVenderFGFileFound, LoadingStatus);
      LoadingStatus += _T("\n");
//      debug.Send(LoadingStatus);

      if(bLoadedAndProbed)
			{
				// Get startup address and call startup routine
				g_pHSI->FrameGrabber.IsSupported = (HAL_FG_IS_SUPPORTED) ::GetProcAddress(FGlib, "HAL_FG_IsSupported");

				if (g_pHSI->FrameGrabber.IsActive())
				{
					// HAL FRAMEGRABBER is supported
					g_pHSI->FrameGrabber.GetCameraCount = (HAL_FG_GET_CAMERA_COUNT) ::GetProcAddress(FGlib, "HAL_FG_GetCameraCount");
					g_pHSI->FrameGrabber.GetImageSize = (HAL_FG_GET_IMAGE_SIZE) ::GetProcAddress(FGlib, "HAL_FG_GetImageSize");
					if(!g_HSIExt.g_bOfflineOnly)
					{
						g_pHSI->FrameGrabber.Startup = (HAL_FG_STARTUP) ::GetProcAddress(FGlib, "HAL_FG_Startup");
						g_pHSI->FrameGrabber.ProbeDevice = (HAL_FG_PROBE_DEVICE) ::GetProcAddress(FGlib, "HAL_FG_ProbeDevice");
						g_pHSI->FrameGrabber.IsCameraPresent = (HAL_FG_IS_CAMERA_PRESENT) ::GetProcAddress(FGlib, "HAL_FG_IsCameraPresent");
						g_pHSI->FrameGrabber.SetActiveCamera = (HAL_FG_SET_ACTIVE_CAMERA) ::GetProcAddress(FGlib, "HAL_FG_SetActiveCamera");
						g_pHSI->FrameGrabber.StartLiveVideo = (HAL_FG_START_LIVE_VIDEO) ::GetProcAddress(FGlib, "HAL_FG_StartLiveVideo");
						g_pHSI->FrameGrabber.StopLiveVideo = (HAL_FG_STOP_LIVE_VIDEO) ::GetProcAddress(FGlib, "HAL_FG_StopLiveVideo");
						g_pHSI->FrameGrabber.DoGreyscaleSnapshot = (HAL_FG_DO_GREYSCALE_SNAPSHOT) ::GetProcAddress(FGlib, "HAL_FG_DoGreyscaleSnapshot");
						g_pHSI->FrameGrabber.GetGreyscaleSnapshotImage = (HAL_FG_GET_GREYSCALE_SNAPSHOT_IMAGE) ::GetProcAddress(FGlib, "HAL_FG_GetGreyscaleSnapshotImage");
						g_pHSI->FrameGrabber.DoColorSnapshot = (HAL_FG_DO_COLOR_SNAPSHOT) ::GetProcAddress(FGlib, "HAL_FG_DoColorSnapshot");
						g_pHSI->FrameGrabber.GetColorSnapshotPixel = (HAL_FG_GET_COLOR_SNAPSHOT_PIXEL) ::GetProcAddress(FGlib, "HAL_FG_GetColorSnapshotPixel");
						g_pHSI->FrameGrabber.StartUpdateOverlay = (HAL_FG_START_UPDATE_OVERLAY) ::GetProcAddress(FGlib, "HAL_FG_StartUpdateOverlay");
						g_pHSI->FrameGrabber.GetOverlayDC = (HAL_FG_GET_OVERLAY_DC) ::GetProcAddress(FGlib, "HAL_FG_GetOverlayDC");
						g_pHSI->FrameGrabber.DrawOverlayDot = (HAL_FG_DRAW_OVERLAY_DOT) ::GetProcAddress(FGlib, "HAL_FG_DrawOverlayDot");
						g_pHSI->FrameGrabber.ClearOverlay = (HAL_FG_CLEAR_OVERLAY) ::GetProcAddress(FGlib, "HAL_FG_ClearOverlay");
						g_pHSI->FrameGrabber.EndUpdateOverlay = (HAL_FG_END_UPDATE_OVERLAY) ::GetProcAddress(FGlib, "HAL_FG_EndUpdateOverlay");
						g_pHSI->FrameGrabber.GetTransparentColor = (HAL_FG_GET_TRANSPARENT_COLOR) ::GetProcAddress(FGlib, "HAL_FG_GetTransparentColor");
						g_pHSI->FrameGrabber.GetFieldonetime = (HAL_FG_GET_FIELDONETIME) ::GetProcAddress(FGlib, "HAL_FG_GetFieldonetime");
						g_pHSI->FrameGrabber.GetFieldtwotime = (HAL_FG_GET_FIELDTWOTIME) ::GetProcAddress(FGlib, "HAL_FG_GetFieldtwotime");
						g_pHSI->FrameGrabber.SetGrabHook = (HAL_FG_SET_GRAB_HOOK) ::GetProcAddress(FGlib, "HAL_FG_SetGrabHook");
						g_pHSI->FrameGrabber.ClearGrabHook = (HAL_FG_CLEAR_GRAB_HOOK) ::GetProcAddress(FGlib, "HAL_FG_ClearGrabHook");
						g_pHSI->FrameGrabber.Shutdown = (HAL_FG_SHUTDOWN) ::GetProcAddress(FGlib, "HAL_FG_Shutdown");
						g_pHSI->FrameGrabber.StartOfFocus = (HAL_FG_STARTOFFOCUS) ::GetProcAddress(FGlib, "HAL_FG_StartOfFocus");
						g_pHSI->FrameGrabber.EndOfFocus = (HAL_FG_ENDOFFOCUS) ::GetProcAddress(FGlib, "HAL_FG_EndOfFocus");
						g_pHSI->FrameGrabber.GreyscaleRGB = (HAL_FG_GREYSCALE_RGB) ::GetProcAddress(FGlib, "HAL_FG_GreyscaleRGB");
            g_pHSI->FrameGrabber.IsCameraColor = (HAL_FG_IS_CAMERA_COLOR) ::GetProcAddress(FGlib, "HAL_FG_IsCameraColor");  //109287
            g_pHSI->FrameGrabber.SetTransparency = (HAL_FG_SET_TRANSPARENCY) ::GetProcAddress(FGlib, "HAL_FG_SetTransparency");
					}
				}
			}
			else if(!bOfflineOnly)
			{
				CString Message;
				if(bDefWAIFGFileFound == TRUE || bWAIVenderFGFileFound == TRUE)
				{
					Message.LoadString(IDS_FRAME_GRABBER_MISSING_DEPENDENT_DLL);
				}
				else
				{
					Message.LoadString(IDS_NC_FILE_NOT_FOUND);
				}

				Message = DLLsFoundWithFailedLoad + _T(" - ") + Message;
				TCHAR Msg[HAL_MaxStringLength+1];
				wcsncpy_s(Msg, HAL_MaxStringLength+1, Message, HAL_MaxStringLength);
				UINT EventCallbackID = 0;
        g_pHSI->Event(HAL_EVENT_FUNCTION, HAL_EVENT_DISPLAY_OK_MESSAGE, Msg, EventCallbackID);
				return HAL_STATUS_FILE_NOT_FOUND;
			}
		}
    else
    {
//      debug.Send(_T("Framegrabber not active - Load FrameGrabber library skipped\n"));
    }

// #endif

	}
	else
		return HAL_STATUS_FAILED;

	return Status;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_MapSupportedFunctions(CHAL *pHAL, HWND hWnd, bool bOfflineOnly)
{
	HAL_STATUS Status = HAL_STATUS_NORMAL;
	pHAL->Illumination.IsSupported = (HAL_ILLUMINATION_IS_SUPPORTED) HAL_Illumination_IsSupported;
	if(pHAL->Illumination.IsActive(true))
	{
		pHAL->Illumination.GetLampCount = (HAL_ILLUMINATION_GET_LAMP_COUNT) HAL_Illumination_GetLampCount;
		pHAL->Illumination.GetLampInfo = (HAL_ILLUMINATION_GET_LAMP_INFO) HAL_Illumination_GetLampInfo;
		if(!g_HSIExt.g_bOfflineOnly)
		{
			pHAL->Illumination.Startup = (HAL_ILLUMINATION_STARTUP) HAL_Illumination_Startup;
			pHAL->Illumination.GetLampState = (HAL_ILLUMINATION_GET_LAMP_STATE) HAL_Illumination_GetLampState;
			pHAL->Illumination.SetLampState = (HAL_ILLUMINATION_SET_LAMP_STATE) HAL_Illumination_SetLampState;
			pHAL->Illumination.Shutdown = (HAL_ILLUMINATION_SHUTDOWN) HAL_Illumination_Shutdown;
		}
	}
	pHAL->Motion.IsSupported = (HAL_MOTION_IS_SUPPORTED) HAL_Motion_IsSupported;
	if(pHAL->Motion.IsActive(true))
	{
		pHAL->Motion.GetAxisCount = (HAL_MOTION_GET_AXIS_COUNT) HAL_Motion_GetAxisCount;
		pHAL->Motion.GetSpeedXYZ = (HAL_MOTION_GET_SPEED_XYZ) HAL_Motion_GetSpeedXYZ;
		pHAL->Motion.GetSpeedR = (HAL_MOTION_GET_SPEED_R) HAL_Motion_GetSpeedR;
		pHAL->Motion.GetSettleTime = (HAL_MOTION_GET_SETTLE_TIME) HAL_Motion_GetSettleTime;
		pHAL->Motion.GetDeadband = (HAL_MOTION_GET_DEADBAND) HAL_Motion_GetDeadband;
		pHAL->Motion.GetRefreshDeadband = (HAL_MOTION_GET_REFRESH_DEADBAND) HAL_Motion_GetRefreshDeadband;
		pHAL->Motion.GetStageLimits = (HAL_MOTION_GET_STAGE_LIMITS) HAL_Motion_GetStageLimits;
		pHAL->Motion.SetStageLimits = (HAL_MOTION_SET_STAGE_LIMITS) HAL_Motion_SetStageLimits;
    pHAL->Motion.GetMaxSpeed = (HAL_MOTION_GET_MAX_SPEED) HAL_Motion_GetMaxSpeed;
		if(!g_HSIExt.g_bOfflineOnly)
		{
			pHAL->Motion.Startup = (HAL_MOTION_STARTUP) HAL_Motion_Startup;
			pHAL->Motion.SetSpeedXYZ = (HAL_MOTION_SET_SPEED_XYZ) HAL_Motion_SetSpeedXYZ;
			pHAL->Motion.SetSpeedR = (HAL_MOTION_SET_SPEED_R) HAL_Motion_SetSpeedR;
			pHAL->Motion.SetAccelerationXYZ = (HAL_MOTION_SET_ACCELERATION_XYZ) HAL_Motion_SetAccelerationXYZ;
			pHAL->Motion.SetAccelerationR   = (HAL_MOTION_SET_ACCELERATION_R) HAL_Motion_SetAccelerationR;
      pHAL->Motion.GetAccelerationXYZ   = (HAL_MOTION_GET_ACCELERATION_XYZ) HAL_Motion_GetAccelerationXYZ;
      pHAL->Motion.GetAccelerationR = (HAL_MOTION_GET_ACCELERATION_R) HAL_Motion_GetAccelerationR;
			pHAL->Motion.GetPositionXYZ = (HAL_MOTION_GET_POSITION_XYZ) HAL_Motion_GetPositionXYZ;
			pHAL->Motion.SetPositionXYZ = (HAL_MOTION_SET_POSITION_XYZ) HAL_Motion_SetPositionXYZ;
			pHAL->Motion.GetPositionR = (HAL_MOTION_GET_POSITION_R) HAL_Motion_GetPositionR;
			pHAL->Motion.SetPositionR = (HAL_MOTION_SET_POSITION_R) HAL_Motion_SetPositionR;
			pHAL->Motion.IsHomed = (HAL_MOTION_IS_HOMED) HAL_Motion_IsHomed;
			pHAL->Motion.Shutdown = (HAL_MOTION_SHUTDOWN) HAL_Motion_Shutdown;
		}
	}
	pHAL->Pendant.IsSupported = (HAL_PENDANT_IS_SUPPORTED) HAL_Pendant_IsSupported;
	if(pHAL->Pendant.IsActive(true))
	{
		if(!g_HSIExt.g_bOfflineOnly)
		{
			pHAL->Pendant.Startup = (HAL_PENDANT_STARTUP) HAL_Pendant_Startup;
			pHAL->Pendant.Enable = (HAL_PENDANT_ENABLE) HAL_Pendant_Enable;
			pHAL->Pendant.Shutdown = (HAL_PENDANT_SHUTDOWN) HAL_Pendant_Shutdown;
		}
	}

	pHAL->Optics.IsSupported = (HAL_OPTICS_IS_SUPPORTED) HAL_Optics_IsSupported;
	if(pHAL->Optics.IsActive(true))
	{
//		pHAL->Optics.GetMagnificationSteps = (HAL_OPTICS_GET_MAGNIFICATION_STEPS) HAL_Optics_GetMagnificationSteps;
//		pHAL->Optics.GetDeadband = (HAL_OPTICS_GET_DEADBAND) HAL_Optics_GetDeadband;
		if(!g_HSIExt.g_bOfflineOnly)
		{
			pHAL->Optics.Startup = (HAL_OPTICS_STARTUP) HAL_Optics_Startup;
			pHAL->Optics.GetScaleRange = (HAL_OPTICS_GET_SCALE_RANGE) HAL_Optics_GetScaleRange;
			pHAL->Optics.GetScalePosition = (HAL_OPTICS_GET_SCALE_POSITION) HAL_Optics_GetScalePosition;
			pHAL->Optics.SetScalePosition = (HAL_OPTICS_SET_SCALE_POSITION) HAL_Optics_SetScalePosition;
			pHAL->Optics.EnableGrid = (HAL_OPTICS_ENABLE_GRID) HAL_Optics_EnableGrid;
			pHAL->Optics.IsGridEnabled = (HAL_OPTICS_IS_GRID_ENABLED) HAL_Optics_IsGridEnabled;
			pHAL->Optics.EnableLaser = (HAL_OPTICS_ENABLE_LASER) HAL_Optics_EnableLaser;
			pHAL->Optics.IsLaserEnabled = (HAL_OPTICS_IS_LASER_ENABLED) HAL_Optics_IsLaserEnabled;
			pHAL->Optics.Shutdown = (HAL_OPTICS_SHUTDOWN) HAL_Optics_Shutdown;

			// Load HSI library
			HINSTANCE OpticsLib = ::AfxLoadLibrary(_T("WAI_Optics.dll"));
			if(OpticsLib)
			{
			  //Get startup address and call startup routine
			  HAL_STARTUP Startup = (HAL_STARTUP) ::GetProcAddress(OpticsLib, "HAL_Startup");
			  if(Startup)
			  {
					//store these function pointers (WAI_Optics.dll will change these)
					HAL_SHUTDOWN    pOrginalShutdown   = pHAL->Shutdown;
					HAL_GET_VERSION pOrginalGetVersion = pHAL->GetVersion;
							
					//TKr/100924: Adaption on V1.84 (new g_lFramegrabberType)
          //if(Startup(hWnd, pHAL, bOfflineOnly, g_lFramegrabberType) == HAL_STATUS_NORMAL)
#pragma message("do we need a real framegrabber type here")
					if(Startup(hWnd, pHAL, bOfflineOnly, 0) == HAL_STATUS_NORMAL)
					{
						//restore the original function pointers
						pHAL->Shutdown									= pOrginalShutdown;
						pHAL->GetVersion								= pOrginalGetVersion;

						//store the function pointers from the WAI_Optics.dll
						//(will be used in HMV-Startup and -Shutdown)
						g_HSIExt.g_lpfnWAIOpticsStartup				= pHAL->Optics.Startup;
						g_HSIExt.g_lpfnWALOpticsShutdown			= pHAL->Optics.Shutdown;

					}
					else
					{
						Status = HAL_STATUS_FAILED;
					}
				}
				else
				{
					Status = HAL_STATUS_FAILED;
				}
      }
			else
			{
				AfxMessageBox(_T("Failed Startup"));
				Status = HAL_STATUS_FAILED;
      }
		}
	}

	// Set exported HAL LASERPROBE function addresses
	pHAL->LaserProbe.IsSupported = (HAL_LP_IS_SUPPORTED) HAL_LP_IsSupported;

	if(pHAL->LaserProbe.IsActive(true))
	{
		// HAL LASERPROBE is supported
		if(!g_HSIExt.g_bOfflineOnly)
		{
			pHAL->LaserProbe.Startup = (HAL_LP_STARTUP) HAL_LP_Startup;
			pHAL->LaserProbe.Enable = (HAL_LP_ENABLE) HAL_LP_Enable;
			pHAL->LaserProbe.IsEnabled = (HAL_LP_IS_ENABLED) HAL_LP_IsEnabled;
			pHAL->LaserProbe.GetActiveProbe = (HAL_LP_GET_ACTIVE_PROBE) HAL_LP_GetActiveProbe;
			pHAL->LaserProbe.SetActiveProbe = (HAL_LP_SET_ACTIVE_PROBE) HAL_LP_SetActiveProbe;
			pHAL->LaserProbe.SetupMeasurePoint = (HAL_LP_SETUP_MEASURE_POINT) HAL_LP_SetupMeasurePoint;
			pHAL->LaserProbe.DoMeasure = (HAL_LP_DO_MEASURE) HAL_LP_DoMeasure;
			pHAL->LaserProbe.GetMeasureData = (HAL_LP_GET_MEASURE_DATA) HAL_LP_GetMeasureData;
			pHAL->LaserProbe.Shutdown = (HAL_LP_SHUTDOWN) HAL_LP_Shutdown;
		}
	}

	// Set exported HAL TOUCHPROBE function addresses
	pHAL->TouchProbe.IsSupported = (HAL_TP_IS_SUPPORTED) HAL_TP_IsSupported;

	if(pHAL->TouchProbe.IsActive(true))
	{
		// HAL TOUCHPROBE is supported
		if(!g_HSIExt.g_bOfflineOnly)
		{
			pHAL->TouchProbe.Startup = (HAL_TP_STARTUP) HAL_TP_Startup;
			pHAL->TouchProbe.Enable = (HAL_TP_ENABLE) HAL_TP_Enable;
			pHAL->TouchProbe.GetActiveProbe = (HAL_TP_GET_ACTIVE_PROBE) HAL_TP_GetActiveProbe;
			pHAL->TouchProbe.SetActiveProbe = (HAL_TP_SET_ACTIVE_PROBE) HAL_TP_SetActiveProbe;
			pHAL->TouchProbe.SetManualTouchData = (HAL_TP_SET_MANUAL_TOUCH_DATA) HAL_TP_SetManualTouchData;
			pHAL->TouchProbe.GetTipOffset = (HAL_TP_GET_TIP_OFFSET) HAL_TP_GetTipOffset;
			pHAL->TouchProbe.SetTipOffset = (HAL_TP_SET_TIP_OFFSET) HAL_TP_SetTipOffset;
			pHAL->TouchProbe.SetupMeasurePoint = (HAL_TP_SETUP_MEASURE_POINT) HAL_TP_SetupMeasurePoint;
			pHAL->TouchProbe.DoMeasure = (HAL_TP_DO_MEASURE) HAL_TP_DoMeasure;
			pHAL->TouchProbe.IsMeasuring = (HAL_TP_IS_MEASURING) HAL_TP_IsMeasuring;
			pHAL->TouchProbe.GetMeasureData = (HAL_TP_GET_MEASURE_DATA) HAL_TP_GetMeasureData;
			pHAL->TouchProbe.Shutdown = (HAL_TP_SHUTDOWN) HAL_TP_Shutdown;
		}
	}

	// Set exported HAL FIXTURE function addresses
	pHAL->Fixture.IsSupported = (HAL_FIXTURE_IS_SUPPORTED) HAL_Fixture_IsSupported;

	if(pHAL->Fixture.IsActive(true))
	{
		// HAL FIXTURE is supported
		if(!g_HSIExt.g_bOfflineOnly)
		{
			//pHAL->Fixture.Startup = (HAL_FIXTURE_STARTUP) HAL_Fixture_Startup;
			//pHAL->Fixture.Shutdown = (HAL_FIXTURE_SHUTDOWN) HAL_Fixture_Shutdown;
		}
	}

	// Set exported HAL TOOLCHANGER function addresses
	pHAL->ToolChanger.IsSupported = (HAL_TC_IS_SUPPORTED) HAL_TC_IsSupported;

	if(pHAL->ToolChanger.IsActive(true))
	{
		// HAL TOOLCHANGER is supported
		if(!g_HSIExt.g_bOfflineOnly)
		{
			//pHAL->ToolChanger.Startup = (HAL_TC_STARTUP) HAL_TC_Startup;
			//pHAL->ToolChanger.Shutdown = (HAL_TC_SHUTDOWN) HAL_TC_Shutdown;
		}
	}

	return Status;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetMachineCount(int &NumMachines)
{
	NumMachines=HAL_NUM_MACHINE_TYPES;
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetMachineInfo(int Machine, TCHAR *MachineName, TCHAR *FirmwareVersion)
{
	switch(Machine)
	{
	case HAL_MACHINE_TYPE_EXCEL:
		wcsncpy_s(MachineName, HAL_MaxStringLength+1, _T("MicroVu Excel"), HAL_MaxStringLength);
		wcsncpy_s(FirmwareVersion, HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
		break;

	case HAL_MACHINE_TYPE_VECTRA:
		wcsncpy_s(MachineName, HAL_MaxStringLength+1, _T("MicroVu Vectra"), HAL_MaxStringLength);
		wcsncpy_s(FirmwareVersion, HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
		break;

	case HAL_MACHINE_TYPE_UNSELECTED:
	default:
		wcsncpy_s(MachineName, HAL_MaxStringLength+1, _T("Not selected"), HAL_MaxStringLength);
		wcsncpy_s(FirmwareVersion, HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
		break;
	}
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetActiveMachine(int &Machine)
{
	Machine=g_HSIExt.m_ActiveMachineType;
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_SetActiveMachine(int Machine)
{
  g_HSIExt.InitialiseMachineType((HAL_MACHINE_TYPE)Machine);
  return HAL_STATUS_NORMAL;
}


//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_SetLocale(UINT /*LCID*/)
{
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_SetRegistryRootKey(TCHAR * /*RegistryKey*/)
{
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_PreSetupDialog(CPropertySheet * /*SetupDlg*/, bool /*bOfflineSetup*/)
{
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_PostSetupDialog(CPropertySheet * /*SetupDlg*/)
{
	return HAL_STATUS_NORMAL;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Calibrate(HAL_CALIBRATE_TYPE /*Type*/)
{
	HAL_STATUS Status = HAL_STATUS_NORMAL;

	return Status;
}

//***********************************************************************************************
//
//***********************************************************************************************
HAL_STATUS HAL_Notify (HAL_NOTIFY_TYPE Type)
{
	HAL_STATUS retVal=HAL_STATUS_NORMAL;

	if(Type==HAL_NOTIFY_PROGRAM_EXECUTION_START)
	{
		TCHAR Msg[HAL_MaxStringLength+1];
		CString MsgStr;
		MsgStr.LoadString(IDS_ALIGN_ROTARY);
		wcsncpy_s(Msg, HAL_MaxStringLength+1, MsgStr, HAL_MaxStringLength);

		// Do the below event call ONLY if rotary table enabled.
		if(g_HSIExt.m_AxisEnabled[HAL_AXIS_Q] && IsRotaryEnabled())
		{
// xxxx			g_pHSI->Event(HAL_EVENT_FUNCTION, HAL_EVENT_DISPLAY_OK_MESSAGE, Msg, EventCallbackID);

			// OK - lets store the rotary offset position at this point
			if(IsBoardPresent())
			{
				// Read current position
        //long Position[4] = {0,0,0,0};
        //long Direction[4];
//        UNREFERENCED_PARAMETER(Direction);
//				bool Error[4];
//				gCncBd->getAxisInfo(Position, Direction, Error);
				//g_HSIExt.m_AxisRefMarkOffset[HAL_AXIS_Q] = Position[HAL_AXIS_Q];
			}
		}
	}
	return retVal;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetCustomCalibrationTypeInfo(HAL_CALIBRATE_TYPE /*Type*/, TCHAR * /*Name*/)
{
	HAL_STATUS Status = HAL_STATUS_NORMAL;

	return Status;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_EventResponse(UINT /*EventCallbackID*/, HAL_EVENT_RESPONSE_TYPE /*ResponseType*/)
{
	HAL_STATUS Status = HAL_STATUS_NORMAL;

	return Status;
}

//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetCustomMessage(HAL_CUSTOM_MESSAGE_TYPE Msg,TCHAR *Message)
{
	HAL_STATUS Status = HAL_STATUS_NORMAL;

	if(g_HSIExt.m_HomeManual)
	{
		CString MessageStr;
		switch(Msg)
		{
		case HAL_CUSTOM_MESSAGE_HOME_MACHINE:
			if(g_HSIExt.m_HomeToLimitSwitch)
				MessageStr.LoadString(IDS_HOME_MANUAL_MACHINE_LIMIT);
			else
				MessageStr.LoadString(IDS_HOME_MANUAL_MACHINE_REF);
			break;

		default:
			break;
		}
		wcsncpy_s(Message, HAL_MaxStringLength+1, MessageStr, HAL_MaxStringLength);
	}

	return Status;
}

///////////////////////////////////////////////////////////////////////////////
// For USB, we will initialize this 
// If it is not initialized, we will initialize the Mv_USB.
// If it is already initialized, we reply with true;
bool IsBoardPresent()
{
  return (g_pMv_Proto?true:false);
}

//////////////////////////////////////////////////////////////////////
bool IsControllerPresent()
{
//	return (IsBoardPresent() && gCncBd && gCncBd->isCncAllowed());
  return true;
}

//////////////////////////////////////////////////////////////////////
bool IsZoomMoving(void)
{
	long Zoom1=0,Zoom2=-1;

	g_pHSI->Optics.GetScalePosition(Zoom1);
	Sleep(50);
	g_pHSI->Optics.GetScalePosition(Zoom2);

	if(labs(Zoom1-Zoom2)>2)
		return true;
	else
		return false;
};

//////////////////////////////////////////////////////////////////////
bool IsRotaryEnabled(void)
{
	ASSERT(g_pHSI->Event);

	UINT EventCallbackID;
	TCHAR EventData[HAL_MaxStringLength+1];
	wcsncpy_s(EventData,HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
	HAL_EVENT_RESPONSE_TYPE EventResponse=g_pHSI->Event(HAL_EVENT_FUNCTION, HAL_EVENT_IS_ROTAB_ENABLED, EventData, EventCallbackID);
	return EventResponse==HAL_EVENT_RESPONSE_YES;
};

///////////////////////////////////////////////////////////////////////////////
void HAL_SendDebug(LPCTSTR format, ...)
{
  va_list list;
  va_start(list, format);
//  debug.SendAndFlush(format, list);
}

///////////////////////////////////////////////////////////////////////////////

double TimeInMsecs(void)
{
  double Msecs;

  LARGE_INTEGER HPCounterTicksPerSecond;
  BOOL HasHPCounter = QueryPerformanceFrequency(&HPCounterTicksPerSecond);

  if (HasHPCounter == TRUE)
  {
    // Use high resolution clock.
    double HPCounterTicksPerMsec = (DWORD)((double) HPCounterTicksPerSecond.QuadPart / 1000.0);
    LARGE_INTEGER HPTicks;
    QueryPerformanceCounter(&HPTicks);
    Msecs = ((double)HPTicks.QuadPart / HPCounterTicksPerMsec);
  }
  else
  {
    // Use clock with less resolution.
    Msecs = GetTickCount();
  }
  return Msecs;
}

///////////////////////////////////////////////////////////////////////////////