//------------------------------------------------------------------*
HRESULT CControlMgt::DoSimpleCommand(UINT uCmd, UINT uTrials)
{
HRESULT hr = S_OK;
if(uTrials == 1)
{
UINT uLen = 0;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
hr = myConnection.TransferData(FALSE, uCmd, &pData, &uLen);
if (pData)
{
HEAP_FREE(pData, uLen);
}
}
else
{
UINT uResult = (UINT)-1;
for (IEC_UINT uCount = 0; SUCCEEDED(hr) && uResult != 0 && uCount < uTrials; uCount++)
{
UINT uLen = sizeof(IEC_UINT);
BYTE *pData = NULL;
if (uCount > 0) {
SleepEx(100, TRUE);
}
HEAP_ALLOC(pData, uLen);
*(IEC_UINT*)pData = TRANSLATE_SHORT(uCount);
hr = myConnection.TransferData(FALSE, uCmd, &pData, &uLen);
if (SUCCEEDED(hr) && uLen < sizeof(IEC_UINT)) {
hr = E_FAIL;
}
if (SUCCEEDED(hr)) {
uResult = TRANSLATE_SHORT(*(IEC_UINT *)pData);
}
HEAP_FREE(pData, uLen);
}
if (uCount == uTrials)
{
hr = E_FAIL;
}
}
return hr;
}
STDMETHODIMP
CControlMgt::ProjectDownload(/*[in]*/ SAFEARRAY/*(unsigned char)*/ **ppDataDown)
{
HRESULT hr;
unsigned char HUGEP *parr;
// Get a pointer to the elements of the array.
hr = ::SafeArrayAccessData(*ppDataDown, (void HUGEP**)&parr);
if(FAILED(hr))
{
return hr;
}
UINT uLen = ((*ppDataDown)->rgsabound[0]).cElements;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
memcpy(pData, parr, uLen);
::SafeArrayUnaccessData(*ppDataDown);
hr = myConnection.TransferData(FALSE, CMD_SAVE_PROJECT, &pData, &uLen);
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
BOOL
arrowAdd( SDWORD iBaseX, SDWORD iBaseY, SDWORD iBaseZ,
SDWORD iHeadX, SDWORD iHeadY, SDWORD iHeadZ, UBYTE iColour )
{
ARROW *psArrow;
if ( !HEAP_ALLOC( g_psArrowHeap, &psArrow) )
{
return FALSE;
}
/* ivis y,z swapped */
psArrow->vecBase.x = iBaseX;
psArrow->vecBase.y = iBaseZ;
psArrow->vecBase.z = iBaseY;
psArrow->vecHead.x = iHeadX;
psArrow->vecHead.y = iHeadZ;
psArrow->vecHead.z = iHeadY;
psArrow->iColour = iColour;
/* add to list */
psArrow->psNext = g_psArrowList;
g_psArrowList = psArrow;
}
static void GetDNSPrefixes(StringTimeNode **head)
{
DWORD dwRetVal = 0;
ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
ULONG family = AF_UNSPEC;
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
ULONG outBufLen = 0;
PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
outBufLen = sizeof(IP_ADAPTER_ADDRESSES);
pAddresses = (IP_ADAPTER_ADDRESSES *)HEAP_ALLOC(outBufLen);
if (pAddresses == NULL)
return;
// Make an initial call to GetAdaptersAddresses to get the
// size needed into the outBufLen variable
ULONG ret = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
if (ERROR_BUFFER_OVERFLOW == ret) {
HEAP_FREE(pAddresses);
pAddresses = (IP_ADAPTER_ADDRESSES *) HEAP_ALLOC(outBufLen);
}
if (pAddresses == NULL)
return;
dwRetVal = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
if (dwRetVal == NO_ERROR) {
pCurrAddresses = pAddresses;
while (pCurrAddresses) {
WCHAR *dnsSuffix = pCurrAddresses->DnsSuffix;
if (dnsSuffix && *dnsSuffix) {
char *dnsSuffix2 = WstrToUtf8(dnsSuffix);
StringTimeNodeAllocAndInsert(head, dnsSuffix2);
free(dnsSuffix2);
}
pCurrAddresses = pCurrAddresses->Next;
}
}
HEAP_FREE(pAddresses);
return;
}
STDMETHODIMP
CControlMgt::ProjectUpload(/*[out]*/ SAFEARRAY/*(unsigned char)*/ **ppDataUp)
{
HRESULT hr = S_OK;
UINT uLen = 0;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
hr = myConnection.TransferData(FALSE, CMD_LOAD_PROJECT, &pData, &uLen);
if (hr!=S_OK)
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
SAFEARRAYBOUND Bound;
Bound.lLbound = 0;
Bound.cElements = uLen;
(*ppDataUp) = ::SafeArrayCreate(VT_UI1, 1, &Bound);
if (NULL == (*ppDataUp))
{
return E_FAIL;
}
long lIndex = 0;
for(lIndex = 0; lIndex<(long)uLen; lIndex++)
{
unsigned char ch = pData[lIndex];
hr = ::SafeArrayPutElement((*ppDataUp), &lIndex,
(void*)(&ch));
if (FAILED(hr))
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
}
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
// create a new group
BOOL grpCreate(DROID_GROUP **ppsGroup)
{
if (!HEAP_ALLOC(psGrpHeap, ppsGroup))
{
return FALSE;
}
(*ppsGroup)->type = GT_NORMAL;
(*ppsGroup)->refCount = 0;
(*ppsGroup)->psList = NULL;
(*ppsGroup)->psCommander = NULL;
memset(&(*ppsGroup)->sRunData, 0, sizeof(RUN_DATA));
return TRUE;
}
/*************************************************************************
* 5. Definition of external functions
*************************************************************************/
ADBG_Case_t *ADBG_Case_New(
const ADBG_Case_SuiteEntry_t *SuiteEntry_p,
ADBG_SuiteData_t *SuiteData_p
)
{
ADBG_Case_t *Case_p;
Case_p = HEAP_ALLOC(ADBG_Case_t);
if (Case_p == NULL)
return NULL;
memset(Case_p, 0, sizeof(ADBG_Case_t));
Case_p->SuiteEntry_p = SuiteEntry_p;
Case_p->SuiteData_p = SuiteData_p;
return Case_p;
}
STDMETHODIMP
CControlMgt::SaveFile(/*[in, string]*/ BSTR sName, /*[in]*/ SAFEARRAY/*(unsigned char)*/ **ppData)
{
HRESULT hr;
unsigned char HUGEP *parr;
CString strName = sName;
// Get a pointer to the elements of the array.
hr = ::SafeArrayAccessData(*ppData, (void HUGEP**)&parr);
if(FAILED(hr))
{
return hr;
}
UINT uLenData = ((*ppData)->rgsabound[0]).cElements;
UINT uLenString = strName.GetLength() + 1;
UINT uLen = uLenData + uLenString;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
strcpy((char*)pData, strName);
pData[uLenString-1] = 0;
memcpy(&(pData[uLenString]), parr, uLenData);
::SafeArrayUnaccessData(*ppData);
hr = myConnection.TransferData(FALSE, CMD_SAVE_FILE, &pData, &uLen);
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
// IpType : 0 : IPV6 and IPV4; 4:IPV4; 6:IPV6
U32 CDeviceMgr_i::GetAdapterInfo(NET_ADAPTER_INFO AdapterList[10],U8& AdapterListCnt, U8 IpType)
{
U32 ret = ERR_OK_I;
//DWORD dwSize = 0;
//DWORD dwRetVal = 0;
int i = 0;
// Set the flags to pass to GetAdaptersAddresses
ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
// default to unspecified address family (both)
ULONG family = AF_UNSPEC;
//LPVOID lpMsgBuf = NULL;
PIP_ADAPTER_ADDRESSES pAddresses = NULL;
//ULONG outBufLen = 0;
PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = NULL;
IP_ADAPTER_PREFIX *pPrefix = NULL;
if (IpType == 4)
family = AF_INET;
else if (IpType == 6)
family = AF_INET6;
else
family = AF_UNSPEC;
ULONG uListSize = sizeof(g_buffer); // max. 10 adpater
//int nAdapterIndex = 0;
bool bDeleteBuffer = FALSE;
pAddresses = (PIP_ADAPTER_ADDRESSES)g_buffer;
AdapterListCnt = 0;
DWORD dwRet = GetAdaptersAddresses(family, flags, NULL, pAddresses, &uListSize);
if (dwRet == ERROR_NO_DATA) // No adapter information exists for the local computer.
{
TRACE_I(_T("** No adapter information exists for the local computer!\n"));
ret = ERR_NO_ADAPTER_I;
}
else if (dwRet == ERROR_BUFFER_OVERFLOW)
{
pAddresses = (PIP_ADAPTER_ADDRESSES)HEAP_ALLOC(uListSize);
bDeleteBuffer = TRUE;
dwRet = GetAdaptersAddresses(family, flags, NULL, pAddresses, &uListSize);
if(pAddresses == NULL)
return ERR_NO_MORE_MEMORY_I;
}
else if(dwRet == ERROR_INVALID_PARAMETER)
{
ret = ERR_INVALID_PARAM_I;
}
else
{
ret = ERR_WIN32_ERROR_I;
}
TCHAR buff[256];
//DWORD bufflen = 256;
if (dwRet == ERROR_SUCCESS)
{
ret = ERR_OK_I;
pCurrAddresses = pAddresses;
U8 ulIdx = 0;
while (pCurrAddresses)
{
if(ulIdx >= 10)
break;
NET_ADAPTER_INFO* pAdapterList = (NET_ADAPTER_INFO*)&AdapterList[ulIdx++];
AdapterListCnt = ulIdx;
//printf("\tLength of the IP_ADAPTER_ADDRESS struct: %ld\n", pCurrAddresses->Length);
pAdapterList->IfIndex = pCurrAddresses->IfIndex;
//printf("\tIfIndex (IPv4 interface): %u\n", pCurrAddresses->IfIndex); // Specifies the index of the interface with which these addresses are associated.
#ifdef HAVE_UNICODE_I
mbs2wcsz(buff, sizeof(buff), pCurrAddresses->AdapterName);
StrCpyN(pAdapterList->szAdapterName,buff, sizeof(pAdapterList->szAdapterName));
#else
StrCpyN(pAdapterList->szAdapterName, pCurrAddresses->AdapterName, sizeof(pAdapterList->szAdapterName));
#endif
//printf("\tAdapter name: %s\n", pCurrAddresses->AdapterName);
pAdapterList->bWirelessCard = IsWirelessCard(pAdapterList->szAdapterName);
#ifdef HAVE_UNICODE_I
StrCpyN(pAdapterList->szDnsSuffix, pCurrAddresses->DnsSuffix, sizeof(pAdapterList->szDnsSuffix));
#else
wcs2mbsz(buff, sizeof(buff), pCurrAddresses->DnsSuffix);
//printf("\tDNS Suffix: %s\n", buff);
StrCpyN(pAdapterList->szDnsSuffix, buff, sizeof(pAdapterList->szDnsSuffix));
#endif
#ifdef HAVE_UNICODE_I
StrCpyN(pAdapterList->szDescription, pCurrAddresses->Description, sizeof(pAdapterList->szDescription));
#else
wcs2mbsz(buff, sizeof(buff), pCurrAddresses->Description);
StrCpyN(pAdapterList->szDescription, buff, sizeof(pAdapterList->szDescription));
#endif
//_tprintf(_T("\tDescription: %s\n"), pAdapterList->szDescription);
#ifdef HAVE_UNICODE_I
StrCpyN(pAdapterList->szConnectionName, pCurrAddresses->FriendlyName, sizeof(pAdapterList->szConnectionName));
#else
wcs2mbsz(buff, sizeof(buff), pCurrAddresses->FriendlyName);
StrCpyN(pAdapterList->szConnectionName, buff, sizeof(pAdapterList->szConnectionName));
#endif
//printf("\tFriendly name: %s\n", buff);
pUnicast = pCurrAddresses->FirstUnicastAddress;
if (pUnicast != NULL)
{
for (i = 0; pUnicast != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pUnicast->Address, i, pAdapterList->UnicastAddr) == FALSE)
break;
//printf("\tIP Address(Unicast Addresses): %s \n", buff);
pUnicast = pUnicast->Next;
}
pAdapterList->UnicastAddrCnt = (u8)(i&0x0FF);
//printf("\tNumber of Unicast Addresses: %d\n", i);
}
else
{
pAdapterList->UnicastAddrCnt = 0;
//printf("\tNo Unicast Addresses\n");
}
pAnycast = pCurrAddresses->FirstAnycastAddress;
if (pAnycast)
{
for (i = 0; pAnycast != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pAnycast->Address, i, pAdapterList->AnycastAddr) == FALSE)
break;
//printf("\tIP Address(Anycast Addresses): %s \n", buff);
pAnycast = pAnycast->Next;
}
//printf("\tNumber of Anycast Addresses: %d\n", i);
pAdapterList->AnycastAddrCnt = (u8)(i&0x0FF);
}
else
{
pAdapterList->AnycastAddrCnt = 0;
// printf("\tNo Anycast Addresses\n");
}
pMulticast = pCurrAddresses->FirstMulticastAddress;
if (pMulticast)
{
for (i = 0; pMulticast != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pMulticast->Address, i, pAdapterList->MulticastAddr) == FALSE)
break;
//printf("\tIP Address(Multicast Addresses): %s \n", buff);
pMulticast = pMulticast->Next;
}
pAdapterList->MulticastAddrCnt = (u8)(i&0x0FF);
//printf("\tNumber of Multicast Addresses: %d\n", i);
}
else
{
//printf("\tNo Multicast Addresses\n");
pAdapterList->MulticastAddrCnt = 0;
}
pDnServer = pCurrAddresses->FirstDnsServerAddress;
if (pDnServer)
{
for (i = 0; pDnServer != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pDnServer->Address, i, pAdapterList->DnsServer) == FALSE)
break;
//printf("\tIP Address(DNS Server): %s \n", buff);
pDnServer = pDnServer->Next;
}
pAdapterList->DnsServerCnt = (u8)(i&0x0FF);
//printf("\tNumber of DNS Server Addresses: %d\n", i);
}
else
{
//printf("\tNo DNS Server Addresses\n");
pAdapterList->DnsServerCnt = 0;
}
pPrefix = pCurrAddresses->FirstPrefix;
if (pPrefix)
{
for (i = 0; pPrefix != NULL; i++)
{
if(i>=0xFF)
break;
if(FillIpAddr(buff, pPrefix->Address, i, pAdapterList->PrefixAddr) == FALSE)
break;
pPrefix = pPrefix->Next;
}
pAdapterList->PrefixAddrCnt = (u8)(i&0x0FF);
}
else
{
pAdapterList->PrefixAddrCnt = 0;
//printf("\tNo IP Adapter Prefix entries\n");
}
pAdapterList->uMacAddressLen = 0;
pAdapterList->uMacAddress[0] = 0;
if (pCurrAddresses->PhysicalAddressLength != 0)
{
pAdapterList->uMacAddressLen = (u8)(pCurrAddresses->PhysicalAddressLength);
memcpy(pAdapterList->uMacAddress, pCurrAddresses->PhysicalAddress, pAdapterList->uMacAddressLen);
FormatMACToStr(pAdapterList->szMacAddr, pCurrAddresses->PhysicalAddress, pCurrAddresses->PhysicalAddressLength);
}
/*
IP_ADAPTER_DDNS_ENABLED(0x01) Dynamic DNS is enabled on this adapter.
IP_ADAPTER_REGISTER_ADAPTER_SUFFIX (0x02) Register the DNS suffix for this adapter.
IP_ADAPTER_DHCP_ENABLED (0x04) Dynamic Host Configuration Protocol is enabled on this adapter.
*/
//printf("\tFlags: %ld\n", pCurrAddresses->Flags);
pAdapterList->Flags = pCurrAddresses->Flags;
pAdapterList->bDhcpEnabled = (pCurrAddresses->Flags&IP_ADAPTER_DHCP_ENABLED) ? TRUE:FALSE;
pAdapterList->bDDNSEnabled = (pCurrAddresses->Flags&IP_ADAPTER_DDNS_ENABLED) ? TRUE:FALSE;
pAdapterList->Mtu = pCurrAddresses->Mtu;
//printf("\tMtu: %lu Bytes\n", pCurrAddresses->Mtu); // Specifies the maximum transmission unit (MTU), in bytes.
/*
#define MIB_IF_TYPE_OTHER 1
#define MIB_IF_TYPE_ETHERNET 6
#define MIB_IF_TYPE_TOKENRING 9
#define MIB_IF_TYPE_FDDI 15
#define MIB_IF_TYPE_PPP 23
#define MIB_IF_TYPE_LOOPBACK 24
#define MIB_IF_TYPE_SLIP 28
*/
pAdapterList->IfType = pCurrAddresses->IfType;
//printf("\tIfType: %ld\n", pCurrAddresses->IfType); // Specifies the type of interface using the values defined by the Internet Assigned Numbers Authority (IANA).
if(pCurrAddresses->IfType == MIB_IF_TYPE_ETHERNET)
{
pAdapterList->bEthernetCard = TRUE;
pAdapterList->bPhysicalCard = TRUE;
}
else
{
pAdapterList->bEthernetCard = FALSE;
pAdapterList->bPhysicalCard = FALSE;
}
/*
// OperStatus values from RFC 2863
typedef enum {
IfOperStatusUp = 1,
IfOperStatusDown,
IfOperStatusTesting,
IfOperStatusUnknown,
IfOperStatusDormant,
IfOperStatusNotPresent,
IfOperStatusLowerLayerDown
} IF_OPER_STATUS; */
pAdapterList->OperStatus = pCurrAddresses->OperStatus;
if(pCurrAddresses->OperStatus==IfOperStatusUp)
{
pAdapterList->bConnected = TRUE;
}
else if(pCurrAddresses->OperStatus==IfOperStatusDown)
{
pAdapterList->bConnected = FALSE;
}
//printf("\tOperStatus: %ld\n", pCurrAddresses->OperStatus);
// Specifies the operational status of the interface
pAdapterList->Ipv6IfIndex = pCurrAddresses->Ipv6IfIndex;
//printf("\tIpv6IfIndex (IPv6 interface): %u\n", pCurrAddresses->Ipv6IfIndex);
// printf("\tZoneIndices (hex): ");
// for (i = 0; i < 16; i++)
// {
// printf("%lx ", pCurrAddresses->ZoneIndices[i]);
// }
// printf("\n");
pCurrAddresses = pCurrAddresses->Next;
} // while
}
else if (dwRet == ERROR_NO_DATA) // No adapter information exists for the local computer.
{
TRACE_I(_T("*** No adapter information exists for the local computer!\n"));
ret = ERR_NO_ADAPTER_I;
}
else if (dwRet == ERROR_BUFFER_OVERFLOW)
{
ret = ERR_NO_MORE_MEMORY_I;
}
else if(dwRet == ERROR_INVALID_PARAMETER)
{
ret = ERR_INVALID_PARAM_I;
}
else
{
ret = ERR_WIN32_ERROR_I;
}
if(bDeleteBuffer && pAddresses)
{
HEAP_FREE(pAddresses);
}
return ret;
}
STDMETHODIMP
CControlMgt::ProjectInfoUpload(/*[out, string]*/ BSTR* psProjVers,
/*[out, string]*/ BSTR* psProjName,
/*[out, string]*/ BSTR* psModified,
/*[out, string]*/ BSTR* psCreated,
/*[out, string]*/ BSTR* psOwner,
/*[out, string]*/ BSTR* psComment1,
/*[out, string]*/ BSTR* psComment2,
/*[out, string]*/ BSTR* psComment3)
{
HRESULT hr = S_OK;
CString strProjVers;
CString strProjName;
CString strModified;
CString strCreated;
CString strOwner;
CString strComment1;
CString strComment2;
CString strComment3;
if (psProjVers == NULL ||
psProjName == NULL ||
psModified == NULL ||
psCreated == NULL ||
psOwner == NULL ||
psComment1 == NULL ||
psComment2 == NULL ||
psComment3 == NULL)
{
return E_POINTER;
}
*psProjVers = NULL;
*psProjName = NULL;
*psModified = NULL;
*psCreated = NULL;
*psOwner = NULL;
*psComment1 = NULL;
*psComment2 = NULL;
*psComment3 = NULL;
UINT uLen = 0;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
hr = myConnection.TransferData(FALSE, CMD_GET_PROJ_INFO, &pData, &uLen);
if (uLen < sizeof(XProjInfo))
{
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
try
{
XProjInfo* pPI = (XProjInfo*)pData;
strProjVers = pPI->szProjVers;
strProjName = pPI->szProjName;
strModified = pPI->szModified;
strCreated = pPI->szCreated;
strOwner = pPI->szOwner;
strComment1 = pPI->szComment1;
strComment2 = pPI->szComment2;
strComment3 = pPI->szComment3;
*psProjVers = strProjVers.AllocSysString();
*psProjName = strProjName.AllocSysString();
*psModified = strModified.AllocSysString();
*psCreated = strCreated.AllocSysString();
*psOwner = strOwner.AllocSysString();
*psComment1 = strComment1.AllocSysString();
*psComment2 = strComment2.AllocSysString();
*psComment3 = strComment3.AllocSysString();
}
catch (CMemoryException* e)
{
e->Delete();
if (*psProjVers)
{
SysFreeString(*psProjVers);
}
if (*psProjName)
{
SysFreeString(*psProjName);
}
if (*psModified)
{
SysFreeString(*psModified);
}
if (*psCreated)
{
SysFreeString(*psCreated);
}
if (*psOwner)
{
SysFreeString(*psOwner);
}
if (*psComment1)
{
SysFreeString(*psComment1);
}
if (*psComment2)
{
SysFreeString(*psComment2);
}
if (*psComment3)
{
SysFreeString(*psComment3);
}
hr = E_OUTOFMEMORY;
}
}
HEAP_FREE(pData, uLen);
return hr;
}
//=======================================================================
// interface ICustOnlCmds
//=======================================================================
//------------------------------------------------------------------*
STDMETHODIMP
CControlMgt::CustDownUpLoad(/*[in]*/ SAFEARRAY/*(unsigned char)*/ **ppDataDown,
/*[out]*/ SAFEARRAY/*(unsigned char)*/ **ppDataUp)
{
HRESULT hr;
unsigned char HUGEP *parr;
// Get a pointer to the elements of the array.
hr = ::SafeArrayAccessData(*ppDataDown, (void HUGEP**)&parr);
if(FAILED(hr))
{
return hr;
}
UINT uLen = ((*ppDataDown)->rgsabound[0]).cElements;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
memcpy(pData, parr, uLen);
::SafeArrayUnaccessData(*ppDataDown);
hr = myConnection.TransferData(FALSE, CMD_CUSTOM, &pData, &uLen);
if (hr!=S_OK)
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
SAFEARRAYBOUND Bound;
Bound.lLbound = 0;
Bound.cElements = uLen;
(*ppDataUp) = ::SafeArrayCreate(VT_UI1, 1, &Bound);
if (NULL == (*ppDataUp))
{
return E_FAIL;
}
long lIndex = 0;
for(lIndex = 0; lIndex<(long)uLen; lIndex++)
{
unsigned char ch = pData[lIndex];
hr = ::SafeArrayPutElement((*ppDataUp), &lIndex,
(void*)(&ch));
if (FAILED(hr))
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
}
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
STDMETHODIMP
CControlMgt::LoadFile(/*[in, string]*/ BSTR sName, /*[out]*/ SAFEARRAY/*(unsigned char)*/ **ppData)
{
HRESULT hr;
CString strName = sName;
UINT uLen= strName.GetLength() + 1;
BYTE *pData = NULL;
HEAP_ALLOC(pData, uLen);
strcpy((char*)pData, strName);
pData[uLen-1] = 0;
hr = myConnection.TransferData(FALSE, CMD_LOAD_FILE, &pData, &uLen);
if (hr!=S_OK)
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
SAFEARRAYBOUND Bound;
Bound.lLbound = 0;
Bound.cElements = uLen;
(*ppData) = ::SafeArrayCreate(VT_UI1, 1, &Bound);
if (NULL == (*ppData))
{
return E_FAIL;
}
long lIndex = 0;
for(lIndex = 0; lIndex<(long)uLen; lIndex++)
{
unsigned char ch = pData[lIndex];
hr = ::SafeArrayPutElement((*ppData), &lIndex,
(void*)(&ch));
if (FAILED(hr))
{
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
}
if (pData)
{
HEAP_FREE(pData, uLen);
}
return hr;
}
/* Create a button widget data structure */
BOOL buttonCreate(W_BUTTON **ppsWidget, W_BUTINIT *psInit)
{
if (psInit->style & ~(WBUT_PLAIN | WIDG_HIDDEN | WFORM_NOCLICKMOVE |
WBUT_NOPRIMARY | WBUT_SECONDARY | WBUT_TXTCENTRE ))
{
ASSERT((FALSE, "Unknown button style"));
return FALSE;
}
//#ifdef DEBUG
// if (psInit->pText)
// {
// ASSERT((PTRVALID(psInit->psFont, sizeof(PROP_FONT)),
// "buttonCreate: Invalid font pointer"));
// }
//#endif
/* Allocate the required memory */
#if W_USE_MALLOC
*ppsWidget = (W_BUTTON *)MALLOC(sizeof(W_BUTTON));
if (*ppsWidget == NULL)
#else
if (!HEAP_ALLOC(psButHeap, ppsWidget))
#endif
{
ASSERT((FALSE, "buttonCreate: Out of memory"));
return FALSE;
}
/* Allocate memory for the text and copy it if necessary */
if (psInit->pText)
{
#if W_USE_STRHEAP
if (!widgAllocCopyString(&(*ppsWidget)->pText, psInit->pText))
{
ASSERT((FALSE, "buttonCreate: Out of memory"));
#if W_USE_MALLOC
FREE(*ppsWidget);
#else
HEAP_FREE(psButHeap, *ppsWidget);
#endif
return FALSE;
}
#else
(*ppsWidget)->pText = psInit->pText;
#endif
}
else
{
(*ppsWidget)->pText = NULL;
}
/* Allocate the memory for the tip and copy it if necessary */
if (psInit->pTip)
{
#if W_USE_STRHEAP
if (!widgAllocCopyString(&(*ppsWidget)->pTip, psInit->pTip))
{
/* Out of memory - just carry on without the tip */
ASSERT((FALSE, "buttonCreate: Out of memory"));
(*ppsWidget)->pTip = NULL;
}
#else
(*ppsWidget)->pTip = psInit->pTip;
#endif
}
else
{
(*ppsWidget)->pTip = NULL;
}
/* Initialise the structure */
(*ppsWidget)->type = WIDG_BUTTON;
(*ppsWidget)->id = psInit->id;
(*ppsWidget)->formID = psInit->formID;
(*ppsWidget)->style = psInit->style;
(*ppsWidget)->x = psInit->x;
(*ppsWidget)->y = psInit->y;
(*ppsWidget)->width = psInit->width;
(*ppsWidget)->height = psInit->height;
(*ppsWidget)->callback = psInit->pCallback;
(*ppsWidget)->pUserData = psInit->pUserData;
(*ppsWidget)->UserData = psInit->UserData;
(*ppsWidget)->AudioCallback = WidgGetAudioCallback();
(*ppsWidget)->HilightAudioID = WidgGetHilightAudioID();
(*ppsWidget)->ClickedAudioID = WidgGetClickedAudioID();
if (psInit->pDisplay)
{
(*ppsWidget)->display = psInit->pDisplay;
}
else
{
(*ppsWidget)->display = buttonDisplay;
}
// (*ppsWidget)->psFont = psInit->psFont;
(*ppsWidget)->FontID = psInit->FontID;
buttonInitialise(*ppsWidget);
return TRUE;
}
void* lzowrite_init(const char* filename) {
//Prepare the buffers
struct lzowrite_buffer* buffer = malloc(sizeof(struct lzowrite_buffer));
buffer->output = fopen(filename, "w");
buffer->length = 0;
//Allocate workmemory
HEAP_ALLOC(wrkmem, LZO1X_1_MEM_COMPRESS);
buffer->workmemory = wrkmem;
//Write LZO fileformat
unsigned char magic[LZOWRITE_LZO_MAGIC_LEN] = LZOWRITE_LZO_MAGIC;
fwrite(magic, sizeof(unsigned char), LZOWRITE_LZO_MAGIC_LEN, buffer->output);
//Init header
struct lzowrite_file_header* fheader = malloc(sizeof(struct lzowrite_file_header));
fheader->version = LZOWRITE_LZO_VERSION;
fheader->library_version = lzo_version();
fheader->needed_version = LZOWRITE_LZO_VERSION_NEEDED_TO_EXTRACT;
fheader->compression_method = LZOWRITE_LZO_METHOD;
fheader->compression_level = LZOWRITE_LZO_COMPRESSION_LEVEL;
fheader->compression_flags = LZOWRITE_LZO_FLAGS;
fheader->mode = LZOWRITE_LZO_MODE;
fheader->file_name_length = 0;
fheader->file_header_checksum = 1;
fheader->file_mtime_high = 0;
fheader->file_mtime_low = 0;
fwrite(&fheader->version, sizeof(uint16_t), 1, buffer->output);
fwrite(&fheader->library_version, sizeof(uint16_t), 1, buffer->output);
fwrite(&fheader->needed_version, sizeof(uint16_t), 1, buffer->output);
fwrite(&fheader->compression_method, sizeof(uint8_t), 1, buffer->output);
fwrite(&fheader->compression_level, sizeof(uint8_t), 1, buffer->output);
fwrite(&fheader->compression_flags, sizeof(uint32_t), 1, buffer->output);
fwrite(&fheader->mode, sizeof(uint32_t), 1, buffer->output);
fwrite(&fheader->file_mtime_low, sizeof(uint32_t), 1, buffer->output);
fwrite(&fheader->file_mtime_high, sizeof(uint32_t), 1, buffer->output);
fwrite(&fheader->file_name_length, sizeof(uint8_t), 1, buffer->output);
//Calculate checksum
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->version, 2);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->library_version, 2);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->needed_version, 2);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->compression_method, 1);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->compression_level, 1);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->compression_flags, 4);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->mode, 4);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->file_mtime_low, 4);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->file_mtime_high, 4);
fheader->file_header_checksum = lzo_adler32(fheader->file_header_checksum, (lzo_bytep)&fheader->file_name_length, 1);
fwrite(&((uint8_t*)(&fheader->file_header_checksum))[3], sizeof(uint8_t), 1, buffer->output);
fwrite(&((uint8_t*)(&fheader->file_header_checksum))[2], sizeof(uint8_t), 1, buffer->output);
fwrite(&((uint8_t*)(&fheader->file_header_checksum))[1], sizeof(uint8_t), 1, buffer->output);
fwrite(&((uint8_t*)(&fheader->file_header_checksum))[0], sizeof(uint8_t), 1, buffer->output);
free(fheader);
return buffer;
}
void Model::loadC3D(XBuffer& buf)
{
int i,j,size;
int num_vert_total,version;
int num,vert_ind,norm_ind,sort_info;
unsigned color_id,color_shift;
char skip_char;
int phi,psi,tetta;
buf > version;
//std::cout<<"Load C3D. Version:"<<version<<std::endl;
if(version != C3D_VERSION_1 && version != C3D_VERSION_3)
ErrH.Abort("Incorrect C3D version", version);
buf > num_vert > num_norm > num_poly > num_vert_total;
buf > xmax > ymax > zmax;
buf > xmin > ymin > zmin;
buf > x_off > y_off > z_off;
buf > rmax;
buf > phi > psi > tetta;
/*std::cout<<"num_vert:"<<num_vert<<" num_norm:"<<num_norm<<" num_poly:"<<num_poly<<" num_vert_total:"<<num_vert_total<<std::endl;
std::cout<<"xmax:"<<xmax<<" ymax:"<<ymax<<" zmax:"<<zmax<<std::endl;
std::cout<<"xmin:"<<xmin<<" ymin:"<<ymin<<" zmin:"<<zmin<<std::endl;
std::cout<<"x_off:"<<x_off<<" y_off:"<<y_off<<" z_off:"<<z_off<<std::endl;
std::cout<<"rmax:"<<rmax<<std::endl;
std::cout<<"phi:"<<phi<<" psi:"<<psi<<" tetta:"<<tetta<<std::endl;*/
if(version == C3D_VERSION_3)
buf > volume > rcm > J;
else
ErrH.Abort("C3D - old version.You need to update all m3d & a3d");
size = num_vert*sizeof(Vertex) + num_norm*sizeof(Normal) + num_poly*sizeof(Polygon);
memory_allocation_method = 1;
HEAP_BEGIN(size);
vertices = HEAP_ALLOC(num_vert,Vertex);
normals = HEAP_ALLOC(num_norm,Normal);
polygons = HEAP_ALLOC(num_poly,Polygon);
if(phi == 83 && psi == 83 && tetta == 83){
float tf;
for(i = 0;i < num_vert;i++){
buf > tf > tf > tf;
buf > vertices[i].x_8 > vertices[i].y_8 > vertices[i].z_8
> sort_info;
}
}
else{
int ti;
for(i = 0;i < num_vert;i++){
buf > ti > ti > ti;
buf > vertices[i].x_8 > vertices[i].y_8 > vertices[i].z_8
> sort_info;
}
}
for(i = 0;i < num_norm;i++)
buf > normals[i].x > normals[i].y > normals[i].z
> normals[i].n_power > sort_info;
for(i = 0;i < num_poly;i++){
buf > num > sort_info
> color_id > color_shift
> skip_char > skip_char
> skip_char > skip_char
> polygons[i].middle_x > polygons[i].middle_y > polygons[i].middle_z;
polygons[i].color_id = color_id < COLORS_IDS::MAX_COLORS_IDS ? color_id : COLORS_IDS::BODY;
if(num != 3)
ErrH.Abort("Non triangular 3D model");
for(j = 0;j < 3;j++){
buf > vert_ind > norm_ind;
polygons[i].vertices[j] = &vertices[vert_ind];
polygons[i].normals[j] = &normals[norm_ind];
}
}
//buf.set(3*num_poly*sizeof(VariablePolygon*),XB_CUR);
buf.set(3*num_poly*4,XB_CUR);
HEAP_END;
}
/* Create a button widget data structure */
BOOL labelCreate(W_LABEL **ppsWidget, W_LABINIT *psInit)
{
/* Do some validation on the initialisation struct */
if (psInit->style & ~(WLAB_PLAIN | WLAB_ALIGNLEFT |
WLAB_ALIGNRIGHT | WLAB_ALIGNCENTRE | WIDG_HIDDEN))
{
ASSERT((FALSE, "Unknown button style"));
return FALSE;
}
// ASSERT((PTRVALID(psInit->psFont, sizeof(PROP_FONT)),
// "labelCreate: Invalid font pointer"));
/* Allocate the required memory */
#if W_USE_MALLOC
*ppsWidget = (W_LABEL *)MALLOC(sizeof(W_LABEL));
if (*ppsWidget == NULL)
#else
if (!HEAP_ALLOC(psLabHeap, ppsWidget))
#endif
{
ASSERT((FALSE, "Out of memory"));
return FALSE;
}
/* Allocate the memory for the tip and copy it if necessary */
if (psInit->pTip)
{
#if W_USE_STRHEAP
if (!widgAllocCopyString(&(*ppsWidget)->pTip, psInit->pTip))
{
/* Out of memory - just carry on without the tip */
ASSERT((FALSE, "buttonCreate: Out of memory"));
(*ppsWidget)->pTip = NULL;
}
#else
(*ppsWidget)->pTip = psInit->pTip;
#endif
}
else
{
(*ppsWidget)->pTip = NULL;
}
/* Initialise the structure */
(*ppsWidget)->type = WIDG_LABEL;
(*ppsWidget)->id = psInit->id;
(*ppsWidget)->formID = psInit->formID;
(*ppsWidget)->style = psInit->style;
(*ppsWidget)->x = psInit->x;
(*ppsWidget)->y = psInit->y;
(*ppsWidget)->width = psInit->width;
(*ppsWidget)->height = psInit->height;
if (psInit->pDisplay)
{
(*ppsWidget)->display = psInit->pDisplay;
}
else
{
(*ppsWidget)->display = labelDisplay;
}
(*ppsWidget)->callback = psInit->pCallback;
(*ppsWidget)->pUserData = psInit->pUserData;
(*ppsWidget)->UserData = psInit->UserData;
// (*ppsWidget)->psFont = psInit->psFont;
(*ppsWidget)->FontID = psInit->FontID;
if (psInit->pText)
{
widgCopyString((*ppsWidget)->aText, psInit->pText);
}
else
{
*(*ppsWidget)->aText = 0;
}
return TRUE;
}
void Model::loadC3Dvariable(XBuffer& buf)
{
int i,j,size;
int num_vert_total,version;
int num,vert_ind,norm_ind,sort_info;
unsigned color_id,color_shift;
int phi,psi,tetta;
buf > version;
if(version != C3D_VERSION_1 && version != C3D_VERSION_3)
ErrH.Abort("Incorrect C3D version");
buf > num_vert > num_norm > num_poly > num_vert_total;
buf > xmax > ymax > zmax;
buf > xmin > ymin > zmin;
buf > x_off > y_off > z_off;
buf > rmax;
buf > phi > psi > tetta;
if(version == C3D_VERSION_3)
buf > volume > rcm > J;
#ifdef _ROAD_
else
ErrH.Abort("C3D - old version.You need to update all m3d & a3d");
#endif
#ifdef COMPACT_3D
size = num_vert*sizeof(Vertex) + num_norm*sizeof(Normal) + num_poly*sizeof(VariablePolygon);
#else
size = num_vert*sizeof(Vertex) + num_norm*sizeof(Normal) +
num_poly*(sizeof(VariablePolygon) + 3*sizeof(VariablePolygon*));
#endif
size += num_vert_total*(sizeof(Vertex*) + sizeof(Normal*));
memory_allocation_method = 1;
HEAP_BEGIN(size);
vertices = HEAP_ALLOC(num_vert,Vertex);
normals = HEAP_ALLOC(num_norm,Normal);
variable_polygons = HEAP_ALLOC(num_poly,VariablePolygon);
if(phi == 83 && psi == 83 && tetta == 83){
for(i = 0;i < num_vert;i++){
#ifdef COMPACT_3D
float tf;
buf > tf > tf > tf;
#else
buf > vertices[i].x > vertices[i].y > vertices[i].z;
#endif
buf > vertices[i].x_8 > vertices[i].y_8 > vertices[i].z_8
> sort_info;
}
}
else{
int ti;
for(i = 0;i < num_vert;i++){
#ifdef COMPACT_3D
buf > ti > ti > ti;
#else
buf > ti;
vertices[i].x = (float)ti;
buf > ti;
vertices[i].y = (float)ti;
buf > ti;
vertices[i].z = (float)ti;
#endif
buf > vertices[i].x_8 > vertices[i].y_8 > vertices[i].z_8
> sort_info;
}
}
for(i = 0;i < num_norm;i++)
buf > normals[i].x > normals[i].y > normals[i].z
> normals[i].n_power > sort_info;
for(i = 0;i < num_poly;i++){
buf > num > sort_info
> color_id > color_shift
> variable_polygons[i].flat_normal.x > variable_polygons[i].flat_normal.y
> variable_polygons[i].flat_normal.z > variable_polygons[i].flat_normal.n_power
> variable_polygons[i].middle_x > variable_polygons[i].middle_y > variable_polygons[i].middle_z;
variable_polygons[i].color_id = color_id < COLORS_IDS::MAX_COLORS_IDS ? color_id : COLORS_IDS::BODY;
variable_polygons[i].num_vert = num;
variable_polygons[i].vertices = HEAP_ALLOC(num,Vertex*);
variable_polygons[i].normals = HEAP_ALLOC(num,Normal*);
for(j = 0;j < num;j++){
buf > vert_ind > norm_ind;
variable_polygons[i].vertices[j] = &vertices[vert_ind];
variable_polygons[i].normals[j] = &normals[norm_ind];
}
}
#ifndef COMPACT_3D
int poly_ind;
for(i = 0;i < 3;i++){
sorted_variable_polygons[i] = HEAP_ALLOC(num_poly,VariablePolygon*);
for(j = 0;j < num_poly;j++){
buf > poly_ind;
sorted_variable_polygons[i][j] = &variable_polygons[poly_ind];
}
}
#else
//buf.set(3*num_poly*sizeof(VariablePolygon*),XB_CUR);
buf.set(3*num_poly*4,XB_CUR);
#endif
HEAP_END;
}
/* Receive
* ----------------------------------------------------------------------------
*/
ECommError CLogBlock::Receive (BYTE *bypCommand, BYTE **ppData, UINT *upLen)
{
HEAP_FREE(*ppData, *upLen);
// Build block frame
if (m_pDataFrame == NULL)
{
m_pDataFrame = (XFrame *)new char [HD_FRAME + m_Para.uBlockLen];
}
memset (m_pDataFrame, 0x00, HD_FRAME);
*upLen = 0;
USHORT uBlock = 0;
UINT uBlockLen = 0;
UINT uDataLen = 0;
BOOL bLast = FALSE;
ECommError eError;
UINT uProgMax = m_uMaxRecvProg;
UINT uProgCur = 0;
while (! bLast)
{
PROGRESS(uProgCur,uProgMax);
// Block count starts with 1!
uBlock++;
eError = ceError;
for (UINT i = 0; (i < m_uRepeatOnError && eError != ceOK) || i == 0; i++)
{
bLast = FALSE;
// Send request for response block
eError = SendInfoBlock (uBlock, BT_REQ);
if (eError != ceOK)
{
// Communication error sending block
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
continue;
}
uBlockLen = m_Para.uBlockLen + HD_FRAME;
// Receive block
eError = m_pPhys->Receive((BYTE *)m_pDataFrame, &uBlockLen);
if (eError != ceOK)
{
// Communication error or time out; try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
continue;
}
// Check block size
if (uBlockLen < HD_FRAME)
{
// Received block could not be a valid block; try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Invalid block length.\n"));
eError = ceError;
continue;
}
// Convert Big -> Little Endian
TtoH(m_pDataFrame);
if (HD_FRAME + m_pDataFrame->BLK.uLen != uBlockLen)
{
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] CRC frame data length check failed.\n"));
PROGRESS_LAST(uProgMax);
return ceCRC;
}
// Check CRC
if (CheckCRC (m_pDataFrame) != ceOK)
{
TRACE (_T("CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_CRC_\n"));
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] CRC check failed.\n"));
// Wrong checksum; send NACK and try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
eError = ceCRC;
continue;
}
// Check block type
if (m_pDataFrame->byType != BT_DATA)
{
// Received block could not be a valid block; try again
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Invalid block type (data expected).\n"));
eError = ceError;
continue;
}
bLast = m_pDataFrame->BLK.byLast;
// Check block number
if (m_pDataFrame->BLK.uBlock != uBlock)
{
// Received block number does not match
SleepEx (m_uWaitResend, FALSE);
m_pPhys->Flush();
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Invalid block number.\n"));
eError = ceError;
continue;
}
*bypCommand = m_pDataFrame->BLK.CMD.byCommand;
uDataLen = m_pDataFrame->BLK.uLen;
// Create Command Buffer
if (uBlock == 1)
{
HEAP_ALLOC(*ppData, uDataLen);
}
else
{
HEAP_RE_ALLOC(*ppData, *upLen + uDataLen);
}
if (*ppData == NULL)
{
TrcPrint(TRC_ERROR, _T("[CLogBlock][Receive] Alloc Memory.\n"));
eError = ceError;
continue;
}
// Copy data
memcpy(*ppData + *upLen, m_pDataFrame->BLK.CMD.pData, uDataLen);
*upLen += uDataLen;
if (m_pDataFrame->BLK.CMD.byCommand > 0x80u)
{
// Error Message from VMM
TRACE(_T("<<< %-8s %3d %4d \n"), _T("FAILED"), uBlock, m_pDataFrame->BLK.uLen);
TrcPrint(TRC_INTERFACE, _T("<<< %-8s %3d %4d \n"), _T("FAILED"), uBlock, m_pDataFrame->BLK.uLen);
PROGRESS_LAST(uProgMax);
return ceOK;
}
else
{
TRACE(_T("<<< %-8s %3d %3d \n"), m_pDataFrame->BLK.CMD.byCommand <= LAST_CMD_VALUE ? szCommandText[m_pDataFrame->BLK.CMD.byCommand] : _T("Invalid"), uBlock, m_pDataFrame->BLK.uLen);
TrcPrint(TRC_INTERFACE, _T("<<< %-8s %3d %4d \n"), m_pDataFrame->BLK.CMD.byCommand <= LAST_CMD_VALUE ? szCommandText[m_pDataFrame->BLK.CMD.byCommand] : _T("Invalid"), uBlock, m_pDataFrame->BLK.uLen);
}
} // end for
if (eError != ceOK)
{
HEAP_FREE(*ppData, *upLen);
PROGRESS_LAST(uProgMax);
return eError;
}
if (++uProgCur == uProgMax)
{
uProgMax += uProgMax;
}
} // end while
PROGRESS_LAST(uProgMax);
return ceOK;
}
/* Create a barGraph widget data structure */
BOOL barGraphCreate(W_BARGRAPH **ppsWidget, W_BARINIT *psInit)
{
if (psInit->style & ~(WBAR_PLAIN | WBAR_TROUGH | WBAR_DOUBLE | WIDG_HIDDEN))
{
ASSERT((FALSE, "Unknown bar graph style"));
return FALSE;
}
if (psInit->orientation < WBAR_LEFT || psInit->orientation > WBAR_BOTTOM)
{
ASSERT((FALSE, "barGraphCreate: Unknown orientation"));
return FALSE;
}
if (psInit->size > WBAR_SCALE)
{
ASSERT((FALSE, "barGraphCreate: Bar size out of range"));
return FALSE;
}
if ((psInit->style & WBAR_DOUBLE) && (psInit->minorSize > WBAR_SCALE))
{
ASSERT((FALSE, "barGraphCreate: Minor bar size out of range"));
return FALSE;
}
/* Allocate the required memory */
#if W_USE_MALLOC
*ppsWidget = (W_BARGRAPH *)MALLOC(sizeof(W_BARGRAPH));
if (*ppsWidget == NULL)
#else
if (!HEAP_ALLOC(psBarHeap, ppsWidget))
#endif
{
ASSERT((FALSE, "barGraphCreate: Out of memory"));
return FALSE;
}
/* Allocate the memory for the tip and copy it if necessary */
if (psInit->pTip)
{
#if W_USE_STRHEAP
if (!widgAllocCopyString(&(*ppsWidget)->pTip, psInit->pTip))
{
/* Out of memory - just carry on without the tip */
ASSERT((FALSE, "barGraphCreate: Out of memory"));
(*ppsWidget)->pTip = NULL;
}
#else
(*ppsWidget)->pTip = psInit->pTip;
#endif
}
else
{
(*ppsWidget)->pTip = NULL;
}
/* Initialise the structure */
(*ppsWidget)->type = WIDG_BARGRAPH;
(*ppsWidget)->id = psInit->id;
(*ppsWidget)->formID = psInit->formID;
(*ppsWidget)->style = psInit->style;
(*ppsWidget)->x = psInit->x;
(*ppsWidget)->y = psInit->y;
(*ppsWidget)->width = psInit->width;
(*ppsWidget)->height = psInit->height;
(*ppsWidget)->callback = psInit->pCallback;
(*ppsWidget)->pUserData = psInit->pUserData;
(*ppsWidget)->UserData = psInit->UserData;
(*ppsWidget)->barPos = psInit->orientation;
(*ppsWidget)->majorSize = psInit->size;
(*ppsWidget)->minorSize = psInit->minorSize;
(*ppsWidget)->iRange = psInit->iRange;
/* Set the display function */
if (psInit->pDisplay)
{
(*ppsWidget)->display = psInit->pDisplay;
}
else if (psInit->style & WBAR_TROUGH)
{
(*ppsWidget)->display = barGraphDisplayTrough;
}
else if (psInit->style & WBAR_DOUBLE)
{
(*ppsWidget)->display = barGraphDisplayDouble;
}
else
{
(*ppsWidget)->display = barGraphDisplay;
}
/* Set the major colour */
// (*ppsWidget)->majorCol = screenGetCacheColour(psInit->sCol.red,
// psInit->sCol.green, psInit->sCol.blue);
(*ppsWidget)->majorCol = (UBYTE)pal_GetNearestColour(psInit->sCol.red,
psInit->sCol.green, psInit->sCol.blue);
/* Set the minor colour if necessary */
if (psInit->style & WBAR_DOUBLE)
{
// (*ppsWidget)->minorCol = screenGetCacheColour(psInit->sMinorCol.red,
// psInit->sMinorCol.green, psInit->sMinorCol.blue);
(*ppsWidget)->majorCol = (UBYTE)pal_GetNearestColour(psInit->sMinorCol.red,
psInit->sMinorCol.green, psInit->sMinorCol.blue);
}
barGraphInitialise(*ppsWidget);
return TRUE;
}
