rho-tau-extensions 5.5.17

data/libs/enterprise-barcode/ext/platform/wm/src/DecodeNotifier.h

@@ -0,0 +1,149 @@
+/**
+ * \file DecodeNotifier.h
+ * \brief File containing the CDecoderNotifier definitions.
+ *  \author	Darryn Campbell (DCC)
+ *  \date	January 2012 (DCC, Initial Port from RhoElements 1 Code)
+ */
+
+#include <windows.h>
+#include "NotificationLoader.h"
+
+/**
+*  The purpose of this class is to abstract the control of the Device
+*  beeper and wave player so the Scanner instance can just indicate a
+*  good or bad decode.
+*/
+class CDecodeNotifier
+{
+public:
+	/**
+	*  Constructor, initialises variables.
+	*/
+	CDecodeNotifier();
+
+	/**
+	*  Frees memory associated with Wave file paths / names
+	*/
+	~CDecodeNotifier();
+
+	/**
+	*  Allocates memory for Wave file paths / names and initialises
+	*  variables to provided values.
+	*  \param dwDecodeVolume The volume of both good and bad decodes
+	*  \param dwDecodeFrequency The frequency of a good decode beep
+	*  \param dwInvalidDecodeFrequency The frequency of a bad decode beep
+	*  \param dwDecodeDuration The time (ms) that the beeper will sound for
+	*  \param szScanDecodeWav The Wave file to play on a good decode, this will
+	*         override the beeper settings.
+	*  \param szScanInvalidWav The wave file to play on a bad decode, this will
+	*         override the beeper settings.
+	*/
+	void Initialise(DWORD dwDecodeVolume,
+				DWORD dwDecodeFrequency,
+				DWORD dwInvalidDecodeFrequency,
+				DWORD dwDecodeDuration,
+				WCHAR* szScanDecodeWav,
+				WCHAR* szScanInvalidWav);
+	
+
+	/**
+	*  Alert the user of a good decode using either the device's beeper or
+	*  wave file, depending on configuration.
+	*/
+	BOOL GoodDecode();
+	
+	/**
+	*  Alert the user of a bad decode using eith the device's beeper or
+	*  wave file, depending on configuration.
+	*/
+	BOOL BadDecode();
+
+	/**
+	*  Accessor for m_dwDecodeVolume
+	*  \param dwVolume The new decode volume
+	*/
+	void SetDecodeVolume(DWORD dwVolume) {m_dwDecodeVolume = dwVolume;}
+
+	/**
+	*  Accessor for m_dwDecodeVolume
+	*/
+	DWORD GetDecodeVolume() {return m_dwDecodeVolume;}
+
+	/**
+	*  Accessor for m_dwDecodeDuration
+	*  \param dwDuration The new decode duration
+	*/
+	void SetDecodeDuration(DWORD dwDuration) {m_dwDecodeDuration = dwDuration;}
+
+	/**
+	*  Accessor for m_dwDecodeDuration
+	*/
+	DWORD GetDecodeDuration() {return m_dwDecodeDuration;}
+
+	/**
+	*  Accessor for m_dwDecodeFrequency
+	*  \param dwFrequency The new decode frequency
+	*/
+	void SetSuccessfulDecodeFrequency(DWORD dwFrequency) {m_dwDecodeFrequency = dwFrequency;}
+
+	/**
+	*  Accessor for m_dwDecodeFrequency
+	*/
+	DWORD GetSuccessfulDecodeFrequency() {return m_dwDecodeFrequency;}
+
+	/**
+	*  Accessor for m_dwInvalidDecodeFrequency
+	*  \param dwFrequency The new invalid decode frequency
+	*/
+	void SetInvalidDecodeFrequency(DWORD dwFrequency) {m_dwInvalidDecodeFrequency = dwFrequency;}
+
+	/**
+	*  Accessor for m_dwInvalidDecodeFrequency
+	*/
+	DWORD GetInvalidDecodeFrequency() {return m_dwInvalidDecodeFrequency;}
+
+	/**
+	*  Accessor for m_szScanDecodeWav, allocates and deallocates memory as appropriate.
+	*  \param szDecodeSound The new sound to use for a good decode, Windows only supports local file
+	*         paths to Wave files.
+	*/
+	void SetSuccessfulDecodeSound(LPCTSTR szDecodeSound);
+
+	/**
+	*  Accessor for m_szScanDecodeWav.  The returned string will be invalid once SetGoodDecodeSound
+	*  is called again.
+	*/
+	LPCTSTR GetSuccessfulDecodeSound() {return m_szScanDecodeWav;}
+
+	/**
+	*  Accessor for m_szScanInvalidWav, allocates and deallocates memory as appropriate.
+	*  \param szDecodeSound The new sound to use for a bad decode, Windows only supports local file
+	*         paths to Wave files.
+	*/
+	void SetInvalidDecodeSound(LPCTSTR szInvalidDecodeSound);
+
+	/**
+	*  Accessor for m_szScanInvalidWav.  The returned string will be invalid once 
+	*  SetInvalidDecodeSound is called again.
+	*/
+	LPCTSTR GetInvalidDecodeSound() {return m_szScanInvalidWav;}
+
+	/**
+	*  Thread to trigger a device beep at the specified volume / frequency
+	*  using the EMDK notification API
+	*  \param lParam Pointer to the CDecodeNotifier object requesting the beep
+	*/
+	static DWORD DecodeBeepThreadNotify(LPVOID lParam);
+private:
+	DWORD m_dwDecodeVolume;				///<  Decode volume for this beeper
+	DWORD m_dwDecodeDuration;			///<  Decode duration for the beeper (good and bad)
+	DWORD m_dwDecodeFrequency;			///<  Good Decode frequency for this beeper
+	DWORD m_dwInvalidDecodeFrequency;	///<  Bad Decode frequency for this beeper
+	WCHAR* m_szScanDecodeWav;			///<  Wave file to play on good decode
+	WCHAR* m_szScanInvalidWav;			///<  Wave file to play on bad decode
+	int m_iBeeperIndex;					///<  EMDK Notification API index of the device beeper
+	bool m_bGood;						///<  Whether or not the next beeper thread is for a good scan or not.
+	CBarcodeBeeper* m_pNotifications;	///<  EMDK Notifications DLL loaded dynamically
+	BOOL m_bNotificationsLoaded;		///<  Whether or not the Notifications DLL has been loaded
+};
+

data/libs/enterprise-barcode/ext/platform/wm/src/EMDKInterfaceAbstraction.cpp

@@ -0,0 +1,476 @@
+#include "Scanner.h"
+
+
+#pragma region Scanner_Properties
+
+BOOL CScanner::RetrieveScannerParameters(READER_PARAMS* pReaderParams)
+{
+	// Initialize the structure
+	memset(pReaderParams, 0, sizeof(READER_PARAMS));
+	SI_INIT(pReaderParams);
+
+	DWORD dwResult = lpfn_SCAN_GetReaderParams(m_hScanner, pReaderParams);
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to retrieve Scanner Reader Parameters, is the Scanner enabled?";
+	}
+	return (dwResult == E_SCN_SUCCESS);
+}
+
+BOOL CScanner::SetScannerParameters(READER_PARAMS* pReaderParams, DWORD dwSize)
+{
+	// Get pointer to start of params
+	LPVOID lpParams = (LPVOID)&(pReaderParams->ReaderSpecific);
+	LPDWORD lpdwParams = (LPDWORD)lpParams;
+	// Loop through all params
+	for(DWORD i = 0; i < (dwSize / sizeof(DWORD)); i++)
+	{
+		// Set this parameter into structure if it has changed
+		SI_SET_IF_CHANGED(pReaderParams,
+						  ReaderSpecific.dwUntyped[i],
+						  lpdwParams[i]);
+	}
+
+	//  Flush any pending reads before applying the Scanner Parameters.  There is a critical section
+	//  here as the read was being resubmitted after the flush before the reader parameters could be subsequently set.
+	EnterCriticalSection(&m_scanner_prop_cs);
+	DWORD dwFlushResult = lpfn_SCAN_Flush(m_hScanner);
+	DWORD dwResult = lpfn_SCAN_SetReaderParams(m_hScanner, pReaderParams);
+	LeaveCriticalSection(&m_scanner_prop_cs);
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		WCHAR szLog[128];
+		wsprintf(szLog, L"Unable to Set Scanner Reader Parameters, error: %x", dwResult);
+		LOG(WARNING) + szLog;
+	}
+	return (dwResult == E_SCN_SUCCESS);
+}
+
+BOOL CScanner::RetrieveScannerInterfaceParameters(INTERFACE_PARAMS* pInterfaceParams)
+{
+	// Initialize the structure
+	memset(pInterfaceParams, 0, sizeof(INTERFACE_PARAMS));
+	SI_INIT(pInterfaceParams);
+
+	DWORD dwResult = lpfn_SCAN_GetInterfaceParams(m_hScanner, pInterfaceParams);
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to retrieve Scanner Interface Parameters, is the Scanner enabled?";
+	}
+	return (dwResult == E_SCN_SUCCESS);
+}
+
+BOOL CScanner::SetScannerInterfaceParameters(INTERFACE_PARAMS* interfaceParams, DWORD dwSize)
+{
+	// Get pointer to start of params
+	LPVOID lpParams = (LPVOID)&(interfaceParams->InterfaceSpecific);
+	LPDWORD lpdwParams = (LPDWORD)lpParams;
+	// Loop through all params
+	for(DWORD i = 0; i < (dwSize / sizeof(DWORD)); i++)
+	{
+		// Set this parameter into structure if it has changed
+		SI_SET_IF_CHANGED(interfaceParams,
+						  InterfaceSpecific.dwUntyped[i],
+						  lpdwParams[i]);
+	}
+
+	//  Flush any pending reads before applying the Scanner Parameters
+	lpfn_SCAN_Flush(m_hScanner);
+	DWORD dwResult = lpfn_SCAN_SetInterfaceParams(m_hScanner, interfaceParams);
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to Set Scanner Reader Parameters";
+	}
+	return (dwResult == E_SCN_SUCCESS);
+}
+
+#pragma endregion
+
+#pragma region DecoderInterface
+
+//  Gets the decoders supported by the Scanner
+BOOL CScanner::RetrieveSupportedDecoders(WCHAR* szSupportedDecodersArray)
+{
+	BOOL bReturnValue = TRUE;
+	DECODER_LIST decoderList;
+	// Mark entire buffer allocated and not used
+	memset(&decoderList, 0, sizeof(DECODER_LIST));
+	SI_INIT(&decoderList);
+	wcscpy(szSupportedDecodersArray, L"new Array(");
+
+	// Get supported decoder list
+	if (lpfn_SCAN_GetSupportedDecoders(m_hScanner, &decoderList) == E_SCN_SUCCESS)
+	{
+		for(DWORD i=0; i < decoderList.Decoders.dwDecoderCount; i++)
+		{
+			if (decoderStrings[decoderList.Decoders.byList[i]])
+			{	
+				//  Only report the Decoder if we support it
+				wcscat(szSupportedDecodersArray, L"'");
+				wcscat(szSupportedDecodersArray, 
+					decoderStrings[decoderList.Decoders.byList[i]]);
+				wcscat(szSupportedDecodersArray, L"',");
+			}
+		}
+	}
+	else
+	{
+		//  Call to GetSupportedDecoders has failed
+		LOG(WARNING) + L"Unable to retrieve supported decoders";
+		bReturnValue = FALSE;
+	}
+	//  Remove the final comma in the array
+	if (szSupportedDecodersArray[wcslen(szSupportedDecodersArray) - 1] == L',')
+		szSupportedDecodersArray[wcslen(szSupportedDecodersArray) - 1] = L')';
+	else
+		wcscat(szSupportedDecodersArray, L")");
+
+	return bReturnValue;
+}
+
+BOOL CScanner::IsDecoderSupported(BYTE cDecoder)
+{
+	DECODER_LIST decoderList;
+	// Mark entire buffer allocated and not used
+	memset(&decoderList, 0, sizeof(DECODER_LIST));
+	SI_INIT(&decoderList);
+	// Get supported decoder list
+	if (lpfn_SCAN_GetSupportedDecoders(m_hScanner, &decoderList) == E_SCN_SUCCESS)
+	{
+		for(DWORD i=0; i < decoderList.Decoders.dwDecoderCount; i++)
+		{
+			if (decoderList.Decoders.byList[i] == cDecoder)
+			{
+				return TRUE;
+			}
+		}
+	}
+	return FALSE;
+}
+
+BOOL CScanner::EnableDecoder(BYTE cDecoder)
+{
+	BOOL bRetVal = FALSE;
+	if (IsDecoderSupported(cDecoder))
+	{
+		DECODER_LIST decoderList;
+		DWORD dwResult;
+		// Mark entire buffer allocated, and not used
+		memset(&decoderList, 0, sizeof(DECODER_LIST));
+		SI_INIT(&decoderList);
+
+		// Get enabled decoder list
+		dwResult = lpfn_SCAN_GetEnabledDecoders(m_hScanner, &decoderList);
+		if (dwResult == E_SCN_SUCCESS)
+		{
+			//  Check we haven't already enabled the decoder
+			for(DWORD i = 0; i < decoderList.Decoders.dwDecoderCount; i++)
+			{
+				if (decoderList.Decoders.byList[i] == cDecoder)
+				{
+					//  The decoder is already enabled, alert the user and do nothing
+					if (decoderStrings[cDecoder])
+					{
+						WCHAR wLog[MAXLOG];
+						wsprintf(wLog, L"Attempted to enable the decoder %s but it is already enabled", 
+							decoderStrings[cDecoder]);
+						LOG(INFO) + wLog;
+					}
+					return bRetVal;
+				}
+			}
+			decoderList.Decoders.byList[decoderList.Decoders.dwDecoderCount++] = cDecoder;
+			dwResult = lpfn_SCAN_SetEnabledDecoders(m_hScanner,&decoderList);
+			if (dwResult != E_SCN_SUCCESS)
+			{
+				LOG(WARNING) + L"Unable to set Enabled Decoders";
+			}
+			else
+				bRetVal = TRUE;
+		}
+		else
+		{
+			//	Unable to retrieve the enabled decoders
+			LOG(WARNING) + L"Unable to retrieve enabled decoders";
+		}		
+	}
+	else
+	{
+		//  Attempted to enable an unsupported decoder
+		WCHAR wLog[MAXLOG];
+		if (decoderStrings[cDecoder])
+		{
+			wsprintf(wLog, L"Decoder %s is not supported on this device, unable to Enable it", 
+				decoderStrings[cDecoder]);
+			LOG(WARNING) + wLog;
+		}
+	}
+	return bRetVal;
+}
+
+BOOL CScanner::DisableDecoder(BYTE cDecoder)
+{
+	BOOL bRetVal = FALSE;
+	if (IsDecoderSupported(cDecoder))
+	{
+		DECODER_LIST decoderList;
+		DWORD dwResult;
+		// Mark entire buffer allocated, and not used
+		memset(&decoderList, 0, sizeof(DECODER_LIST));
+		SI_INIT(&decoderList);
+		bool bFoundDecoder = false;
+
+		// Get enabled decoder list
+		dwResult = lpfn_SCAN_GetEnabledDecoders(m_hScanner, &decoderList);
+		if (dwResult == E_SCN_SUCCESS)
+		{
+			//  Check we haven't already enabled the decoder
+			for(DWORD i = 0; i < decoderList.Decoders.dwDecoderCount; i++)
+			{
+				if (decoderList.Decoders.byList[i] == cDecoder)
+				{
+					//  The decoder is already enabled
+					memcpy(decoderList.Decoders.byList + i,
+						decoderList.Decoders.byList + (i + 1),
+						decoderList.Decoders.dwDecoderCount - (i - 1));
+						decoderList.Decoders.dwDecoderCount--;
+					bFoundDecoder = true;
+				}
+			}
+			//  Check the decoder was enabled
+			if (!bFoundDecoder)
+			{
+				if (decoderStrings[cDecoder])
+				{
+					WCHAR wLog[MAXLOG];
+					wsprintf(wLog, L"Decoder %s is not enabled, therefore unable to disable it", 
+						decoderStrings[cDecoder]);
+					LOG(INFO) + wLog;
+				}
+			}
+			else
+			{
+				//  The decoder is enabled, disable it (decoderList updated earlier)
+				dwResult = lpfn_SCAN_SetEnabledDecoders(m_hScanner, &decoderList);
+				if (dwResult != E_SCN_SUCCESS)
+				{
+					LOG(WARNING) + L"Unable to set Enabled Decoders";
+				}
+				else
+					bRetVal = TRUE;
+			}
+		}
+		else
+		{
+			//	Unable to retrieve the enabled decoders
+			LOG(WARNING) + L"Unable to retrieve enabled decoders";
+		}		
+	}
+	else
+	{
+		//  Attempted to disable an unsupported decoder
+		if (decoderStrings[cDecoder])
+		{
+			WCHAR wLog[MAXLOG];
+			wsprintf(wLog, L"Decoder %s is not supported on this device, unable to Disable it", 
+				decoderStrings[cDecoder]);
+			LOG(WARNING) + wLog;
+		}
+	}
+	return bRetVal;
+}
+
+//  Retrieve the current parameters for the specified decoder.  lpvParams is an out parameter
+BOOL CScanner::RetrieveDecoderParams(BYTE cDecoder, LPVOID lpvParams, DWORD dwSize)
+{
+	BOOL bRetVal = TRUE;
+	DECODER_PARAMS decoder_params;
+	memset(&decoder_params,sizeof(decoder_params),0);
+	SI_INIT(&decoder_params);
+
+	// Initialize the out parameter in pvParams
+	memset(lpvParams, 0, dwSize);
+	// Initialize the structure to all zeroes
+	memset(&decoder_params,sizeof(decoder_params), 0);
+	
+	// Get current decoder parameters
+	DWORD dwResult = lpfn_SCAN_GetDecoderParams(m_hScanner, (LPDECODER)&cDecoder, &decoder_params);
+
+	// If there was an error getting the parameters
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to retrieve Scanner Decoder Parameters, is the Scanner enabled and the Decoder supported?";
+		bRetVal = FALSE;
+	}
+	else
+	{
+		// Get pointer to start of params
+		LPDWORD lpdwParams = (LPDWORD)lpvParams;
+
+		// Loop through all params and retrieve them
+		for(DWORD i = 0; i < (dwSize / sizeof(DWORD)); i++)
+		{
+			SI_GET_FIELD(&decoder_params, dec_specific.dwUntyped[i], lpdwParams[i]);
+		}
+	}
+
+	return bRetVal;
+}
+
+//  Sets the specified decoder's parameters to those provided in lpvParams
+BOOL CScanner::SetDecoderParams(BYTE cDecoder, LPVOID lpvParams, DWORD dwSize)
+{
+	BOOL bRetVal = TRUE;
+	DECODER_PARAMS decoder_params;
+	// Mark entire buffer allocated and not used
+	memset(&decoder_params,sizeof(decoder_params),0);
+	SI_INIT(&decoder_params);
+	
+	// Get current decoder parameters
+	DWORD dwResult = lpfn_SCAN_GetDecoderParams(m_hScanner,
+									 (LPDECODER)&cDecoder,
+									 &decoder_params);
+
+	// If there was an error getting the parameters
+	if ( dwResult != E_SCN_SUCCESS )
+	{
+		LOG(WARNING) + L"Unable to retrieve decoder parameters";
+		bRetVal = FALSE;
+	}
+	else
+	{
+		// Get pointer to start of params
+		LPDWORD lpdwParams = (LPDWORD)lpvParams;
+
+		// Loop through all params
+		for(DWORD i = 0; i < (dwSize / sizeof(DWORD)); i++)
+		{
+			// Set this parameter into structure if it has changed
+			SI_SET_IF_CHANGED(&decoder_params,
+							  dec_specific.dwUntyped[i],
+							  lpdwParams[i]);
+		}
+
+		// Return the result of setting parameters
+		dwResult = lpfn_SCAN_SetDecoderParams(m_hScanner,
+									 (LPDECODER)&cDecoder,
+									 &decoder_params);
+		if (dwResult != E_SCN_SUCCESS)
+		{
+			LOG(WARNING) + L"Unable to set decoder parameters";
+			bRetVal = FALSE;
+		}
+	}
+	return bRetVal;
+}
+
+//  Set iMinLength or iMaxLength to -1 if you do not wish to modify them
+//  Sets the Maximum or Minimum length of the specified decoder
+BOOL CScanner::SetDecoderLengths(BYTE cDecoder, int iMinLength, int iMaxLength)
+{
+	BOOL bRetVal = TRUE;
+	DECODER_PARAMS decoder_params;
+	memset(&decoder_params,sizeof(decoder_params), 0);
+	SI_INIT(&decoder_params);
+
+	// Get current decoder parameters
+	DWORD dwResult = lpfn_SCAN_GetDecoderParams(m_hScanner,
+									 (LPDECODER)&cDecoder,
+									 &decoder_params);
+
+	// If there was an error getting the parameters
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to retrieve the current Decoder Parameters";
+		bRetVal = FALSE;
+	}
+	else
+	{
+		// Set all parameters into structure if changed
+		if (iMinLength >= 0)
+			SI_SET_IF_CHANGED(&decoder_params, dwMinLength, (DWORD)iMinLength);
+		if (iMaxLength >= 0)
+			SI_SET_IF_CHANGED(&decoder_params, dwMaxLength, (DWORD)iMaxLength);
+
+		// Return the result of setting parameters
+		dwResult = (lpfn_SCAN_SetDecoderParams(m_hScanner,
+									 (LPDECODER)&cDecoder,
+									 &decoder_params));
+		if (dwResult != E_SCN_SUCCESS)
+		{
+			LOG(WARNING) + L"Unable to Set current Decoder Parameters";
+			bRetVal = FALSE;
+		}
+	}
+	return bRetVal;
+}
+
+//  Return the maximum or minimum length of the specified decoder
+int CScanner::GetDecoderLength(BYTE cDecoder, bool bMinLength)
+{
+	int iRetVal = -1;
+	DECODER_PARAMS decoder_params;
+	memset(&decoder_params,sizeof(decoder_params), 0);
+	SI_INIT(&decoder_params);
+
+	// Get current decoder parameters
+	DWORD dwResult = lpfn_SCAN_GetDecoderParams(m_hScanner,
+									 (LPDECODER)&cDecoder,
+									 &decoder_params);
+
+	// If there was an error getting the parameters
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to retrieve the current Decoder Parameters";
+		iRetVal = -1;
+	}
+	else
+	{
+		if (bMinLength)
+			iRetVal = decoder_params.dwMinLength;
+		else
+			iRetVal = decoder_params.dwMaxLength;
+	}
+	return iRetVal;
+}
+
+
+//  Retrieve the UPC EAN parameters.  lpParams is an out parameter
+BOOL CScanner::RetrieveUPCEANParams(LPUPC_EAN_PARAMS lpParams)
+{
+	BOOL bRetVal = TRUE;
+	//  Initialise params structure to return
+	SI_INIT(lpParams);
+
+	//  Get current parameters
+	DWORD dwResult = lpfn_SCAN_GetUPCEANParams(m_hScanner, lpParams);
+
+	// If there was an error getting the parameters
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to retrieve UPC EAN Parameters";
+		bRetVal = FALSE;
+	}
+
+	return bRetVal;
+}
+
+BOOL CScanner::SetUPCEANParams(LPUPC_EAN_PARAMS lpParams)
+{
+	BOOL bRetVal = TRUE;
+	SI_ALLOC_ALL(lpParams);
+
+	//  Set parameters
+	DWORD dwResult = lpfn_SCAN_SetUPCEANParams(m_hScanner, lpParams);
+
+	// If there was an error setting the parameters
+	if (dwResult != E_SCN_SUCCESS)
+	{
+		LOG(WARNING) + L"Unable to set UPC EAN Parameters";
+		bRetVal = FALSE;
+	}
+
+	return bRetVal;
+}
+
+#pragma endregion